id int32 0 252k | repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 51 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 |
|---|---|---|---|---|---|---|---|---|---|---|---|
6,000 | samfoo/vt102 | vt102/__init__.py | screen._print | def _print(self, char):
"""
Print a character at the current cursor position and advance the
cursor.
"""
# Don't make bugs where we try to print a screen.
assert len(char) == 1
try:
try:
# Python 3
char = self.decoder(bytes(char, self.encoding))[0]
except TypeError:
# Python 2.x
char = self.decoder(char)[0]
except UnicodeDecodeError:
char = "?"
if self.current_charset == "g0" and self.g0 is not None:
char = char.translate(self.g0)
elif self.current_charset == "g1" and self.g1 is not None:
char = char.translate(self.g1)
row = self.display[self.y]
self.display[self.y] = row[:self.x] + char + row[self.x+1:]
attrs = self.attributes[self.y]
self.attributes[self.y] = attrs[:self.x] + [self.cursor_attributes] + \
attrs[self.x+1:]
self.x += 1
if self.x >= self.size[1]:
# If this was the last column in a row, move the cursor to the
# next row.
self._linefeed() | python | def _print(self, char):
# Don't make bugs where we try to print a screen.
assert len(char) == 1
try:
try:
# Python 3
char = self.decoder(bytes(char, self.encoding))[0]
except TypeError:
# Python 2.x
char = self.decoder(char)[0]
except UnicodeDecodeError:
char = "?"
if self.current_charset == "g0" and self.g0 is not None:
char = char.translate(self.g0)
elif self.current_charset == "g1" and self.g1 is not None:
char = char.translate(self.g1)
row = self.display[self.y]
self.display[self.y] = row[:self.x] + char + row[self.x+1:]
attrs = self.attributes[self.y]
self.attributes[self.y] = attrs[:self.x] + [self.cursor_attributes] + \
attrs[self.x+1:]
self.x += 1
if self.x >= self.size[1]:
# If this was the last column in a row, move the cursor to the
# next row.
self._linefeed() | [
"def",
"_print",
"(",
"self",
",",
"char",
")",
":",
"# Don't make bugs where we try to print a screen. ",
"assert",
"len",
"(",
"char",
")",
"==",
"1",
"try",
":",
"try",
":",
"# Python 3",
"char",
"=",
"self",
".",
"decoder",
"(",
"bytes",
"(",
"char",
"... | Print a character at the current cursor position and advance the
cursor. | [
"Print",
"a",
"character",
"at",
"the",
"current",
"cursor",
"position",
"and",
"advance",
"the",
"cursor",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L513-L550 |
6,001 | samfoo/vt102 | vt102/__init__.py | screen._index | def _index(self):
"""
Move the cursor down one row in the same column. If the cursor is at
the last row, create a new row at the bottom.
"""
if self.y + 1 >= self.size[0]:
# If the cursor is currently on the last row, then spawn another
# and scroll down (removing the top row).
self.display = self.display[1:] + [u" " * self.size[1]]
else:
# If the cursor is anywhere else, then just move it to the
# next line.
self.y += 1 | python | def _index(self):
if self.y + 1 >= self.size[0]:
# If the cursor is currently on the last row, then spawn another
# and scroll down (removing the top row).
self.display = self.display[1:] + [u" " * self.size[1]]
else:
# If the cursor is anywhere else, then just move it to the
# next line.
self.y += 1 | [
"def",
"_index",
"(",
"self",
")",
":",
"if",
"self",
".",
"y",
"+",
"1",
">=",
"self",
".",
"size",
"[",
"0",
"]",
":",
"# If the cursor is currently on the last row, then spawn another",
"# and scroll down (removing the top row).",
"self",
".",
"display",
"=",
"... | Move the cursor down one row in the same column. If the cursor is at
the last row, create a new row at the bottom. | [
"Move",
"the",
"cursor",
"down",
"one",
"row",
"in",
"the",
"same",
"column",
".",
"If",
"the",
"cursor",
"is",
"at",
"the",
"last",
"row",
"create",
"a",
"new",
"row",
"at",
"the",
"bottom",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L559-L572 |
6,002 | samfoo/vt102 | vt102/__init__.py | screen._reverse_index | def _reverse_index(self):
"""
Move the cursor up one row in the same column. If the cursor is at the
first row, create a new row at the top.
"""
if self.y == 0:
# If the cursor is currently at the first row, then scroll the
# screen up.
self.display = [u" " * self.size[1]] + self.display[:-1]
else:
# If the cursor is anywhere other than the first row than just move
# it up by one row.
self.y -= 1 | python | def _reverse_index(self):
if self.y == 0:
# If the cursor is currently at the first row, then scroll the
# screen up.
self.display = [u" " * self.size[1]] + self.display[:-1]
else:
# If the cursor is anywhere other than the first row than just move
# it up by one row.
self.y -= 1 | [
"def",
"_reverse_index",
"(",
"self",
")",
":",
"if",
"self",
".",
"y",
"==",
"0",
":",
"# If the cursor is currently at the first row, then scroll the",
"# screen up.",
"self",
".",
"display",
"=",
"[",
"u\" \"",
"*",
"self",
".",
"size",
"[",
"1",
"]",
"]",
... | Move the cursor up one row in the same column. If the cursor is at the
first row, create a new row at the top. | [
"Move",
"the",
"cursor",
"up",
"one",
"row",
"in",
"the",
"same",
"column",
".",
"If",
"the",
"cursor",
"is",
"at",
"the",
"first",
"row",
"create",
"a",
"new",
"row",
"at",
"the",
"top",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L574-L586 |
6,003 | samfoo/vt102 | vt102/__init__.py | screen._next_tab_stop | def _next_tab_stop(self):
"""
Return the x value of the next available tabstop or the x value of the
margin if there are no more tabstops.
"""
for stop in sorted(self.tabstops):
if self.x < stop:
return stop
return self.size[1] - 1 | python | def _next_tab_stop(self):
for stop in sorted(self.tabstops):
if self.x < stop:
return stop
return self.size[1] - 1 | [
"def",
"_next_tab_stop",
"(",
"self",
")",
":",
"for",
"stop",
"in",
"sorted",
"(",
"self",
".",
"tabstops",
")",
":",
"if",
"self",
".",
"x",
"<",
"stop",
":",
"return",
"stop",
"return",
"self",
".",
"size",
"[",
"1",
"]",
"-",
"1"
] | Return the x value of the next available tabstop or the x value of the
margin if there are no more tabstops. | [
"Return",
"the",
"x",
"value",
"of",
"the",
"next",
"available",
"tabstop",
"or",
"the",
"x",
"value",
"of",
"the",
"margin",
"if",
"there",
"are",
"no",
"more",
"tabstops",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L604-L613 |
6,004 | samfoo/vt102 | vt102/__init__.py | screen._insert_line | def _insert_line(self, count=1):
"""
Inserts lines at line with cursor. Lines displayed below cursor move
down. Lines moved past the bottom margin are lost.
"""
trimmed = self.display[:self.y+1] + \
[u" " * self.size[1]] * count + \
self.display[self.y+1:self.y+count+1]
self.display = trimmed[:self.size[0]] | python | def _insert_line(self, count=1):
trimmed = self.display[:self.y+1] + \
[u" " * self.size[1]] * count + \
self.display[self.y+1:self.y+count+1]
self.display = trimmed[:self.size[0]] | [
"def",
"_insert_line",
"(",
"self",
",",
"count",
"=",
"1",
")",
":",
"trimmed",
"=",
"self",
".",
"display",
"[",
":",
"self",
".",
"y",
"+",
"1",
"]",
"+",
"[",
"u\" \"",
"*",
"self",
".",
"size",
"[",
"1",
"]",
"]",
"*",
"count",
"+",
"sel... | Inserts lines at line with cursor. Lines displayed below cursor move
down. Lines moved past the bottom margin are lost. | [
"Inserts",
"lines",
"at",
"line",
"with",
"cursor",
".",
"Lines",
"displayed",
"below",
"cursor",
"move",
"down",
".",
"Lines",
"moved",
"past",
"the",
"bottom",
"margin",
"are",
"lost",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L646-L654 |
6,005 | samfoo/vt102 | vt102/__init__.py | screen._delete_line | def _delete_line(self, count=1):
"""
Deletes count lines, starting at line with cursor. As lines are
deleted, lines displayed below cursor move up. Lines added to bottom of
screen have spaces with same character attributes as last line moved
up.
"""
self.display = self.display[:self.y] + \
self.display[self.y+1:]
self.display.append([u" " * self.size[1]] * count)
self.attributes = self.attributes[:self.y] + \
self.attributes[self.y+1:]
last_attributes = self.attributes[-1]
for _ in xrange(count):
self.attributes.append(copy(last_attributes)) | python | def _delete_line(self, count=1):
self.display = self.display[:self.y] + \
self.display[self.y+1:]
self.display.append([u" " * self.size[1]] * count)
self.attributes = self.attributes[:self.y] + \
self.attributes[self.y+1:]
last_attributes = self.attributes[-1]
for _ in xrange(count):
self.attributes.append(copy(last_attributes)) | [
"def",
"_delete_line",
"(",
"self",
",",
"count",
"=",
"1",
")",
":",
"self",
".",
"display",
"=",
"self",
".",
"display",
"[",
":",
"self",
".",
"y",
"]",
"+",
"self",
".",
"display",
"[",
"self",
".",
"y",
"+",
"1",
":",
"]",
"self",
".",
"... | Deletes count lines, starting at line with cursor. As lines are
deleted, lines displayed below cursor move up. Lines added to bottom of
screen have spaces with same character attributes as last line moved
up. | [
"Deletes",
"count",
"lines",
"starting",
"at",
"line",
"with",
"cursor",
".",
"As",
"lines",
"are",
"deleted",
"lines",
"displayed",
"below",
"cursor",
"move",
"up",
".",
"Lines",
"added",
"to",
"bottom",
"of",
"screen",
"have",
"spaces",
"with",
"same",
"... | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L656-L670 |
6,006 | samfoo/vt102 | vt102/__init__.py | screen._delete_character | def _delete_character(self, count=1):
"""
Deletes count characters, starting with the character at cursor
position. When a character is deleted, all characters to the right
of cursor move left.
"""
# First resize the text display
row = self.display[self.y]
count = min(count, self.size[1] - self.x)
row = row[:self.x] + row[self.x+count:] + u" " * count
self.display[self.y] = row
# Then resize the attribute array too
attrs = self.attributes[self.y]
attrs = attrs[:self.x] + attrs[self.x+count:] + [self.default_attributes] * count
self.attributes[self.y] = attrs | python | def _delete_character(self, count=1):
# First resize the text display
row = self.display[self.y]
count = min(count, self.size[1] - self.x)
row = row[:self.x] + row[self.x+count:] + u" " * count
self.display[self.y] = row
# Then resize the attribute array too
attrs = self.attributes[self.y]
attrs = attrs[:self.x] + attrs[self.x+count:] + [self.default_attributes] * count
self.attributes[self.y] = attrs | [
"def",
"_delete_character",
"(",
"self",
",",
"count",
"=",
"1",
")",
":",
"# First resize the text display",
"row",
"=",
"self",
".",
"display",
"[",
"self",
".",
"y",
"]",
"count",
"=",
"min",
"(",
"count",
",",
"self",
".",
"size",
"[",
"1",
"]",
... | Deletes count characters, starting with the character at cursor
position. When a character is deleted, all characters to the right
of cursor move left. | [
"Deletes",
"count",
"characters",
"starting",
"with",
"the",
"character",
"at",
"cursor",
"position",
".",
"When",
"a",
"character",
"is",
"deleted",
"all",
"characters",
"to",
"the",
"right",
"of",
"cursor",
"move",
"left",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L672-L688 |
6,007 | samfoo/vt102 | vt102/__init__.py | screen._erase_in_line | def _erase_in_line(self, type_of=0):
"""
Erases the row in a specific way, depending on the type_of.
"""
row = self.display[self.y]
attrs = self.attributes[self.y]
if type_of == 0:
# Erase from the cursor to the end of line, including the cursor
row = row[:self.x] + u" " * (self.size[1] - self.x)
attrs = attrs[:self.x] + [self.default_attributes] * (self.size[1] - self.x)
elif type_of == 1:
# Erase from the beginning of the line to the cursor, including it
row = u" " * (self.x+1) + row[self.x+1:]
attrs = [self.default_attributes] * (self.x+1) + attrs[self.x+1:]
elif type_of == 2:
# Erase the entire line.
row = u" " * self.size[1]
attrs = [self.default_attributes] * self.size[1]
self.display[self.y] = row
self.attributes[self.y] = attrs | python | def _erase_in_line(self, type_of=0):
row = self.display[self.y]
attrs = self.attributes[self.y]
if type_of == 0:
# Erase from the cursor to the end of line, including the cursor
row = row[:self.x] + u" " * (self.size[1] - self.x)
attrs = attrs[:self.x] + [self.default_attributes] * (self.size[1] - self.x)
elif type_of == 1:
# Erase from the beginning of the line to the cursor, including it
row = u" " * (self.x+1) + row[self.x+1:]
attrs = [self.default_attributes] * (self.x+1) + attrs[self.x+1:]
elif type_of == 2:
# Erase the entire line.
row = u" " * self.size[1]
attrs = [self.default_attributes] * self.size[1]
self.display[self.y] = row
self.attributes[self.y] = attrs | [
"def",
"_erase_in_line",
"(",
"self",
",",
"type_of",
"=",
"0",
")",
":",
"row",
"=",
"self",
".",
"display",
"[",
"self",
".",
"y",
"]",
"attrs",
"=",
"self",
".",
"attributes",
"[",
"self",
".",
"y",
"]",
"if",
"type_of",
"==",
"0",
":",
"# Era... | Erases the row in a specific way, depending on the type_of. | [
"Erases",
"the",
"row",
"in",
"a",
"specific",
"way",
"depending",
"on",
"the",
"type_of",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L690-L711 |
6,008 | samfoo/vt102 | vt102/__init__.py | screen._cursor_down | def _cursor_down(self, count=1):
"""
Moves cursor down count lines in same column. Cursor stops at bottom
margin.
"""
self.y = min(self.size[0] - 1, self.y + count) | python | def _cursor_down(self, count=1):
self.y = min(self.size[0] - 1, self.y + count) | [
"def",
"_cursor_down",
"(",
"self",
",",
"count",
"=",
"1",
")",
":",
"self",
".",
"y",
"=",
"min",
"(",
"self",
".",
"size",
"[",
"0",
"]",
"-",
"1",
",",
"self",
".",
"y",
"+",
"count",
")"
] | Moves cursor down count lines in same column. Cursor stops at bottom
margin. | [
"Moves",
"cursor",
"down",
"count",
"lines",
"in",
"same",
"column",
".",
"Cursor",
"stops",
"at",
"bottom",
"margin",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L765-L770 |
6,009 | samfoo/vt102 | vt102/__init__.py | screen._cursor_forward | def _cursor_forward(self, count=1):
"""
Moves cursor right count columns. Cursor stops at right margin.
"""
self.x = min(self.size[1] - 1, self.x + count) | python | def _cursor_forward(self, count=1):
self.x = min(self.size[1] - 1, self.x + count) | [
"def",
"_cursor_forward",
"(",
"self",
",",
"count",
"=",
"1",
")",
":",
"self",
".",
"x",
"=",
"min",
"(",
"self",
".",
"size",
"[",
"1",
"]",
"-",
"1",
",",
"self",
".",
"x",
"+",
"count",
")"
] | Moves cursor right count columns. Cursor stops at right margin. | [
"Moves",
"cursor",
"right",
"count",
"columns",
".",
"Cursor",
"stops",
"at",
"right",
"margin",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L778-L782 |
6,010 | samfoo/vt102 | vt102/__init__.py | screen._cursor_position | def _cursor_position(self, row=0, column=0):
"""
Set the cursor to a specific row and column.
Obnoxiously row/column is 1 based, instead of zero based, so we need
to compensate. I know I've created bugs in here somehow.
Confoundingly, inputs of 0 are still acceptable, and should move to
the beginning of the row/column as if they were 1. *sigh*
"""
if row == 0:
row = 1
if column == 0:
column = 1
self.y = min(row - 1, self.size[0] - 1)
self.x = min(column - 1, self.size[1] - 1) | python | def _cursor_position(self, row=0, column=0):
if row == 0:
row = 1
if column == 0:
column = 1
self.y = min(row - 1, self.size[0] - 1)
self.x = min(column - 1, self.size[1] - 1) | [
"def",
"_cursor_position",
"(",
"self",
",",
"row",
"=",
"0",
",",
"column",
"=",
"0",
")",
":",
"if",
"row",
"==",
"0",
":",
"row",
"=",
"1",
"if",
"column",
"==",
"0",
":",
"column",
"=",
"1",
"self",
".",
"y",
"=",
"min",
"(",
"row",
"-",
... | Set the cursor to a specific row and column.
Obnoxiously row/column is 1 based, instead of zero based, so we need
to compensate. I know I've created bugs in here somehow.
Confoundingly, inputs of 0 are still acceptable, and should move to
the beginning of the row/column as if they were 1. *sigh* | [
"Set",
"the",
"cursor",
"to",
"a",
"specific",
"row",
"and",
"column",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L784-L800 |
6,011 | samfoo/vt102 | vt102/__init__.py | screen._text_attr | def _text_attr(self, attr):
"""
Given a text attribute, set the current cursor appropriately.
"""
attr = text[attr]
if attr == "reset":
self.cursor_attributes = self.default_attributes
elif attr == "underline-off":
self.cursor_attributes = self._remove_text_attr("underline")
elif attr == "blink-off":
self.cursor_attributes = self._remove_text_attr("blink")
elif attr == "reverse-off":
self.cursor_attributes = self._remove_text_attr("reverse")
else:
self.cursor_attributes = self._add_text_attr(attr) | python | def _text_attr(self, attr):
attr = text[attr]
if attr == "reset":
self.cursor_attributes = self.default_attributes
elif attr == "underline-off":
self.cursor_attributes = self._remove_text_attr("underline")
elif attr == "blink-off":
self.cursor_attributes = self._remove_text_attr("blink")
elif attr == "reverse-off":
self.cursor_attributes = self._remove_text_attr("reverse")
else:
self.cursor_attributes = self._add_text_attr(attr) | [
"def",
"_text_attr",
"(",
"self",
",",
"attr",
")",
":",
"attr",
"=",
"text",
"[",
"attr",
"]",
"if",
"attr",
"==",
"\"reset\"",
":",
"self",
".",
"cursor_attributes",
"=",
"self",
".",
"default_attributes",
"elif",
"attr",
"==",
"\"underline-off\"",
":",
... | Given a text attribute, set the current cursor appropriately. | [
"Given",
"a",
"text",
"attribute",
"set",
"the",
"current",
"cursor",
"appropriately",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L820-L834 |
6,012 | samfoo/vt102 | vt102/__init__.py | screen._color_attr | def _color_attr(self, ground, attr):
"""
Given a color attribute, set the current cursor appropriately.
"""
attr = colors[ground][attr]
attrs = self.cursor_attributes
if ground == "foreground":
self.cursor_attributes = (attrs[0], attr, attrs[2])
elif ground == "background":
self.cursor_attributes = (attrs[0], attrs[1], attr) | python | def _color_attr(self, ground, attr):
attr = colors[ground][attr]
attrs = self.cursor_attributes
if ground == "foreground":
self.cursor_attributes = (attrs[0], attr, attrs[2])
elif ground == "background":
self.cursor_attributes = (attrs[0], attrs[1], attr) | [
"def",
"_color_attr",
"(",
"self",
",",
"ground",
",",
"attr",
")",
":",
"attr",
"=",
"colors",
"[",
"ground",
"]",
"[",
"attr",
"]",
"attrs",
"=",
"self",
".",
"cursor_attributes",
"if",
"ground",
"==",
"\"foreground\"",
":",
"self",
".",
"cursor_attrib... | Given a color attribute, set the current cursor appropriately. | [
"Given",
"a",
"color",
"attribute",
"set",
"the",
"current",
"cursor",
"appropriately",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L836-L845 |
6,013 | samfoo/vt102 | vt102/__init__.py | screen._set_attr | def _set_attr(self, attr):
"""
Given some text attribute, set the current cursor attributes
appropriately.
"""
if attr in text:
self._text_attr(attr)
elif attr in colors["foreground"]:
self._color_attr("foreground", attr)
elif attr in colors["background"]:
self._color_attr("background", attr) | python | def _set_attr(self, attr):
if attr in text:
self._text_attr(attr)
elif attr in colors["foreground"]:
self._color_attr("foreground", attr)
elif attr in colors["background"]:
self._color_attr("background", attr) | [
"def",
"_set_attr",
"(",
"self",
",",
"attr",
")",
":",
"if",
"attr",
"in",
"text",
":",
"self",
".",
"_text_attr",
"(",
"attr",
")",
"elif",
"attr",
"in",
"colors",
"[",
"\"foreground\"",
"]",
":",
"self",
".",
"_color_attr",
"(",
"\"foreground\"",
",... | Given some text attribute, set the current cursor attributes
appropriately. | [
"Given",
"some",
"text",
"attribute",
"set",
"the",
"current",
"cursor",
"attributes",
"appropriately",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L847-L857 |
6,014 | samfoo/vt102 | vt102/__init__.py | screen._select_graphic_rendition | def _select_graphic_rendition(self, *attrs):
"""
Set the current text attribute.
"""
if len(attrs) == 0:
# No arguments means that we're really trying to do a reset.
attrs = [0]
for attr in attrs:
self._set_attr(attr) | python | def _select_graphic_rendition(self, *attrs):
if len(attrs) == 0:
# No arguments means that we're really trying to do a reset.
attrs = [0]
for attr in attrs:
self._set_attr(attr) | [
"def",
"_select_graphic_rendition",
"(",
"self",
",",
"*",
"attrs",
")",
":",
"if",
"len",
"(",
"attrs",
")",
"==",
"0",
":",
"# No arguments means that we're really trying to do a reset.",
"attrs",
"=",
"[",
"0",
"]",
"for",
"attr",
"in",
"attrs",
":",
"self"... | Set the current text attribute. | [
"Set",
"the",
"current",
"text",
"attribute",
"."
] | ff5be883bc9a880a422b09bb87b210d7c408cf2c | https://github.com/samfoo/vt102/blob/ff5be883bc9a880a422b09bb87b210d7c408cf2c/vt102/__init__.py#L859-L869 |
6,015 | gmr/flatdict | flatdict.py | FlatDict.setdefault | def setdefault(self, key, default):
"""If key is in the flat dictionary, return its value. If not,
insert key with a value of default and return default.
default defaults to ``None``.
:param mixed key: The key name
:param mixed default: The default value
:rtype: mixed
"""
if key not in self or not self.__getitem__(key):
self.__setitem__(key, default)
return self.__getitem__(key) | python | def setdefault(self, key, default):
if key not in self or not self.__getitem__(key):
self.__setitem__(key, default)
return self.__getitem__(key) | [
"def",
"setdefault",
"(",
"self",
",",
"key",
",",
"default",
")",
":",
"if",
"key",
"not",
"in",
"self",
"or",
"not",
"self",
".",
"__getitem__",
"(",
"key",
")",
":",
"self",
".",
"__setitem__",
"(",
"key",
",",
"default",
")",
"return",
"self",
... | If key is in the flat dictionary, return its value. If not,
insert key with a value of default and return default.
default defaults to ``None``.
:param mixed key: The key name
:param mixed default: The default value
:rtype: mixed | [
"If",
"key",
"is",
"in",
"the",
"flat",
"dictionary",
"return",
"its",
"value",
".",
"If",
"not",
"insert",
"key",
"with",
"a",
"value",
"of",
"default",
"and",
"return",
"default",
".",
"default",
"defaults",
"to",
"None",
"."
] | 40bfa64972b2dc148643116db786aa106e7d7d56 | https://github.com/gmr/flatdict/blob/40bfa64972b2dc148643116db786aa106e7d7d56/flatdict.py#L308-L320 |
6,016 | gmr/flatdict | flatdict.py | FlatterDict._child_as_list | def _child_as_list(self, pk, ck):
"""Returns a list of values from the child FlatterDict instance
with string based integer keys.
:param str pk: The parent key
:param str ck: The child key
:rtype: list
"""
return [self._values[pk][ck][k]
for k in sorted(self._values[pk][ck].keys(),
key=lambda x: int(x))] | python | def _child_as_list(self, pk, ck):
return [self._values[pk][ck][k]
for k in sorted(self._values[pk][ck].keys(),
key=lambda x: int(x))] | [
"def",
"_child_as_list",
"(",
"self",
",",
"pk",
",",
"ck",
")",
":",
"return",
"[",
"self",
".",
"_values",
"[",
"pk",
"]",
"[",
"ck",
"]",
"[",
"k",
"]",
"for",
"k",
"in",
"sorted",
"(",
"self",
".",
"_values",
"[",
"pk",
"]",
"[",
"ck",
"]... | Returns a list of values from the child FlatterDict instance
with string based integer keys.
:param str pk: The parent key
:param str ck: The child key
:rtype: list | [
"Returns",
"a",
"list",
"of",
"values",
"from",
"the",
"child",
"FlatterDict",
"instance",
"with",
"string",
"based",
"integer",
"keys",
"."
] | 40bfa64972b2dc148643116db786aa106e7d7d56 | https://github.com/gmr/flatdict/blob/40bfa64972b2dc148643116db786aa106e7d7d56/flatdict.py#L450-L461 |
6,017 | eugene-eeo/graphlite | graphlite/query.py | V.gen_query | def gen_query(self):
"""
Generate an SQL query for the edge object.
"""
return (
SQL.forwards_relation(self.src, self.rel) if self.dst is None else
SQL.inverse_relation(self.dst, self.rel)
) | python | def gen_query(self):
return (
SQL.forwards_relation(self.src, self.rel) if self.dst is None else
SQL.inverse_relation(self.dst, self.rel)
) | [
"def",
"gen_query",
"(",
"self",
")",
":",
"return",
"(",
"SQL",
".",
"forwards_relation",
"(",
"self",
".",
"src",
",",
"self",
".",
"rel",
")",
"if",
"self",
".",
"dst",
"is",
"None",
"else",
"SQL",
".",
"inverse_relation",
"(",
"self",
".",
"dst",... | Generate an SQL query for the edge object. | [
"Generate",
"an",
"SQL",
"query",
"for",
"the",
"edge",
"object",
"."
] | 8d17e9549ee8610570dcde1b427431a2584395b7 | https://github.com/eugene-eeo/graphlite/blob/8d17e9549ee8610570dcde1b427431a2584395b7/graphlite/query.py#L43-L50 |
6,018 | eugene-eeo/graphlite | graphlite/query.py | Query.traverse | def traverse(self, edge):
"""
Traverse the graph, and selecting the destination
nodes for a particular relation that the selected
nodes are a source of, i.e. select the friends of
my friends. You can traverse indefinitely.
:param edge: The edge query. If the edge's
destination node is specified then the source
nodes will be selected.
"""
query = self.statement
rel, dst = edge.rel, edge.dst
statement, params = (
SQL.compound_fwd_query(query, rel) if dst is None else
SQL.compound_inv_query(query, rel, dst)
)
return self.derived(statement, params, replace=True) | python | def traverse(self, edge):
query = self.statement
rel, dst = edge.rel, edge.dst
statement, params = (
SQL.compound_fwd_query(query, rel) if dst is None else
SQL.compound_inv_query(query, rel, dst)
)
return self.derived(statement, params, replace=True) | [
"def",
"traverse",
"(",
"self",
",",
"edge",
")",
":",
"query",
"=",
"self",
".",
"statement",
"rel",
",",
"dst",
"=",
"edge",
".",
"rel",
",",
"edge",
".",
"dst",
"statement",
",",
"params",
"=",
"(",
"SQL",
".",
"compound_fwd_query",
"(",
"query",
... | Traverse the graph, and selecting the destination
nodes for a particular relation that the selected
nodes are a source of, i.e. select the friends of
my friends. You can traverse indefinitely.
:param edge: The edge query. If the edge's
destination node is specified then the source
nodes will be selected. | [
"Traverse",
"the",
"graph",
"and",
"selecting",
"the",
"destination",
"nodes",
"for",
"a",
"particular",
"relation",
"that",
"the",
"selected",
"nodes",
"are",
"a",
"source",
"of",
"i",
".",
"e",
".",
"select",
"the",
"friends",
"of",
"my",
"friends",
".",... | 8d17e9549ee8610570dcde1b427431a2584395b7 | https://github.com/eugene-eeo/graphlite/blob/8d17e9549ee8610570dcde1b427431a2584395b7/graphlite/query.py#L117-L134 |
6,019 | eugene-eeo/graphlite | graphlite/graph.py | Graph.setup_sql | def setup_sql(self, graphs):
"""
Sets up the SQL tables for the graph object,
and creates indexes as well.
:param graphs: The graphs to create.
"""
with closing(self.db.cursor()) as cursor:
for table in graphs:
cursor.execute(SQL.CREATE_TABLE % (table))
for index in SQL.INDEXES:
cursor.execute(index % (table))
self.db.commit() | python | def setup_sql(self, graphs):
with closing(self.db.cursor()) as cursor:
for table in graphs:
cursor.execute(SQL.CREATE_TABLE % (table))
for index in SQL.INDEXES:
cursor.execute(index % (table))
self.db.commit() | [
"def",
"setup_sql",
"(",
"self",
",",
"graphs",
")",
":",
"with",
"closing",
"(",
"self",
".",
"db",
".",
"cursor",
"(",
")",
")",
"as",
"cursor",
":",
"for",
"table",
"in",
"graphs",
":",
"cursor",
".",
"execute",
"(",
"SQL",
".",
"CREATE_TABLE",
... | Sets up the SQL tables for the graph object,
and creates indexes as well.
:param graphs: The graphs to create. | [
"Sets",
"up",
"the",
"SQL",
"tables",
"for",
"the",
"graph",
"object",
"and",
"creates",
"indexes",
"as",
"well",
"."
] | 8d17e9549ee8610570dcde1b427431a2584395b7 | https://github.com/eugene-eeo/graphlite/blob/8d17e9549ee8610570dcde1b427431a2584395b7/graphlite/graph.py#L21-L33 |
6,020 | eugene-eeo/graphlite | graphlite/sql.py | remove | def remove(src, rel, dst):
"""
Returns an SQL statement that removes edges from
the SQL backing store. Either `src` or `dst` may
be specified, even both.
:param src: The source node.
:param rel: The relation.
:param dst: The destination node.
"""
smt = 'DELETE FROM %s' % rel
queries = []
params = []
if src is not None:
queries.append('src = ?')
params.append(src)
if dst is not None:
queries.append('dst = ?')
params.append(dst)
if not queries:
return smt, params
smt = '%s WHERE %s' % (smt, ' AND '.join(queries))
return smt, params | python | def remove(src, rel, dst):
smt = 'DELETE FROM %s' % rel
queries = []
params = []
if src is not None:
queries.append('src = ?')
params.append(src)
if dst is not None:
queries.append('dst = ?')
params.append(dst)
if not queries:
return smt, params
smt = '%s WHERE %s' % (smt, ' AND '.join(queries))
return smt, params | [
"def",
"remove",
"(",
"src",
",",
"rel",
",",
"dst",
")",
":",
"smt",
"=",
"'DELETE FROM %s'",
"%",
"rel",
"queries",
"=",
"[",
"]",
"params",
"=",
"[",
"]",
"if",
"src",
"is",
"not",
"None",
":",
"queries",
".",
"append",
"(",
"'src = ?'",
")",
... | Returns an SQL statement that removes edges from
the SQL backing store. Either `src` or `dst` may
be specified, even both.
:param src: The source node.
:param rel: The relation.
:param dst: The destination node. | [
"Returns",
"an",
"SQL",
"statement",
"that",
"removes",
"edges",
"from",
"the",
"SQL",
"backing",
"store",
".",
"Either",
"src",
"or",
"dst",
"may",
"be",
"specified",
"even",
"both",
"."
] | 8d17e9549ee8610570dcde1b427431a2584395b7 | https://github.com/eugene-eeo/graphlite/blob/8d17e9549ee8610570dcde1b427431a2584395b7/graphlite/sql.py#L28-L53 |
6,021 | eugene-eeo/graphlite | graphlite/transaction.py | Transaction.perform_ops | def perform_ops(self):
"""
Performs the stored operations on the database
connection.
"""
with self.db:
with closing(self.db.cursor()) as cursor:
cursor.execute('BEGIN TRANSACTION')
self._perform_ops(cursor) | python | def perform_ops(self):
with self.db:
with closing(self.db.cursor()) as cursor:
cursor.execute('BEGIN TRANSACTION')
self._perform_ops(cursor) | [
"def",
"perform_ops",
"(",
"self",
")",
":",
"with",
"self",
".",
"db",
":",
"with",
"closing",
"(",
"self",
".",
"db",
".",
"cursor",
"(",
")",
")",
"as",
"cursor",
":",
"cursor",
".",
"execute",
"(",
"'BEGIN TRANSACTION'",
")",
"self",
".",
"_perfo... | Performs the stored operations on the database
connection. | [
"Performs",
"the",
"stored",
"operations",
"on",
"the",
"database",
"connection",
"."
] | 8d17e9549ee8610570dcde1b427431a2584395b7 | https://github.com/eugene-eeo/graphlite/blob/8d17e9549ee8610570dcde1b427431a2584395b7/graphlite/transaction.py#L85-L93 |
6,022 | wtolson/gnsq | gnsq/httpclient.py | HTTPClient.from_url | def from_url(cls, url, **kwargs):
"""Create a client from a url."""
url = urllib3.util.parse_url(url)
if url.host:
kwargs.setdefault('host', url.host)
if url.port:
kwargs.setdefault('port', url.port)
if url.scheme == 'https':
kwargs.setdefault('connection_class', urllib3.HTTPSConnectionPool)
return cls(**kwargs) | python | def from_url(cls, url, **kwargs):
url = urllib3.util.parse_url(url)
if url.host:
kwargs.setdefault('host', url.host)
if url.port:
kwargs.setdefault('port', url.port)
if url.scheme == 'https':
kwargs.setdefault('connection_class', urllib3.HTTPSConnectionPool)
return cls(**kwargs) | [
"def",
"from_url",
"(",
"cls",
",",
"url",
",",
"*",
"*",
"kwargs",
")",
":",
"url",
"=",
"urllib3",
".",
"util",
".",
"parse_url",
"(",
"url",
")",
"if",
"url",
".",
"host",
":",
"kwargs",
".",
"setdefault",
"(",
"'host'",
",",
"url",
".",
"host... | Create a client from a url. | [
"Create",
"a",
"client",
"from",
"a",
"url",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/httpclient.py#L28-L40 |
6,023 | wtolson/gnsq | gnsq/nsqd.py | NsqdTCPClient.connect | def connect(self):
"""Initialize connection to the nsqd."""
if self.state == DISCONNECTED:
raise errors.NSQException('connection already closed')
if self.is_connected:
return
stream = Stream(self.address, self.port, self.timeout)
stream.connect()
self.stream = stream
self.state = CONNECTED
self.send(nsq.MAGIC_V2) | python | def connect(self):
if self.state == DISCONNECTED:
raise errors.NSQException('connection already closed')
if self.is_connected:
return
stream = Stream(self.address, self.port, self.timeout)
stream.connect()
self.stream = stream
self.state = CONNECTED
self.send(nsq.MAGIC_V2) | [
"def",
"connect",
"(",
"self",
")",
":",
"if",
"self",
".",
"state",
"==",
"DISCONNECTED",
":",
"raise",
"errors",
".",
"NSQException",
"(",
"'connection already closed'",
")",
"if",
"self",
".",
"is_connected",
":",
"return",
"stream",
"=",
"Stream",
"(",
... | Initialize connection to the nsqd. | [
"Initialize",
"connection",
"to",
"the",
"nsqd",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L205-L218 |
6,024 | wtolson/gnsq | gnsq/nsqd.py | NsqdTCPClient.close_stream | def close_stream(self):
"""Close the underlying socket."""
if not self.is_connected:
return
self.stream.close()
self.state = DISCONNECTED
self.on_close.send(self) | python | def close_stream(self):
if not self.is_connected:
return
self.stream.close()
self.state = DISCONNECTED
self.on_close.send(self) | [
"def",
"close_stream",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"is_connected",
":",
"return",
"self",
".",
"stream",
".",
"close",
"(",
")",
"self",
".",
"state",
"=",
"DISCONNECTED",
"self",
".",
"on_close",
".",
"send",
"(",
"self",
")"
] | Close the underlying socket. | [
"Close",
"the",
"underlying",
"socket",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L220-L227 |
6,025 | wtolson/gnsq | gnsq/nsqd.py | NsqdTCPClient.read_response | def read_response(self):
"""Read an individual response from nsqd.
:returns: tuple of the frame type and the processed data.
"""
response = self._read_response()
frame, data = nsq.unpack_response(response)
self.last_response = time.time()
if frame not in self._frame_handlers:
raise errors.NSQFrameError('unknown frame {}'.format(frame))
frame_handler = self._frame_handlers[frame]
processed_data = frame_handler(data)
return frame, processed_data | python | def read_response(self):
response = self._read_response()
frame, data = nsq.unpack_response(response)
self.last_response = time.time()
if frame not in self._frame_handlers:
raise errors.NSQFrameError('unknown frame {}'.format(frame))
frame_handler = self._frame_handlers[frame]
processed_data = frame_handler(data)
return frame, processed_data | [
"def",
"read_response",
"(",
"self",
")",
":",
"response",
"=",
"self",
".",
"_read_response",
"(",
")",
"frame",
",",
"data",
"=",
"nsq",
".",
"unpack_response",
"(",
"response",
")",
"self",
".",
"last_response",
"=",
"time",
".",
"time",
"(",
")",
"... | Read an individual response from nsqd.
:returns: tuple of the frame type and the processed data. | [
"Read",
"an",
"individual",
"response",
"from",
"nsqd",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L244-L259 |
6,026 | wtolson/gnsq | gnsq/nsqd.py | NsqdTCPClient.identify | def identify(self):
"""Update client metadata on the server and negotiate features.
:returns: nsqd response data if there was feature negotiation,
otherwise ``None``
"""
self.send(nsq.identify({
# nsqd 0.2.28+
'client_id': self.client_id,
'hostname': self.hostname,
# nsqd 0.2.19+
'feature_negotiation': True,
'heartbeat_interval': self.heartbeat_interval,
# nsqd 0.2.21+
'output_buffer_size': self.output_buffer_size,
'output_buffer_timeout': self.output_buffer_timeout,
# nsqd 0.2.22+
'tls_v1': self.tls_v1,
# nsqd 0.2.23+
'snappy': self.snappy,
'deflate': self.deflate,
'deflate_level': self.deflate_level,
# nsqd nsqd 0.2.25+
'sample_rate': self.sample_rate,
'user_agent': self.user_agent,
}))
frame, data = self.read_response()
if frame == nsq.FRAME_TYPE_ERROR:
raise data
if data == nsq.OK:
return
try:
data = json.loads(data.decode('utf-8'))
except ValueError:
self.close_stream()
raise errors.NSQException(
'failed to parse IDENTIFY response JSON from nsqd: '
'{!r}'.format(data))
self.max_ready_count = data.get('max_rdy_count', self.max_ready_count)
if self.tls_v1 and data.get('tls_v1'):
self.upgrade_to_tls()
if self.snappy and data.get('snappy'):
self.upgrade_to_snappy()
elif self.deflate and data.get('deflate'):
self.deflate_level = data.get('deflate_level', self.deflate_level)
self.upgrade_to_defalte()
if self.auth_secret and data.get('auth_required'):
self.auth()
return data | python | def identify(self):
self.send(nsq.identify({
# nsqd 0.2.28+
'client_id': self.client_id,
'hostname': self.hostname,
# nsqd 0.2.19+
'feature_negotiation': True,
'heartbeat_interval': self.heartbeat_interval,
# nsqd 0.2.21+
'output_buffer_size': self.output_buffer_size,
'output_buffer_timeout': self.output_buffer_timeout,
# nsqd 0.2.22+
'tls_v1': self.tls_v1,
# nsqd 0.2.23+
'snappy': self.snappy,
'deflate': self.deflate,
'deflate_level': self.deflate_level,
# nsqd nsqd 0.2.25+
'sample_rate': self.sample_rate,
'user_agent': self.user_agent,
}))
frame, data = self.read_response()
if frame == nsq.FRAME_TYPE_ERROR:
raise data
if data == nsq.OK:
return
try:
data = json.loads(data.decode('utf-8'))
except ValueError:
self.close_stream()
raise errors.NSQException(
'failed to parse IDENTIFY response JSON from nsqd: '
'{!r}'.format(data))
self.max_ready_count = data.get('max_rdy_count', self.max_ready_count)
if self.tls_v1 and data.get('tls_v1'):
self.upgrade_to_tls()
if self.snappy and data.get('snappy'):
self.upgrade_to_snappy()
elif self.deflate and data.get('deflate'):
self.deflate_level = data.get('deflate_level', self.deflate_level)
self.upgrade_to_defalte()
if self.auth_secret and data.get('auth_required'):
self.auth()
return data | [
"def",
"identify",
"(",
"self",
")",
":",
"self",
".",
"send",
"(",
"nsq",
".",
"identify",
"(",
"{",
"# nsqd 0.2.28+",
"'client_id'",
":",
"self",
".",
"client_id",
",",
"'hostname'",
":",
"self",
".",
"hostname",
",",
"# nsqd 0.2.19+",
"'feature_negotiatio... | Update client metadata on the server and negotiate features.
:returns: nsqd response data if there was feature negotiation,
otherwise ``None`` | [
"Update",
"client",
"metadata",
"on",
"the",
"server",
"and",
"negotiate",
"features",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L329-L393 |
6,027 | wtolson/gnsq | gnsq/nsqd.py | NsqdTCPClient.auth | def auth(self):
"""Send authorization secret to nsqd."""
self.send(nsq.auth(self.auth_secret))
frame, data = self.read_response()
if frame == nsq.FRAME_TYPE_ERROR:
raise data
try:
response = json.loads(data.decode('utf-8'))
except ValueError:
self.close_stream()
raise errors.NSQException(
'failed to parse AUTH response JSON from nsqd: '
'{!r}'.format(data))
self.on_auth.send(self, response=response)
return response | python | def auth(self):
self.send(nsq.auth(self.auth_secret))
frame, data = self.read_response()
if frame == nsq.FRAME_TYPE_ERROR:
raise data
try:
response = json.loads(data.decode('utf-8'))
except ValueError:
self.close_stream()
raise errors.NSQException(
'failed to parse AUTH response JSON from nsqd: '
'{!r}'.format(data))
self.on_auth.send(self, response=response)
return response | [
"def",
"auth",
"(",
"self",
")",
":",
"self",
".",
"send",
"(",
"nsq",
".",
"auth",
"(",
"self",
".",
"auth_secret",
")",
")",
"frame",
",",
"data",
"=",
"self",
".",
"read_response",
"(",
")",
"if",
"frame",
"==",
"nsq",
".",
"FRAME_TYPE_ERROR",
"... | Send authorization secret to nsqd. | [
"Send",
"authorization",
"secret",
"to",
"nsqd",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L395-L412 |
6,028 | wtolson/gnsq | gnsq/nsqd.py | NsqdTCPClient.subscribe | def subscribe(self, topic, channel):
"""Subscribe to a nsq `topic` and `channel`."""
self.send(nsq.subscribe(topic, channel)) | python | def subscribe(self, topic, channel):
self.send(nsq.subscribe(topic, channel)) | [
"def",
"subscribe",
"(",
"self",
",",
"topic",
",",
"channel",
")",
":",
"self",
".",
"send",
"(",
"nsq",
".",
"subscribe",
"(",
"topic",
",",
"channel",
")",
")"
] | Subscribe to a nsq `topic` and `channel`. | [
"Subscribe",
"to",
"a",
"nsq",
"topic",
"and",
"channel",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L414-L416 |
6,029 | wtolson/gnsq | gnsq/nsqd.py | NsqdTCPClient.publish | def publish(self, topic, data, defer=None):
"""Publish a message to the given topic over tcp.
:param topic: the topic to publish to
:param data: bytestring data to publish
:param defer: duration in milliseconds to defer before publishing
(requires nsq 0.3.6)
"""
if defer is None:
self.send(nsq.publish(topic, data))
else:
self.send(nsq.deferpublish(topic, data, defer)) | python | def publish(self, topic, data, defer=None):
if defer is None:
self.send(nsq.publish(topic, data))
else:
self.send(nsq.deferpublish(topic, data, defer)) | [
"def",
"publish",
"(",
"self",
",",
"topic",
",",
"data",
",",
"defer",
"=",
"None",
")",
":",
"if",
"defer",
"is",
"None",
":",
"self",
".",
"send",
"(",
"nsq",
".",
"publish",
"(",
"topic",
",",
"data",
")",
")",
"else",
":",
"self",
".",
"se... | Publish a message to the given topic over tcp.
:param topic: the topic to publish to
:param data: bytestring data to publish
:param defer: duration in milliseconds to defer before publishing
(requires nsq 0.3.6) | [
"Publish",
"a",
"message",
"to",
"the",
"given",
"topic",
"over",
"tcp",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L418-L431 |
6,030 | wtolson/gnsq | gnsq/nsqd.py | NsqdTCPClient.ready | def ready(self, count):
"""Indicate you are ready to receive ``count`` messages."""
self.ready_count = count
self.send(nsq.ready(count)) | python | def ready(self, count):
self.ready_count = count
self.send(nsq.ready(count)) | [
"def",
"ready",
"(",
"self",
",",
"count",
")",
":",
"self",
".",
"ready_count",
"=",
"count",
"self",
".",
"send",
"(",
"nsq",
".",
"ready",
"(",
"count",
")",
")"
] | Indicate you are ready to receive ``count`` messages. | [
"Indicate",
"you",
"are",
"ready",
"to",
"receive",
"count",
"messages",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L442-L445 |
6,031 | wtolson/gnsq | gnsq/nsqd.py | NsqdHTTPClient.publish | def publish(self, topic, data, defer=None):
"""Publish a message to the given topic over http.
:param topic: the topic to publish to
:param data: bytestring data to publish
:param defer: duration in millisconds to defer before publishing
(requires nsq 0.3.6)
"""
nsq.assert_valid_topic_name(topic)
fields = {'topic': topic}
if defer is not None:
fields['defer'] = '{}'.format(defer)
return self._request('POST', '/pub', fields=fields, body=data) | python | def publish(self, topic, data, defer=None):
nsq.assert_valid_topic_name(topic)
fields = {'topic': topic}
if defer is not None:
fields['defer'] = '{}'.format(defer)
return self._request('POST', '/pub', fields=fields, body=data) | [
"def",
"publish",
"(",
"self",
",",
"topic",
",",
"data",
",",
"defer",
"=",
"None",
")",
":",
"nsq",
".",
"assert_valid_topic_name",
"(",
"topic",
")",
"fields",
"=",
"{",
"'topic'",
":",
"topic",
"}",
"if",
"defer",
"is",
"not",
"None",
":",
"field... | Publish a message to the given topic over http.
:param topic: the topic to publish to
:param data: bytestring data to publish
:param defer: duration in millisconds to defer before publishing
(requires nsq 0.3.6) | [
"Publish",
"a",
"message",
"to",
"the",
"given",
"topic",
"over",
"http",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L507-L523 |
6,032 | wtolson/gnsq | gnsq/nsqd.py | NsqdHTTPClient.create_topic | def create_topic(self, topic):
"""Create a topic."""
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/create', fields={'topic': topic}) | python | def create_topic(self, topic):
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/create', fields={'topic': topic}) | [
"def",
"create_topic",
"(",
"self",
",",
"topic",
")",
":",
"nsq",
".",
"assert_valid_topic_name",
"(",
"topic",
")",
"return",
"self",
".",
"_request",
"(",
"'POST'",
",",
"'/topic/create'",
",",
"fields",
"=",
"{",
"'topic'",
":",
"topic",
"}",
")"
] | Create a topic. | [
"Create",
"a",
"topic",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L556-L559 |
6,033 | wtolson/gnsq | gnsq/nsqd.py | NsqdHTTPClient.delete_topic | def delete_topic(self, topic):
"""Delete a topic."""
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/delete', fields={'topic': topic}) | python | def delete_topic(self, topic):
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/delete', fields={'topic': topic}) | [
"def",
"delete_topic",
"(",
"self",
",",
"topic",
")",
":",
"nsq",
".",
"assert_valid_topic_name",
"(",
"topic",
")",
"return",
"self",
".",
"_request",
"(",
"'POST'",
",",
"'/topic/delete'",
",",
"fields",
"=",
"{",
"'topic'",
":",
"topic",
"}",
")"
] | Delete a topic. | [
"Delete",
"a",
"topic",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L561-L564 |
6,034 | wtolson/gnsq | gnsq/nsqd.py | NsqdHTTPClient.empty_topic | def empty_topic(self, topic):
"""Empty all the queued messages for an existing topic."""
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/empty', fields={'topic': topic}) | python | def empty_topic(self, topic):
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/empty', fields={'topic': topic}) | [
"def",
"empty_topic",
"(",
"self",
",",
"topic",
")",
":",
"nsq",
".",
"assert_valid_topic_name",
"(",
"topic",
")",
"return",
"self",
".",
"_request",
"(",
"'POST'",
",",
"'/topic/empty'",
",",
"fields",
"=",
"{",
"'topic'",
":",
"topic",
"}",
")"
] | Empty all the queued messages for an existing topic. | [
"Empty",
"all",
"the",
"queued",
"messages",
"for",
"an",
"existing",
"topic",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L580-L583 |
6,035 | wtolson/gnsq | gnsq/nsqd.py | NsqdHTTPClient.empty_channel | def empty_channel(self, topic, channel):
"""Empty all the queued messages for an existing channel."""
nsq.assert_valid_topic_name(topic)
nsq.assert_valid_channel_name(channel)
return self._request('POST', '/channel/empty',
fields={'topic': topic, 'channel': channel}) | python | def empty_channel(self, topic, channel):
nsq.assert_valid_topic_name(topic)
nsq.assert_valid_channel_name(channel)
return self._request('POST', '/channel/empty',
fields={'topic': topic, 'channel': channel}) | [
"def",
"empty_channel",
"(",
"self",
",",
"topic",
",",
"channel",
")",
":",
"nsq",
".",
"assert_valid_topic_name",
"(",
"topic",
")",
"nsq",
".",
"assert_valid_channel_name",
"(",
"channel",
")",
"return",
"self",
".",
"_request",
"(",
"'POST'",
",",
"'/cha... | Empty all the queued messages for an existing channel. | [
"Empty",
"all",
"the",
"queued",
"messages",
"for",
"an",
"existing",
"channel",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L585-L590 |
6,036 | wtolson/gnsq | gnsq/nsqd.py | NsqdHTTPClient.pause_topic | def pause_topic(self, topic):
"""Pause message flow to all channels on an existing topic.
Messages will queue at topic.
"""
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/pause', fields={'topic': topic}) | python | def pause_topic(self, topic):
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/pause', fields={'topic': topic}) | [
"def",
"pause_topic",
"(",
"self",
",",
"topic",
")",
":",
"nsq",
".",
"assert_valid_topic_name",
"(",
"topic",
")",
"return",
"self",
".",
"_request",
"(",
"'POST'",
",",
"'/topic/pause'",
",",
"fields",
"=",
"{",
"'topic'",
":",
"topic",
"}",
")"
] | Pause message flow to all channels on an existing topic.
Messages will queue at topic. | [
"Pause",
"message",
"flow",
"to",
"all",
"channels",
"on",
"an",
"existing",
"topic",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L592-L598 |
6,037 | wtolson/gnsq | gnsq/nsqd.py | NsqdHTTPClient.unpause_topic | def unpause_topic(self, topic):
"""Resume message flow to channels of an existing, paused, topic."""
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/unpause', fields={'topic': topic}) | python | def unpause_topic(self, topic):
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/unpause', fields={'topic': topic}) | [
"def",
"unpause_topic",
"(",
"self",
",",
"topic",
")",
":",
"nsq",
".",
"assert_valid_topic_name",
"(",
"topic",
")",
"return",
"self",
".",
"_request",
"(",
"'POST'",
",",
"'/topic/unpause'",
",",
"fields",
"=",
"{",
"'topic'",
":",
"topic",
"}",
")"
] | Resume message flow to channels of an existing, paused, topic. | [
"Resume",
"message",
"flow",
"to",
"channels",
"of",
"an",
"existing",
"paused",
"topic",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L600-L603 |
6,038 | wtolson/gnsq | gnsq/nsqd.py | NsqdHTTPClient.stats | def stats(self, topic=None, channel=None, text=False):
"""Return internal instrumented statistics.
:param topic: (optional) filter to topic
:param channel: (optional) filter to channel
:param text: return the stats as a string (default: ``False``)
"""
if text:
fields = {'format': 'text'}
else:
fields = {'format': 'json'}
if topic:
nsq.assert_valid_topic_name(topic)
fields['topic'] = topic
if channel:
nsq.assert_valid_channel_name(channel)
fields['channel'] = channel
return self._request('GET', '/stats', fields=fields) | python | def stats(self, topic=None, channel=None, text=False):
if text:
fields = {'format': 'text'}
else:
fields = {'format': 'json'}
if topic:
nsq.assert_valid_topic_name(topic)
fields['topic'] = topic
if channel:
nsq.assert_valid_channel_name(channel)
fields['channel'] = channel
return self._request('GET', '/stats', fields=fields) | [
"def",
"stats",
"(",
"self",
",",
"topic",
"=",
"None",
",",
"channel",
"=",
"None",
",",
"text",
"=",
"False",
")",
":",
"if",
"text",
":",
"fields",
"=",
"{",
"'format'",
":",
"'text'",
"}",
"else",
":",
"fields",
"=",
"{",
"'format'",
":",
"'j... | Return internal instrumented statistics.
:param topic: (optional) filter to topic
:param channel: (optional) filter to channel
:param text: return the stats as a string (default: ``False``) | [
"Return",
"internal",
"instrumented",
"statistics",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/nsqd.py#L622-L644 |
6,039 | wtolson/gnsq | gnsq/producer.py | Producer.join | def join(self, timeout=None, raise_error=False):
"""Block until all connections have closed and workers stopped."""
self._workers.join(timeout, raise_error) | python | def join(self, timeout=None, raise_error=False):
self._workers.join(timeout, raise_error) | [
"def",
"join",
"(",
"self",
",",
"timeout",
"=",
"None",
",",
"raise_error",
"=",
"False",
")",
":",
"self",
".",
"_workers",
".",
"join",
"(",
"timeout",
",",
"raise_error",
")"
] | Block until all connections have closed and workers stopped. | [
"Block",
"until",
"all",
"connections",
"have",
"closed",
"and",
"workers",
"stopped",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/producer.py#L132-L134 |
6,040 | wtolson/gnsq | gnsq/producer.py | Producer.publish | def publish(self, topic, data, defer=None, block=True, timeout=None,
raise_error=True):
"""Publish a message to the given topic.
:param topic: the topic to publish to
:param data: bytestring data to publish
:param defer: duration in milliseconds to defer before publishing
(requires nsq 0.3.6)
:param block: wait for a connection to become available before
publishing the message. If block is `False` and no connections
are available, :class:`~gnsq.errors.NSQNoConnections` is raised
:param timeout: if timeout is a positive number, it blocks at most
``timeout`` seconds before raising
:class:`~gnsq.errors.NSQNoConnections`
:param raise_error: if ``True``, it blocks until a response is received
from the nsqd server, and any error response is raised. Otherwise
an :class:`~gevent.event.AsyncResult` is returned
"""
result = AsyncResult()
conn = self._get_connection(block=block, timeout=timeout)
try:
self._response_queues[conn].append(result)
conn.publish(topic, data, defer=defer)
finally:
self._put_connection(conn)
if raise_error:
return result.get()
return result | python | def publish(self, topic, data, defer=None, block=True, timeout=None,
raise_error=True):
result = AsyncResult()
conn = self._get_connection(block=block, timeout=timeout)
try:
self._response_queues[conn].append(result)
conn.publish(topic, data, defer=defer)
finally:
self._put_connection(conn)
if raise_error:
return result.get()
return result | [
"def",
"publish",
"(",
"self",
",",
"topic",
",",
"data",
",",
"defer",
"=",
"None",
",",
"block",
"=",
"True",
",",
"timeout",
"=",
"None",
",",
"raise_error",
"=",
"True",
")",
":",
"result",
"=",
"AsyncResult",
"(",
")",
"conn",
"=",
"self",
"."... | Publish a message to the given topic.
:param topic: the topic to publish to
:param data: bytestring data to publish
:param defer: duration in milliseconds to defer before publishing
(requires nsq 0.3.6)
:param block: wait for a connection to become available before
publishing the message. If block is `False` and no connections
are available, :class:`~gnsq.errors.NSQNoConnections` is raised
:param timeout: if timeout is a positive number, it blocks at most
``timeout`` seconds before raising
:class:`~gnsq.errors.NSQNoConnections`
:param raise_error: if ``True``, it blocks until a response is received
from the nsqd server, and any error response is raised. Otherwise
an :class:`~gevent.event.AsyncResult` is returned | [
"Publish",
"a",
"message",
"to",
"the",
"given",
"topic",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/producer.py#L252-L287 |
6,041 | wtolson/gnsq | gnsq/producer.py | Producer.multipublish | def multipublish(self, topic, messages, block=True, timeout=None,
raise_error=True):
"""Publish an iterable of messages to the given topic.
:param topic: the topic to publish to
:param messages: iterable of bytestrings to publish
:param block: wait for a connection to become available before
publishing the message. If block is `False` and no connections
are available, :class:`~gnsq.errors.NSQNoConnections` is raised
:param timeout: if timeout is a positive number, it blocks at most
``timeout`` seconds before raising
:class:`~gnsq.errors.NSQNoConnections`
:param raise_error: if ``True``, it blocks until a response is received
from the nsqd server, and any error response is raised. Otherwise
an :class:`~gevent.event.AsyncResult` is returned
"""
result = AsyncResult()
conn = self._get_connection(block=block, timeout=timeout)
try:
self._response_queues[conn].append(result)
conn.multipublish(topic, messages)
finally:
self._put_connection(conn)
if raise_error:
return result.get()
return result | python | def multipublish(self, topic, messages, block=True, timeout=None,
raise_error=True):
result = AsyncResult()
conn = self._get_connection(block=block, timeout=timeout)
try:
self._response_queues[conn].append(result)
conn.multipublish(topic, messages)
finally:
self._put_connection(conn)
if raise_error:
return result.get()
return result | [
"def",
"multipublish",
"(",
"self",
",",
"topic",
",",
"messages",
",",
"block",
"=",
"True",
",",
"timeout",
"=",
"None",
",",
"raise_error",
"=",
"True",
")",
":",
"result",
"=",
"AsyncResult",
"(",
")",
"conn",
"=",
"self",
".",
"_get_connection",
"... | Publish an iterable of messages to the given topic.
:param topic: the topic to publish to
:param messages: iterable of bytestrings to publish
:param block: wait for a connection to become available before
publishing the message. If block is `False` and no connections
are available, :class:`~gnsq.errors.NSQNoConnections` is raised
:param timeout: if timeout is a positive number, it blocks at most
``timeout`` seconds before raising
:class:`~gnsq.errors.NSQNoConnections`
:param raise_error: if ``True``, it blocks until a response is received
from the nsqd server, and any error response is raised. Otherwise
an :class:`~gevent.event.AsyncResult` is returned | [
"Publish",
"an",
"iterable",
"of",
"messages",
"to",
"the",
"given",
"topic",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/producer.py#L289-L321 |
6,042 | wtolson/gnsq | gnsq/lookupd.py | LookupdClient.lookup | def lookup(self, topic):
"""Returns producers for a topic."""
nsq.assert_valid_topic_name(topic)
return self._request('GET', '/lookup', fields={'topic': topic}) | python | def lookup(self, topic):
nsq.assert_valid_topic_name(topic)
return self._request('GET', '/lookup', fields={'topic': topic}) | [
"def",
"lookup",
"(",
"self",
",",
"topic",
")",
":",
"nsq",
".",
"assert_valid_topic_name",
"(",
"topic",
")",
"return",
"self",
".",
"_request",
"(",
"'GET'",
",",
"'/lookup'",
",",
"fields",
"=",
"{",
"'topic'",
":",
"topic",
"}",
")"
] | Returns producers for a topic. | [
"Returns",
"producers",
"for",
"a",
"topic",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/lookupd.py#L26-L29 |
6,043 | wtolson/gnsq | gnsq/lookupd.py | LookupdClient.channels | def channels(self, topic):
"""Returns all known channels of a topic."""
nsq.assert_valid_topic_name(topic)
return self._request('GET', '/channels', fields={'topic': topic}) | python | def channels(self, topic):
nsq.assert_valid_topic_name(topic)
return self._request('GET', '/channels', fields={'topic': topic}) | [
"def",
"channels",
"(",
"self",
",",
"topic",
")",
":",
"nsq",
".",
"assert_valid_topic_name",
"(",
"topic",
")",
"return",
"self",
".",
"_request",
"(",
"'GET'",
",",
"'/channels'",
",",
"fields",
"=",
"{",
"'topic'",
":",
"topic",
"}",
")"
] | Returns all known channels of a topic. | [
"Returns",
"all",
"known",
"channels",
"of",
"a",
"topic",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/lookupd.py#L35-L38 |
6,044 | wtolson/gnsq | gnsq/lookupd.py | LookupdClient.tombstone_topic | def tombstone_topic(self, topic, node):
"""Tombstones a specific producer of an existing topic."""
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/tombstone',
fields={'topic': topic, 'node': node}) | python | def tombstone_topic(self, topic, node):
nsq.assert_valid_topic_name(topic)
return self._request('POST', '/topic/tombstone',
fields={'topic': topic, 'node': node}) | [
"def",
"tombstone_topic",
"(",
"self",
",",
"topic",
",",
"node",
")",
":",
"nsq",
".",
"assert_valid_topic_name",
"(",
"topic",
")",
"return",
"self",
".",
"_request",
"(",
"'POST'",
",",
"'/topic/tombstone'",
",",
"fields",
"=",
"{",
"'topic'",
":",
"top... | Tombstones a specific producer of an existing topic. | [
"Tombstones",
"a",
"specific",
"producer",
"of",
"an",
"existing",
"topic",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/lookupd.py#L68-L72 |
6,045 | wtolson/gnsq | gnsq/decorators.py | deprecated | def deprecated(fn):
"""Mark a function as deprecated and warn the user on use."""
@functools.wraps(fn)
def wrapper(*args, **kwargs):
warnings.warn(fn.__doc__.split('\n')[0],
category=DeprecationWarning, stacklevel=2)
return fn(*args, **kwargs)
return wrapper | python | def deprecated(fn):
@functools.wraps(fn)
def wrapper(*args, **kwargs):
warnings.warn(fn.__doc__.split('\n')[0],
category=DeprecationWarning, stacklevel=2)
return fn(*args, **kwargs)
return wrapper | [
"def",
"deprecated",
"(",
"fn",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"fn",
")",
"def",
"wrapper",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"warnings",
".",
"warn",
"(",
"fn",
".",
"__doc__",
".",
"split",
"(",
"'\\n'",
")",
... | Mark a function as deprecated and warn the user on use. | [
"Mark",
"a",
"function",
"as",
"deprecated",
"and",
"warn",
"the",
"user",
"on",
"use",
"."
] | 0fd02578b2c9c5fa30626d78579db2a46c10edac | https://github.com/wtolson/gnsq/blob/0fd02578b2c9c5fa30626d78579db2a46c10edac/gnsq/decorators.py#L26-L33 |
6,046 | llllllllll/codetransformer | codetransformer/core.py | _new_lnotab | def _new_lnotab(instrs, lnotab):
"""The updated lnotab after the instructions have been transformed.
Parameters
----------
instrs : iterable[Instruction]
The new instructions.
lnotab : dict[Instruction -> int]
The lnotab for the old code object.
Returns
-------
new_lnotab : dict[Instruction -> int]
The post transform lnotab.
"""
return {
lno: _a_if_not_none(instr._stolen_by, instr)
for lno, instr in lnotab.items()
} | python | def _new_lnotab(instrs, lnotab):
return {
lno: _a_if_not_none(instr._stolen_by, instr)
for lno, instr in lnotab.items()
} | [
"def",
"_new_lnotab",
"(",
"instrs",
",",
"lnotab",
")",
":",
"return",
"{",
"lno",
":",
"_a_if_not_none",
"(",
"instr",
".",
"_stolen_by",
",",
"instr",
")",
"for",
"lno",
",",
"instr",
"in",
"lnotab",
".",
"items",
"(",
")",
"}"
] | The updated lnotab after the instructions have been transformed.
Parameters
----------
instrs : iterable[Instruction]
The new instructions.
lnotab : dict[Instruction -> int]
The lnotab for the old code object.
Returns
-------
new_lnotab : dict[Instruction -> int]
The post transform lnotab. | [
"The",
"updated",
"lnotab",
"after",
"the",
"instructions",
"have",
"been",
"transformed",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/core.py#L32-L50 |
6,047 | llllllllll/codetransformer | codetransformer/core.py | CodeTransformer.transform_consts | def transform_consts(self, consts):
"""transformer for the co_consts field.
Override this method to transform the `co_consts` of the code object.
Parameters
----------
consts : tuple
The co_consts
Returns
-------
new_consts : tuple
The new constants.
"""
return tuple(
self.transform(Code.from_pycode(const)).to_pycode()
if isinstance(const, CodeType) else
const
for const in consts
) | python | def transform_consts(self, consts):
return tuple(
self.transform(Code.from_pycode(const)).to_pycode()
if isinstance(const, CodeType) else
const
for const in consts
) | [
"def",
"transform_consts",
"(",
"self",
",",
"consts",
")",
":",
"return",
"tuple",
"(",
"self",
".",
"transform",
"(",
"Code",
".",
"from_pycode",
"(",
"const",
")",
")",
".",
"to_pycode",
"(",
")",
"if",
"isinstance",
"(",
"const",
",",
"CodeType",
"... | transformer for the co_consts field.
Override this method to transform the `co_consts` of the code object.
Parameters
----------
consts : tuple
The co_consts
Returns
-------
new_consts : tuple
The new constants. | [
"transformer",
"for",
"the",
"co_consts",
"field",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/core.py#L104-L124 |
6,048 | llllllllll/codetransformer | codetransformer/core.py | CodeTransformer.transform | def transform(self, code, *, name=None, filename=None):
"""Transform a codetransformer.Code object applying the transforms.
Parameters
----------
code : Code
The code object to transform.
name : str, optional
The new name for this code object.
filename : str, optional
The new filename for this code object.
Returns
-------
new_code : Code
The transformed code object.
"""
# reverse lookups from for constants and names.
reversed_consts = {}
reversed_names = {}
reversed_varnames = {}
for instr in code:
if isinstance(instr, LOAD_CONST):
reversed_consts[instr] = instr.arg
if instr.uses_name:
reversed_names[instr] = instr.arg
if isinstance(instr, (STORE_FAST, LOAD_FAST)):
reversed_varnames[instr] = instr.arg
instrs, consts = tuple(zip(*reversed_consts.items())) or ((), ())
for instr, const in zip(instrs, self.transform_consts(consts)):
instr.arg = const
instrs, names = tuple(zip(*reversed_names.items())) or ((), ())
for instr, name_ in zip(instrs, self.transform_names(names)):
instr.arg = name_
instrs, varnames = tuple(zip(*reversed_varnames.items())) or ((), ())
for instr, varname in zip(instrs, self.transform_varnames(varnames)):
instr.arg = varname
with self._new_context(code):
post_transform = self.patterndispatcher(code)
return Code(
post_transform,
code.argnames,
cellvars=self.transform_cellvars(code.cellvars),
freevars=self.transform_freevars(code.freevars),
name=name if name is not None else code.name,
filename=filename if filename is not None else code.filename,
firstlineno=code.firstlineno,
lnotab=_new_lnotab(post_transform, code.lnotab),
flags=code.flags,
) | python | def transform(self, code, *, name=None, filename=None):
# reverse lookups from for constants and names.
reversed_consts = {}
reversed_names = {}
reversed_varnames = {}
for instr in code:
if isinstance(instr, LOAD_CONST):
reversed_consts[instr] = instr.arg
if instr.uses_name:
reversed_names[instr] = instr.arg
if isinstance(instr, (STORE_FAST, LOAD_FAST)):
reversed_varnames[instr] = instr.arg
instrs, consts = tuple(zip(*reversed_consts.items())) or ((), ())
for instr, const in zip(instrs, self.transform_consts(consts)):
instr.arg = const
instrs, names = tuple(zip(*reversed_names.items())) or ((), ())
for instr, name_ in zip(instrs, self.transform_names(names)):
instr.arg = name_
instrs, varnames = tuple(zip(*reversed_varnames.items())) or ((), ())
for instr, varname in zip(instrs, self.transform_varnames(varnames)):
instr.arg = varname
with self._new_context(code):
post_transform = self.patterndispatcher(code)
return Code(
post_transform,
code.argnames,
cellvars=self.transform_cellvars(code.cellvars),
freevars=self.transform_freevars(code.freevars),
name=name if name is not None else code.name,
filename=filename if filename is not None else code.filename,
firstlineno=code.firstlineno,
lnotab=_new_lnotab(post_transform, code.lnotab),
flags=code.flags,
) | [
"def",
"transform",
"(",
"self",
",",
"code",
",",
"*",
",",
"name",
"=",
"None",
",",
"filename",
"=",
"None",
")",
":",
"# reverse lookups from for constants and names.",
"reversed_consts",
"=",
"{",
"}",
"reversed_names",
"=",
"{",
"}",
"reversed_varnames",
... | Transform a codetransformer.Code object applying the transforms.
Parameters
----------
code : Code
The code object to transform.
name : str, optional
The new name for this code object.
filename : str, optional
The new filename for this code object.
Returns
-------
new_code : Code
The transformed code object. | [
"Transform",
"a",
"codetransformer",
".",
"Code",
"object",
"applying",
"the",
"transforms",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/core.py#L150-L204 |
6,049 | llllllllll/codetransformer | codetransformer/utils/pretty.py | pformat_ast | def pformat_ast(node,
include_attributes=INCLUDE_ATTRIBUTES_DEFAULT,
indent=INDENT_DEFAULT):
"""
Pretty-format an AST tree element
Parameters
----------
node : ast.AST
Top-level node to render.
include_attributes : bool, optional
Whether to include node attributes. Default False.
indent : str, optional.
Indentation string for nested expressions. Default is two spaces.
"""
def _fmt(node, prefix, level):
def with_indent(*strs):
return ''.join(((indent * level,) + strs))
with_prefix = partial(with_indent, prefix)
if isinstance(node, Name):
# Special Case:
# Render Name nodes on a single line.
yield with_prefix(
type(node).__name__,
'(id=',
repr(node.id),
', ctx=',
type(node.ctx).__name__,
'()),',
)
elif isinstance(node, Num):
# Special Case:
# Render Num nodes on a single line without names.
yield with_prefix(
type(node).__name__,
'(%r),' % node.n,
)
elif isinstance(node, AST):
fields_attrs = list(
chain(
iter_fields(node),
iter_attributes(node) if include_attributes else (),
)
)
if not fields_attrs:
# Special Case:
# Render the whole expression on one line if there are no
# attributes.
yield with_prefix(type(node).__name__, '(),')
return
yield with_prefix(type(node).__name__, '(')
for name, value in fields_attrs:
yield from _fmt(value, name + '=', level + 1)
# Put a trailing comma if we're not at the top level.
yield with_indent(')', ',' if level > 0 else '')
elif isinstance(node, list):
if not node:
# Special Case:
# Render empty lists on one line.
yield with_prefix('[],')
return
yield with_prefix('[')
yield from chain.from_iterable(
map(partial(_fmt, prefix='', level=level + 1), node)
)
yield with_indent('],')
else:
yield with_prefix(repr(node), ',')
return '\n'.join(_fmt(node, prefix='', level=0)) | python | def pformat_ast(node,
include_attributes=INCLUDE_ATTRIBUTES_DEFAULT,
indent=INDENT_DEFAULT):
def _fmt(node, prefix, level):
def with_indent(*strs):
return ''.join(((indent * level,) + strs))
with_prefix = partial(with_indent, prefix)
if isinstance(node, Name):
# Special Case:
# Render Name nodes on a single line.
yield with_prefix(
type(node).__name__,
'(id=',
repr(node.id),
', ctx=',
type(node.ctx).__name__,
'()),',
)
elif isinstance(node, Num):
# Special Case:
# Render Num nodes on a single line without names.
yield with_prefix(
type(node).__name__,
'(%r),' % node.n,
)
elif isinstance(node, AST):
fields_attrs = list(
chain(
iter_fields(node),
iter_attributes(node) if include_attributes else (),
)
)
if not fields_attrs:
# Special Case:
# Render the whole expression on one line if there are no
# attributes.
yield with_prefix(type(node).__name__, '(),')
return
yield with_prefix(type(node).__name__, '(')
for name, value in fields_attrs:
yield from _fmt(value, name + '=', level + 1)
# Put a trailing comma if we're not at the top level.
yield with_indent(')', ',' if level > 0 else '')
elif isinstance(node, list):
if not node:
# Special Case:
# Render empty lists on one line.
yield with_prefix('[],')
return
yield with_prefix('[')
yield from chain.from_iterable(
map(partial(_fmt, prefix='', level=level + 1), node)
)
yield with_indent('],')
else:
yield with_prefix(repr(node), ',')
return '\n'.join(_fmt(node, prefix='', level=0)) | [
"def",
"pformat_ast",
"(",
"node",
",",
"include_attributes",
"=",
"INCLUDE_ATTRIBUTES_DEFAULT",
",",
"indent",
"=",
"INDENT_DEFAULT",
")",
":",
"def",
"_fmt",
"(",
"node",
",",
"prefix",
",",
"level",
")",
":",
"def",
"with_indent",
"(",
"*",
"strs",
")",
... | Pretty-format an AST tree element
Parameters
----------
node : ast.AST
Top-level node to render.
include_attributes : bool, optional
Whether to include node attributes. Default False.
indent : str, optional.
Indentation string for nested expressions. Default is two spaces. | [
"Pretty",
"-",
"format",
"an",
"AST",
"tree",
"element"
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/utils/pretty.py#L31-L108 |
6,050 | llllllllll/codetransformer | codetransformer/utils/pretty.py | pprint_ast | def pprint_ast(node,
include_attributes=INCLUDE_ATTRIBUTES_DEFAULT,
indent=INDENT_DEFAULT,
file=None):
"""
Pretty-print an AST tree.
Parameters
----------
node : ast.AST
Top-level node to render.
include_attributes : bool, optional
Whether to include node attributes. Default False.
indent : str, optional.
Indentation string for nested expressions. Default is two spaces.
file : None or file-like object, optional
File to use to print output. If the default of `None` is passed, we
use sys.stdout.
"""
if file is None:
file = sys.stdout
print(
pformat_ast(
node,
include_attributes=include_attributes,
indent=indent
),
file=file,
) | python | def pprint_ast(node,
include_attributes=INCLUDE_ATTRIBUTES_DEFAULT,
indent=INDENT_DEFAULT,
file=None):
if file is None:
file = sys.stdout
print(
pformat_ast(
node,
include_attributes=include_attributes,
indent=indent
),
file=file,
) | [
"def",
"pprint_ast",
"(",
"node",
",",
"include_attributes",
"=",
"INCLUDE_ATTRIBUTES_DEFAULT",
",",
"indent",
"=",
"INDENT_DEFAULT",
",",
"file",
"=",
"None",
")",
":",
"if",
"file",
"is",
"None",
":",
"file",
"=",
"sys",
".",
"stdout",
"print",
"(",
"pfo... | Pretty-print an AST tree.
Parameters
----------
node : ast.AST
Top-level node to render.
include_attributes : bool, optional
Whether to include node attributes. Default False.
indent : str, optional.
Indentation string for nested expressions. Default is two spaces.
file : None or file-like object, optional
File to use to print output. If the default of `None` is passed, we
use sys.stdout. | [
"Pretty",
"-",
"print",
"an",
"AST",
"tree",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/utils/pretty.py#L117-L146 |
6,051 | llllllllll/codetransformer | codetransformer/utils/pretty.py | walk_code | def walk_code(co, _prefix=''):
"""
Traverse a code object, finding all consts which are also code objects.
Yields pairs of (name, code object).
"""
name = _prefix + co.co_name
yield name, co
yield from chain.from_iterable(
walk_code(c, _prefix=_extend_name(name, co))
for c in co.co_consts
if isinstance(c, CodeType)
) | python | def walk_code(co, _prefix=''):
name = _prefix + co.co_name
yield name, co
yield from chain.from_iterable(
walk_code(c, _prefix=_extend_name(name, co))
for c in co.co_consts
if isinstance(c, CodeType)
) | [
"def",
"walk_code",
"(",
"co",
",",
"_prefix",
"=",
"''",
")",
":",
"name",
"=",
"_prefix",
"+",
"co",
".",
"co_name",
"yield",
"name",
",",
"co",
"yield",
"from",
"chain",
".",
"from_iterable",
"(",
"walk_code",
"(",
"c",
",",
"_prefix",
"=",
"_exte... | Traverse a code object, finding all consts which are also code objects.
Yields pairs of (name, code object). | [
"Traverse",
"a",
"code",
"object",
"finding",
"all",
"consts",
"which",
"are",
"also",
"code",
"objects",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/utils/pretty.py#L149-L161 |
6,052 | llllllllll/codetransformer | codetransformer/utils/pretty.py | a | def a(text, mode='exec', indent=' ', file=None):
"""
Interactive convenience for displaying the AST of a code string.
Writes a pretty-formatted AST-tree to `file`.
Parameters
----------
text : str
Text of Python code to render as AST.
mode : {'exec', 'eval'}, optional
Mode for `ast.parse`. Default is 'exec'.
indent : str, optional
String to use for indenting nested expressions. Default is two spaces.
file : None or file-like object, optional
File to use to print output. If the default of `None` is passed, we
use sys.stdout.
"""
pprint_ast(parse(text, mode=mode), indent=indent, file=file) | python | def a(text, mode='exec', indent=' ', file=None):
pprint_ast(parse(text, mode=mode), indent=indent, file=file) | [
"def",
"a",
"(",
"text",
",",
"mode",
"=",
"'exec'",
",",
"indent",
"=",
"' '",
",",
"file",
"=",
"None",
")",
":",
"pprint_ast",
"(",
"parse",
"(",
"text",
",",
"mode",
"=",
"mode",
")",
",",
"indent",
"=",
"indent",
",",
"file",
"=",
"file",
... | Interactive convenience for displaying the AST of a code string.
Writes a pretty-formatted AST-tree to `file`.
Parameters
----------
text : str
Text of Python code to render as AST.
mode : {'exec', 'eval'}, optional
Mode for `ast.parse`. Default is 'exec'.
indent : str, optional
String to use for indenting nested expressions. Default is two spaces.
file : None or file-like object, optional
File to use to print output. If the default of `None` is passed, we
use sys.stdout. | [
"Interactive",
"convenience",
"for",
"displaying",
"the",
"AST",
"of",
"a",
"code",
"string",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/utils/pretty.py#L172-L190 |
6,053 | llllllllll/codetransformer | codetransformer/utils/pretty.py | d | def d(obj, mode='exec', file=None):
"""
Interactive convenience for displaying the disassembly of a function,
module, or code string.
Compiles `text` and recursively traverses the result looking for `code`
objects to render with `dis.dis`.
Parameters
----------
obj : str, CodeType, or object with __code__ attribute
Object to disassemble.
If `obj` is an instance of CodeType, we use it unchanged.
If `obj` is a string, we compile it with `mode` and then disassemble.
Otherwise, we look for a `__code__` attribute on `obj`.
mode : {'exec', 'eval'}, optional
Mode for `compile`. Default is 'exec'.
file : None or file-like object, optional
File to use to print output. If the default of `None` is passed, we
use sys.stdout.
"""
if file is None:
file = sys.stdout
for name, co in walk_code(extract_code(obj, compile_mode=mode)):
print(name, file=file)
print('-' * len(name), file=file)
dis.dis(co, file=file)
print('', file=file) | python | def d(obj, mode='exec', file=None):
if file is None:
file = sys.stdout
for name, co in walk_code(extract_code(obj, compile_mode=mode)):
print(name, file=file)
print('-' * len(name), file=file)
dis.dis(co, file=file)
print('', file=file) | [
"def",
"d",
"(",
"obj",
",",
"mode",
"=",
"'exec'",
",",
"file",
"=",
"None",
")",
":",
"if",
"file",
"is",
"None",
":",
"file",
"=",
"sys",
".",
"stdout",
"for",
"name",
",",
"co",
"in",
"walk_code",
"(",
"extract_code",
"(",
"obj",
",",
"compil... | Interactive convenience for displaying the disassembly of a function,
module, or code string.
Compiles `text` and recursively traverses the result looking for `code`
objects to render with `dis.dis`.
Parameters
----------
obj : str, CodeType, or object with __code__ attribute
Object to disassemble.
If `obj` is an instance of CodeType, we use it unchanged.
If `obj` is a string, we compile it with `mode` and then disassemble.
Otherwise, we look for a `__code__` attribute on `obj`.
mode : {'exec', 'eval'}, optional
Mode for `compile`. Default is 'exec'.
file : None or file-like object, optional
File to use to print output. If the default of `None` is passed, we
use sys.stdout. | [
"Interactive",
"convenience",
"for",
"displaying",
"the",
"disassembly",
"of",
"a",
"function",
"module",
"or",
"code",
"string",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/utils/pretty.py#L193-L221 |
6,054 | llllllllll/codetransformer | codetransformer/utils/pretty.py | extract_code | def extract_code(obj, compile_mode):
"""
Generic function for converting objects into instances of `CodeType`.
"""
try:
code = obj.__code__
if isinstance(code, CodeType):
return code
raise ValueError(
"{obj} has a `__code__` attribute, "
"but it's an instance of {notcode!r}, not CodeType.".format(
obj=obj,
notcode=type(code).__name__,
)
)
except AttributeError:
raise ValueError("Don't know how to extract code from %s." % obj) | python | def extract_code(obj, compile_mode):
try:
code = obj.__code__
if isinstance(code, CodeType):
return code
raise ValueError(
"{obj} has a `__code__` attribute, "
"but it's an instance of {notcode!r}, not CodeType.".format(
obj=obj,
notcode=type(code).__name__,
)
)
except AttributeError:
raise ValueError("Don't know how to extract code from %s." % obj) | [
"def",
"extract_code",
"(",
"obj",
",",
"compile_mode",
")",
":",
"try",
":",
"code",
"=",
"obj",
".",
"__code__",
"if",
"isinstance",
"(",
"code",
",",
"CodeType",
")",
":",
"return",
"code",
"raise",
"ValueError",
"(",
"\"{obj} has a `__code__` attribute, \"... | Generic function for converting objects into instances of `CodeType`. | [
"Generic",
"function",
"for",
"converting",
"objects",
"into",
"instances",
"of",
"CodeType",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/utils/pretty.py#L225-L241 |
6,055 | llllllllll/codetransformer | codetransformer/utils/pretty.py | display | def display(text, mode='exec', file=None):
"""
Show `text`, rendered as AST and as Bytecode.
Parameters
----------
text : str
Text of Python code to render.
mode : {'exec', 'eval'}, optional
Mode for `ast.parse` and `compile`. Default is 'exec'.
file : None or file-like object, optional
File to use to print output. If the default of `None` is passed, we
use sys.stdout.
"""
if file is None:
file = sys.stdout
ast_section = StringIO()
a(text, mode=mode, file=ast_section)
code_section = StringIO()
d(text, mode=mode, file=code_section)
rendered = _DISPLAY_TEMPLATE.format(
text=text,
ast=ast_section.getvalue(),
code=code_section.getvalue(),
)
print(rendered, file=file) | python | def display(text, mode='exec', file=None):
if file is None:
file = sys.stdout
ast_section = StringIO()
a(text, mode=mode, file=ast_section)
code_section = StringIO()
d(text, mode=mode, file=code_section)
rendered = _DISPLAY_TEMPLATE.format(
text=text,
ast=ast_section.getvalue(),
code=code_section.getvalue(),
)
print(rendered, file=file) | [
"def",
"display",
"(",
"text",
",",
"mode",
"=",
"'exec'",
",",
"file",
"=",
"None",
")",
":",
"if",
"file",
"is",
"None",
":",
"file",
"=",
"sys",
".",
"stdout",
"ast_section",
"=",
"StringIO",
"(",
")",
"a",
"(",
"text",
",",
"mode",
"=",
"mode... | Show `text`, rendered as AST and as Bytecode.
Parameters
----------
text : str
Text of Python code to render.
mode : {'exec', 'eval'}, optional
Mode for `ast.parse` and `compile`. Default is 'exec'.
file : None or file-like object, optional
File to use to print output. If the default of `None` is passed, we
use sys.stdout. | [
"Show",
"text",
"rendered",
"as",
"AST",
"and",
"as",
"Bytecode",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/utils/pretty.py#L275-L304 |
6,056 | llllllllll/codetransformer | codetransformer/transformers/pattern_matched_exceptions.py | match | def match(match_expr, exc_type, exc_value, exc_traceback):
"""
Called to determine whether or not an except block should be matched.
True -> enter except block
False -> don't enter except block
"""
# Emulate standard behavior when match_expr is an exception subclass.
if isinstance(match_expr, type) and issubclass(match_expr, BaseException):
return issubclass(exc_type, match_expr)
# Match on type and args when match_expr is an exception instance.
return (
issubclass(exc_type, type(match_expr))
and
match_expr.args == exc_value.args
) | python | def match(match_expr, exc_type, exc_value, exc_traceback):
# Emulate standard behavior when match_expr is an exception subclass.
if isinstance(match_expr, type) and issubclass(match_expr, BaseException):
return issubclass(exc_type, match_expr)
# Match on type and args when match_expr is an exception instance.
return (
issubclass(exc_type, type(match_expr))
and
match_expr.args == exc_value.args
) | [
"def",
"match",
"(",
"match_expr",
",",
"exc_type",
",",
"exc_value",
",",
"exc_traceback",
")",
":",
"# Emulate standard behavior when match_expr is an exception subclass.",
"if",
"isinstance",
"(",
"match_expr",
",",
"type",
")",
"and",
"issubclass",
"(",
"match_expr"... | Called to determine whether or not an except block should be matched.
True -> enter except block
False -> don't enter except block | [
"Called",
"to",
"determine",
"whether",
"or",
"not",
"an",
"except",
"block",
"should",
"be",
"matched",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/transformers/pattern_matched_exceptions.py#L15-L31 |
6,057 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | decompile | def decompile(f):
"""
Decompile a function.
Parameters
----------
f : function
The function to decompile.
Returns
-------
ast : ast.FunctionDef
A FunctionDef node that compiles to f.
"""
co = f.__code__
args, kwonly, varargs, varkwargs = paramnames(co)
annotations = f.__annotations__ or {}
defaults = list(f.__defaults__ or ())
kw_defaults = f.__kwdefaults__ or {}
if f.__name__ == '<lambda>':
node = ast.Lambda
body = pycode_to_body(co, DecompilationContext(in_lambda=True))[0]
extra_kwargs = {}
else:
node = ast.FunctionDef
body = pycode_to_body(co, DecompilationContext(in_function_block=True))
extra_kwargs = {
'decorator_list': [],
'returns': annotations.get('return')
}
return node(
name=f.__name__,
args=make_function_arguments(
args=args,
kwonly=kwonly,
varargs=varargs,
varkwargs=varkwargs,
defaults=defaults,
kw_defaults=kw_defaults,
annotations=annotations,
),
body=body,
**extra_kwargs
) | python | def decompile(f):
co = f.__code__
args, kwonly, varargs, varkwargs = paramnames(co)
annotations = f.__annotations__ or {}
defaults = list(f.__defaults__ or ())
kw_defaults = f.__kwdefaults__ or {}
if f.__name__ == '<lambda>':
node = ast.Lambda
body = pycode_to_body(co, DecompilationContext(in_lambda=True))[0]
extra_kwargs = {}
else:
node = ast.FunctionDef
body = pycode_to_body(co, DecompilationContext(in_function_block=True))
extra_kwargs = {
'decorator_list': [],
'returns': annotations.get('return')
}
return node(
name=f.__name__,
args=make_function_arguments(
args=args,
kwonly=kwonly,
varargs=varargs,
varkwargs=varkwargs,
defaults=defaults,
kw_defaults=kw_defaults,
annotations=annotations,
),
body=body,
**extra_kwargs
) | [
"def",
"decompile",
"(",
"f",
")",
":",
"co",
"=",
"f",
".",
"__code__",
"args",
",",
"kwonly",
",",
"varargs",
",",
"varkwargs",
"=",
"paramnames",
"(",
"co",
")",
"annotations",
"=",
"f",
".",
"__annotations__",
"or",
"{",
"}",
"defaults",
"=",
"li... | Decompile a function.
Parameters
----------
f : function
The function to decompile.
Returns
-------
ast : ast.FunctionDef
A FunctionDef node that compiles to f. | [
"Decompile",
"a",
"function",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L52-L97 |
6,058 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | pycode_to_body | def pycode_to_body(co, context):
"""
Convert a Python code object to a list of AST body elements.
"""
code = Code.from_pycode(co)
# On each instruction, temporarily store all the jumps to the **next**
# instruction. This is used in _make_expr to determine when an expression
# is part of a short-circuiting expression.
for a, b in sliding_window(2, code.instrs):
a._next_target_of = b._target_of
b._next_target_of = set()
try:
body = instrs_to_body(deque(code.instrs), context)
if context.in_function_block:
return make_global_and_nonlocal_decls(code.instrs) + body
return body
finally:
# Clean up jump target data.
for i in code.instrs:
del i._next_target_of | python | def pycode_to_body(co, context):
code = Code.from_pycode(co)
# On each instruction, temporarily store all the jumps to the **next**
# instruction. This is used in _make_expr to determine when an expression
# is part of a short-circuiting expression.
for a, b in sliding_window(2, code.instrs):
a._next_target_of = b._target_of
b._next_target_of = set()
try:
body = instrs_to_body(deque(code.instrs), context)
if context.in_function_block:
return make_global_and_nonlocal_decls(code.instrs) + body
return body
finally:
# Clean up jump target data.
for i in code.instrs:
del i._next_target_of | [
"def",
"pycode_to_body",
"(",
"co",
",",
"context",
")",
":",
"code",
"=",
"Code",
".",
"from_pycode",
"(",
"co",
")",
"# On each instruction, temporarily store all the jumps to the **next**",
"# instruction. This is used in _make_expr to determine when an expression",
"# is par... | Convert a Python code object to a list of AST body elements. | [
"Convert",
"a",
"Python",
"code",
"object",
"to",
"a",
"list",
"of",
"AST",
"body",
"elements",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L100-L121 |
6,059 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | instrs_to_body | def instrs_to_body(instrs, context):
"""
Convert a list of Instruction objects to a list of AST body nodes.
"""
stack = []
body = []
process_instrs(instrs, stack, body, context)
if stack:
raise DecompilationError(
"Non-empty stack at the end of instrs_to_body(): %s." % stack
)
return body | python | def instrs_to_body(instrs, context):
stack = []
body = []
process_instrs(instrs, stack, body, context)
if stack:
raise DecompilationError(
"Non-empty stack at the end of instrs_to_body(): %s." % stack
)
return body | [
"def",
"instrs_to_body",
"(",
"instrs",
",",
"context",
")",
":",
"stack",
"=",
"[",
"]",
"body",
"=",
"[",
"]",
"process_instrs",
"(",
"instrs",
",",
"stack",
",",
"body",
",",
"context",
")",
"if",
"stack",
":",
"raise",
"DecompilationError",
"(",
"\... | Convert a list of Instruction objects to a list of AST body nodes. | [
"Convert",
"a",
"list",
"of",
"Instruction",
"objects",
"to",
"a",
"list",
"of",
"AST",
"body",
"nodes",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L124-L136 |
6,060 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | process_instrs | def process_instrs(queue, stack, body, context):
"""
Process instructions from the instruction queue.
"""
next_instr = queue.popleft
while queue:
newcontext = _process_instr(next_instr(), queue, stack, body, context)
if newcontext is not None:
context = newcontext | python | def process_instrs(queue, stack, body, context):
next_instr = queue.popleft
while queue:
newcontext = _process_instr(next_instr(), queue, stack, body, context)
if newcontext is not None:
context = newcontext | [
"def",
"process_instrs",
"(",
"queue",
",",
"stack",
",",
"body",
",",
"context",
")",
":",
"next_instr",
"=",
"queue",
".",
"popleft",
"while",
"queue",
":",
"newcontext",
"=",
"_process_instr",
"(",
"next_instr",
"(",
")",
",",
"queue",
",",
"stack",
"... | Process instructions from the instruction queue. | [
"Process",
"instructions",
"from",
"the",
"instruction",
"queue",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L139-L147 |
6,061 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_if_statement | def make_if_statement(instr, queue, stack, context):
"""
Make an ast.If block from a POP_JUMP_IF_TRUE or POP_JUMP_IF_FALSE.
"""
test_expr = make_expr(stack)
if isinstance(instr, instrs.POP_JUMP_IF_TRUE):
test_expr = ast.UnaryOp(op=ast.Not(), operand=test_expr)
first_block = popwhile(op.is_not(instr.arg), queue, side='left')
if isinstance(first_block[-1], instrs.RETURN_VALUE):
body = instrs_to_body(first_block, context)
return ast.If(test=test_expr, body=body, orelse=[])
jump_to_end = expect(
first_block.pop(), instrs.JUMP_FORWARD, "at end of if-block"
)
body = instrs_to_body(first_block, context)
# First instruction after the whole if-block.
end = jump_to_end.arg
if instr.arg is jump_to_end.arg:
orelse = []
else:
orelse = instrs_to_body(
popwhile(op.is_not(end), queue, side='left'),
context,
)
return ast.If(test=test_expr, body=body, orelse=orelse) | python | def make_if_statement(instr, queue, stack, context):
test_expr = make_expr(stack)
if isinstance(instr, instrs.POP_JUMP_IF_TRUE):
test_expr = ast.UnaryOp(op=ast.Not(), operand=test_expr)
first_block = popwhile(op.is_not(instr.arg), queue, side='left')
if isinstance(first_block[-1], instrs.RETURN_VALUE):
body = instrs_to_body(first_block, context)
return ast.If(test=test_expr, body=body, orelse=[])
jump_to_end = expect(
first_block.pop(), instrs.JUMP_FORWARD, "at end of if-block"
)
body = instrs_to_body(first_block, context)
# First instruction after the whole if-block.
end = jump_to_end.arg
if instr.arg is jump_to_end.arg:
orelse = []
else:
orelse = instrs_to_body(
popwhile(op.is_not(end), queue, side='left'),
context,
)
return ast.If(test=test_expr, body=body, orelse=orelse) | [
"def",
"make_if_statement",
"(",
"instr",
",",
"queue",
",",
"stack",
",",
"context",
")",
":",
"test_expr",
"=",
"make_expr",
"(",
"stack",
")",
"if",
"isinstance",
"(",
"instr",
",",
"instrs",
".",
"POP_JUMP_IF_TRUE",
")",
":",
"test_expr",
"=",
"ast",
... | Make an ast.If block from a POP_JUMP_IF_TRUE or POP_JUMP_IF_FALSE. | [
"Make",
"an",
"ast",
".",
"If",
"block",
"from",
"a",
"POP_JUMP_IF_TRUE",
"or",
"POP_JUMP_IF_FALSE",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L182-L211 |
6,062 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | _process_instr_import_name | def _process_instr_import_name(instr, queue, stack, body, context):
"""
Process an IMPORT_NAME instruction.
Side Effects
------------
Pops two instuctions from `stack`
Consumes instructions from `queue` to the end of the import statement.
Appends an ast.Import or ast.ImportFrom node to `body`.
"""
# If this is "import module", fromlist is None.
# If this this is "from module import a, b fromlist will be ('a', 'b').
fromlist = stack.pop().arg
# level argument to __import__. Should be 0, 1, or 2.
level = stack.pop().arg
module = instr.arg
if fromlist is None: # Regular import.
attr_loads = _pop_import_LOAD_ATTRs(module, queue)
store = queue.popleft()
# There are two cases where we should emit an alias:
# import a as <anything but a>
# import a.b.c as <anything (including a)>
if attr_loads or module.split('.')[0] != store.arg:
asname = store.arg
else:
asname = None
body.append(
ast.Import(
names=[
ast.alias(
name=module,
asname=(asname),
),
],
level=level,
),
)
return
elif fromlist == ('*',): # From module import *.
expect(queue.popleft(), instrs.IMPORT_STAR, "after IMPORT_NAME")
body.append(
ast.ImportFrom(
module=module,
names=[ast.alias(name='*', asname=None)],
level=level,
),
)
return
# Consume a pair of IMPORT_FROM, STORE_NAME instructions for each entry in
# fromlist.
names = list(map(make_importfrom_alias(queue, body, context), fromlist))
body.append(ast.ImportFrom(module=module, names=names, level=level))
# Remove the final POP_TOP of the imported module.
expect(queue.popleft(), instrs.POP_TOP, "after 'from import'") | python | def _process_instr_import_name(instr, queue, stack, body, context):
# If this is "import module", fromlist is None.
# If this this is "from module import a, b fromlist will be ('a', 'b').
fromlist = stack.pop().arg
# level argument to __import__. Should be 0, 1, or 2.
level = stack.pop().arg
module = instr.arg
if fromlist is None: # Regular import.
attr_loads = _pop_import_LOAD_ATTRs(module, queue)
store = queue.popleft()
# There are two cases where we should emit an alias:
# import a as <anything but a>
# import a.b.c as <anything (including a)>
if attr_loads or module.split('.')[0] != store.arg:
asname = store.arg
else:
asname = None
body.append(
ast.Import(
names=[
ast.alias(
name=module,
asname=(asname),
),
],
level=level,
),
)
return
elif fromlist == ('*',): # From module import *.
expect(queue.popleft(), instrs.IMPORT_STAR, "after IMPORT_NAME")
body.append(
ast.ImportFrom(
module=module,
names=[ast.alias(name='*', asname=None)],
level=level,
),
)
return
# Consume a pair of IMPORT_FROM, STORE_NAME instructions for each entry in
# fromlist.
names = list(map(make_importfrom_alias(queue, body, context), fromlist))
body.append(ast.ImportFrom(module=module, names=names, level=level))
# Remove the final POP_TOP of the imported module.
expect(queue.popleft(), instrs.POP_TOP, "after 'from import'") | [
"def",
"_process_instr_import_name",
"(",
"instr",
",",
"queue",
",",
"stack",
",",
"body",
",",
"context",
")",
":",
"# If this is \"import module\", fromlist is None.",
"# If this this is \"from module import a, b fromlist will be ('a', 'b').",
"fromlist",
"=",
"stack",
".",
... | Process an IMPORT_NAME instruction.
Side Effects
------------
Pops two instuctions from `stack`
Consumes instructions from `queue` to the end of the import statement.
Appends an ast.Import or ast.ImportFrom node to `body`. | [
"Process",
"an",
"IMPORT_NAME",
"instruction",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L226-L283 |
6,063 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_importfrom_alias | def make_importfrom_alias(queue, body, context, name):
"""
Make an ast.alias node for the names list of an ast.ImportFrom.
Parameters
----------
queue : deque
Instruction Queue
body : list
Current body.
context : DecompilationContext
name : str
Expected name of the IMPORT_FROM node to be popped.
Returns
-------
alias : ast.alias
Side Effects
------------
Consumes IMPORT_FROM and STORE_NAME instructions from queue.
"""
import_from, store = queue.popleft(), queue.popleft()
expect(import_from, instrs.IMPORT_FROM, "after IMPORT_NAME")
if not import_from.arg == name:
raise DecompilationError(
"IMPORT_FROM name mismatch. Expected %r, but got %s." % (
name, import_from,
)
)
return ast.alias(
name=name,
asname=store.arg if store.arg != name else None,
) | python | def make_importfrom_alias(queue, body, context, name):
import_from, store = queue.popleft(), queue.popleft()
expect(import_from, instrs.IMPORT_FROM, "after IMPORT_NAME")
if not import_from.arg == name:
raise DecompilationError(
"IMPORT_FROM name mismatch. Expected %r, but got %s." % (
name, import_from,
)
)
return ast.alias(
name=name,
asname=store.arg if store.arg != name else None,
) | [
"def",
"make_importfrom_alias",
"(",
"queue",
",",
"body",
",",
"context",
",",
"name",
")",
":",
"import_from",
",",
"store",
"=",
"queue",
".",
"popleft",
"(",
")",
",",
"queue",
".",
"popleft",
"(",
")",
"expect",
"(",
"import_from",
",",
"instrs",
... | Make an ast.alias node for the names list of an ast.ImportFrom.
Parameters
----------
queue : deque
Instruction Queue
body : list
Current body.
context : DecompilationContext
name : str
Expected name of the IMPORT_FROM node to be popped.
Returns
-------
alias : ast.alias
Side Effects
------------
Consumes IMPORT_FROM and STORE_NAME instructions from queue. | [
"Make",
"an",
"ast",
".",
"alias",
"node",
"for",
"the",
"names",
"list",
"of",
"an",
"ast",
".",
"ImportFrom",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L316-L350 |
6,064 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | _make_function | def _make_function(instr, queue, stack, body, context):
"""
Set a make_function_context, then push onto the stack.
"""
assert stack, "Empty stack before MAKE_FUNCTION."
prev = stack[-1]
expect(prev, instrs.LOAD_CONST, "before MAKE_FUNCTION")
stack.append(instr)
if is_lambda_name(prev.arg):
return
return context.update(
make_function_context=MakeFunctionContext(
closure=isinstance(instr, instrs.MAKE_CLOSURE),
)
) | python | def _make_function(instr, queue, stack, body, context):
assert stack, "Empty stack before MAKE_FUNCTION."
prev = stack[-1]
expect(prev, instrs.LOAD_CONST, "before MAKE_FUNCTION")
stack.append(instr)
if is_lambda_name(prev.arg):
return
return context.update(
make_function_context=MakeFunctionContext(
closure=isinstance(instr, instrs.MAKE_CLOSURE),
)
) | [
"def",
"_make_function",
"(",
"instr",
",",
"queue",
",",
"stack",
",",
"body",
",",
"context",
")",
":",
"assert",
"stack",
",",
"\"Empty stack before MAKE_FUNCTION.\"",
"prev",
"=",
"stack",
"[",
"-",
"1",
"]",
"expect",
"(",
"prev",
",",
"instrs",
".",
... | Set a make_function_context, then push onto the stack. | [
"Set",
"a",
"make_function_context",
"then",
"push",
"onto",
"the",
"stack",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L385-L402 |
6,065 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_assignment | def make_assignment(instr, queue, stack):
"""
Make an ast.Assign node.
"""
value = make_expr(stack)
# Make assignment targets.
# If there are multiple assignments (e.g. 'a = b = c'),
# each LHS expression except the last is preceded by a DUP_TOP instruction.
# Thus, we make targets until we don't see a DUP_TOP, and then make one
# more.
targets = []
while isinstance(instr, instrs.DUP_TOP):
targets.append(make_assign_target(queue.popleft(), queue, stack))
instr = queue.popleft()
targets.append(make_assign_target(instr, queue, stack))
return ast.Assign(targets=targets, value=value) | python | def make_assignment(instr, queue, stack):
value = make_expr(stack)
# Make assignment targets.
# If there are multiple assignments (e.g. 'a = b = c'),
# each LHS expression except the last is preceded by a DUP_TOP instruction.
# Thus, we make targets until we don't see a DUP_TOP, and then make one
# more.
targets = []
while isinstance(instr, instrs.DUP_TOP):
targets.append(make_assign_target(queue.popleft(), queue, stack))
instr = queue.popleft()
targets.append(make_assign_target(instr, queue, stack))
return ast.Assign(targets=targets, value=value) | [
"def",
"make_assignment",
"(",
"instr",
",",
"queue",
",",
"stack",
")",
":",
"value",
"=",
"make_expr",
"(",
"stack",
")",
"# Make assignment targets.",
"# If there are multiple assignments (e.g. 'a = b = c'),",
"# each LHS expression except the last is preceded by a DUP_TOP ins... | Make an ast.Assign node. | [
"Make",
"an",
"ast",
".",
"Assign",
"node",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L429-L447 |
6,066 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | pop_with_body_instrs | def pop_with_body_instrs(setup_with_instr, queue):
"""
Pop instructions from `queue` that form the body of a with block.
"""
body_instrs = popwhile(op.is_not(setup_with_instr.arg), queue, side='left')
# Last two instructions should always be POP_BLOCK, LOAD_CONST(None).
# These don't correspond to anything in the AST, so remove them here.
load_none = body_instrs.pop()
expect(load_none, instrs.LOAD_CONST, "at end of with-block")
pop_block = body_instrs.pop()
expect(pop_block, instrs.POP_BLOCK, "at end of with-block")
if load_none.arg is not None:
raise DecompilationError(
"Expected LOAD_CONST(None), but got "
"%r instead" % (load_none)
)
# Target of the setup_with should be a WITH_CLEANUP instruction followed by
# an END_FINALLY. Neither of these correspond to anything in the AST.
with_cleanup = queue.popleft()
expect(with_cleanup, instrs.WITH_CLEANUP, "at end of with-block")
end_finally = queue.popleft()
expect(end_finally, instrs.END_FINALLY, "at end of with-block")
return body_instrs | python | def pop_with_body_instrs(setup_with_instr, queue):
body_instrs = popwhile(op.is_not(setup_with_instr.arg), queue, side='left')
# Last two instructions should always be POP_BLOCK, LOAD_CONST(None).
# These don't correspond to anything in the AST, so remove them here.
load_none = body_instrs.pop()
expect(load_none, instrs.LOAD_CONST, "at end of with-block")
pop_block = body_instrs.pop()
expect(pop_block, instrs.POP_BLOCK, "at end of with-block")
if load_none.arg is not None:
raise DecompilationError(
"Expected LOAD_CONST(None), but got "
"%r instead" % (load_none)
)
# Target of the setup_with should be a WITH_CLEANUP instruction followed by
# an END_FINALLY. Neither of these correspond to anything in the AST.
with_cleanup = queue.popleft()
expect(with_cleanup, instrs.WITH_CLEANUP, "at end of with-block")
end_finally = queue.popleft()
expect(end_finally, instrs.END_FINALLY, "at end of with-block")
return body_instrs | [
"def",
"pop_with_body_instrs",
"(",
"setup_with_instr",
",",
"queue",
")",
":",
"body_instrs",
"=",
"popwhile",
"(",
"op",
".",
"is_not",
"(",
"setup_with_instr",
".",
"arg",
")",
",",
"queue",
",",
"side",
"=",
"'left'",
")",
"# Last two instructions should alw... | Pop instructions from `queue` that form the body of a with block. | [
"Pop",
"instructions",
"from",
"queue",
"that",
"form",
"the",
"body",
"of",
"a",
"with",
"block",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L574-L599 |
6,067 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_withitem | def make_withitem(queue, stack):
"""
Make an ast.withitem node.
"""
context_expr = make_expr(stack)
# This is a POP_TOP for just "with <expr>:".
# This is a STORE_NAME(name) for "with <expr> as <name>:".
as_instr = queue.popleft()
if isinstance(as_instr, (instrs.STORE_FAST,
instrs.STORE_NAME,
instrs.STORE_DEREF,
instrs.STORE_GLOBAL)):
return ast.withitem(
context_expr=context_expr,
optional_vars=make_assign_target(as_instr, queue, stack),
)
elif isinstance(as_instr, instrs.POP_TOP):
return ast.withitem(context_expr=context_expr, optional_vars=None)
else:
raise DecompilationError(
"Don't know how to make withitem from %s" % as_instr,
) | python | def make_withitem(queue, stack):
context_expr = make_expr(stack)
# This is a POP_TOP for just "with <expr>:".
# This is a STORE_NAME(name) for "with <expr> as <name>:".
as_instr = queue.popleft()
if isinstance(as_instr, (instrs.STORE_FAST,
instrs.STORE_NAME,
instrs.STORE_DEREF,
instrs.STORE_GLOBAL)):
return ast.withitem(
context_expr=context_expr,
optional_vars=make_assign_target(as_instr, queue, stack),
)
elif isinstance(as_instr, instrs.POP_TOP):
return ast.withitem(context_expr=context_expr, optional_vars=None)
else:
raise DecompilationError(
"Don't know how to make withitem from %s" % as_instr,
) | [
"def",
"make_withitem",
"(",
"queue",
",",
"stack",
")",
":",
"context_expr",
"=",
"make_expr",
"(",
"stack",
")",
"# This is a POP_TOP for just \"with <expr>:\".",
"# This is a STORE_NAME(name) for \"with <expr> as <name>:\".",
"as_instr",
"=",
"queue",
".",
"popleft",
"("... | Make an ast.withitem node. | [
"Make",
"an",
"ast",
".",
"withitem",
"node",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L602-L623 |
6,068 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_for_loop | def make_for_loop(loop_body_instrs, else_body_instrs, context):
"""
Make an ast.For node.
"""
# Instructions from start until GET_ITER are the builders for the iterator
# expression.
iterator_expr = make_expr(
popwhile(not_a(instrs.GET_ITER), loop_body_instrs, side='left')
)
# Next is the GET_ITER instruction, which we don't need.
loop_body_instrs.popleft()
# Next is FOR_ITER, which is the jump target for Continue nodes.
top_of_loop = loop_body_instrs.popleft()
# This can be a STORE_* or an UNPACK_SEQUENCE followed by some number of
# stores.
target = make_assign_target(
loop_body_instrs.popleft(),
loop_body_instrs,
stack=[],
)
body, orelse_body = make_loop_body_and_orelse(
top_of_loop, loop_body_instrs, else_body_instrs, context
)
return ast.For(
target=target,
iter=iterator_expr,
body=body,
orelse=orelse_body,
) | python | def make_for_loop(loop_body_instrs, else_body_instrs, context):
# Instructions from start until GET_ITER are the builders for the iterator
# expression.
iterator_expr = make_expr(
popwhile(not_a(instrs.GET_ITER), loop_body_instrs, side='left')
)
# Next is the GET_ITER instruction, which we don't need.
loop_body_instrs.popleft()
# Next is FOR_ITER, which is the jump target for Continue nodes.
top_of_loop = loop_body_instrs.popleft()
# This can be a STORE_* or an UNPACK_SEQUENCE followed by some number of
# stores.
target = make_assign_target(
loop_body_instrs.popleft(),
loop_body_instrs,
stack=[],
)
body, orelse_body = make_loop_body_and_orelse(
top_of_loop, loop_body_instrs, else_body_instrs, context
)
return ast.For(
target=target,
iter=iterator_expr,
body=body,
orelse=orelse_body,
) | [
"def",
"make_for_loop",
"(",
"loop_body_instrs",
",",
"else_body_instrs",
",",
"context",
")",
":",
"# Instructions from start until GET_ITER are the builders for the iterator",
"# expression.",
"iterator_expr",
"=",
"make_expr",
"(",
"popwhile",
"(",
"not_a",
"(",
"instrs",
... | Make an ast.For node. | [
"Make",
"an",
"ast",
".",
"For",
"node",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L636-L669 |
6,069 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_while_loop | def make_while_loop(test_and_body_instrs, else_body_instrs, context):
"""
Make an ast.While node.
Parameters
----------
test_and_body_instrs : deque
Queue of instructions forming the loop test expression and body.
else_body_instrs : deque
Queue of instructions forming the else block of the loop.
context : DecompilationContext
"""
top_of_loop = test_and_body_instrs[0]
# The popped elements are the stack_builders for the loop test expression.
# The top of the loop_body_instrs is either a POP_JUMP_IF_TRUE or a
# POP_JUMP_IF_FALSE.
test, body_instrs = make_while_loop_test_expr(test_and_body_instrs)
body, orelse_body = make_loop_body_and_orelse(
top_of_loop, body_instrs, else_body_instrs, context,
)
# while-else blocks are not yet supported or handled.
return ast.While(test=test, body=body, orelse=orelse_body) | python | def make_while_loop(test_and_body_instrs, else_body_instrs, context):
top_of_loop = test_and_body_instrs[0]
# The popped elements are the stack_builders for the loop test expression.
# The top of the loop_body_instrs is either a POP_JUMP_IF_TRUE or a
# POP_JUMP_IF_FALSE.
test, body_instrs = make_while_loop_test_expr(test_and_body_instrs)
body, orelse_body = make_loop_body_and_orelse(
top_of_loop, body_instrs, else_body_instrs, context,
)
# while-else blocks are not yet supported or handled.
return ast.While(test=test, body=body, orelse=orelse_body) | [
"def",
"make_while_loop",
"(",
"test_and_body_instrs",
",",
"else_body_instrs",
",",
"context",
")",
":",
"top_of_loop",
"=",
"test_and_body_instrs",
"[",
"0",
"]",
"# The popped elements are the stack_builders for the loop test expression.",
"# The top of the loop_body_instrs is e... | Make an ast.While node.
Parameters
----------
test_and_body_instrs : deque
Queue of instructions forming the loop test expression and body.
else_body_instrs : deque
Queue of instructions forming the else block of the loop.
context : DecompilationContext | [
"Make",
"an",
"ast",
".",
"While",
"node",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L713-L736 |
6,070 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | pop_loop_instrs | def pop_loop_instrs(setup_loop_instr, queue):
"""
Determine whether setup_loop_instr is setting up a for-loop or a
while-loop. Then pop the loop instructions from queue.
The easiest way to tell the difference is to look at the target of the
JUMP_ABSOLUTE instruction at the end of the loop. If it jumps to a
FOR_ITER, then this is a for-loop. Otherwise it's a while-loop.
The jump we want to inspect is the first JUMP_ABSOLUTE instruction prior to
the jump target of `setup_loop_instr`.
Parameters
----------
setup_loop_instr : instructions.SETUP_LOOP
First instruction of the loop being parsed.
queue : collections.deque
Queue of unprocessed instructions.
Returns
-------
loop_type : str, {'for', 'while'}
The kind of loop being constructed.
loop_instrs : deque
The instructions forming body of the loop.
else_instrs : deque
The instructions forming the else-block of the loop.
Side Effects
------------
Pops all returned instructions from `queue`.
"""
# Grab everything from left side of the queue until the jump target of
# SETUP_LOOP.
body = popwhile(op.is_not(setup_loop_instr.arg), queue, side='left')
# Anything after the last POP_BLOCK instruction is the else-block.
else_body = popwhile(not_a(instrs.POP_BLOCK), body, side='right')
jump_to_top, pop_block = body[-2], body[-1]
if not isinstance(jump_to_top, instrs.JUMP_ABSOLUTE):
raise DecompilationError(
"Penultimate instruction of loop body is "
"%s, not JUMP_ABSOLUTE." % jump_to_top,
)
if not isinstance(pop_block, instrs.POP_BLOCK):
raise DecompilationError(
"Last instruction of loop body is "
"%s, not pop_block." % pop_block,
)
loop_expr = jump_to_top.arg
if isinstance(loop_expr, instrs.FOR_ITER):
return 'for', body, else_body
return 'while', body, else_body | python | def pop_loop_instrs(setup_loop_instr, queue):
# Grab everything from left side of the queue until the jump target of
# SETUP_LOOP.
body = popwhile(op.is_not(setup_loop_instr.arg), queue, side='left')
# Anything after the last POP_BLOCK instruction is the else-block.
else_body = popwhile(not_a(instrs.POP_BLOCK), body, side='right')
jump_to_top, pop_block = body[-2], body[-1]
if not isinstance(jump_to_top, instrs.JUMP_ABSOLUTE):
raise DecompilationError(
"Penultimate instruction of loop body is "
"%s, not JUMP_ABSOLUTE." % jump_to_top,
)
if not isinstance(pop_block, instrs.POP_BLOCK):
raise DecompilationError(
"Last instruction of loop body is "
"%s, not pop_block." % pop_block,
)
loop_expr = jump_to_top.arg
if isinstance(loop_expr, instrs.FOR_ITER):
return 'for', body, else_body
return 'while', body, else_body | [
"def",
"pop_loop_instrs",
"(",
"setup_loop_instr",
",",
"queue",
")",
":",
"# Grab everything from left side of the queue until the jump target of",
"# SETUP_LOOP.",
"body",
"=",
"popwhile",
"(",
"op",
".",
"is_not",
"(",
"setup_loop_instr",
".",
"arg",
")",
",",
"queue... | Determine whether setup_loop_instr is setting up a for-loop or a
while-loop. Then pop the loop instructions from queue.
The easiest way to tell the difference is to look at the target of the
JUMP_ABSOLUTE instruction at the end of the loop. If it jumps to a
FOR_ITER, then this is a for-loop. Otherwise it's a while-loop.
The jump we want to inspect is the first JUMP_ABSOLUTE instruction prior to
the jump target of `setup_loop_instr`.
Parameters
----------
setup_loop_instr : instructions.SETUP_LOOP
First instruction of the loop being parsed.
queue : collections.deque
Queue of unprocessed instructions.
Returns
-------
loop_type : str, {'for', 'while'}
The kind of loop being constructed.
loop_instrs : deque
The instructions forming body of the loop.
else_instrs : deque
The instructions forming the else-block of the loop.
Side Effects
------------
Pops all returned instructions from `queue`. | [
"Determine",
"whether",
"setup_loop_instr",
"is",
"setting",
"up",
"a",
"for",
"-",
"loop",
"or",
"a",
"while",
"-",
"loop",
".",
"Then",
"pop",
"the",
"loop",
"instructions",
"from",
"queue",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L784-L839 |
6,071 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | _make_expr | def _make_expr(toplevel, stack_builders):
"""
Override the single-dispatched make_expr with wrapper logic for handling
short-circuiting expressions.
"""
base_expr = _make_expr_internal(toplevel, stack_builders)
if not toplevel._next_target_of:
return base_expr
subexprs = deque([base_expr])
ops = deque([])
while stack_builders and stack_builders[-1] in toplevel._next_target_of:
jump = stack_builders.pop()
if not isinstance(jump, _BOOLOP_JUMP_TYPES):
raise DecompilationError(
"Don't know how to decompile %s inside expression." % jump,
)
subexprs.appendleft(make_expr(stack_builders))
ops.appendleft(_BOOLOP_JUMP_TO_AST_OP[type(jump)]())
if len(subexprs) <= 1:
raise DecompilationError(
"Expected at least one JUMP instruction before expression."
)
return normalize_boolop(make_boolop(subexprs, ops)) | python | def _make_expr(toplevel, stack_builders):
base_expr = _make_expr_internal(toplevel, stack_builders)
if not toplevel._next_target_of:
return base_expr
subexprs = deque([base_expr])
ops = deque([])
while stack_builders and stack_builders[-1] in toplevel._next_target_of:
jump = stack_builders.pop()
if not isinstance(jump, _BOOLOP_JUMP_TYPES):
raise DecompilationError(
"Don't know how to decompile %s inside expression." % jump,
)
subexprs.appendleft(make_expr(stack_builders))
ops.appendleft(_BOOLOP_JUMP_TO_AST_OP[type(jump)]())
if len(subexprs) <= 1:
raise DecompilationError(
"Expected at least one JUMP instruction before expression."
)
return normalize_boolop(make_boolop(subexprs, ops)) | [
"def",
"_make_expr",
"(",
"toplevel",
",",
"stack_builders",
")",
":",
"base_expr",
"=",
"_make_expr_internal",
"(",
"toplevel",
",",
"stack_builders",
")",
"if",
"not",
"toplevel",
".",
"_next_target_of",
":",
"return",
"base_expr",
"subexprs",
"=",
"deque",
"(... | Override the single-dispatched make_expr with wrapper logic for handling
short-circuiting expressions. | [
"Override",
"the",
"single",
"-",
"dispatched",
"make_expr",
"with",
"wrapper",
"logic",
"for",
"handling",
"short",
"-",
"circuiting",
"expressions",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L856-L881 |
6,072 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_call_keywords | def make_call_keywords(stack_builders, count):
"""
Make the keywords entry for an ast.Call node.
"""
out = []
for _ in range(count):
value = make_expr(stack_builders)
load_kwname = stack_builders.pop()
if not isinstance(load_kwname, instrs.LOAD_CONST):
raise DecompilationError(
"Expected a LOAD_CONST, but got %r" % load_kwname
)
if not isinstance(load_kwname.arg, str):
raise DecompilationError(
"Expected LOAD_CONST of a str, but got %r." % load_kwname,
)
out.append(ast.keyword(arg=load_kwname.arg, value=value))
out.reverse()
return out | python | def make_call_keywords(stack_builders, count):
out = []
for _ in range(count):
value = make_expr(stack_builders)
load_kwname = stack_builders.pop()
if not isinstance(load_kwname, instrs.LOAD_CONST):
raise DecompilationError(
"Expected a LOAD_CONST, but got %r" % load_kwname
)
if not isinstance(load_kwname.arg, str):
raise DecompilationError(
"Expected LOAD_CONST of a str, but got %r." % load_kwname,
)
out.append(ast.keyword(arg=load_kwname.arg, value=value))
out.reverse()
return out | [
"def",
"make_call_keywords",
"(",
"stack_builders",
",",
"count",
")",
":",
"out",
"=",
"[",
"]",
"for",
"_",
"in",
"range",
"(",
"count",
")",
":",
"value",
"=",
"make_expr",
"(",
"stack_builders",
")",
"load_kwname",
"=",
"stack_builders",
".",
"pop",
... | Make the keywords entry for an ast.Call node. | [
"Make",
"the",
"keywords",
"entry",
"for",
"an",
"ast",
".",
"Call",
"node",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1040-L1058 |
6,073 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_call_positionals | def make_call_positionals(stack_builders, count):
"""
Make the args entry for an ast.Call node.
"""
out = [make_expr(stack_builders) for _ in range(count)]
out.reverse()
return out | python | def make_call_positionals(stack_builders, count):
out = [make_expr(stack_builders) for _ in range(count)]
out.reverse()
return out | [
"def",
"make_call_positionals",
"(",
"stack_builders",
",",
"count",
")",
":",
"out",
"=",
"[",
"make_expr",
"(",
"stack_builders",
")",
"for",
"_",
"in",
"range",
"(",
"count",
")",
"]",
"out",
".",
"reverse",
"(",
")",
"return",
"out"
] | Make the args entry for an ast.Call node. | [
"Make",
"the",
"args",
"entry",
"for",
"an",
"ast",
".",
"Call",
"node",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1061-L1067 |
6,074 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | _make_expr_empty_dict | def _make_expr_empty_dict(toplevel, stack_builders):
"""
This should only be hit for empty dicts. Anything else should hit the
STORE_MAP handler instead.
"""
if toplevel.arg:
raise DecompilationError(
"make_expr() called with nonzero BUILD_MAP arg %d" % toplevel.arg
)
if stack_builders:
raise DecompilationError(
"Unexpected stack_builders for BUILD_MAP(0): %s" % stack_builders
)
return ast.Dict(keys=[], values=[]) | python | def _make_expr_empty_dict(toplevel, stack_builders):
if toplevel.arg:
raise DecompilationError(
"make_expr() called with nonzero BUILD_MAP arg %d" % toplevel.arg
)
if stack_builders:
raise DecompilationError(
"Unexpected stack_builders for BUILD_MAP(0): %s" % stack_builders
)
return ast.Dict(keys=[], values=[]) | [
"def",
"_make_expr_empty_dict",
"(",
"toplevel",
",",
"stack_builders",
")",
":",
"if",
"toplevel",
".",
"arg",
":",
"raise",
"DecompilationError",
"(",
"\"make_expr() called with nonzero BUILD_MAP arg %d\"",
"%",
"toplevel",
".",
"arg",
")",
"if",
"stack_builders",
"... | This should only be hit for empty dicts. Anything else should hit the
STORE_MAP handler instead. | [
"This",
"should",
"only",
"be",
"hit",
"for",
"empty",
"dicts",
".",
"Anything",
"else",
"should",
"hit",
"the",
"STORE_MAP",
"handler",
"instead",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1106-L1120 |
6,075 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | find_build_map | def find_build_map(stack_builders):
"""
Find the BUILD_MAP instruction for which the last element of
``stack_builders`` is a store.
"""
assert isinstance(stack_builders[-1], instrs.STORE_MAP)
to_consume = 0
for instr in reversed(stack_builders):
if isinstance(instr, instrs.STORE_MAP):
# NOTE: This branch should always be hit on the first iteration.
to_consume += 1
elif isinstance(instr, instrs.BUILD_MAP):
to_consume -= instr.arg
if to_consume <= 0:
return instr
else:
raise DecompilationError(
"Couldn't find BUILD_MAP for last element of %s." % stack_builders
) | python | def find_build_map(stack_builders):
assert isinstance(stack_builders[-1], instrs.STORE_MAP)
to_consume = 0
for instr in reversed(stack_builders):
if isinstance(instr, instrs.STORE_MAP):
# NOTE: This branch should always be hit on the first iteration.
to_consume += 1
elif isinstance(instr, instrs.BUILD_MAP):
to_consume -= instr.arg
if to_consume <= 0:
return instr
else:
raise DecompilationError(
"Couldn't find BUILD_MAP for last element of %s." % stack_builders
) | [
"def",
"find_build_map",
"(",
"stack_builders",
")",
":",
"assert",
"isinstance",
"(",
"stack_builders",
"[",
"-",
"1",
"]",
",",
"instrs",
".",
"STORE_MAP",
")",
"to_consume",
"=",
"0",
"for",
"instr",
"in",
"reversed",
"(",
"stack_builders",
")",
":",
"i... | Find the BUILD_MAP instruction for which the last element of
``stack_builders`` is a store. | [
"Find",
"the",
"BUILD_MAP",
"instruction",
"for",
"which",
"the",
"last",
"element",
"of",
"stack_builders",
"is",
"a",
"store",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1143-L1162 |
6,076 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | _make_dict_elems | def _make_dict_elems(build_instr, builders):
"""
Return a list of keys and a list of values for the dictionary literal
generated by ``build_instr``.
"""
keys = []
values = []
for _ in range(build_instr.arg):
popped = builders.pop()
if not isinstance(popped, instrs.STORE_MAP):
raise DecompilationError(
"Expected a STORE_MAP but got %s" % popped
)
keys.append(make_expr(builders))
values.append(make_expr(builders))
# Keys and values are emitted in reverse order of how they appear in the
# AST.
keys.reverse()
values.reverse()
return keys, values | python | def _make_dict_elems(build_instr, builders):
keys = []
values = []
for _ in range(build_instr.arg):
popped = builders.pop()
if not isinstance(popped, instrs.STORE_MAP):
raise DecompilationError(
"Expected a STORE_MAP but got %s" % popped
)
keys.append(make_expr(builders))
values.append(make_expr(builders))
# Keys and values are emitted in reverse order of how they appear in the
# AST.
keys.reverse()
values.reverse()
return keys, values | [
"def",
"_make_dict_elems",
"(",
"build_instr",
",",
"builders",
")",
":",
"keys",
"=",
"[",
"]",
"values",
"=",
"[",
"]",
"for",
"_",
"in",
"range",
"(",
"build_instr",
".",
"arg",
")",
":",
"popped",
"=",
"builders",
".",
"pop",
"(",
")",
"if",
"n... | Return a list of keys and a list of values for the dictionary literal
generated by ``build_instr``. | [
"Return",
"a",
"list",
"of",
"keys",
"and",
"a",
"list",
"of",
"values",
"for",
"the",
"dictionary",
"literal",
"generated",
"by",
"build_instr",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1165-L1186 |
6,077 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | normalize_tuple_slice | def normalize_tuple_slice(node):
"""
Normalize an ast.Tuple node representing the internals of a slice.
Returns the node wrapped in an ast.Index.
Returns an ExtSlice node built from the tuple elements if there are any
slices.
"""
if not any(isinstance(elt, ast.Slice) for elt in node.elts):
return ast.Index(value=node)
return ast.ExtSlice(
[
# Wrap non-Slice nodes in Index nodes.
elt if isinstance(elt, ast.Slice) else ast.Index(value=elt)
for elt in node.elts
]
) | python | def normalize_tuple_slice(node):
if not any(isinstance(elt, ast.Slice) for elt in node.elts):
return ast.Index(value=node)
return ast.ExtSlice(
[
# Wrap non-Slice nodes in Index nodes.
elt if isinstance(elt, ast.Slice) else ast.Index(value=elt)
for elt in node.elts
]
) | [
"def",
"normalize_tuple_slice",
"(",
"node",
")",
":",
"if",
"not",
"any",
"(",
"isinstance",
"(",
"elt",
",",
"ast",
".",
"Slice",
")",
"for",
"elt",
"in",
"node",
".",
"elts",
")",
":",
"return",
"ast",
".",
"Index",
"(",
"value",
"=",
"node",
")... | Normalize an ast.Tuple node representing the internals of a slice.
Returns the node wrapped in an ast.Index.
Returns an ExtSlice node built from the tuple elements if there are any
slices. | [
"Normalize",
"an",
"ast",
".",
"Tuple",
"node",
"representing",
"the",
"internals",
"of",
"a",
"slice",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1244-L1261 |
6,078 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | _binop_handler | def _binop_handler(nodetype):
"""
Factory function for binary operator handlers.
"""
def _handler(toplevel, stack_builders):
right = make_expr(stack_builders)
left = make_expr(stack_builders)
return ast.BinOp(left=left, op=nodetype(), right=right)
return _handler | python | def _binop_handler(nodetype):
def _handler(toplevel, stack_builders):
right = make_expr(stack_builders)
left = make_expr(stack_builders)
return ast.BinOp(left=left, op=nodetype(), right=right)
return _handler | [
"def",
"_binop_handler",
"(",
"nodetype",
")",
":",
"def",
"_handler",
"(",
"toplevel",
",",
"stack_builders",
")",
":",
"right",
"=",
"make_expr",
"(",
"stack_builders",
")",
"left",
"=",
"make_expr",
"(",
"stack_builders",
")",
"return",
"ast",
".",
"BinOp... | Factory function for binary operator handlers. | [
"Factory",
"function",
"for",
"binary",
"operator",
"handlers",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1344-L1352 |
6,079 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_function_arguments | def make_function_arguments(args,
kwonly,
varargs,
varkwargs,
defaults,
kw_defaults,
annotations):
"""
Make an ast.arguments from the args parsed out of a code object.
"""
return ast.arguments(
args=[ast.arg(arg=a, annotation=annotations.get(a)) for a in args],
kwonlyargs=[
ast.arg(arg=a, annotation=annotations.get(a)) for a in kwonly
],
defaults=defaults,
kw_defaults=list(map(kw_defaults.get, kwonly)),
vararg=None if varargs is None else ast.arg(
arg=varargs, annotation=annotations.get(varargs),
),
kwarg=None if varkwargs is None else ast.arg(
arg=varkwargs, annotation=annotations.get(varkwargs)
),
) | python | def make_function_arguments(args,
kwonly,
varargs,
varkwargs,
defaults,
kw_defaults,
annotations):
return ast.arguments(
args=[ast.arg(arg=a, annotation=annotations.get(a)) for a in args],
kwonlyargs=[
ast.arg(arg=a, annotation=annotations.get(a)) for a in kwonly
],
defaults=defaults,
kw_defaults=list(map(kw_defaults.get, kwonly)),
vararg=None if varargs is None else ast.arg(
arg=varargs, annotation=annotations.get(varargs),
),
kwarg=None if varkwargs is None else ast.arg(
arg=varkwargs, annotation=annotations.get(varkwargs)
),
) | [
"def",
"make_function_arguments",
"(",
"args",
",",
"kwonly",
",",
"varargs",
",",
"varkwargs",
",",
"defaults",
",",
"kw_defaults",
",",
"annotations",
")",
":",
"return",
"ast",
".",
"arguments",
"(",
"args",
"=",
"[",
"ast",
".",
"arg",
"(",
"arg",
"=... | Make an ast.arguments from the args parsed out of a code object. | [
"Make",
"an",
"ast",
".",
"arguments",
"from",
"the",
"args",
"parsed",
"out",
"of",
"a",
"code",
"object",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1433-L1456 |
6,080 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_global_and_nonlocal_decls | def make_global_and_nonlocal_decls(code_instrs):
"""
Find all STORE_GLOBAL and STORE_DEREF instructions in `instrs` and convert
them into a canonical list of `ast.Global` and `ast.Nonlocal` declarations.
"""
globals_ = sorted(set(
i.arg for i in code_instrs if isinstance(i, instrs.STORE_GLOBAL)
))
nonlocals = sorted(set(
i.arg for i in code_instrs
if isinstance(i, instrs.STORE_DEREF) and i.vartype == 'free'
))
out = []
if globals_:
out.append(ast.Global(names=globals_))
if nonlocals:
out.append(ast.Nonlocal(names=nonlocals))
return out | python | def make_global_and_nonlocal_decls(code_instrs):
globals_ = sorted(set(
i.arg for i in code_instrs if isinstance(i, instrs.STORE_GLOBAL)
))
nonlocals = sorted(set(
i.arg for i in code_instrs
if isinstance(i, instrs.STORE_DEREF) and i.vartype == 'free'
))
out = []
if globals_:
out.append(ast.Global(names=globals_))
if nonlocals:
out.append(ast.Nonlocal(names=nonlocals))
return out | [
"def",
"make_global_and_nonlocal_decls",
"(",
"code_instrs",
")",
":",
"globals_",
"=",
"sorted",
"(",
"set",
"(",
"i",
".",
"arg",
"for",
"i",
"in",
"code_instrs",
"if",
"isinstance",
"(",
"i",
",",
"instrs",
".",
"STORE_GLOBAL",
")",
")",
")",
"nonlocals... | Find all STORE_GLOBAL and STORE_DEREF instructions in `instrs` and convert
them into a canonical list of `ast.Global` and `ast.Nonlocal` declarations. | [
"Find",
"all",
"STORE_GLOBAL",
"and",
"STORE_DEREF",
"instructions",
"in",
"instrs",
"and",
"convert",
"them",
"into",
"a",
"canonical",
"list",
"of",
"ast",
".",
"Global",
"and",
"ast",
".",
"Nonlocal",
"declarations",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1469-L1487 |
6,081 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | make_defaults_and_annotations | def make_defaults_and_annotations(make_function_instr, builders):
"""
Get the AST expressions corresponding to the defaults, kwonly defaults, and
annotations for a function created by `make_function_instr`.
"""
# Integer counts.
n_defaults, n_kwonlydefaults, n_annotations = unpack_make_function_arg(
make_function_instr.arg
)
if n_annotations:
# TOS should be a tuple of annotation names.
load_annotation_names = builders.pop()
annotations = dict(zip(
reversed(load_annotation_names.arg),
(make_expr(builders) for _ in range(n_annotations - 1))
))
else:
annotations = {}
kwonlys = {}
while n_kwonlydefaults:
default_expr = make_expr(builders)
key_instr = builders.pop()
if not isinstance(key_instr, instrs.LOAD_CONST):
raise DecompilationError(
"kwonlydefault key is not a LOAD_CONST: %s" % key_instr
)
if not isinstance(key_instr.arg, str):
raise DecompilationError(
"kwonlydefault key builder is not a "
"'LOAD_CONST of a string: %s" % key_instr
)
kwonlys[key_instr.arg] = default_expr
n_kwonlydefaults -= 1
defaults = make_exprs(builders, n_defaults)
return defaults, kwonlys, annotations | python | def make_defaults_and_annotations(make_function_instr, builders):
# Integer counts.
n_defaults, n_kwonlydefaults, n_annotations = unpack_make_function_arg(
make_function_instr.arg
)
if n_annotations:
# TOS should be a tuple of annotation names.
load_annotation_names = builders.pop()
annotations = dict(zip(
reversed(load_annotation_names.arg),
(make_expr(builders) for _ in range(n_annotations - 1))
))
else:
annotations = {}
kwonlys = {}
while n_kwonlydefaults:
default_expr = make_expr(builders)
key_instr = builders.pop()
if not isinstance(key_instr, instrs.LOAD_CONST):
raise DecompilationError(
"kwonlydefault key is not a LOAD_CONST: %s" % key_instr
)
if not isinstance(key_instr.arg, str):
raise DecompilationError(
"kwonlydefault key builder is not a "
"'LOAD_CONST of a string: %s" % key_instr
)
kwonlys[key_instr.arg] = default_expr
n_kwonlydefaults -= 1
defaults = make_exprs(builders, n_defaults)
return defaults, kwonlys, annotations | [
"def",
"make_defaults_and_annotations",
"(",
"make_function_instr",
",",
"builders",
")",
":",
"# Integer counts.",
"n_defaults",
",",
"n_kwonlydefaults",
",",
"n_annotations",
"=",
"unpack_make_function_arg",
"(",
"make_function_instr",
".",
"arg",
")",
"if",
"n_annotati... | Get the AST expressions corresponding to the defaults, kwonly defaults, and
annotations for a function created by `make_function_instr`. | [
"Get",
"the",
"AST",
"expressions",
"corresponding",
"to",
"the",
"defaults",
"kwonly",
"defaults",
"and",
"annotations",
"for",
"a",
"function",
"created",
"by",
"make_function_instr",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1490-L1527 |
6,082 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | _check_make_function_instrs | def _check_make_function_instrs(load_code_instr,
load_name_instr,
make_function_instr,
*,
expect_lambda=False):
"""
Validate the instructions passed to a make_function call.
"""
# Validate load_code_instr.
if not isinstance(load_code_instr, instrs.LOAD_CONST):
raise TypeError(
"make_function expected 'load_code_instr` to be a "
"LOAD_CONST, but got %s" % load_code_instr,
)
if not isinstance(load_code_instr.arg, types.CodeType):
raise TypeError(
"make_function expected load_code_instr "
"to load a code object, but got %s" % load_code_instr.arg,
)
# Validate load_name_instr
if not isinstance(load_name_instr, instrs.LOAD_CONST):
raise TypeError(
"make_function expected 'load_name_instr` to be a "
"LOAD_CONST, but got %s" % load_code_instr,
)
if not isinstance(load_name_instr.arg, str):
raise TypeError(
"make_function expected load_name_instr "
"to load a string, but got %r instead" % load_name_instr.arg
)
# This is an endswith rather than '==' because the arg is the
# fully-qualified name.
is_lambda = is_lambda_name(load_name_instr.arg)
if expect_lambda and not is_lambda:
raise ValueError(
"Expected to make a function named <lambda>, but "
"got %r instead." % load_name_instr.arg
)
if not expect_lambda and is_lambda:
raise ValueError("Unexpectedly received lambda function.")
# Validate make_function_instr
if not isinstance(make_function_instr, (instrs.MAKE_FUNCTION,
instrs.MAKE_CLOSURE)):
raise TypeError(
"make_function expected a MAKE_FUNCTION or MAKE_CLOSURE"
"instruction, but got %s instead." % make_function_instr
) | python | def _check_make_function_instrs(load_code_instr,
load_name_instr,
make_function_instr,
*,
expect_lambda=False):
# Validate load_code_instr.
if not isinstance(load_code_instr, instrs.LOAD_CONST):
raise TypeError(
"make_function expected 'load_code_instr` to be a "
"LOAD_CONST, but got %s" % load_code_instr,
)
if not isinstance(load_code_instr.arg, types.CodeType):
raise TypeError(
"make_function expected load_code_instr "
"to load a code object, but got %s" % load_code_instr.arg,
)
# Validate load_name_instr
if not isinstance(load_name_instr, instrs.LOAD_CONST):
raise TypeError(
"make_function expected 'load_name_instr` to be a "
"LOAD_CONST, but got %s" % load_code_instr,
)
if not isinstance(load_name_instr.arg, str):
raise TypeError(
"make_function expected load_name_instr "
"to load a string, but got %r instead" % load_name_instr.arg
)
# This is an endswith rather than '==' because the arg is the
# fully-qualified name.
is_lambda = is_lambda_name(load_name_instr.arg)
if expect_lambda and not is_lambda:
raise ValueError(
"Expected to make a function named <lambda>, but "
"got %r instead." % load_name_instr.arg
)
if not expect_lambda and is_lambda:
raise ValueError("Unexpectedly received lambda function.")
# Validate make_function_instr
if not isinstance(make_function_instr, (instrs.MAKE_FUNCTION,
instrs.MAKE_CLOSURE)):
raise TypeError(
"make_function expected a MAKE_FUNCTION or MAKE_CLOSURE"
"instruction, but got %s instead." % make_function_instr
) | [
"def",
"_check_make_function_instrs",
"(",
"load_code_instr",
",",
"load_name_instr",
",",
"make_function_instr",
",",
"*",
",",
"expect_lambda",
"=",
"False",
")",
":",
"# Validate load_code_instr.",
"if",
"not",
"isinstance",
"(",
"load_code_instr",
",",
"instrs",
"... | Validate the instructions passed to a make_function call. | [
"Validate",
"the",
"instructions",
"passed",
"to",
"a",
"make_function",
"call",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1550-L1601 |
6,083 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | pop_arguments | def pop_arguments(instr, stack):
"""
Pop instructions off `stack` until we pop all instructions that will
produce values popped by `instr`.
"""
needed = instr.stack_effect
if needed >= 0:
raise DecompilationError(
"%s is does not have a negative stack effect" % instr
)
for popcount, to_pop in enumerate(reversed(stack), start=1):
needed += to_pop.stack_effect
if not needed:
break
else:
raise DecompilationError(
"Reached end of stack without finding inputs to %s" % instr,
)
popped = stack[-popcount:]
stack[:] = stack[:-popcount]
return popped | python | def pop_arguments(instr, stack):
needed = instr.stack_effect
if needed >= 0:
raise DecompilationError(
"%s is does not have a negative stack effect" % instr
)
for popcount, to_pop in enumerate(reversed(stack), start=1):
needed += to_pop.stack_effect
if not needed:
break
else:
raise DecompilationError(
"Reached end of stack without finding inputs to %s" % instr,
)
popped = stack[-popcount:]
stack[:] = stack[:-popcount]
return popped | [
"def",
"pop_arguments",
"(",
"instr",
",",
"stack",
")",
":",
"needed",
"=",
"instr",
".",
"stack_effect",
"if",
"needed",
">=",
"0",
":",
"raise",
"DecompilationError",
"(",
"\"%s is does not have a negative stack effect\"",
"%",
"instr",
")",
"for",
"popcount",
... | Pop instructions off `stack` until we pop all instructions that will
produce values popped by `instr`. | [
"Pop",
"instructions",
"off",
"stack",
"until",
"we",
"pop",
"all",
"instructions",
"that",
"will",
"produce",
"values",
"popped",
"by",
"instr",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1604-L1627 |
6,084 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | _check_stack_for_module_return | def _check_stack_for_module_return(stack):
"""
Verify that the stack is in the expected state before the dummy
RETURN_VALUE instruction of a module or class.
"""
fail = (
len(stack) != 1
or not isinstance(stack[0], instrs.LOAD_CONST)
or stack[0].arg is not None
)
if fail:
raise DecompilationError(
"Reached end of non-function code "
"block with unexpected stack: %s." % stack
) | python | def _check_stack_for_module_return(stack):
fail = (
len(stack) != 1
or not isinstance(stack[0], instrs.LOAD_CONST)
or stack[0].arg is not None
)
if fail:
raise DecompilationError(
"Reached end of non-function code "
"block with unexpected stack: %s." % stack
) | [
"def",
"_check_stack_for_module_return",
"(",
"stack",
")",
":",
"fail",
"=",
"(",
"len",
"(",
"stack",
")",
"!=",
"1",
"or",
"not",
"isinstance",
"(",
"stack",
"[",
"0",
"]",
",",
"instrs",
".",
"LOAD_CONST",
")",
"or",
"stack",
"[",
"0",
"]",
".",
... | Verify that the stack is in the expected state before the dummy
RETURN_VALUE instruction of a module or class. | [
"Verify",
"that",
"the",
"stack",
"is",
"in",
"the",
"expected",
"state",
"before",
"the",
"dummy",
"RETURN_VALUE",
"instruction",
"of",
"a",
"module",
"or",
"class",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1630-L1645 |
6,085 | llllllllll/codetransformer | codetransformer/decompiler/_343.py | expect | def expect(instr, expected, context):
"""
Check that an instruction is of the expected type.
"""
if not isinstance(instr, expected):
raise DecompilationError(
"Expected a {expected} instruction {context}. Got {instr}.".format(
instr=instr, expected=expected, context=context,
)
)
return instr | python | def expect(instr, expected, context):
if not isinstance(instr, expected):
raise DecompilationError(
"Expected a {expected} instruction {context}. Got {instr}.".format(
instr=instr, expected=expected, context=context,
)
)
return instr | [
"def",
"expect",
"(",
"instr",
",",
"expected",
",",
"context",
")",
":",
"if",
"not",
"isinstance",
"(",
"instr",
",",
"expected",
")",
":",
"raise",
"DecompilationError",
"(",
"\"Expected a {expected} instruction {context}. Got {instr}.\"",
".",
"format",
"(",
"... | Check that an instruction is of the expected type. | [
"Check",
"that",
"an",
"instruction",
"is",
"of",
"the",
"expected",
"type",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/_343.py#L1648-L1658 |
6,086 | llllllllll/codetransformer | codetransformer/transformers/literals.py | overloaded_constants | def overloaded_constants(type_, __doc__=None):
"""A factory for transformers that apply functions to literals.
Parameters
----------
type_ : type
The type to overload.
__doc__ : str, optional
Docstring for the generated transformer.
Returns
-------
transformer : subclass of CodeTransformer
A new code transformer class that will overload the provided
literal types.
"""
typename = type_.__name__
if typename.endswith('x'):
typename += 'es'
elif not typename.endswith('s'):
typename += 's'
if __doc__ is None:
__doc__ = _format_constant_docstring(type_)
return type(
"overloaded_" + typename,
(_ConstantTransformerBase,), {
'_type': type_,
'__doc__': __doc__,
},
) | python | def overloaded_constants(type_, __doc__=None):
typename = type_.__name__
if typename.endswith('x'):
typename += 'es'
elif not typename.endswith('s'):
typename += 's'
if __doc__ is None:
__doc__ = _format_constant_docstring(type_)
return type(
"overloaded_" + typename,
(_ConstantTransformerBase,), {
'_type': type_,
'__doc__': __doc__,
},
) | [
"def",
"overloaded_constants",
"(",
"type_",
",",
"__doc__",
"=",
"None",
")",
":",
"typename",
"=",
"type_",
".",
"__name__",
"if",
"typename",
".",
"endswith",
"(",
"'x'",
")",
":",
"typename",
"+=",
"'es'",
"elif",
"not",
"typename",
".",
"endswith",
... | A factory for transformers that apply functions to literals.
Parameters
----------
type_ : type
The type to overload.
__doc__ : str, optional
Docstring for the generated transformer.
Returns
-------
transformer : subclass of CodeTransformer
A new code transformer class that will overload the provided
literal types. | [
"A",
"factory",
"for",
"transformers",
"that",
"apply",
"functions",
"to",
"literals",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/transformers/literals.py#L237-L268 |
6,087 | llllllllll/codetransformer | codetransformer/decompiler/__init__.py | paramnames | def paramnames(co):
"""
Get the parameter names from a pycode object.
Returns a 4-tuple of (args, kwonlyargs, varargs, varkwargs).
varargs and varkwargs will be None if the function doesn't take *args or
**kwargs, respectively.
"""
flags = co.co_flags
varnames = co.co_varnames
argcount, kwonlyargcount = co.co_argcount, co.co_kwonlyargcount
total = argcount + kwonlyargcount
args = varnames[:argcount]
kwonlyargs = varnames[argcount:total]
varargs, varkwargs = None, None
if flags & Flag.CO_VARARGS:
varargs = varnames[total]
total += 1
if flags & Flag.CO_VARKEYWORDS:
varkwargs = varnames[total]
return args, kwonlyargs, varargs, varkwargs | python | def paramnames(co):
flags = co.co_flags
varnames = co.co_varnames
argcount, kwonlyargcount = co.co_argcount, co.co_kwonlyargcount
total = argcount + kwonlyargcount
args = varnames[:argcount]
kwonlyargs = varnames[argcount:total]
varargs, varkwargs = None, None
if flags & Flag.CO_VARARGS:
varargs = varnames[total]
total += 1
if flags & Flag.CO_VARKEYWORDS:
varkwargs = varnames[total]
return args, kwonlyargs, varargs, varkwargs | [
"def",
"paramnames",
"(",
"co",
")",
":",
"flags",
"=",
"co",
".",
"co_flags",
"varnames",
"=",
"co",
".",
"co_varnames",
"argcount",
",",
"kwonlyargcount",
"=",
"co",
".",
"co_argcount",
",",
"co",
".",
"co_kwonlyargcount",
"total",
"=",
"argcount",
"+",
... | Get the parameter names from a pycode object.
Returns a 4-tuple of (args, kwonlyargs, varargs, varkwargs).
varargs and varkwargs will be None if the function doesn't take *args or
**kwargs, respectively. | [
"Get",
"the",
"parameter",
"names",
"from",
"a",
"pycode",
"object",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/decompiler/__init__.py#L6-L29 |
6,088 | llllllllll/codetransformer | codetransformer/code.py | _freevar_argname | def _freevar_argname(arg, cellvars, freevars):
"""
Get the name of the variable manipulated by a 'uses_free' instruction.
Parameters
----------
arg : int
The raw argument to a uses_free instruction that we want to resolve to
a name.
cellvars : list[str]
The co_cellvars of the function for which we want to resolve `arg`.
freevars : list[str]
The co_freevars of the function for which we want to resolve `arg`.
Notes
-----
From https://docs.python.org/3.5/library/dis.html#opcode-LOAD_CLOSURE:
The name of the variable is co_cellvars[i] if i is less than the length
of co_cellvars. Otherwise it is co_freevars[i - len(co_cellvars)]
"""
len_cellvars = len(cellvars)
if arg < len_cellvars:
return cellvars[arg]
return freevars[arg - len_cellvars] | python | def _freevar_argname(arg, cellvars, freevars):
len_cellvars = len(cellvars)
if arg < len_cellvars:
return cellvars[arg]
return freevars[arg - len_cellvars] | [
"def",
"_freevar_argname",
"(",
"arg",
",",
"cellvars",
",",
"freevars",
")",
":",
"len_cellvars",
"=",
"len",
"(",
"cellvars",
")",
"if",
"arg",
"<",
"len_cellvars",
":",
"return",
"cellvars",
"[",
"arg",
"]",
"return",
"freevars",
"[",
"arg",
"-",
"len... | Get the name of the variable manipulated by a 'uses_free' instruction.
Parameters
----------
arg : int
The raw argument to a uses_free instruction that we want to resolve to
a name.
cellvars : list[str]
The co_cellvars of the function for which we want to resolve `arg`.
freevars : list[str]
The co_freevars of the function for which we want to resolve `arg`.
Notes
-----
From https://docs.python.org/3.5/library/dis.html#opcode-LOAD_CLOSURE:
The name of the variable is co_cellvars[i] if i is less than the length
of co_cellvars. Otherwise it is co_freevars[i - len(co_cellvars)] | [
"Get",
"the",
"name",
"of",
"the",
"variable",
"manipulated",
"by",
"a",
"uses_free",
"instruction",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/code.py#L193-L217 |
6,089 | llllllllll/codetransformer | codetransformer/code.py | pycode | def pycode(argcount,
kwonlyargcount,
nlocals,
stacksize,
flags,
codestring,
constants,
names,
varnames,
filename,
name,
firstlineno,
lnotab,
freevars=(),
cellvars=()):
"""types.CodeType constructor that accepts keyword arguments.
See Also
--------
types.CodeType
"""
return CodeType(
argcount,
kwonlyargcount,
nlocals,
stacksize,
flags,
codestring,
constants,
names,
varnames,
filename,
name,
firstlineno,
lnotab,
freevars,
cellvars,
) | python | def pycode(argcount,
kwonlyargcount,
nlocals,
stacksize,
flags,
codestring,
constants,
names,
varnames,
filename,
name,
firstlineno,
lnotab,
freevars=(),
cellvars=()):
return CodeType(
argcount,
kwonlyargcount,
nlocals,
stacksize,
flags,
codestring,
constants,
names,
varnames,
filename,
name,
firstlineno,
lnotab,
freevars,
cellvars,
) | [
"def",
"pycode",
"(",
"argcount",
",",
"kwonlyargcount",
",",
"nlocals",
",",
"stacksize",
",",
"flags",
",",
"codestring",
",",
"constants",
",",
"names",
",",
"varnames",
",",
"filename",
",",
"name",
",",
"firstlineno",
",",
"lnotab",
",",
"freevars",
"... | types.CodeType constructor that accepts keyword arguments.
See Also
--------
types.CodeType | [
"types",
".",
"CodeType",
"constructor",
"that",
"accepts",
"keyword",
"arguments",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/code.py#L220-L257 |
6,090 | llllllllll/codetransformer | codetransformer/code.py | Code.from_pycode | def from_pycode(cls, co):
"""Create a Code object from a python code object.
Parameters
----------
co : CodeType
The python code object.
Returns
-------
code : Code
The codetransformer Code object.
"""
# Make it sparse to instrs[n] is the instruction at bytecode[n]
sparse_instrs = tuple(
_sparse_args(
Instruction.from_opcode(
b.opcode,
Instruction._no_arg if b.arg is None else _RawArg(b.arg),
) for b in Bytecode(co)
),
)
for idx, instr in enumerate(sparse_instrs):
if instr is None:
# The sparse value
continue
if instr.absjmp:
instr.arg = sparse_instrs[instr.arg]
elif instr.reljmp:
instr.arg = sparse_instrs[instr.arg + idx + argsize + 1]
elif isinstance(instr, LOAD_CONST):
instr.arg = co.co_consts[instr.arg]
elif instr.uses_name:
instr.arg = co.co_names[instr.arg]
elif instr.uses_varname:
instr.arg = co.co_varnames[instr.arg]
elif instr.uses_free:
instr.arg = _freevar_argname(
instr.arg,
co.co_freevars,
co.co_cellvars,
)
elif instr.have_arg and isinstance(instr.arg, _RawArg):
instr.arg = int(instr.arg)
flags = Flag.unpack(co.co_flags)
has_vargs = flags['CO_VARARGS']
has_kwargs = flags['CO_VARKEYWORDS']
# Here we convert the varnames format into our argnames format.
paramnames = co.co_varnames[
:(co.co_argcount +
co.co_kwonlyargcount +
has_vargs +
has_kwargs)
]
# We start with the positional arguments.
new_paramnames = list(paramnames[:co.co_argcount])
# Add *args next.
if has_vargs:
new_paramnames.append('*' + paramnames[-1 - has_kwargs])
# Add positional only arguments next.
new_paramnames.extend(paramnames[
co.co_argcount:co.co_argcount + co.co_kwonlyargcount
])
# Add **kwargs last.
if has_kwargs:
new_paramnames.append('**' + paramnames[-1])
return cls(
filter(bool, sparse_instrs),
argnames=new_paramnames,
cellvars=co.co_cellvars,
freevars=co.co_freevars,
name=co.co_name,
filename=co.co_filename,
firstlineno=co.co_firstlineno,
lnotab={
lno: sparse_instrs[off] for off, lno in findlinestarts(co)
},
flags=flags,
) | python | def from_pycode(cls, co):
# Make it sparse to instrs[n] is the instruction at bytecode[n]
sparse_instrs = tuple(
_sparse_args(
Instruction.from_opcode(
b.opcode,
Instruction._no_arg if b.arg is None else _RawArg(b.arg),
) for b in Bytecode(co)
),
)
for idx, instr in enumerate(sparse_instrs):
if instr is None:
# The sparse value
continue
if instr.absjmp:
instr.arg = sparse_instrs[instr.arg]
elif instr.reljmp:
instr.arg = sparse_instrs[instr.arg + idx + argsize + 1]
elif isinstance(instr, LOAD_CONST):
instr.arg = co.co_consts[instr.arg]
elif instr.uses_name:
instr.arg = co.co_names[instr.arg]
elif instr.uses_varname:
instr.arg = co.co_varnames[instr.arg]
elif instr.uses_free:
instr.arg = _freevar_argname(
instr.arg,
co.co_freevars,
co.co_cellvars,
)
elif instr.have_arg and isinstance(instr.arg, _RawArg):
instr.arg = int(instr.arg)
flags = Flag.unpack(co.co_flags)
has_vargs = flags['CO_VARARGS']
has_kwargs = flags['CO_VARKEYWORDS']
# Here we convert the varnames format into our argnames format.
paramnames = co.co_varnames[
:(co.co_argcount +
co.co_kwonlyargcount +
has_vargs +
has_kwargs)
]
# We start with the positional arguments.
new_paramnames = list(paramnames[:co.co_argcount])
# Add *args next.
if has_vargs:
new_paramnames.append('*' + paramnames[-1 - has_kwargs])
# Add positional only arguments next.
new_paramnames.extend(paramnames[
co.co_argcount:co.co_argcount + co.co_kwonlyargcount
])
# Add **kwargs last.
if has_kwargs:
new_paramnames.append('**' + paramnames[-1])
return cls(
filter(bool, sparse_instrs),
argnames=new_paramnames,
cellvars=co.co_cellvars,
freevars=co.co_freevars,
name=co.co_name,
filename=co.co_filename,
firstlineno=co.co_firstlineno,
lnotab={
lno: sparse_instrs[off] for off, lno in findlinestarts(co)
},
flags=flags,
) | [
"def",
"from_pycode",
"(",
"cls",
",",
"co",
")",
":",
"# Make it sparse to instrs[n] is the instruction at bytecode[n]",
"sparse_instrs",
"=",
"tuple",
"(",
"_sparse_args",
"(",
"Instruction",
".",
"from_opcode",
"(",
"b",
".",
"opcode",
",",
"Instruction",
".",
"_... | Create a Code object from a python code object.
Parameters
----------
co : CodeType
The python code object.
Returns
-------
code : Code
The codetransformer Code object. | [
"Create",
"a",
"Code",
"object",
"from",
"a",
"python",
"code",
"object",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/code.py#L429-L510 |
6,091 | llllllllll/codetransformer | codetransformer/code.py | Code.to_pycode | def to_pycode(self):
"""Create a python code object from the more abstract
codetransfomer.Code object.
Returns
-------
co : CodeType
The python code object.
"""
consts = self.consts
names = self.names
varnames = self.varnames
freevars = self.freevars
cellvars = self.cellvars
bc = bytearray()
for instr in self.instrs:
bc.append(instr.opcode) # Write the opcode byte.
if isinstance(instr, LOAD_CONST):
# Resolve the constant index.
bc.extend(consts.index(instr.arg).to_bytes(argsize, 'little'))
elif instr.uses_name:
# Resolve the name index.
bc.extend(names.index(instr.arg).to_bytes(argsize, 'little'))
elif instr.uses_varname:
# Resolve the local variable index.
bc.extend(
varnames.index(instr.arg).to_bytes(argsize, 'little'),
)
elif instr.uses_free:
# uses_free is really "uses freevars **or** cellvars".
try:
# look for the name in cellvars
bc.extend(
cellvars.index(instr.arg).to_bytes(argsize, 'little'),
)
except ValueError:
# fall back to freevars, incrementing the length of
# cellvars.
bc.extend(
(freevars.index(instr.arg) + len(cellvars)).to_bytes(
argsize,
'little',
)
)
elif instr.absjmp:
# Resolve the absolute jump target.
bc.extend(
self.bytecode_offset(instr.arg).to_bytes(
argsize,
'little',
),
)
elif instr.reljmp:
# Resolve the relative jump target.
# We do this by subtracting the curren't instructions's
# sparse index from the sparse index of the argument.
# We then subtract argsize - 1 to account for the bytes the
# current instruction takes up.
bytecode_offset = self.bytecode_offset
bc.extend((
bytecode_offset(instr.arg) -
bytecode_offset(instr) -
argsize -
1
).to_bytes(argsize, 'little',))
elif instr.have_arg:
# Write any other arg here.
bc.extend(instr.arg.to_bytes(argsize, 'little'))
elif WORDCODE:
# with wordcode, all instructions are padded to 2 bytes
bc.append(0)
return CodeType(
self.argcount,
self.kwonlyargcount,
len(varnames),
self.stacksize,
self.py_flags,
bytes(bc),
consts,
names,
varnames,
self.filename,
self.name,
self.firstlineno,
self.py_lnotab,
freevars,
cellvars,
) | python | def to_pycode(self):
consts = self.consts
names = self.names
varnames = self.varnames
freevars = self.freevars
cellvars = self.cellvars
bc = bytearray()
for instr in self.instrs:
bc.append(instr.opcode) # Write the opcode byte.
if isinstance(instr, LOAD_CONST):
# Resolve the constant index.
bc.extend(consts.index(instr.arg).to_bytes(argsize, 'little'))
elif instr.uses_name:
# Resolve the name index.
bc.extend(names.index(instr.arg).to_bytes(argsize, 'little'))
elif instr.uses_varname:
# Resolve the local variable index.
bc.extend(
varnames.index(instr.arg).to_bytes(argsize, 'little'),
)
elif instr.uses_free:
# uses_free is really "uses freevars **or** cellvars".
try:
# look for the name in cellvars
bc.extend(
cellvars.index(instr.arg).to_bytes(argsize, 'little'),
)
except ValueError:
# fall back to freevars, incrementing the length of
# cellvars.
bc.extend(
(freevars.index(instr.arg) + len(cellvars)).to_bytes(
argsize,
'little',
)
)
elif instr.absjmp:
# Resolve the absolute jump target.
bc.extend(
self.bytecode_offset(instr.arg).to_bytes(
argsize,
'little',
),
)
elif instr.reljmp:
# Resolve the relative jump target.
# We do this by subtracting the curren't instructions's
# sparse index from the sparse index of the argument.
# We then subtract argsize - 1 to account for the bytes the
# current instruction takes up.
bytecode_offset = self.bytecode_offset
bc.extend((
bytecode_offset(instr.arg) -
bytecode_offset(instr) -
argsize -
1
).to_bytes(argsize, 'little',))
elif instr.have_arg:
# Write any other arg here.
bc.extend(instr.arg.to_bytes(argsize, 'little'))
elif WORDCODE:
# with wordcode, all instructions are padded to 2 bytes
bc.append(0)
return CodeType(
self.argcount,
self.kwonlyargcount,
len(varnames),
self.stacksize,
self.py_flags,
bytes(bc),
consts,
names,
varnames,
self.filename,
self.name,
self.firstlineno,
self.py_lnotab,
freevars,
cellvars,
) | [
"def",
"to_pycode",
"(",
"self",
")",
":",
"consts",
"=",
"self",
".",
"consts",
"names",
"=",
"self",
".",
"names",
"varnames",
"=",
"self",
".",
"varnames",
"freevars",
"=",
"self",
".",
"freevars",
"cellvars",
"=",
"self",
".",
"cellvars",
"bc",
"="... | Create a python code object from the more abstract
codetransfomer.Code object.
Returns
-------
co : CodeType
The python code object. | [
"Create",
"a",
"python",
"code",
"object",
"from",
"the",
"more",
"abstract",
"codetransfomer",
".",
"Code",
"object",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/code.py#L512-L600 |
6,092 | llllllllll/codetransformer | codetransformer/code.py | Code.consts | def consts(self):
"""The constants referenced in this code object.
"""
# We cannot use a set comprehension because consts do not need
# to be hashable.
consts = []
append_const = consts.append
for instr in self.instrs:
if isinstance(instr, LOAD_CONST) and instr.arg not in consts:
append_const(instr.arg)
return tuple(consts) | python | def consts(self):
# We cannot use a set comprehension because consts do not need
# to be hashable.
consts = []
append_const = consts.append
for instr in self.instrs:
if isinstance(instr, LOAD_CONST) and instr.arg not in consts:
append_const(instr.arg)
return tuple(consts) | [
"def",
"consts",
"(",
"self",
")",
":",
"# We cannot use a set comprehension because consts do not need",
"# to be hashable.",
"consts",
"=",
"[",
"]",
"append_const",
"=",
"consts",
".",
"append",
"for",
"instr",
"in",
"self",
".",
"instrs",
":",
"if",
"isinstance"... | The constants referenced in this code object. | [
"The",
"constants",
"referenced",
"in",
"this",
"code",
"object",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/code.py#L634-L644 |
6,093 | llllllllll/codetransformer | codetransformer/code.py | Code.names | def names(self):
"""The names referenced in this code object.
Names come from instructions like LOAD_GLOBAL or STORE_ATTR
where the name of the global or attribute is needed at runtime.
"""
# We must sort to preserve the order between calls.
# The set comprehension is to drop the duplicates.
return tuple(sorted({
instr.arg for instr in self.instrs if instr.uses_name
})) | python | def names(self):
# We must sort to preserve the order between calls.
# The set comprehension is to drop the duplicates.
return tuple(sorted({
instr.arg for instr in self.instrs if instr.uses_name
})) | [
"def",
"names",
"(",
"self",
")",
":",
"# We must sort to preserve the order between calls.",
"# The set comprehension is to drop the duplicates.",
"return",
"tuple",
"(",
"sorted",
"(",
"{",
"instr",
".",
"arg",
"for",
"instr",
"in",
"self",
".",
"instrs",
"if",
"ins... | The names referenced in this code object.
Names come from instructions like LOAD_GLOBAL or STORE_ATTR
where the name of the global or attribute is needed at runtime. | [
"The",
"names",
"referenced",
"in",
"this",
"code",
"object",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/code.py#L647-L657 |
6,094 | llllllllll/codetransformer | codetransformer/code.py | Code.varnames | def varnames(self):
"""The names of all of the local variables in this code object.
"""
# We must sort to preserve the order between calls.
# The set comprehension is to drop the duplicates.
return self._argnames + tuple(sorted({
instr.arg
for instr in self.instrs
if instr.uses_varname and instr.arg not in self._argnames
})) | python | def varnames(self):
# We must sort to preserve the order between calls.
# The set comprehension is to drop the duplicates.
return self._argnames + tuple(sorted({
instr.arg
for instr in self.instrs
if instr.uses_varname and instr.arg not in self._argnames
})) | [
"def",
"varnames",
"(",
"self",
")",
":",
"# We must sort to preserve the order between calls.",
"# The set comprehension is to drop the duplicates.",
"return",
"self",
".",
"_argnames",
"+",
"tuple",
"(",
"sorted",
"(",
"{",
"instr",
".",
"arg",
"for",
"instr",
"in",
... | The names of all of the local variables in this code object. | [
"The",
"names",
"of",
"all",
"of",
"the",
"local",
"variables",
"in",
"this",
"code",
"object",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/code.py#L669-L678 |
6,095 | llllllllll/codetransformer | codetransformer/code.py | Code.py_lnotab | def py_lnotab(self):
"""The encoded lnotab that python uses to compute when lines start.
Note
----
See Objects/lnotab_notes.txt in the cpython source for more details.
"""
reverse_lnotab = reverse_dict(self.lnotab)
py_lnotab = []
prev_instr = 0
prev_lno = self.firstlineno
for addr, instr in enumerate(_sparse_args(self.instrs)):
lno = reverse_lnotab.get(instr)
if lno is None:
continue
delta = lno - prev_lno
py_lnotab.append(addr - prev_instr)
py_lnotab.append(min(delta, max_lnotab_increment))
delta -= max_lnotab_increment
while delta > 0:
py_lnotab.append(0)
py_lnotab.append(min(delta, max_lnotab_increment))
delta -= max_lnotab_increment
prev_lno = lno
prev_instr = addr
return bytes(py_lnotab) | python | def py_lnotab(self):
reverse_lnotab = reverse_dict(self.lnotab)
py_lnotab = []
prev_instr = 0
prev_lno = self.firstlineno
for addr, instr in enumerate(_sparse_args(self.instrs)):
lno = reverse_lnotab.get(instr)
if lno is None:
continue
delta = lno - prev_lno
py_lnotab.append(addr - prev_instr)
py_lnotab.append(min(delta, max_lnotab_increment))
delta -= max_lnotab_increment
while delta > 0:
py_lnotab.append(0)
py_lnotab.append(min(delta, max_lnotab_increment))
delta -= max_lnotab_increment
prev_lno = lno
prev_instr = addr
return bytes(py_lnotab) | [
"def",
"py_lnotab",
"(",
"self",
")",
":",
"reverse_lnotab",
"=",
"reverse_dict",
"(",
"self",
".",
"lnotab",
")",
"py_lnotab",
"=",
"[",
"]",
"prev_instr",
"=",
"0",
"prev_lno",
"=",
"self",
".",
"firstlineno",
"for",
"addr",
",",
"instr",
"in",
"enumer... | The encoded lnotab that python uses to compute when lines start.
Note
----
See Objects/lnotab_notes.txt in the cpython source for more details. | [
"The",
"encoded",
"lnotab",
"that",
"python",
"uses",
"to",
"compute",
"when",
"lines",
"start",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/code.py#L783-L811 |
6,096 | llllllllll/codetransformer | codetransformer/code.py | Code.stacksize | def stacksize(self):
"""The maximum amount of stack space used by this code object.
"""
return max(scanl(
op.add,
0,
map(op.attrgetter('stack_effect'), self.instrs),
)) | python | def stacksize(self):
return max(scanl(
op.add,
0,
map(op.attrgetter('stack_effect'), self.instrs),
)) | [
"def",
"stacksize",
"(",
"self",
")",
":",
"return",
"max",
"(",
"scanl",
"(",
"op",
".",
"add",
",",
"0",
",",
"map",
"(",
"op",
".",
"attrgetter",
"(",
"'stack_effect'",
")",
",",
"self",
".",
"instrs",
")",
",",
")",
")"
] | The maximum amount of stack space used by this code object. | [
"The",
"maximum",
"amount",
"of",
"stack",
"space",
"used",
"by",
"this",
"code",
"object",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/code.py#L814-L821 |
6,097 | llllllllll/codetransformer | codetransformer/utils/immutable.py | initialize_slot | def initialize_slot(obj, name, value):
"""Initalize an unitialized slot to a value.
If there is already a value for this slot, this is a nop.
Parameters
----------
obj : immutable
An immutable object.
name : str
The name of the slot to initialize.
value : any
The value to initialize the slot to.
"""
if not hasattr(obj, name):
object_setattr(obj, name, value) | python | def initialize_slot(obj, name, value):
if not hasattr(obj, name):
object_setattr(obj, name, value) | [
"def",
"initialize_slot",
"(",
"obj",
",",
"name",
",",
"value",
")",
":",
"if",
"not",
"hasattr",
"(",
"obj",
",",
"name",
")",
":",
"object_setattr",
"(",
"obj",
",",
"name",
",",
"value",
")"
] | Initalize an unitialized slot to a value.
If there is already a value for this slot, this is a nop.
Parameters
----------
obj : immutable
An immutable object.
name : str
The name of the slot to initialize.
value : any
The value to initialize the slot to. | [
"Initalize",
"an",
"unitialized",
"slot",
"to",
"a",
"value",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/utils/immutable.py#L61-L76 |
6,098 | llllllllll/codetransformer | codetransformer/utils/functional.py | scanl | def scanl(f, n, ns):
"""Reduce ns by f starting with n yielding each intermediate value.
tuple(scanl(f, n, ns))[-1] == reduce(f, ns, n)
Parameters
----------
f : callable
A binary function.
n : any
The starting value.
ns : iterable of any
The iterable to scan over.
Yields
------
p : any
The value of reduce(f, ns[:idx]) where idx is the current index.
Examples
--------
>>> import operator as op
>>> tuple(scanl(op.add, 0, (1, 2, 3, 4)))
(0, 1, 3, 6, 10)
"""
yield n
for m in ns:
n = f(n, m)
yield n | python | def scanl(f, n, ns):
yield n
for m in ns:
n = f(n, m)
yield n | [
"def",
"scanl",
"(",
"f",
",",
"n",
",",
"ns",
")",
":",
"yield",
"n",
"for",
"m",
"in",
"ns",
":",
"n",
"=",
"f",
"(",
"n",
",",
"m",
")",
"yield",
"n"
] | Reduce ns by f starting with n yielding each intermediate value.
tuple(scanl(f, n, ns))[-1] == reduce(f, ns, n)
Parameters
----------
f : callable
A binary function.
n : any
The starting value.
ns : iterable of any
The iterable to scan over.
Yields
------
p : any
The value of reduce(f, ns[:idx]) where idx is the current index.
Examples
--------
>>> import operator as op
>>> tuple(scanl(op.add, 0, (1, 2, 3, 4)))
(0, 1, 3, 6, 10) | [
"Reduce",
"ns",
"by",
"f",
"starting",
"with",
"n",
"yielding",
"each",
"intermediate",
"value",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/utils/functional.py#L21-L49 |
6,099 | llllllllll/codetransformer | codetransformer/utils/functional.py | ffill | def ffill(iterable):
"""Forward fill non None values in some iterable.
Parameters
----------
iterable : iterable
The iterable to forward fill.
Yields
------
e : any
The last non None value or None if there has not been a non None value.
"""
it = iter(iterable)
previous = next(it)
yield previous
for e in it:
if e is None:
yield previous
else:
previous = e
yield e | python | def ffill(iterable):
it = iter(iterable)
previous = next(it)
yield previous
for e in it:
if e is None:
yield previous
else:
previous = e
yield e | [
"def",
"ffill",
"(",
"iterable",
")",
":",
"it",
"=",
"iter",
"(",
"iterable",
")",
"previous",
"=",
"next",
"(",
"it",
")",
"yield",
"previous",
"for",
"e",
"in",
"it",
":",
"if",
"e",
"is",
"None",
":",
"yield",
"previous",
"else",
":",
"previous... | Forward fill non None values in some iterable.
Parameters
----------
iterable : iterable
The iterable to forward fill.
Yields
------
e : any
The last non None value or None if there has not been a non None value. | [
"Forward",
"fill",
"non",
"None",
"values",
"in",
"some",
"iterable",
"."
] | c5f551e915df45adc7da7e0b1b635f0cc6a1bb27 | https://github.com/llllllllll/codetransformer/blob/c5f551e915df45adc7da7e0b1b635f0cc6a1bb27/codetransformer/utils/functional.py#L75-L96 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.