Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Continue the code snippet: <|code_start|>
approach = Group(
murta2014a, pimentel2015a,
_display="no Work flow",
_approach_name="noWorkflow",
<|code_end|>
. Use current file imports:
from snowballing.approaches import Group
from ..constants import *
from ...work.y2014 import murta2014a
from ...work.y2015 import pimentel2015a
and context (classes, functions, or code) from other files:
# Path: snowballing/approaches.py
# class Group:
# """Represent an Approach or a Group of work.
#
# Arguments:
#
# * `args` -- list of work that represents the group
#
# * `kwargs` -- map of attributes to be applied for the group and its works
#
# * Exception: the keyword `dont_cite=` also represents a list of works that
# belong to the group
#
#
# Expected attributes:
#
# * _cite: cite group by authors
#
# * True indicates that the approach must be referenced by its authors
# * False indicates that the approach can referenced by name
#
# * _meta: list of dicts with attributes for comparing approaches
#
# * A single approach can have more than one meta dict
# * It is possible to use the distinct meta dicts to describe different
# aspects
#
# * _about: HTML describing the approach
#
# Doctest:
#
# .. doctest::
#
# >>> from .operations import reload, work_by_varname
# >>> reload()
# >>> murta2014a = work_by_varname("murta2014a")
# >>> pimentel2015a = work_by_varname("pimentel2015a")
# >>> pimentel2015a.display == "now"
# False
# >>> APPROACHES.clear()
# >>> len(APPROACHES)
# 0
# >>> group = Group(
# ... murta2014a, pimentel2015a,
# ... display="now",
# ... _cite=True,
# ... _meta=[dict(
# ... scripts=True
# ... )]
# ... )
# >>> group.display
# 'now'
# >>> pimentel2015a.display == "now"
# True
# >>> len(APPROACHES)
# 1
# """
# _category = config.APPROACH_RELATED_CATEGORY
# def __init__(self, *args ,**kwargs):
# work = list(args)
# if dhas(kwargs, "approach_dont_cite"):
# work += dget(kwargs, "approach_dont_cite")
# oset(self, "approach_dont_cite", dget(kwargs, "approach_dont_cite"))
# ddel(kwargs, "approach_dont_cite")
# oset(self, "approach_work", work)
#
# for key, item in kwargs.items():
# for arg in work:
# if not hasattr(arg, config.APPROACH_FORCE_PREFIX + key):
# setattr(arg, key, item)
# setattr(self, key, item)
#
# if self._category == config.APPROACH_RELATED_CATEGORY:
# APPROACHES.append(self)
#
# Path: snowballing/bibtex/database/work/y2014.py
#
# Path: snowballing/bibtex/database/work/y2015.py
. Output only the next line. | _cite=False, |
Based on the snippet: <|code_start|>
CiSE = journal("CiSE", "Computing in Science & Engineering")
ICSE = conference("ICSE", "International Conference on Software Engineering")
IPAW = conference("IPAW", "International Provenance and Annotation Workshop")
<|code_end|>
, predict the immediate next line with the help of imports:
from snowballing.models import Place, DB
from snowballing.common_places import *
and context (classes, functions, sometimes code) from other files:
# Path: snowballing/models.py
# class Place(object):
# """Represent a publication Place
#
# It has the following attributes:
#
# * :attr:`~acronym` -- place acronym (e.g., 'IPAW')
#
# * Surround it with <>, if the place has no acronym or you do not know it
# (e.g., '<ImaginaryAcronym>')
#
# * :attr:`~name` -- full name of the place (e.g., 'International Provenance
# and Annotation Workshop')
#
# * :attr:`~type` -- place acronym (e.g., 'IPAW')
#
# Other attributes are optional and can be used to include extra information
# about the place.
# Note however that it has the following reversed attributes:
#
# * :meth:`~_draw` -- method that draws the place
#
#
# Doctest:
#
# .. doctest::
#
# >>> ipaw = Place('IPAW',
# ... 'International Provenance and Annotation Workshop',
# ... 'conference')
# >>> ipaw.acronym
# 'IPAW'
# >>> ipaw.name
# 'International Provenance and Annotation Workshop'
# >>> ipaw.type
# 'conference'
#
# Places are considered equal if they have the same name
# >>> ipaw2 = Place('I', 'International Provenance and Annotation Workshop',
# ... 'journal')
# >>> ipaw == ipaw2
# True
# """
#
# def __init__(self, acronym, name="", *args, **kwargs):
# if name == "":
# name = acronym
#
# self.acronym = acronym
# self.name = name
#
# if args:
# self.type = args[0]
#
# for key, value in kwargs.items():
# setattr(self, key, value)
#
# def __eq__(self, other):
# if not other:
# return False
# return self.name == other.name
#
# def __str__(self):
# return self.name
#
# def __repr__(self):
# return self.acronym
#
# def __hash__(self):
# return hash(self.name)
#
# DB = Database()
. Output only the next line. | TaPP = conference("TaPP", "Workshop on the Theory and Practice of Provenance") |
Next line prediction: <|code_start|># coding: utf-8
dbindex.last_citation_file = dbindex.this_file(__file__)
DB(Citation(
murta2014a, freire2008a, ref="[5]",
contexts=[
"There are two types of provenance for scientific workflows: prospective and retrospective [5]. Prospective provenance describes the structure of the experiment and corresponds to the workflow definition, the graph of the activities, and their associated parameters. Retrospective provenance captures the steps taken during the workflow execution, and while it has similar (graph) structure, it is constructed using information collected at runtime, including activities invoked and parameter values used, intermediate data produced, the execution start and end times, etc"
<|code_end|>
. Use current file imports:
(from snowballing.models import *
from snowballing import dbindex
from ..work.y2008 import freire2008a
from ..work.y2014 import murta2014a
from ..work.y2015 import pimentel2015a)
and context including class names, function names, or small code snippets from other files:
# Path: snowballing/dbindex.py
# def citation_file(name):
# def year_file(year):
# def places_file():
# def this_file(filename):
# def discover_year(varname, year=None, fail_raise=True):
# def increment_char(letter):
# def increment_str(varname):
# def parse_varname(varname, group_index):
#
# Path: snowballing/bibtex/database/work/y2008.py
#
# Path: snowballing/bibtex/database/work/y2014.py
#
# Path: snowballing/bibtex/database/work/y2015.py
. Output only the next line. | ], |
Here is a snippet: <|code_start|># coding: utf-8
dbindex.last_citation_file = dbindex.this_file(__file__)
DB(Citation(
murta2014a, freire2008a, ref="[5]",
contexts=[
"There are two types of provenance for scientific workflows: prospective and retrospective [5]. Prospective provenance describes the structure of the experiment and corresponds to the workflow definition, the graph of the activities, and their associated parameters. Retrospective provenance captures the steps taken during the workflow execution, and while it has similar (graph) structure, it is constructed using information collected at runtime, including activities invoked and parameter values used, intermediate data produced, the execution start and end times, etc"
],
))
DB(Citation(
pimentel2015a, murta2014a, ref="",
contexts=[
],
<|code_end|>
. Write the next line using the current file imports:
from snowballing.models import *
from snowballing import dbindex
from ..work.y2008 import freire2008a
from ..work.y2014 import murta2014a
from ..work.y2015 import pimentel2015a
and context from other files:
# Path: snowballing/dbindex.py
# def citation_file(name):
# def year_file(year):
# def places_file():
# def this_file(filename):
# def discover_year(varname, year=None, fail_raise=True):
# def increment_char(letter):
# def increment_str(varname):
# def parse_varname(varname, group_index):
#
# Path: snowballing/bibtex/database/work/y2008.py
#
# Path: snowballing/bibtex/database/work/y2014.py
#
# Path: snowballing/bibtex/database/work/y2015.py
, which may include functions, classes, or code. Output only the next line. | )) |
Given the following code snippet before the placeholder: <|code_start|># coding: utf-8
dbindex.last_citation_file = dbindex.this_file(__file__)
DB(Citation(
murta2014a, freire2008a, ref="[5]",
contexts=[
"There are two types of provenance for scientific workflows: prospective and retrospective [5]. Prospective provenance describes the structure of the experiment and corresponds to the workflow definition, the graph of the activities, and their associated parameters. Retrospective provenance captures the steps taken during the workflow execution, and while it has similar (graph) structure, it is constructed using information collected at runtime, including activities invoked and parameter values used, intermediate data produced, the execution start and end times, etc"
],
))
DB(Citation(
pimentel2015a, murta2014a, ref="",
<|code_end|>
, predict the next line using imports from the current file:
from snowballing.models import *
from snowballing import dbindex
from ..work.y2008 import freire2008a
from ..work.y2014 import murta2014a
from ..work.y2015 import pimentel2015a
and context including class names, function names, and sometimes code from other files:
# Path: snowballing/dbindex.py
# def citation_file(name):
# def year_file(year):
# def places_file():
# def this_file(filename):
# def discover_year(varname, year=None, fail_raise=True):
# def increment_char(letter):
# def increment_str(varname):
# def parse_varname(varname, group_index):
#
# Path: snowballing/bibtex/database/work/y2008.py
#
# Path: snowballing/bibtex/database/work/y2014.py
#
# Path: snowballing/bibtex/database/work/y2015.py
. Output only the next line. | contexts=[ |
Based on the snippet: <|code_start|># coding: utf-8
dbindex.last_citation_file = dbindex.this_file(__file__)
DB(Citation(
murta2014a, freire2008a, ref="[5]",
contexts=[
"There are two types of provenance for scientific workflows: prospective and retrospective [5]. Prospective provenance describes the structure of the experiment and corresponds to the workflow definition, the graph of the activities, and their associated parameters. Retrospective provenance captures the steps taken during the workflow execution, and while it has similar (graph) structure, it is constructed using information collected at runtime, including activities invoked and parameter values used, intermediate data produced, the execution start and end times, etc"
],
))
DB(Citation(
pimentel2015a, murta2014a, ref="",
contexts=[
<|code_end|>
, predict the immediate next line with the help of imports:
from snowballing.models import *
from snowballing import dbindex
from ..work.y2008 import freire2008a
from ..work.y2014 import murta2014a
from ..work.y2015 import pimentel2015a
and context (classes, functions, sometimes code) from other files:
# Path: snowballing/dbindex.py
# def citation_file(name):
# def year_file(year):
# def places_file():
# def this_file(filename):
# def discover_year(varname, year=None, fail_raise=True):
# def increment_char(letter):
# def increment_str(varname):
# def parse_varname(varname, group_index):
#
# Path: snowballing/bibtex/database/work/y2008.py
#
# Path: snowballing/bibtex/database/work/y2014.py
#
# Path: snowballing/bibtex/database/work/y2015.py
. Output only the next line. | ], |
Based on the snippet: <|code_start|>
def add(self, key, value):
return self.add_all(key, {value})
def replace(self, key, values):
if not self._enabled:
return self
self.rules[key] = values
return self
def old_form_to_new(show_deprecation=False):
if show_deprecation:
warnings.warn("""
The following attributes have been deprecated:
* config.FORM_BUTTONS
* config.FORM_TEXT_FIELDS
Please, consider upgrading to the new FORM definition format:
config.FORM = {
'widgets': ...,
'order': ...,
'events': ...,
}
<|code_end|>
, predict the immediate next line with the help of imports:
import warnings
from copy import copy, deepcopy
from itertools import zip_longest
from .collection_helpers import callable_get, setitem, consume
from .utils import match_any
from . import config
and context (classes, functions, sometimes code) from other files:
# Path: snowballing/collection_helpers.py
# def callable_get(collection, key, default=None, args=[]):
# """Get item from collection. Return collection applied to args, if it is callable"""
# result = collection.get(key, default)
# if callable(result):
# return result(*args)
# return result
#
# def setitem(info, key, value):
# """Set item in dict info if value is not None
#
# Doctest:
#
# .. doctest::
#
# >>> info = {}
# >>> setitem(info, 'def', 2)
# >>> info
# {'def': 2}
# >>> setitem(info, 'abc', None)
# >>> info
# {'def': 2}
# """
# if value is not None:
# info[key] = value
#
# def consume(info, key):
# """Consumes key from dict
#
# Arguments:
#
# * `info` -- dict
# * `key` -- key
#
# Doctest:
#
# .. doctest::
#
# >>> info = {'abc': 1, 'def': 2}
# >>> consume(info, 'abc')
# 1
# >>> info
# {'def': 2}
# >>> consume(info, 'abc') is None
# True
# """
# if key not in info:
# return None
# result = info[key]
# del info[key]
# return result
#
# Path: snowballing/utils.py
# def match_any(string, regexes):
# """Check if string matches any regex in list
#
# Doctest:
#
# .. doctest::
#
# >>> match_any("a", ["b", "c"])
# False
# >>> match_any("a", ["b", "c", "a"])
# True
# >>> match_any("_a", ["b", "c", "a"])
# False
# >>> match_any("_a", ["b", "c", "a", "_.*"])
# True
# """
# if len(regexes) >= 100:
# return any(re.match(regex + "$", string) for regex in regexes)
# else:
# combined = "({})".format(")|(".join(regex + "$" for regex in regexes))
# return bool(re.match(combined, string))
. Output only the next line. | For obtaining an equivalent form definition, run: |
Continue the code snippet: <|code_start|>
def prepend(self, key, value):
return self.prepend_all(key, [value])
def add_all(self, key, values):
if not self._enabled:
return self
if key not in self.rules:
self.rules[key] = set()
for value in values:
self.rules[key].add(value)
return self
def add(self, key, value):
return self.add_all(key, {value})
def replace(self, key, values):
if not self._enabled:
return self
self.rules[key] = values
return self
def old_form_to_new(show_deprecation=False):
if show_deprecation:
warnings.warn("""
The following attributes have been deprecated:
* config.FORM_BUTTONS
<|code_end|>
. Use current file imports:
import warnings
from copy import copy, deepcopy
from itertools import zip_longest
from .collection_helpers import callable_get, setitem, consume
from .utils import match_any
from . import config
and context (classes, functions, or code) from other files:
# Path: snowballing/collection_helpers.py
# def callable_get(collection, key, default=None, args=[]):
# """Get item from collection. Return collection applied to args, if it is callable"""
# result = collection.get(key, default)
# if callable(result):
# return result(*args)
# return result
#
# def setitem(info, key, value):
# """Set item in dict info if value is not None
#
# Doctest:
#
# .. doctest::
#
# >>> info = {}
# >>> setitem(info, 'def', 2)
# >>> info
# {'def': 2}
# >>> setitem(info, 'abc', None)
# >>> info
# {'def': 2}
# """
# if value is not None:
# info[key] = value
#
# def consume(info, key):
# """Consumes key from dict
#
# Arguments:
#
# * `info` -- dict
# * `key` -- key
#
# Doctest:
#
# .. doctest::
#
# >>> info = {'abc': 1, 'def': 2}
# >>> consume(info, 'abc')
# 1
# >>> info
# {'def': 2}
# >>> consume(info, 'abc') is None
# True
# """
# if key not in info:
# return None
# result = info[key]
# del info[key]
# return result
#
# Path: snowballing/utils.py
# def match_any(string, regexes):
# """Check if string matches any regex in list
#
# Doctest:
#
# .. doctest::
#
# >>> match_any("a", ["b", "c"])
# False
# >>> match_any("a", ["b", "c", "a"])
# True
# >>> match_any("_a", ["b", "c", "a"])
# False
# >>> match_any("_a", ["b", "c", "a", "_.*"])
# True
# """
# if len(regexes) >= 100:
# return any(re.match(regex + "$", string) for regex in regexes)
# else:
# combined = "({})".format(")|(".join(regex + "$" for regex in regexes))
# return bool(re.match(combined, string))
. Output only the next line. | * config.FORM_TEXT_FIELDS |
Predict the next line for this snippet: <|code_start|> return self.add_all(key, {value})
def replace(self, key, values):
if not self._enabled:
return self
self.rules[key] = values
return self
def old_form_to_new(show_deprecation=False):
if show_deprecation:
warnings.warn("""
The following attributes have been deprecated:
* config.FORM_BUTTONS
* config.FORM_TEXT_FIELDS
Please, consider upgrading to the new FORM definition format:
config.FORM = {
'widgets': ...,
'order': ...,
'events': ...,
}
For obtaining an equivalent form definition, run:
<|code_end|>
with the help of current file imports:
import warnings
from copy import copy, deepcopy
from itertools import zip_longest
from .collection_helpers import callable_get, setitem, consume
from .utils import match_any
from . import config
and context from other files:
# Path: snowballing/collection_helpers.py
# def callable_get(collection, key, default=None, args=[]):
# """Get item from collection. Return collection applied to args, if it is callable"""
# result = collection.get(key, default)
# if callable(result):
# return result(*args)
# return result
#
# def setitem(info, key, value):
# """Set item in dict info if value is not None
#
# Doctest:
#
# .. doctest::
#
# >>> info = {}
# >>> setitem(info, 'def', 2)
# >>> info
# {'def': 2}
# >>> setitem(info, 'abc', None)
# >>> info
# {'def': 2}
# """
# if value is not None:
# info[key] = value
#
# def consume(info, key):
# """Consumes key from dict
#
# Arguments:
#
# * `info` -- dict
# * `key` -- key
#
# Doctest:
#
# .. doctest::
#
# >>> info = {'abc': 1, 'def': 2}
# >>> consume(info, 'abc')
# 1
# >>> info
# {'def': 2}
# >>> consume(info, 'abc') is None
# True
# """
# if key not in info:
# return None
# result = info[key]
# del info[key]
# return result
#
# Path: snowballing/utils.py
# def match_any(string, regexes):
# """Check if string matches any regex in list
#
# Doctest:
#
# .. doctest::
#
# >>> match_any("a", ["b", "c"])
# False
# >>> match_any("a", ["b", "c", "a"])
# True
# >>> match_any("_a", ["b", "c", "a"])
# False
# >>> match_any("_a", ["b", "c", "a", "_.*"])
# True
# """
# if len(regexes) >= 100:
# return any(re.match(regex + "$", string) for regex in regexes)
# else:
# combined = "({})".format(")|(".join(regex + "$" for regex in regexes))
# return bool(re.match(combined, string))
, which may contain function names, class names, or code. Output only the next line. | from snowballing.rules import old_form_to_new |
Continue the code snippet: <|code_start|> self.rules[key] = set()
for value in values:
self.rules[key].add(value)
return self
def add(self, key, value):
return self.add_all(key, {value})
def replace(self, key, values):
if not self._enabled:
return self
self.rules[key] = values
return self
def old_form_to_new(show_deprecation=False):
if show_deprecation:
warnings.warn("""
The following attributes have been deprecated:
* config.FORM_BUTTONS
* config.FORM_TEXT_FIELDS
Please, consider upgrading to the new FORM definition format:
config.FORM = {
'widgets': ...,
'order': ...,
<|code_end|>
. Use current file imports:
import warnings
from copy import copy, deepcopy
from itertools import zip_longest
from .collection_helpers import callable_get, setitem, consume
from .utils import match_any
from . import config
and context (classes, functions, or code) from other files:
# Path: snowballing/collection_helpers.py
# def callable_get(collection, key, default=None, args=[]):
# """Get item from collection. Return collection applied to args, if it is callable"""
# result = collection.get(key, default)
# if callable(result):
# return result(*args)
# return result
#
# def setitem(info, key, value):
# """Set item in dict info if value is not None
#
# Doctest:
#
# .. doctest::
#
# >>> info = {}
# >>> setitem(info, 'def', 2)
# >>> info
# {'def': 2}
# >>> setitem(info, 'abc', None)
# >>> info
# {'def': 2}
# """
# if value is not None:
# info[key] = value
#
# def consume(info, key):
# """Consumes key from dict
#
# Arguments:
#
# * `info` -- dict
# * `key` -- key
#
# Doctest:
#
# .. doctest::
#
# >>> info = {'abc': 1, 'def': 2}
# >>> consume(info, 'abc')
# 1
# >>> info
# {'def': 2}
# >>> consume(info, 'abc') is None
# True
# """
# if key not in info:
# return None
# result = info[key]
# del info[key]
# return result
#
# Path: snowballing/utils.py
# def match_any(string, regexes):
# """Check if string matches any regex in list
#
# Doctest:
#
# .. doctest::
#
# >>> match_any("a", ["b", "c"])
# False
# >>> match_any("a", ["b", "c", "a"])
# True
# >>> match_any("_a", ["b", "c", "a"])
# False
# >>> match_any("_a", ["b", "c", "a", "_.*"])
# True
# """
# if len(regexes) >= 100:
# return any(re.match(regex + "$", string) for regex in regexes)
# else:
# combined = "({})".format(")|(".join(regex + "$" for regex in regexes))
# return bool(re.match(combined, string))
. Output only the next line. | 'events': ..., |
Given snippet: <|code_start|>
approach = Group(
murta2014a, pimentel2015a,
display="no Work flow",
approach_name="noWorkflow",
_cite=False,
_meta=[dict(
target=PYTHON,
)],
_about="""
<p>
noWorkflow (<a href="#murta2014a" class="reference">murta2014a</a>; <a href="#pimentel2015a" class="reference">pimentel2015a</a>) captures provenance from Python scripts for <span class="goal">comprehension</span>.
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from snowballing.approaches import Group
from ..constants import *
from ...work.y2014 import murta2014a
from ...work.y2015 import pimentel2015a
and context:
# Path: snowballing/approaches.py
# class Group:
# """Represent an Approach or a Group of work.
#
# Arguments:
#
# * `args` -- list of work that represents the group
#
# * `kwargs` -- map of attributes to be applied for the group and its works
#
# * Exception: the keyword `dont_cite=` also represents a list of works that
# belong to the group
#
#
# Expected attributes:
#
# * _cite: cite group by authors
#
# * True indicates that the approach must be referenced by its authors
# * False indicates that the approach can referenced by name
#
# * _meta: list of dicts with attributes for comparing approaches
#
# * A single approach can have more than one meta dict
# * It is possible to use the distinct meta dicts to describe different
# aspects
#
# * _about: HTML describing the approach
#
# Doctest:
#
# .. doctest::
#
# >>> from .operations import reload, work_by_varname
# >>> reload()
# >>> murta2014a = work_by_varname("murta2014a")
# >>> pimentel2015a = work_by_varname("pimentel2015a")
# >>> pimentel2015a.display == "now"
# False
# >>> APPROACHES.clear()
# >>> len(APPROACHES)
# 0
# >>> group = Group(
# ... murta2014a, pimentel2015a,
# ... display="now",
# ... _cite=True,
# ... _meta=[dict(
# ... scripts=True
# ... )]
# ... )
# >>> group.display
# 'now'
# >>> pimentel2015a.display == "now"
# True
# >>> len(APPROACHES)
# 1
# """
# _category = config.APPROACH_RELATED_CATEGORY
# def __init__(self, *args ,**kwargs):
# work = list(args)
# if dhas(kwargs, "approach_dont_cite"):
# work += dget(kwargs, "approach_dont_cite")
# oset(self, "approach_dont_cite", dget(kwargs, "approach_dont_cite"))
# ddel(kwargs, "approach_dont_cite")
# oset(self, "approach_work", work)
#
# for key, item in kwargs.items():
# for arg in work:
# if not hasattr(arg, config.APPROACH_FORCE_PREFIX + key):
# setattr(arg, key, item)
# setattr(self, key, item)
#
# if self._category == config.APPROACH_RELATED_CATEGORY:
# APPROACHES.append(self)
#
# Path: snowballing/example/database/work/y2014.py
#
# Path: snowballing/example/database/work/y2015.py
which might include code, classes, or functions. Output only the next line. | <span class="collection"> |
Given snippet: <|code_start|>
approach = Group(
murta2014a, pimentel2015a,
display="no Work flow",
approach_name="noWorkflow",
_cite=False,
_meta=[dict(
target=PYTHON,
)],
_about="""
<p>
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from snowballing.approaches import Group
from ..constants import *
from ...work.y2014 import murta2014a
from ...work.y2015 import pimentel2015a
and context:
# Path: snowballing/approaches.py
# class Group:
# """Represent an Approach or a Group of work.
#
# Arguments:
#
# * `args` -- list of work that represents the group
#
# * `kwargs` -- map of attributes to be applied for the group and its works
#
# * Exception: the keyword `dont_cite=` also represents a list of works that
# belong to the group
#
#
# Expected attributes:
#
# * _cite: cite group by authors
#
# * True indicates that the approach must be referenced by its authors
# * False indicates that the approach can referenced by name
#
# * _meta: list of dicts with attributes for comparing approaches
#
# * A single approach can have more than one meta dict
# * It is possible to use the distinct meta dicts to describe different
# aspects
#
# * _about: HTML describing the approach
#
# Doctest:
#
# .. doctest::
#
# >>> from .operations import reload, work_by_varname
# >>> reload()
# >>> murta2014a = work_by_varname("murta2014a")
# >>> pimentel2015a = work_by_varname("pimentel2015a")
# >>> pimentel2015a.display == "now"
# False
# >>> APPROACHES.clear()
# >>> len(APPROACHES)
# 0
# >>> group = Group(
# ... murta2014a, pimentel2015a,
# ... display="now",
# ... _cite=True,
# ... _meta=[dict(
# ... scripts=True
# ... )]
# ... )
# >>> group.display
# 'now'
# >>> pimentel2015a.display == "now"
# True
# >>> len(APPROACHES)
# 1
# """
# _category = config.APPROACH_RELATED_CATEGORY
# def __init__(self, *args ,**kwargs):
# work = list(args)
# if dhas(kwargs, "approach_dont_cite"):
# work += dget(kwargs, "approach_dont_cite")
# oset(self, "approach_dont_cite", dget(kwargs, "approach_dont_cite"))
# ddel(kwargs, "approach_dont_cite")
# oset(self, "approach_work", work)
#
# for key, item in kwargs.items():
# for arg in work:
# if not hasattr(arg, config.APPROACH_FORCE_PREFIX + key):
# setattr(arg, key, item)
# setattr(self, key, item)
#
# if self._category == config.APPROACH_RELATED_CATEGORY:
# APPROACHES.append(self)
#
# Path: snowballing/example/database/work/y2014.py
#
# Path: snowballing/example/database/work/y2015.py
which might include code, classes, or functions. Output only the next line. | noWorkflow (<a href="#murta2014a" class="reference">murta2014a</a>; <a href="#pimentel2015a" class="reference">pimentel2015a</a>) captures provenance from Python scripts for <span class="goal">comprehension</span>. |
Based on the snippet: <|code_start|>
approach = Group(
murta2014a, pimentel2015a,
display="no Work flow",
approach_name="noWorkflow",
_cite=False,
_meta=[dict(
target=PYTHON,
)],
<|code_end|>
, predict the immediate next line with the help of imports:
from snowballing.approaches import Group
from ..constants import *
from ...work.y2014 import murta2014a
from ...work.y2015 import pimentel2015a
and context (classes, functions, sometimes code) from other files:
# Path: snowballing/approaches.py
# class Group:
# """Represent an Approach or a Group of work.
#
# Arguments:
#
# * `args` -- list of work that represents the group
#
# * `kwargs` -- map of attributes to be applied for the group and its works
#
# * Exception: the keyword `dont_cite=` also represents a list of works that
# belong to the group
#
#
# Expected attributes:
#
# * _cite: cite group by authors
#
# * True indicates that the approach must be referenced by its authors
# * False indicates that the approach can referenced by name
#
# * _meta: list of dicts with attributes for comparing approaches
#
# * A single approach can have more than one meta dict
# * It is possible to use the distinct meta dicts to describe different
# aspects
#
# * _about: HTML describing the approach
#
# Doctest:
#
# .. doctest::
#
# >>> from .operations import reload, work_by_varname
# >>> reload()
# >>> murta2014a = work_by_varname("murta2014a")
# >>> pimentel2015a = work_by_varname("pimentel2015a")
# >>> pimentel2015a.display == "now"
# False
# >>> APPROACHES.clear()
# >>> len(APPROACHES)
# 0
# >>> group = Group(
# ... murta2014a, pimentel2015a,
# ... display="now",
# ... _cite=True,
# ... _meta=[dict(
# ... scripts=True
# ... )]
# ... )
# >>> group.display
# 'now'
# >>> pimentel2015a.display == "now"
# True
# >>> len(APPROACHES)
# 1
# """
# _category = config.APPROACH_RELATED_CATEGORY
# def __init__(self, *args ,**kwargs):
# work = list(args)
# if dhas(kwargs, "approach_dont_cite"):
# work += dget(kwargs, "approach_dont_cite")
# oset(self, "approach_dont_cite", dget(kwargs, "approach_dont_cite"))
# ddel(kwargs, "approach_dont_cite")
# oset(self, "approach_work", work)
#
# for key, item in kwargs.items():
# for arg in work:
# if not hasattr(arg, config.APPROACH_FORCE_PREFIX + key):
# setattr(arg, key, item)
# setattr(self, key, item)
#
# if self._category == config.APPROACH_RELATED_CATEGORY:
# APPROACHES.append(self)
#
# Path: snowballing/example/database/work/y2014.py
#
# Path: snowballing/example/database/work/y2015.py
. Output only the next line. | _about=""" |
Given the code snippet: <|code_start|># coding: utf-8
dbindex.last_citation_file = dbindex.this_file(__file__)
DB(Citation(
murta2014a, freire2008a, ref="5",
contexts=[
"There are two types of provenance for scientific workflows: prospective and retrospective [5]. Prospective provenance describes the structure of the experiment and corresponds to the workflow definition, the graph of the activities, and their associated parameters. Retrospective provenance captures the steps taken during the workflow execution, and while it has similar (graph) structure, it is constructed using information collected at runtime, including activities invoked and parameter values used, intermediate data produced, the execution start and end times, etc"
],
))
DB(Citation(
pimentel2015a, murta2014a, ref="",
contexts=[
],
<|code_end|>
, generate the next line using the imports in this file:
from snowballing.models import *
from snowballing import dbindex
from ..work.y2008 import freire2008a
from ..work.y2014 import murta2014a
from ..work.y2015 import pimentel2015a
and context (functions, classes, or occasionally code) from other files:
# Path: snowballing/dbindex.py
# def citation_file(name):
# def year_file(year):
# def places_file():
# def this_file(filename):
# def discover_year(varname, year=None, fail_raise=True):
# def increment_char(letter):
# def increment_str(varname):
# def parse_varname(varname, group_index):
#
# Path: snowballing/example/database/work/y2008.py
#
# Path: snowballing/example/database/work/y2014.py
#
# Path: snowballing/example/database/work/y2015.py
. Output only the next line. | )) |
Based on the snippet: <|code_start|># coding: utf-8
dbindex.last_citation_file = dbindex.this_file(__file__)
DB(Citation(
murta2014a, freire2008a, ref="5",
contexts=[
"There are two types of provenance for scientific workflows: prospective and retrospective [5]. Prospective provenance describes the structure of the experiment and corresponds to the workflow definition, the graph of the activities, and their associated parameters. Retrospective provenance captures the steps taken during the workflow execution, and while it has similar (graph) structure, it is constructed using information collected at runtime, including activities invoked and parameter values used, intermediate data produced, the execution start and end times, etc"
<|code_end|>
, predict the immediate next line with the help of imports:
from snowballing.models import *
from snowballing import dbindex
from ..work.y2008 import freire2008a
from ..work.y2014 import murta2014a
from ..work.y2015 import pimentel2015a
and context (classes, functions, sometimes code) from other files:
# Path: snowballing/dbindex.py
# def citation_file(name):
# def year_file(year):
# def places_file():
# def this_file(filename):
# def discover_year(varname, year=None, fail_raise=True):
# def increment_char(letter):
# def increment_str(varname):
# def parse_varname(varname, group_index):
#
# Path: snowballing/example/database/work/y2008.py
#
# Path: snowballing/example/database/work/y2014.py
#
# Path: snowballing/example/database/work/y2015.py
. Output only the next line. | ], |
Given snippet: <|code_start|># coding: utf-8
dbindex.last_citation_file = dbindex.this_file(__file__)
DB(Citation(
murta2014a, freire2008a, ref="5",
contexts=[
"There are two types of provenance for scientific workflows: prospective and retrospective [5]. Prospective provenance describes the structure of the experiment and corresponds to the workflow definition, the graph of the activities, and their associated parameters. Retrospective provenance captures the steps taken during the workflow execution, and while it has similar (graph) structure, it is constructed using information collected at runtime, including activities invoked and parameter values used, intermediate data produced, the execution start and end times, etc"
],
))
DB(Citation(
pimentel2015a, murta2014a, ref="",
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from snowballing.models import *
from snowballing import dbindex
from ..work.y2008 import freire2008a
from ..work.y2014 import murta2014a
from ..work.y2015 import pimentel2015a
and context:
# Path: snowballing/dbindex.py
# def citation_file(name):
# def year_file(year):
# def places_file():
# def this_file(filename):
# def discover_year(varname, year=None, fail_raise=True):
# def increment_char(letter):
# def increment_str(varname):
# def parse_varname(varname, group_index):
#
# Path: snowballing/example/database/work/y2008.py
#
# Path: snowballing/example/database/work/y2014.py
#
# Path: snowballing/example/database/work/y2015.py
which might include code, classes, or functions. Output only the next line. | contexts=[ |
Next line prediction: <|code_start|># coding: utf-8
dbindex.last_citation_file = dbindex.this_file(__file__)
DB(Citation(
murta2014a, freire2008a, ref="5",
contexts=[
"There are two types of provenance for scientific workflows: prospective and retrospective [5]. Prospective provenance describes the structure of the experiment and corresponds to the workflow definition, the graph of the activities, and their associated parameters. Retrospective provenance captures the steps taken during the workflow execution, and while it has similar (graph) structure, it is constructed using information collected at runtime, including activities invoked and parameter values used, intermediate data produced, the execution start and end times, etc"
],
))
DB(Citation(
pimentel2015a, murta2014a, ref="",
contexts=[
],
<|code_end|>
. Use current file imports:
(from snowballing.models import *
from snowballing import dbindex
from ..work.y2008 import freire2008a
from ..work.y2014 import murta2014a
from ..work.y2015 import pimentel2015a)
and context including class names, function names, or small code snippets from other files:
# Path: snowballing/dbindex.py
# def citation_file(name):
# def year_file(year):
# def places_file():
# def this_file(filename):
# def discover_year(varname, year=None, fail_raise=True):
# def increment_char(letter):
# def increment_str(varname):
# def parse_varname(varname, group_index):
#
# Path: snowballing/example/database/work/y2008.py
#
# Path: snowballing/example/database/work/y2014.py
#
# Path: snowballing/example/database/work/y2015.py
. Output only the next line. | )) |
Given snippet: <|code_start|>
def hooks(display_step, last_step, batch_size, loss, accuracy):
return [
tf.train.StopAtStepHook(last_step=last_step),
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import tensorflow as tf
from .logger import (StepLoggerHook,
LossLoggerHook,
AccuracyLoggerHook,
TimeLoggerHook,
EolLoggerHook)
and context:
# Path: model/logger/step.py
# class StepLoggerHook(LoggerHook):
#
# def __init__(self, display_step, last_step):
# super().__init__(display_step)
#
# self._last_step_length = len(str(last_step))
#
# def after_display_step_run(self, run_context, run_values):
# s = '[step {:0{}d}]'.format(self._step, self._last_step_length)
#
# print(s, end=' ')
#
# Path: model/logger/time.py
# class TimeLoggerHook(LoggerHook):
#
# def __init__(self, display_step, batch_size, last_step):
# super().__init__(display_step)
#
# self._batch_size = batch_size
# self._last_step = last_step
#
# def before_display_step_run(self, run_context):
# self._start_time = time.time()
#
# def after_display_step_run(self, run_context, run_values):
# duration = time.time() - self._start_time
# remaining = (self._last_step - self._step) * duration / 60
# examples_per_sec = self._batch_size / duration
#
# s = ', '.join([
# '[{:.1f} examples/sec'.format(examples_per_sec),
# '{:.2f} sec/batch'.format(duration),
# '{:.1f} min remaining]'.format(remaining),
# ])
#
# print(s, end=' ')
#
# Path: model/logger/loss.py
# class LossLoggerHook(LoggerHook):
#
# def __init__(self, display_step, loss):
# super().__init__(display_step)
#
# self._loss = loss
#
# def before_display_step_run(self, run_context):
# return tf.train.SessionRunArgs(self._loss)
#
# def after_display_step_run(self, run_context, run_values):
# loss = run_values.results
#
# s = '[loss = {:.2f}]'.format(loss)
#
# print(s, end=' ')
#
# Path: model/logger/accuracy.py
# class AccuracyLoggerHook(LoggerHook):
#
# def __init__(self, display_step, accuracy):
# super().__init__(display_step)
#
# self._accuracy = accuracy
#
# def before_display_step_run(self, run_context):
# return tf.train.SessionRunArgs(self._accuracy)
#
# def after_display_step_run(self, run_context, run_values):
# accuracy = run_values.results
#
# s = '[accuracy = {:.2f}]'.format(accuracy)
#
# print(s, end=' ')
#
# Path: model/logger/eol.py
# class EolLoggerHook(LoggerHook):
#
# def __init__(self, display_step):
# super().__init__(display_step)
#
# def after_display_step_run(self, run_context, run_values):
# print('')
which might include code, classes, or functions. Output only the next line. | tf.train.NanTensorHook(loss), |
Using the snippet: <|code_start|>from __future__ import print_function
class StepLoggerHook(LoggerHook):
def __init__(self, display_step, last_step):
<|code_end|>
, determine the next line of code. You have imports:
from .logger import LoggerHook
and context (class names, function names, or code) available:
# Path: model/logger/logger.py
# class LoggerHook(tf.train.SessionRunHook):
#
# def __init__(self, display_step):
# self._display_step = display_step
#
# def begin(self):
# self._step = -1
#
# def before_run(self, run_context):
# self._step += 1
#
# if self._step % self._display_step == 0:
# return self.before_display_step_run(run_context)
#
# def after_run(self, run_context, run_values):
# if self._step % self._display_step == 0:
# self.after_display_step_run(run_context, run_values)
#
# def before_display_step_run(self, run_context):
# pass
#
# def after_display_step_run(self, run_context, run_values):
# pass
. Output only the next line. | super().__init__(display_step) |
Given snippet: <|code_start|>from __future__ import print_function
class TimeLoggerHook(LoggerHook):
def __init__(self, display_step, batch_size, last_step):
super().__init__(display_step)
self._batch_size = batch_size
self._last_step = last_step
def before_display_step_run(self, run_context):
self._start_time = time.time()
def after_display_step_run(self, run_context, run_values):
duration = time.time() - self._start_time
remaining = (self._last_step - self._step) * duration / 60
examples_per_sec = self._batch_size / duration
s = ', '.join([
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import time
from datetime import datetime
from .logger import LoggerHook
and context:
# Path: model/logger/logger.py
# class LoggerHook(tf.train.SessionRunHook):
#
# def __init__(self, display_step):
# self._display_step = display_step
#
# def begin(self):
# self._step = -1
#
# def before_run(self, run_context):
# self._step += 1
#
# if self._step % self._display_step == 0:
# return self.before_display_step_run(run_context)
#
# def after_run(self, run_context, run_values):
# if self._step % self._display_step == 0:
# self.after_display_step_run(run_context, run_values)
#
# def before_display_step_run(self, run_context):
# pass
#
# def after_display_step_run(self, run_context, run_values):
# pass
which might include code, classes, or functions. Output only the next line. | '[{:.1f} examples/sec'.format(examples_per_sec), |
Based on the snippet: <|code_start|>
class SlicTest(tf.test.TestCase):
def test_slic(self):
image = tf.constant([
[[255, 255, 255], [255, 255, 255], [0, 0, 0], [0, 0, 0]],
[[255, 255, 255], [255, 255, 255], [0, 0, 0], [0, 0, 0]],
[[0, 0, 0], [0, 0, 0], [255, 255, 255], [255, 255, 255]],
[[0, 0, 0], [0, 0, 0], [255, 255, 255], [255, 255, 255]],
])
expected = [
<|code_end|>
, predict the immediate next line with the help of imports:
import tensorflow as tf
from .slic import slic
and context (classes, functions, sometimes code) from other files:
# Path: segmentation/algorithm/slic.py
# def slic(image, num_segments=NUM_SEGMENTS, compactness=COMPACTNESS,
# max_iterations=MAX_ITERATIONS, sigma=SIGMA,
# min_size_factor=MIN_SIZE_FACTOR, max_size_factor=MAX_SIZE_FACTOR,
# enforce_connectivity=CONNECTIVITY):
# """Segments an image using k-means clustering in Color-(x,y,z) space.
#
# Args:
# image: The image.
# num_segments: The (approiximate) number of segments in the segmented
# output image (optional).
# compactness: Balances color-space proximity and image-space-proximity.
# Higher values give more weight to image-space proximity (optional).
# max_iterations: Maximum number of iterations of k-means.
# sigma: Width of Gaussian kernel used in preprocessing (optional).
# min_size_factor: Proportion of the minimum segment size to be removed
# with respect to the supposed segment size
# `depth*width*height/num_segments` (optional).
# max_size_factor: Proportion of the maximum connected segment size
# (optional).
# enforce_connectivitiy: Whether the generated segments are connected or
# not (optional).
#
# Returns:
# Integer mask indicating segment labels.
# """
#
# image = tf.cast(image, tf.uint8)
#
# def _slic(image):
# segmentation = skimage_slic(image, num_segments, compactness,
# max_iterations, sigma,
# min_size_factor=min_size_factor,
# max_size_factor=max_size_factor,
# enforce_connectivity=enforce_connectivity,
# slic_zero=False)
# return segmentation.astype(np.int32)
#
# return tf.py_func(_slic, [image], tf.int32, stateful=False, name='slic')
. Output only the next line. | [0, 0, 1, 1], |
Given snippet: <|code_start|>
class SlicoTest(tf.test.TestCase):
def test_slico(self):
image = tf.constant([
[[255, 255, 255], [255, 255, 255], [0, 0, 0], [0, 0, 0]],
[[255, 255, 255], [255, 255, 255], [0, 0, 0], [0, 0, 0]],
[[0, 0, 0], [0, 0, 0], [255, 255, 255], [255, 255, 255]],
[[0, 0, 0], [0, 0, 0], [255, 255, 255], [255, 255, 255]],
])
expected = [
[0, 0, 1, 1],
[0, 0, 1, 1],
[2, 2, 3, 3],
[2, 2, 3, 3],
]
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import tensorflow as tf
from .slico import slico
and context:
# Path: segmentation/algorithm/slico.py
# def slico(image, num_segments=NUM_SEGMENTS, compactness=COMPACTNESS,
# max_iterations=MAX_ITERATIONS, sigma=SIGMA,
# min_size_factor=MIN_SIZE_FACTOR, max_size_factor=MAX_SIZE_FACTOR,
# enforce_connectivity=CONNECTIVITY):
# """Segments an image using k-means clustering in Color-(x,y,z) space.
#
# Args:
# image: The image.
# num_segments: The (approiximate) number of segments in the segmented
# output image (optional).
# compactness: Initial value to balance color-space proximity and
# image-space-proximity. Higher values give more weight to image-space
# proximity (optional).
# max_iterations: Maximum number of iterations of k-means.
# sigma: Width of Gaussian kernel used in preprocessing (optional).
# min_size_factor: Proportion of the minimum segment size to be removed
# with respect to the supposed segment size
# `depth*width*height/num_segments` (optional).
# max_size_factor: Proportion of the maximum connected segment size
# (optional).
# enforce_connectivitiy: Whether the generated segments are connected or
# not (optional).
#
# Returns:
# Segmentation algorithm that takes a single image as argument.
# """
#
# image = tf.cast(image, tf.uint8)
#
# def _slico(image):
# segmentation = skimage_slic(image, num_segments, compactness,
# max_iterations, sigma,
# min_size_factor=min_size_factor,
# max_size_factor=max_size_factor,
# enforce_connectivity=enforce_connectivity,
# slic_zero=True)
# return segmentation.astype(np.int32)
#
# return tf.py_func(_slico, [image], tf.int32, stateful=False, name='slico')
which might include code, classes, or functions. Output only the next line. | with self.test_session() as sess: |
Given snippet: <|code_start|>
class FelzenszwalbTest(tf.test.TestCase):
def test_felzenszwalb(self):
image = tf.constant([
[[255, 255, 255], [255, 255, 255], [0, 0, 0], [0, 0, 0]],
[[255, 255, 255], [255, 255, 255], [0, 0, 0], [0, 0, 0]],
[[0, 0, 0], [0, 0, 0], [255, 255, 255], [255, 255, 255]],
[[0, 0, 0], [0, 0, 0], [255, 255, 255], [255, 255, 255]],
])
expected = [
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import tensorflow as tf
from .felzenszwalb import felzenszwalb
and context:
# Path: segmentation/algorithm/felzenszwalb.py
# def felzenszwalb(image, scale=SCALE, sigma=SIGMA, min_size=MIN_SIZE):
# """Computes Felsenszwalb's efficient graph based image segmentation.
#
# Args:
# image: The image.
# scale: Float indicating largeness of clusters (optional).
# sigma: Width of Gaussian kernel used in preprocessing (optional).
# min_size: Minimum component size. Enforced using postprocessing
# (optional).
#
# Returns:
# Integer mask indicating segment labels.
# """
#
# image = tf.cast(image, tf.uint8)
#
# def _felzenszwalb(image):
# segmentation = skimage_felzenszwalb(image, scale, sigma, min_size)
# return segmentation.astype(np.int32)
#
# return tf.py_func(_felzenszwalb, [image], tf.int32, stateful=False,
# name='felzenszwalb')
which might include code, classes, or functions. Output only the next line. | [0, 0, 0, 0], |
Next line prediction: <|code_start|>from __future__ import division
class AdjacencyTest(tf.test.TestCase):
def test_adjacency_unweighted(self):
segmentation = tf.constant([
[0, 0, 1, 1],
[0, 0, 0, 1],
[2, 0, 0, 3],
[2, 2, 3, 3],
], dtype=tf.int32)
expected = [
[0, 1, 1, 1],
[1, 0, 0, 1],
[1, 0, 0, 1],
<|code_end|>
. Use current file imports:
(import tensorflow as tf
import numpy as np
from .adjacency import adjacency_unweighted, adjacency_euclidean_distance)
and context including class names, function names, or small code snippets from other files:
# Path: segmentation/adjacency.py
# def adjacency_unweighted(segmentation, connectivity=CONNECTIVITY):
# """Computes the adjacency matrix of the Region Adjacency Graph.
#
# Given an segmentation, this method constructs the constructs the
# corresponding Region Adjacency Graphh (RAG). Each node in the RAG
# represents a set of pixels with the same label in `segmentation`. An edge
# between two nodes exist if the nodes are spatial connected.
#
# Args:
# segmentation: The segmentation.
# connectivity: Integer. Pixels with a squared distance less than
# `connectivity` from each other are considered adjacent (optional).
#
# Returns:
# An adjacent matrix with shape [num_segments, num_segments].
# """
#
# def _adjacency(segmentation):
# graph = RAG(segmentation, connectivity=connectivity)
#
# # Simply return the unweighted adjacency matrix of the computed graph.
# return nx.to_numpy_matrix(graph, dtype=np.float32)
#
# return tf.py_func(
# _adjacency, [segmentation], tf.float32, stateful=False,
# name='adjacency_unweighted')
#
# def adjacency_euclidean_distance(segmentation, connectivity=CONNECTIVITY):
# """Computes the adjacency matrix of the Region Adjacency Graph using the
# euclidian distance between the centroids of adjacent segments.
#
# Given an segmentation, this method constructs the constructs the
# corresponding Region Adjacency Graphh (RAG). Each node in the RAG
# represents a set of pixels with the same label in `segmentation`. An edge
# between two nodes exist if the nodes are spatial connected. The weight
# between two adjacent regions represents represents how nearby tow segments
# are.
#
# Args:
# segmentation: The segmentation.
# connectivity: Integer. Pixels with a squared distance less than
# `connectivity` from each other are considered adjacent (optional).
#
# Returns:
# An adjacent matrix with shape [num_segments, num_segments].
# """
#
# def _adjacency_euclidean_distance(segmentation):
# graph = RAG(segmentation, connectivity=connectivity)
#
# # Initialize the node's data for computing their centroids.
# for n in graph:
# graph.node[n].update({'count': 0,
# 'centroid': np.zeros((2), dtype=np.float32)})
#
# # Run through each segmentation pixel and add the pixel's coordinates
# # to the centroid data.
# for index in np.ndindex(segmentation.shape):
# current = segmentation[index]
# graph.node[current]['count'] += 1
# graph.node[current]['centroid'] += index
#
# # Centroid is the sum of all pixel coordinates / pixel count.
# for n in graph:
# graph.node[n]['centroid'] = (graph.node[n]['centroid'] /
# graph.node[n]['count'])
#
# # Run through each edge and calculate the euclidian distance based on
# # the two node's centroids.
# for n1, n2, d in graph.edges_iter(data=True):
# diff = graph.node[n1]['centroid'] - graph.node[n2]['centroid']
# d['weight'] = np.linalg.norm(diff)
#
# # Return graph as adjacency matrix.
# return nx.to_numpy_matrix(graph, dtype=np.float32)
#
# return tf.py_func(
# _adjacency_euclidean_distance, [segmentation], tf.float32,
# stateful=False, name='adjacency_euclid_distance')
. Output only the next line. | [1, 1, 1, 0], |
Using the snippet: <|code_start|>
with self.test_session() as sess:
adjacency_matrix = adjacency_unweighted(segmentation)
self.assertAllEqual(adjacency_matrix.eval(), expected)
def test_adjacency_euclidean_distance(self):
segmentation = tf.constant([
[0, 0, 1, 1],
[0, 0, 0, 1],
[2, 0, 0, 3],
[2, 2, 3, 3],
], dtype=tf.int32)
c = np.array([
[(0+1+0+1+2+1+2)/7, (0+1+0+1+2+1+2)/7],
[(0+0+1)/3, (2+3+3)/3],
[(2+3+3)/3, (0+0+1)/3],
[(3+2+3)/3, (3+2+3)/3],
], dtype=np.float32)
def _distance(centroid, index1, index2):
return np.linalg.norm(centroid[index1] - centroid[index2])
expected = [
[0, _distance(c, 0, 1), _distance(c, 0, 2), _distance(c, 0, 3)],
[_distance(c, 1, 0), 0, 0, _distance(c, 1, 3)],
[_distance(c, 2, 0), 0, 0, _distance(c, 2, 3)],
[_distance(c, 3, 0), _distance(c, 3, 1), _distance(c, 3, 2), 0],
]
<|code_end|>
, determine the next line of code. You have imports:
import tensorflow as tf
import numpy as np
from .adjacency import adjacency_unweighted, adjacency_euclidean_distance
and context (class names, function names, or code) available:
# Path: segmentation/adjacency.py
# def adjacency_unweighted(segmentation, connectivity=CONNECTIVITY):
# """Computes the adjacency matrix of the Region Adjacency Graph.
#
# Given an segmentation, this method constructs the constructs the
# corresponding Region Adjacency Graphh (RAG). Each node in the RAG
# represents a set of pixels with the same label in `segmentation`. An edge
# between two nodes exist if the nodes are spatial connected.
#
# Args:
# segmentation: The segmentation.
# connectivity: Integer. Pixels with a squared distance less than
# `connectivity` from each other are considered adjacent (optional).
#
# Returns:
# An adjacent matrix with shape [num_segments, num_segments].
# """
#
# def _adjacency(segmentation):
# graph = RAG(segmentation, connectivity=connectivity)
#
# # Simply return the unweighted adjacency matrix of the computed graph.
# return nx.to_numpy_matrix(graph, dtype=np.float32)
#
# return tf.py_func(
# _adjacency, [segmentation], tf.float32, stateful=False,
# name='adjacency_unweighted')
#
# def adjacency_euclidean_distance(segmentation, connectivity=CONNECTIVITY):
# """Computes the adjacency matrix of the Region Adjacency Graph using the
# euclidian distance between the centroids of adjacent segments.
#
# Given an segmentation, this method constructs the constructs the
# corresponding Region Adjacency Graphh (RAG). Each node in the RAG
# represents a set of pixels with the same label in `segmentation`. An edge
# between two nodes exist if the nodes are spatial connected. The weight
# between two adjacent regions represents represents how nearby tow segments
# are.
#
# Args:
# segmentation: The segmentation.
# connectivity: Integer. Pixels with a squared distance less than
# `connectivity` from each other are considered adjacent (optional).
#
# Returns:
# An adjacent matrix with shape [num_segments, num_segments].
# """
#
# def _adjacency_euclidean_distance(segmentation):
# graph = RAG(segmentation, connectivity=connectivity)
#
# # Initialize the node's data for computing their centroids.
# for n in graph:
# graph.node[n].update({'count': 0,
# 'centroid': np.zeros((2), dtype=np.float32)})
#
# # Run through each segmentation pixel and add the pixel's coordinates
# # to the centroid data.
# for index in np.ndindex(segmentation.shape):
# current = segmentation[index]
# graph.node[current]['count'] += 1
# graph.node[current]['centroid'] += index
#
# # Centroid is the sum of all pixel coordinates / pixel count.
# for n in graph:
# graph.node[n]['centroid'] = (graph.node[n]['centroid'] /
# graph.node[n]['count'])
#
# # Run through each edge and calculate the euclidian distance based on
# # the two node's centroids.
# for n1, n2, d in graph.edges_iter(data=True):
# diff = graph.node[n1]['centroid'] - graph.node[n2]['centroid']
# d['weight'] = np.linalg.norm(diff)
#
# # Return graph as adjacency matrix.
# return nx.to_numpy_matrix(graph, dtype=np.float32)
#
# return tf.py_func(
# _adjacency_euclidean_distance, [segmentation], tf.float32,
# stateful=False, name='adjacency_euclid_distance')
. Output only the next line. | with self.test_session() as sess: |
Given snippet: <|code_start|>
class QuickshiftTest(tf.test.TestCase):
def test_quickshift(self):
image = tf.constant([
[[255, 255, 255], [255, 255, 255], [0, 0, 0], [0, 0, 0]],
[[255, 255, 255], [255, 255, 255], [0, 0, 0], [0, 0, 0]],
[[0, 0, 0], [0, 0, 0], [255, 255, 255], [255, 255, 255]],
[[0, 0, 0], [0, 0, 0], [255, 255, 255], [255, 255, 255]],
])
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import tensorflow as tf
from .quickshift import quickshift
and context:
# Path: segmentation/algorithm/quickshift.py
# def quickshift(image, ratio=RATIO, kernel_size=KERNEL_SIZE,
# max_distance=MAX_DISTANCE, sigma=SIGMA):
# """Segments an image using quickshift clustering in Color-(x,y) space.
#
# Args:
# image: The image.
# ratio: Float in range [0, 1] that balances color-space proximity
# and image-space-proximity. Higher values give more weight to
# colorspace (optional).
# kernel_size: Width of Gaussian kernel used in smoothing the sample
# density. Higher means fewer clusters (optional).
# max_distance: Cut-off point for data distances. Higher means fewer
# clusters (optional).
# sigma: Width of Gaussian kernel used in preprocessing (optional).
#
# Returns:
# Integer mask indicating segment labels.
# """
#
# image = tf.cast(image, tf.uint8)
#
# def _quickshift(image):
# segmentation = skimage_quickshift(image, ratio, kernel_size,
# max_distance, sigma=sigma)
# return segmentation.astype(np.int32)
#
# # TODO quickshift is stateful?
# return tf.py_func(_quickshift, [image], tf.int32, stateful=True,
# name='quickshift')
which might include code, classes, or functions. Output only the next line. | expected = [ |
Here is a snippet: <|code_start|>
with self.test_session() as sess:
neighborhoods = neighborhoods_weights_to_root(
adjacency, sequence, size)
self.assertAllEqual(neighborhoods.eval(), expected)
def test_grid_spiral(self):
sequence = tf.constant([5, 6])
# 3x4 Grid
adjacency = tf.constant([
[0, 1, 0, 0, 1, sqrt(2), 0, 0, 0, 0, 0, 0],
[1, 0, 1, 0, sqrt(2), 1, sqrt(2), 0, 0, 0, 0, 0],
[0, 1, 0, 1, 0, sqrt(2), 1, sqrt(2), 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, sqrt(2), 1, 0, 0, 0, 0],
[1, sqrt(2), 0, 0, 0, 1, 0, 0, 1, sqrt(2), 0, 0],
[sqrt(2), 1, sqrt(2), 0, 1, 0, 1, 0, sqrt(2), 1, sqrt(2), 0],
[0, sqrt(2), 1, sqrt(2), 0, 1, 0, 1, 0, sqrt(2), 1, sqrt(2)],
[0, 0, sqrt(2), 1, 0, 0, 1, 0, 0, 0, sqrt(2), 1],
[0, 0, 0, 0, 1, sqrt(2), 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, sqrt(2), 1, sqrt(2), 0, 1, 0, 1, 0],
[0, 0, 0, 0, 0, sqrt(2), 1, sqrt(2), 0, 1, 0, 1],
[0, 0, 0, 0, 0, 0, sqrt(2), 1, 0, 0, 1, 0]
])
size = 13
expected = [
[5, 1, 0, 4, 8, 9, 10, 6, 2, 3, 7, 11, -1],
[6, 2, 1, 5, 9, 10, 11, 7, 3, -1, -1, -1, -1],
<|code_end|>
. Write the next line using the current file imports:
from math import sqrt
from .neighborhood_assembly import neighborhoods_weights_to_root,\
neighborhoods_grid_spiral
import tensorflow as tf
and context from other files:
# Path: patchy/helper/neighborhood_assembly.py
# def neighborhoods_weights_to_root(adjacency, sequence, size):
# def _neighborhoods_weights_to_root(adjacency, sequence):
# graph = nx.from_numpy_matrix(adjacency)
#
# neighborhoods = np.zeros((sequence.shape[0], size), dtype=np.int32)
# neighborhoods.fill(-1)
#
# for i in xrange(0, sequence.shape[0]):
# n = sequence[i]
# if n < 0:
# break
#
# shortest = nx.single_source_dijkstra_path_length(graph, n).items()
# shortest = sorted(shortest, key=lambda v: v[1])
# shortest = shortest[:size]
#
# for j in xrange(0, min(size, len(shortest))):
# neighborhoods[i][j] = shortest[j][0]
#
# return neighborhoods
#
# return tf.py_func(_neighborhoods_weights_to_root, [adjacency, sequence],
# tf.int32, stateful=False,
# name='neighborhoods_weights_to_root')
#
# def neighborhoods_grid_spiral(adjacency, sequence, size):
# def _neighborhoods_grid_spiral(adjacency, sequence):
# graph = nx.from_numpy_matrix(adjacency)
#
# neighborhoods = np.zeros((sequence.shape[0], size), dtype=np.int32)
# neighborhoods.fill(-1)
#
# # Note: This method just works properly on planar graphs where nodes
# # are placed in a grid like layout and are weighted by distance.
# #
# # Add root to arr => [root]
# # Find nearest neighbor x to root
# # Add x => arr = [root, x]
# # Find nearest neighbor y with n(x, y) and min w(x,y) + w(root, y)
# # that is not already in arr.
# # set x = y
# # repeat until arr.length == size
#
# for i in xrange(0, sequence.shape[0]):
# root = sequence[i]
# if root < 0:
# break
#
# # Add root node to the beginning of the neighborhood.
# neighborhoods[i][0] = root
# x = root
#
# ws = nx.single_source_dijkstra_path_length(graph, root)
# ws = list(ws.items())
#
# for j in xrange(1, size):
# if x == -1:
# break
#
# y = -1
# weight = float('inf')
# for _, n, d, in graph.edges_iter(x, data=True):
# if n in neighborhoods[i]:
# continue
#
# w = ws[n][1] + d['weight']
# if w < weight:
# y = n
# weight = w
#
# neighborhoods[i][j] = y
# x = y
#
# return neighborhoods
#
# return tf.py_func(_neighborhoods_grid_spiral, [adjacency, sequence],
# tf.int32, stateful=False,
# name='neighborhoods_grid_spiral')
, which may include functions, classes, or code. Output only the next line. | ] |
Given the code snippet: <|code_start|> neighborhoods = neighborhoods_weights_to_root(
adjacency, sequence, size)
self.assertAllEqual(neighborhoods.eval(), expected)
def test_grid_spiral(self):
sequence = tf.constant([5, 6])
# 3x4 Grid
adjacency = tf.constant([
[0, 1, 0, 0, 1, sqrt(2), 0, 0, 0, 0, 0, 0],
[1, 0, 1, 0, sqrt(2), 1, sqrt(2), 0, 0, 0, 0, 0],
[0, 1, 0, 1, 0, sqrt(2), 1, sqrt(2), 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, sqrt(2), 1, 0, 0, 0, 0],
[1, sqrt(2), 0, 0, 0, 1, 0, 0, 1, sqrt(2), 0, 0],
[sqrt(2), 1, sqrt(2), 0, 1, 0, 1, 0, sqrt(2), 1, sqrt(2), 0],
[0, sqrt(2), 1, sqrt(2), 0, 1, 0, 1, 0, sqrt(2), 1, sqrt(2)],
[0, 0, sqrt(2), 1, 0, 0, 1, 0, 0, 0, sqrt(2), 1],
[0, 0, 0, 0, 1, sqrt(2), 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, sqrt(2), 1, sqrt(2), 0, 1, 0, 1, 0],
[0, 0, 0, 0, 0, sqrt(2), 1, sqrt(2), 0, 1, 0, 1],
[0, 0, 0, 0, 0, 0, sqrt(2), 1, 0, 0, 1, 0]
])
size = 13
expected = [
[5, 1, 0, 4, 8, 9, 10, 6, 2, 3, 7, 11, -1],
[6, 2, 1, 5, 9, 10, 11, 7, 3, -1, -1, -1, -1],
]
<|code_end|>
, generate the next line using the imports in this file:
from math import sqrt
from .neighborhood_assembly import neighborhoods_weights_to_root,\
neighborhoods_grid_spiral
import tensorflow as tf
and context (functions, classes, or occasionally code) from other files:
# Path: patchy/helper/neighborhood_assembly.py
# def neighborhoods_weights_to_root(adjacency, sequence, size):
# def _neighborhoods_weights_to_root(adjacency, sequence):
# graph = nx.from_numpy_matrix(adjacency)
#
# neighborhoods = np.zeros((sequence.shape[0], size), dtype=np.int32)
# neighborhoods.fill(-1)
#
# for i in xrange(0, sequence.shape[0]):
# n = sequence[i]
# if n < 0:
# break
#
# shortest = nx.single_source_dijkstra_path_length(graph, n).items()
# shortest = sorted(shortest, key=lambda v: v[1])
# shortest = shortest[:size]
#
# for j in xrange(0, min(size, len(shortest))):
# neighborhoods[i][j] = shortest[j][0]
#
# return neighborhoods
#
# return tf.py_func(_neighborhoods_weights_to_root, [adjacency, sequence],
# tf.int32, stateful=False,
# name='neighborhoods_weights_to_root')
#
# def neighborhoods_grid_spiral(adjacency, sequence, size):
# def _neighborhoods_grid_spiral(adjacency, sequence):
# graph = nx.from_numpy_matrix(adjacency)
#
# neighborhoods = np.zeros((sequence.shape[0], size), dtype=np.int32)
# neighborhoods.fill(-1)
#
# # Note: This method just works properly on planar graphs where nodes
# # are placed in a grid like layout and are weighted by distance.
# #
# # Add root to arr => [root]
# # Find nearest neighbor x to root
# # Add x => arr = [root, x]
# # Find nearest neighbor y with n(x, y) and min w(x,y) + w(root, y)
# # that is not already in arr.
# # set x = y
# # repeat until arr.length == size
#
# for i in xrange(0, sequence.shape[0]):
# root = sequence[i]
# if root < 0:
# break
#
# # Add root node to the beginning of the neighborhood.
# neighborhoods[i][0] = root
# x = root
#
# ws = nx.single_source_dijkstra_path_length(graph, root)
# ws = list(ws.items())
#
# for j in xrange(1, size):
# if x == -1:
# break
#
# y = -1
# weight = float('inf')
# for _, n, d, in graph.edges_iter(x, data=True):
# if n in neighborhoods[i]:
# continue
#
# w = ws[n][1] + d['weight']
# if w < weight:
# y = n
# weight = w
#
# neighborhoods[i][j] = y
# x = y
#
# return neighborhoods
#
# return tf.py_func(_neighborhoods_grid_spiral, [adjacency, sequence],
# tf.int32, stateful=False,
# name='neighborhoods_grid_spiral')
. Output only the next line. | with self.test_session() as sess: |
Based on the snippet: <|code_start|>from __future__ import print_function
class MemoryLoggerHook(LoggerHook):
def __init__(self, display_step):
super().__init__(display_step)
def after_display_step_run(self, run_context, run_values):
<|code_end|>
, predict the immediate next line with the help of imports:
import tensorflow as tf
from .logger import LoggerHook
and context (classes, functions, sometimes code) from other files:
# Path: model/logger/logger.py
# class LoggerHook(tf.train.SessionRunHook):
#
# def __init__(self, display_step):
# self._display_step = display_step
#
# def begin(self):
# self._step = -1
#
# def before_run(self, run_context):
# self._step += 1
#
# if self._step % self._display_step == 0:
# return self.before_display_step_run(run_context)
#
# def after_run(self, run_context, run_values):
# if self._step % self._display_step == 0:
# self.after_display_step_run(run_context, run_values)
#
# def before_display_step_run(self, run_context):
# pass
#
# def after_display_step_run(self, run_context, run_values):
# pass
. Output only the next line. | memory = (self.process.get_memory_info()[0] / float(2 ** 20)) |
Given the code snippet: <|code_start|>from __future__ import print_function
class AccuracyLoggerHook(LoggerHook):
def __init__(self, display_step, accuracy):
super().__init__(display_step)
self._accuracy = accuracy
def before_display_step_run(self, run_context):
return tf.train.SessionRunArgs(self._accuracy)
def after_display_step_run(self, run_context, run_values):
accuracy = run_values.results
s = '[accuracy = {:.2f}]'.format(accuracy)
<|code_end|>
, generate the next line using the imports in this file:
import tensorflow as tf
from .logger import LoggerHook
and context (functions, classes, or occasionally code) from other files:
# Path: model/logger/logger.py
# class LoggerHook(tf.train.SessionRunHook):
#
# def __init__(self, display_step):
# self._display_step = display_step
#
# def begin(self):
# self._step = -1
#
# def before_run(self, run_context):
# self._step += 1
#
# if self._step % self._display_step == 0:
# return self.before_display_step_run(run_context)
#
# def after_run(self, run_context, run_values):
# if self._step % self._display_step == 0:
# self.after_display_step_run(run_context, run_values)
#
# def before_display_step_run(self, run_context):
# pass
#
# def after_display_step_run(self, run_context, run_values):
# pass
. Output only the next line. | print(s, end=' ') |
Given snippet: <|code_start|>
class FeaturesTest(tf.test.TestCase):
def test_features(self):
image = tf.constant([
[[255, 0, 0], [0, 0, 0], [0, 0, 0]],
[[0, 0, 0], [0, 0, 0], [255, 255, 255]],
[[255, 255, 255], [255, 255, 255], [255, 255, 255]],
])
segmentation = tf.constant([
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from math import sqrt, pi as PI
from .feature_extraction import feature_extraction
import tensorflow as tf
and context:
# Path: segmentation/feature_extraction.py
# def feature_extraction(segmentation, image):
# """Extracts a fixed number of features for every segment label in the
# segmentation.
#
# Args:
# segmentation: The segmentation.
# image: The corresponding original image.
#
# Returns:
# Numpy array with shape [num_segments, num_features].
# """
#
# def _feature_extraction(segmentation, intensity_image, image):
# props = regionprops(segmentation, intensity_image)
#
# # Create the output feature vector with shape
# # [num_segments, num_features].
# features = np.zeros((len(props), NUM_FEATURES), dtype=np.float32)
#
# for i, prop in enumerate(props):
# # Moments features.
# features[i][0:16] = prop['moments'].flatten()
#
# # Bounding box features.
# bbox = prop['bbox']
# features[i][16] = bbox[2] - bbox[0]
# features[i][17] = bbox[3] - bbox[1]
#
# # Polygon features.
# features[i][18] = prop['convex_area']
# features[i][19] = prop['perimeter']
#
# # Weighted moments features.
# features[i][20:36] = prop['weighted_moments'].flatten()
#
# # Color features.
# sliced_image = image[bbox[0]:bbox[2], bbox[1]:bbox[3]]
# sliced_image = sliced_image[prop['image']]
#
# features[i][36] = sliced_image[..., 0].mean()
# features[i][37] = sliced_image[..., 1].mean()
# features[i][38] = sliced_image[..., 2].mean()
#
# features[i][39] = sliced_image[..., 0].min()
# features[i][40] = sliced_image[..., 1].min()
# features[i][41] = sliced_image[..., 2].min()
#
# features[i][42] = sliced_image[..., 0].max()
# features[i][43] = sliced_image[..., 1].max()
# features[i][44] = sliced_image[..., 2].max()
#
# return features
#
# # We need to increment the segmentation, because labels with value 0 are
# # ignored when calling regionprops.
# segmentation = segmentation + tf.ones_like(segmentation)
#
# # Get the intensity image with shape [height, width] of the image by
# # converting it to the HSV Colorspace.
# with tf.name_scope('intensity_image', values=[image]):
# intensity_image = tf.cast(image, dtype=tf.uint8)
# intensity_image = tf.image.convert_image_dtype(intensity_image,
# dtype=tf.float32)
# intensity_image = tf.image.rgb_to_hsv(intensity_image)
# intensity_image = tf.strided_slice(
# intensity_image,
# [0, 0, 2],
# [tf.shape(image)[0], tf.shape(image)[1], 3],
# [1, 1, 1])
# intensity_image = tf.squeeze(intensity_image)
#
# return tf.py_func(
# _feature_extraction, [segmentation, intensity_image, image],
# tf.float32, stateful=False, name='feature_extraction')
which might include code, classes, or functions. Output only the next line. | [0, 0, 0], |
Given snippet: <|code_start|> [0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 1, 0, 0, 0],
])
labels = tf.constant([1, 2, 3, 4, 5, 6, 7])
expected = [4, 3, 2, 6, 5, 1, 7]
with self.test_session() as sess:
labeling = betweenness_centrality(adjacency, labels)
self.assertAllEqual(labeling.eval(), expected)
def test_canonize(self):
adjacency = tf.constant([
[0, 1, 1, 0, 1, 1, 0, 0],
[1, 0, 1, 0, 0, 1, 1, 0],
[1, 1, 0, 0, 0, 1, 0, 1],
[0, 0, 0, 0, 0, 1, 1, 0],
[1, 0, 0, 0, 0, 0, 0, 1],
[1, 1, 1, 1, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 0, 0],
])
labels = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
expected = [4, 7, 5, 8, 6, 2, 1, 3]
with self.test_session() as sess:
labeling = canonize(adjacency, labels)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import tensorflow as tf
from .labeling import scanline, betweenness_centrality, canonize
and context:
# Path: patchy/helper/labeling.py
# def scanline(adjacency, labels=None):
# with tf.name_scope('scanline', values=[adjacency, labels]):
# return _labels_default(labels, adjacency)
#
# def betweenness_centrality(adjacency, labels=None):
# def _betweeness_centrality(adjacency, labels):
# graph = nx.from_numpy_matrix(adjacency)
#
# labeling = nx.betweenness_centrality(graph, normalized=False)
# labeling = list(labeling.items())
# labeling = sorted(labeling, key=lambda n: n[1], reverse=True)
#
# return np.array([labels[n[0]] for n in labeling])
#
# labels = _labels_default(labels, adjacency)
# return tf.py_func(_betweeness_centrality, [adjacency, labels], tf.int32,
# stateful=False, name='betweenness_centrality')
#
# def canonize(adjacency, labels=None):
# def _canonical(adjacency, labels):
# count = adjacency.shape[0]
# adjacency_dict = {}
#
# for i in xrange(count):
# adjacency_dict[i] = list(np.nonzero(adjacency[i])[0])
#
# graph = nauty.Graph(count, adjacency_dict=adjacency_dict)
# labeling = nauty.canonical_labeling(graph)
#
# labeling = [labels[i] for i in labeling]
#
# return np.array(labeling, np.int32)
#
# labels = _labels_default(labels, adjacency)
# return tf.py_func(_canonical, [adjacency, labels], tf.int32,
# stateful=False, name='canonical')
which might include code, classes, or functions. Output only the next line. | self.assertAllEqual(labeling.eval(), expected) |
Next line prediction: <|code_start|> [1, 0, 0, 0, 0, 0, 0, 1],
[1, 1, 1, 1, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 0, 0],
])
labels = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
expected = [4, 7, 5, 8, 6, 2, 1, 3]
with self.test_session() as sess:
labeling = canonize(adjacency, labels)
self.assertAllEqual(labeling.eval(), expected)
# Create isomorph graph and check for equal canonical labeling.
adjacency = tf.constant([
[0, 1, 0, 0, 0, 0, 0, 1],
[1, 0, 1, 1, 0, 0, 1, 0],
[0, 1, 0, 1, 1, 0, 1, 0],
[0, 1, 1, 0, 0, 1, 1, 0],
[0, 0, 1, 0, 0, 1, 0, 0],
[0, 0, 0, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 1, 0],
])
expected = [0, 7, 4, 5, 1, 6, 2, 3]
with self.test_session() as sess:
labeling = canonize(adjacency)
<|code_end|>
. Use current file imports:
(import tensorflow as tf
from .labeling import scanline, betweenness_centrality, canonize)
and context including class names, function names, or small code snippets from other files:
# Path: patchy/helper/labeling.py
# def scanline(adjacency, labels=None):
# with tf.name_scope('scanline', values=[adjacency, labels]):
# return _labels_default(labels, adjacency)
#
# def betweenness_centrality(adjacency, labels=None):
# def _betweeness_centrality(adjacency, labels):
# graph = nx.from_numpy_matrix(adjacency)
#
# labeling = nx.betweenness_centrality(graph, normalized=False)
# labeling = list(labeling.items())
# labeling = sorted(labeling, key=lambda n: n[1], reverse=True)
#
# return np.array([labels[n[0]] for n in labeling])
#
# labels = _labels_default(labels, adjacency)
# return tf.py_func(_betweeness_centrality, [adjacency, labels], tf.int32,
# stateful=False, name='betweenness_centrality')
#
# def canonize(adjacency, labels=None):
# def _canonical(adjacency, labels):
# count = adjacency.shape[0]
# adjacency_dict = {}
#
# for i in xrange(count):
# adjacency_dict[i] = list(np.nonzero(adjacency[i])[0])
#
# graph = nauty.Graph(count, adjacency_dict=adjacency_dict)
# labeling = nauty.canonical_labeling(graph)
#
# labeling = [labels[i] for i in labeling]
#
# return np.array(labeling, np.int32)
#
# labels = _labels_default(labels, adjacency)
# return tf.py_func(_canonical, [adjacency, labels], tf.int32,
# stateful=False, name='canonical')
. Output only the next line. | self.assertAllEqual(labeling.eval(), expected) |
Given snippet: <|code_start|>
class MultipartFormdataEncoder:
def __init__(self):
self.boundary = uuid.uuid4().hex
self.content_type = 'multipart/form-data; boundary={}'.format(self.boundary)
@classmethod
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import codecs
import mimetypes
import sys
import uuid
import io
import base64
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError
from .http_adapter import HTTPConnectionError
and context:
# Path: honeyterm_asciinema/asciinema/asciinema/http_adapter.py
# class HTTPConnectionError(Exception):
# pass
which might include code, classes, or functions. Output only the next line. | def u(cls, s): |
Based on the snippet: <|code_start|>
# test for forms
class CommentFormTest(TestCase):
def test_comment_forms(self):
form_data = {
'comment_content' : 'comment'
}
form = CommentForm(data=form_data)
self.assertTrue(form.is_valid())
class ThreadFormTest(TestCase):
def test_thread_forms(self):
thread_data = {
<|code_end|>
, predict the immediate next line with the help of imports:
from django.test import TestCase
from app_forum.models import Forum, Comment
from app_forum.forms import CommentForm, ThreadForm
and context (classes, functions, sometimes code) from other files:
# Path: app_forum/models.py
# class Forum(models.Model):
# """
# Thread Model
# """
#
# class Meta:
# verbose_name_plural = "Title"
#
# forum_author = models.ForeignKey(
# Profile,
# related_name='user_forums',
# null=True,
# blank=True,
# on_delete=models.CASCADE
# )
#
# forum_title = models.CharField(
# max_length=225,
# verbose_name=u'Title',
# blank=False,
# null=False
# )
#
# forum_category = models.ForeignKey(
# 'Category',
# on_delete=models.CASCADE,
# verbose_name=u'Category',
# )
#
# forum_content = MarkdownxField(
# verbose_name=u'Content (Use Markdown)',
# )
#
# is_created = models.DateTimeField(
# auto_now_add=True,
# null=True,
# blank=True
# )
#
# is_modified = models.DateTimeField(
# auto_now=True,
# null=True,
# blank=True
# )
#
# is_hot = models.BooleanField(
# default=False
# )
#
# is_closed = models.BooleanField(
# default=False
# )
#
# def __str__(self):
# return str(self.forum_title)
#
# def latest_comment_author(self):
# return self.forum_comments.latest('is_created').comment_author
#
# def latest_comment_date(self):
# return self.forum_comments.latest('is_created').is_created
#
# def get_absolute_url(self):
# """
# Call Forum ID
# """
# return 'app_forum:forum'
#
# class Comment(models.Model):
# """
# Comment Model
# """
#
# class Meta:
# verbose_name_plural = "Comment"
#
# forum = models.ForeignKey(
# 'Forum',
# on_delete=models.CASCADE,
# related_name='forum_comments'
# )
#
# comment_author = models.ForeignKey(
# Profile,
# related_name='user_comments',
# null=True,
# blank=True,
# on_delete=models.CASCADE
# )
#
# comment_content = MarkdownxField(
# verbose_name=u'Markdown',
# )
#
# is_created = models.DateTimeField(
# auto_now_add=True,
# )
#
# is_modified = models.DateTimeField(
# auto_now=True,
# )
#
# def __str__(self):
# return self.comment_content
#
# Path: app_forum/forms.py
# class CommentForm(forms.ModelForm):
# """
# Comment Form
# """
# class Meta:
# model = Comment
# fields = (
# 'comment_content',
# )
# comment_content = MarkdownxFormField()
# exclude = ['comment_author']
# widgets = {'comment_author': forms.HiddenInput()}
#
# class ThreadForm(forms.ModelForm):
# """
# Comment Form
# """
# class Meta:
# model = Forum
# fields = (
# 'forum_title',
# 'forum_category',
# 'forum_content',
# )
# comment_content = MarkdownxFormField()
# exclude = ['forum_author', 'is_hot']
# widgets = {'forum_author': forms.HiddenInput()}
. Output only the next line. | 'forum_title' : 'title', |
Given the code snippet: <|code_start|>
# test for forms
class CommentFormTest(TestCase):
def test_comment_forms(self):
form_data = {
'comment_content' : 'comment'
}
form = CommentForm(data=form_data)
self.assertTrue(form.is_valid())
class ThreadFormTest(TestCase):
def test_thread_forms(self):
thread_data = {
<|code_end|>
, generate the next line using the imports in this file:
from django.test import TestCase
from app_forum.models import Forum, Comment
from app_forum.forms import CommentForm, ThreadForm
and context (functions, classes, or occasionally code) from other files:
# Path: app_forum/models.py
# class Forum(models.Model):
# """
# Thread Model
# """
#
# class Meta:
# verbose_name_plural = "Title"
#
# forum_author = models.ForeignKey(
# Profile,
# related_name='user_forums',
# null=True,
# blank=True,
# on_delete=models.CASCADE
# )
#
# forum_title = models.CharField(
# max_length=225,
# verbose_name=u'Title',
# blank=False,
# null=False
# )
#
# forum_category = models.ForeignKey(
# 'Category',
# on_delete=models.CASCADE,
# verbose_name=u'Category',
# )
#
# forum_content = MarkdownxField(
# verbose_name=u'Content (Use Markdown)',
# )
#
# is_created = models.DateTimeField(
# auto_now_add=True,
# null=True,
# blank=True
# )
#
# is_modified = models.DateTimeField(
# auto_now=True,
# null=True,
# blank=True
# )
#
# is_hot = models.BooleanField(
# default=False
# )
#
# is_closed = models.BooleanField(
# default=False
# )
#
# def __str__(self):
# return str(self.forum_title)
#
# def latest_comment_author(self):
# return self.forum_comments.latest('is_created').comment_author
#
# def latest_comment_date(self):
# return self.forum_comments.latest('is_created').is_created
#
# def get_absolute_url(self):
# """
# Call Forum ID
# """
# return 'app_forum:forum'
#
# class Comment(models.Model):
# """
# Comment Model
# """
#
# class Meta:
# verbose_name_plural = "Comment"
#
# forum = models.ForeignKey(
# 'Forum',
# on_delete=models.CASCADE,
# related_name='forum_comments'
# )
#
# comment_author = models.ForeignKey(
# Profile,
# related_name='user_comments',
# null=True,
# blank=True,
# on_delete=models.CASCADE
# )
#
# comment_content = MarkdownxField(
# verbose_name=u'Markdown',
# )
#
# is_created = models.DateTimeField(
# auto_now_add=True,
# )
#
# is_modified = models.DateTimeField(
# auto_now=True,
# )
#
# def __str__(self):
# return self.comment_content
#
# Path: app_forum/forms.py
# class CommentForm(forms.ModelForm):
# """
# Comment Form
# """
# class Meta:
# model = Comment
# fields = (
# 'comment_content',
# )
# comment_content = MarkdownxFormField()
# exclude = ['comment_author']
# widgets = {'comment_author': forms.HiddenInput()}
#
# class ThreadForm(forms.ModelForm):
# """
# Comment Form
# """
# class Meta:
# model = Forum
# fields = (
# 'forum_title',
# 'forum_category',
# 'forum_content',
# )
# comment_content = MarkdownxFormField()
# exclude = ['forum_author', 'is_hot']
# widgets = {'forum_author': forms.HiddenInput()}
. Output only the next line. | 'forum_title' : 'title', |
Predict the next line for this snippet: <|code_start|>
class ForumModelTestCase(TestCase):
def test_forum_model_str_method(self):
forum = Forum(forum_title='Example')
self.assertEqual(str(forum), 'Example')
def test_verbose_name_plural(self):
self.assertEqual(str(Forum._meta.verbose_name_plural), u'Title')
def test_comment_model_str_method(self):
comment = Comment(comment_content='Good!')
self.assertEqual(str(comment), 'Good!')
<|code_end|>
with the help of current file imports:
from django.test import TestCase
from app_forum.models import Forum, Comment
and context from other files:
# Path: app_forum/models.py
# class Forum(models.Model):
# """
# Thread Model
# """
#
# class Meta:
# verbose_name_plural = "Title"
#
# forum_author = models.ForeignKey(
# Profile,
# related_name='user_forums',
# null=True,
# blank=True,
# on_delete=models.CASCADE
# )
#
# forum_title = models.CharField(
# max_length=225,
# verbose_name=u'Title',
# blank=False,
# null=False
# )
#
# forum_category = models.ForeignKey(
# 'Category',
# on_delete=models.CASCADE,
# verbose_name=u'Category',
# )
#
# forum_content = MarkdownxField(
# verbose_name=u'Content (Use Markdown)',
# )
#
# is_created = models.DateTimeField(
# auto_now_add=True,
# null=True,
# blank=True
# )
#
# is_modified = models.DateTimeField(
# auto_now=True,
# null=True,
# blank=True
# )
#
# is_hot = models.BooleanField(
# default=False
# )
#
# is_closed = models.BooleanField(
# default=False
# )
#
# def __str__(self):
# return str(self.forum_title)
#
# def latest_comment_author(self):
# return self.forum_comments.latest('is_created').comment_author
#
# def latest_comment_date(self):
# return self.forum_comments.latest('is_created').is_created
#
# def get_absolute_url(self):
# """
# Call Forum ID
# """
# return 'app_forum:forum'
#
# class Comment(models.Model):
# """
# Comment Model
# """
#
# class Meta:
# verbose_name_plural = "Comment"
#
# forum = models.ForeignKey(
# 'Forum',
# on_delete=models.CASCADE,
# related_name='forum_comments'
# )
#
# comment_author = models.ForeignKey(
# Profile,
# related_name='user_comments',
# null=True,
# blank=True,
# on_delete=models.CASCADE
# )
#
# comment_content = MarkdownxField(
# verbose_name=u'Markdown',
# )
#
# is_created = models.DateTimeField(
# auto_now_add=True,
# )
#
# is_modified = models.DateTimeField(
# auto_now=True,
# )
#
# def __str__(self):
# return self.comment_content
, which may contain function names, class names, or code. Output only the next line. | def test_verbose_name_plural(self): |
Given the code snippet: <|code_start|>
class ForumModelTestCase(TestCase):
def test_forum_model_str_method(self):
forum = Forum(forum_title='Example')
self.assertEqual(str(forum), 'Example')
<|code_end|>
, generate the next line using the imports in this file:
from django.test import TestCase
from app_forum.models import Forum, Comment
and context (functions, classes, or occasionally code) from other files:
# Path: app_forum/models.py
# class Forum(models.Model):
# """
# Thread Model
# """
#
# class Meta:
# verbose_name_plural = "Title"
#
# forum_author = models.ForeignKey(
# Profile,
# related_name='user_forums',
# null=True,
# blank=True,
# on_delete=models.CASCADE
# )
#
# forum_title = models.CharField(
# max_length=225,
# verbose_name=u'Title',
# blank=False,
# null=False
# )
#
# forum_category = models.ForeignKey(
# 'Category',
# on_delete=models.CASCADE,
# verbose_name=u'Category',
# )
#
# forum_content = MarkdownxField(
# verbose_name=u'Content (Use Markdown)',
# )
#
# is_created = models.DateTimeField(
# auto_now_add=True,
# null=True,
# blank=True
# )
#
# is_modified = models.DateTimeField(
# auto_now=True,
# null=True,
# blank=True
# )
#
# is_hot = models.BooleanField(
# default=False
# )
#
# is_closed = models.BooleanField(
# default=False
# )
#
# def __str__(self):
# return str(self.forum_title)
#
# def latest_comment_author(self):
# return self.forum_comments.latest('is_created').comment_author
#
# def latest_comment_date(self):
# return self.forum_comments.latest('is_created').is_created
#
# def get_absolute_url(self):
# """
# Call Forum ID
# """
# return 'app_forum:forum'
#
# class Comment(models.Model):
# """
# Comment Model
# """
#
# class Meta:
# verbose_name_plural = "Comment"
#
# forum = models.ForeignKey(
# 'Forum',
# on_delete=models.CASCADE,
# related_name='forum_comments'
# )
#
# comment_author = models.ForeignKey(
# Profile,
# related_name='user_comments',
# null=True,
# blank=True,
# on_delete=models.CASCADE
# )
#
# comment_content = MarkdownxField(
# verbose_name=u'Markdown',
# )
#
# is_created = models.DateTimeField(
# auto_now_add=True,
# )
#
# is_modified = models.DateTimeField(
# auto_now=True,
# )
#
# def __str__(self):
# return self.comment_content
. Output only the next line. | def test_verbose_name_plural(self): |
Given snippet: <|code_start|>
request = self.factory.post(path=url, data=payload)
request.user = user
response = author_edit_view(request, user.profile.slug)
response.client = Client()
self.assertRedirects(
response, reverse('author:author_single', args=[user.profile.slug])
)
# def test_author_edit_view_form_with_another_user(self):
# user = User.objects.create_user(
# username='john',
# email='john.doe@gmail.com',
# password='testing123',
# )
# another_user = User.objects.create_user(
# username='stranger',
# email='stranger@gmail.com',
# password='testing123',
# )
#
# url = reverse('author:author_edit', args=[user.profile.slug])
# request = self.factory.get(path=url)
# request.user = another_user
# response = author_edit_view(request, user.profile.slug)
# response.client = Client()
# self.assertRedirects(response, reverse('forum:forum_list'))
def test_author_edit_view_form(self):
user = User.objects.create_user(
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.contrib.auth.models import User
from django.test import TestCase, RequestFactory, Client
from django.urls import reverse
from app_author.views import author_single_view, author_edit_view
and context:
# Path: app_author/views.py
# def author_single_view(request, slug):
# """
# Render Single User
# :param request:
# :param slug:
# :return:
# """
# author = get_object_or_404(Profile, slug=slug)
# author_forum_list = Forum.objects.filter(forum_author=author.id).order_by("-is_created")[:10]
# author_comments = Comment.objects.filter(comment_author=author.id).order_by("-is_created")[:10]
# total_forums = Forum.objects.filter(forum_author=author.id).annotate(num_comments=Count('forum_author'))
# total_comments = Comment.objects.filter(comment_author=author.id).annotate(num_comments=Count('comment_author'))
# template = 'app_author/author_single.html'
# context = {
# 'author': author,
# 'author_forum_list': author_forum_list,
# 'author_comments': author_comments,
# 'total_forums': total_forums,
# 'total_comments': total_comments
# }
# return render(request, template, context)
#
# @login_required
# def author_edit_view(request, slug):
# """
# Render User Edit Form
# :param request:
# :param slug:
# :return:
# """
# author = get_object_or_404(Profile, slug=slug)
# if request.method == "POST":
# form = ProfileForm(request.POST, request.FILES, instance=author)
# if form.is_valid():
# author = form.save(commit=False)
# author.save()
# return redirect('author:author_single', slug=slug)
# elif request.user != author.user:
# return redirect('forum:forum_list')
# else:
# form = ProfileForm(instance=author)
# return render(request, 'app_author/author_edit.html', {'author': author, 'form': form})
which might include code, classes, or functions. Output only the next line. | username='john', |
Continue the code snippet: <|code_start|> user = User.objects.create_user(
username='john',
email='john.doe@gmail.com',
password='testing123',
)
url = reverse('author:author_single', args=[user.profile.slug])
request = self.factory.get(path=url)
response = author_single_view(request, user.profile.slug)
self.assertEqual(response.status_code, 200)
def test_author_edit_view(self):
user = User.objects.create_user(
username='john',
email='john.doe@gmail.com',
password='testing123',
)
url = reverse('author:author_edit', args=[user.profile.slug])
payload = {
'profile_picture': None,
'profile_name': 'Adit',
'profile_email': 'adiyatmubarak@gmail.com',
'profile_location': None,
'profile_github': 'https://github.com/keda87',
}
request = self.factory.post(path=url, data=payload)
request.user = user
response = author_edit_view(request, user.profile.slug)
response.client = Client()
<|code_end|>
. Use current file imports:
from django.contrib.auth.models import User
from django.test import TestCase, RequestFactory, Client
from django.urls import reverse
from app_author.views import author_single_view, author_edit_view
and context (classes, functions, or code) from other files:
# Path: app_author/views.py
# def author_single_view(request, slug):
# """
# Render Single User
# :param request:
# :param slug:
# :return:
# """
# author = get_object_or_404(Profile, slug=slug)
# author_forum_list = Forum.objects.filter(forum_author=author.id).order_by("-is_created")[:10]
# author_comments = Comment.objects.filter(comment_author=author.id).order_by("-is_created")[:10]
# total_forums = Forum.objects.filter(forum_author=author.id).annotate(num_comments=Count('forum_author'))
# total_comments = Comment.objects.filter(comment_author=author.id).annotate(num_comments=Count('comment_author'))
# template = 'app_author/author_single.html'
# context = {
# 'author': author,
# 'author_forum_list': author_forum_list,
# 'author_comments': author_comments,
# 'total_forums': total_forums,
# 'total_comments': total_comments
# }
# return render(request, template, context)
#
# @login_required
# def author_edit_view(request, slug):
# """
# Render User Edit Form
# :param request:
# :param slug:
# :return:
# """
# author = get_object_or_404(Profile, slug=slug)
# if request.method == "POST":
# form = ProfileForm(request.POST, request.FILES, instance=author)
# if form.is_valid():
# author = form.save(commit=False)
# author.save()
# return redirect('author:author_single', slug=slug)
# elif request.user != author.user:
# return redirect('forum:forum_list')
# else:
# form = ProfileForm(instance=author)
# return render(request, 'app_author/author_edit.html', {'author': author, 'form': form})
. Output only the next line. | self.assertRedirects( |
Given the following code snippet before the placeholder: <|code_start|>
@ast_node
class AutoVectorStatement(ASTNode):
"""An auto variable is automatically allocated onto the stack."""
@needs_builder
def emit(self, context):
# Curiously, B uses the "maximum index" when declaring vectors. This
# mean, for example, that "auto v[3]" should allocate storage for *4*
# words on the stack rather than 3 as would seem more likely.
vector_length = 1 + self.maxidx.value
# Allocate values and record in scope
val = context.builder.alloca(context.word_type, size=vector_length,
name=self.name)
# In contrast to non-vector auto variables, the "value" of a vecotr auto
# is the actual underlying pointer rather than the dereferenced pointer.
context.scope[self.name] = LLVMPointerValue(value=val)
@ast_node
class ExtrnStatement(ASTNode):
def emit(self, context):
context.scope[self.name] = get_or_create_global(context, self.name)
@ast_node
class MultipartStatement(ASTNode):
"""A statement which is like a CompoundStatement but there is no change of
scope."""
def emit(self, context):
for statement in self.statements:
<|code_end|>
, predict the next line using imports from the current file:
from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import create_aligned_global, if_else
from .expression import LLVMPointerValue
import rbc.exception as exc
and context including class names, function names, and sometimes code from other files:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
#
# Path: rbc/codegen/expression.py
# class LLVMPointerValue(RValue):
# """An RValue corresponding to an llvm pointer type punned to the machine
# word type. The pointer value is divided by the machine word length in bytes
# to yield a value which is word-oriented.
#
# It is a Bad Idea (TM) to pass this AST node a pointer which is not
# word-aligned. There is no runtime check for alignment. So, "caveat caller".
#
# This class is not marked as an AST node and so cannot be constructed via the
# make_node() function. This reflects the fact that this is an "internal" node
# not intended for construction by the semantics.
#
# """
# @needs_builder
# def emit(self, context):
# return llvm_ptr_to_address(context, self.value)
. Output only the next line. | statement.emit(context) |
Given the code snippet: <|code_start|>
@ast_node
class AutoVectorStatement(ASTNode):
"""An auto variable is automatically allocated onto the stack."""
@needs_builder
def emit(self, context):
# Curiously, B uses the "maximum index" when declaring vectors. This
# mean, for example, that "auto v[3]" should allocate storage for *4*
# words on the stack rather than 3 as would seem more likely.
vector_length = 1 + self.maxidx.value
# Allocate values and record in scope
val = context.builder.alloca(context.word_type, size=vector_length,
name=self.name)
# In contrast to non-vector auto variables, the "value" of a vecotr auto
# is the actual underlying pointer rather than the dereferenced pointer.
context.scope[self.name] = LLVMPointerValue(value=val)
@ast_node
class ExtrnStatement(ASTNode):
def emit(self, context):
context.scope[self.name] = get_or_create_global(context, self.name)
@ast_node
class MultipartStatement(ASTNode):
"""A statement which is like a CompoundStatement but there is no change of
scope."""
def emit(self, context):
for statement in self.statements:
<|code_end|>
, generate the next line using the imports in this file:
from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import create_aligned_global, if_else
from .expression import LLVMPointerValue
import rbc.exception as exc
and context (functions, classes, or occasionally code) from other files:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
#
# Path: rbc/codegen/expression.py
# class LLVMPointerValue(RValue):
# """An RValue corresponding to an llvm pointer type punned to the machine
# word type. The pointer value is divided by the machine word length in bytes
# to yield a value which is word-oriented.
#
# It is a Bad Idea (TM) to pass this AST node a pointer which is not
# word-aligned. There is no runtime check for alignment. So, "caveat caller".
#
# This class is not marked as an AST node and so cannot be constructed via the
# make_node() function. This reflects the fact that this is an "internal" node
# not intended for construction by the semantics.
#
# """
# @needs_builder
# def emit(self, context):
# return llvm_ptr_to_address(context, self.value)
. Output only the next line. | statement.emit(context) |
Continue the code snippet: <|code_start|> context.builder.position_at_end(while_body)
with context.setting_break_block(while_end):
self.body.emit(context)
# Branch back to condition
context.builder.branch(while_cond)
# Position after loop for further instructions
context.builder.position_at_end(while_end)
@ast_node
class IfStatement(ASTNode):
@needs_builder
def emit(self, context):
with if_else(context, self.cond) as (then, otherwise):
with then:
self.then.emit(context)
with otherwise:
if self.otherwise is not None:
self.otherwise.emit(context)
@ast_node
class ExpressionStatement(ASTNode):
def emit(self, context):
"""An expression statement simply evaluates its expression and discards
the result."""
self.expression.emit(context)
@ast_node
class NullStatement(ASTNode):
<|code_end|>
. Use current file imports:
from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import create_aligned_global, if_else
from .expression import LLVMPointerValue
import rbc.exception as exc
and context (classes, functions, or code) from other files:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
#
# Path: rbc/codegen/expression.py
# class LLVMPointerValue(RValue):
# """An RValue corresponding to an llvm pointer type punned to the machine
# word type. The pointer value is divided by the machine word length in bytes
# to yield a value which is word-oriented.
#
# It is a Bad Idea (TM) to pass this AST node a pointer which is not
# word-aligned. There is no runtime check for alignment. So, "caveat caller".
#
# This class is not marked as an AST node and so cannot be constructed via the
# make_node() function. This reflects the fact that this is an "internal" node
# not intended for construction by the semantics.
#
# """
# @needs_builder
# def emit(self, context):
# return llvm_ptr_to_address(context, self.value)
. Output only the next line. | def emit(self, context): |
Given snippet: <|code_start|> context.builder.position_at_end(while_body)
with context.setting_break_block(while_end):
self.body.emit(context)
# Branch back to condition
context.builder.branch(while_cond)
# Position after loop for further instructions
context.builder.position_at_end(while_end)
@ast_node
class IfStatement(ASTNode):
@needs_builder
def emit(self, context):
with if_else(context, self.cond) as (then, otherwise):
with then:
self.then.emit(context)
with otherwise:
if self.otherwise is not None:
self.otherwise.emit(context)
@ast_node
class ExpressionStatement(ASTNode):
def emit(self, context):
"""An expression statement simply evaluates its expression and discards
the result."""
self.expression.emit(context)
@ast_node
class NullStatement(ASTNode):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import create_aligned_global, if_else
from .expression import LLVMPointerValue
import rbc.exception as exc
and context:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
#
# Path: rbc/codegen/expression.py
# class LLVMPointerValue(RValue):
# """An RValue corresponding to an llvm pointer type punned to the machine
# word type. The pointer value is divided by the machine word length in bytes
# to yield a value which is word-oriented.
#
# It is a Bad Idea (TM) to pass this AST node a pointer which is not
# word-aligned. There is no runtime check for alignment. So, "caveat caller".
#
# This class is not marked as an AST node and so cannot be constructed via the
# make_node() function. This reflects the fact that this is an "internal" node
# not intended for construction by the semantics.
#
# """
# @needs_builder
# def emit(self, context):
# return llvm_ptr_to_address(context, self.value)
which might include code, classes, or functions. Output only the next line. | def emit(self, context): |
Based on the snippet: <|code_start|># Our implementation is such that that only lvalues are a dereferenced rvalue or
# an value retrieved from the current scope.
@ast_node
class DereferencedRValue(RValue):
"""A convenience wrapper representing a dereferenced RValue. The reference()
method simply returns the dereferenced RValue. This value is an LValue in
that it has a reference() method.
"""
def reference(self):
return self.rvalue
@needs_builder
def emit(self, context):
# Convert the rvalue word address into a llvm pointer to a word
ptr_type = context.word_type.as_pointer()
rvalue_val = self.rvalue.emit(context)
word_ptr = address_to_llvm_ptr(context, rvalue_val, ptr_type)
# Load from pointer
return context.builder.load(word_ptr)
@ast_node
class ScopeValue(RValue):
"""LValue constructed by dereferencing an address retrieved from the current
scope."""
def reference(self):
return AddressOfScopeValue(name=self.name)
<|code_end|>
, predict the immediate next line with the help of imports:
from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import (
address_to_llvm_ptr, llvm_ptr_to_address, create_aligned_global, if_else
)
import rbc.exception as exc
and context (classes, functions, sometimes code) from other files:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def address_to_llvm_ptr(context, address_val, ptr_type):
# """Cast a llvm Value representing a word into a pointer. Performs the
# appropriate conversion from word-oriented addresses to llvm's
# byte-oriented addresses. Requires builder to be not None.
#
# This method will arrange that
#
# address_to_llvm_ptr(llvm_ptr_to_address(ptr_val), ptr_type)
#
# is elided into a simple bitcast. This implies that ptr_val must be word
# aligned. It's the responsibility of the code generator to make sure
# that's the case.
#
# """
# # If this address came from a pointer, just return the punned pointer.
# if hasattr(address_val, 'b_ptr'):
# return context.builder.bitcast(address_val.b_ptr, ptr_type)
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.mul(address_val, bpw_const,
# flags=['nuw', 'nsw'])
# ptr_val = context.builder.inttoptr(byte_address, ptr_type)
#
# # HACK: we tag the value with a 'b_address' attribute so that
# # llvm_ptr_to_address() can elide address to pointer followed by pointer
# # to address conversion.
# ptr_val.b_address = address_val
#
# return ptr_val
#
# def llvm_ptr_to_address(context, ptr_val):
# """Cast a llvm Value representing a byte-oriented pointer to a word
# representing a word-oriented address. Requires builder to be not None.
#
# This method will arrange that
#
# llvm_ptr_to_address(address_to_llvm_ptr(address_val, ptr_type))
#
# is elided to address_val irrespective of ptr_type.
#
# """
# # If this pointer came from an address, just return the original address
# # value.
# if hasattr(ptr_val, 'b_address'):
# return ptr_val.b_address
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.ptrtoint(ptr_val, context.word_type)
# address_val = context.builder.udiv(byte_address, bpw_const,
# flags=['exact'])
#
# # HACK: we tag the value with a 'b_ptr' attribute so that
# # address_to_llvm_ptr() can elide pointer to address followed by address
# # to pointer conversion.
# address_val.b_ptr = ptr_val
#
# return address_val
#
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
. Output only the next line. | def emit(self, context): |
Based on the snippet: <|code_start|> """A convenience wrapper representing a dereferenced RValue. The reference()
method simply returns the dereferenced RValue. This value is an LValue in
that it has a reference() method.
"""
def reference(self):
return self.rvalue
@needs_builder
def emit(self, context):
# Convert the rvalue word address into a llvm pointer to a word
ptr_type = context.word_type.as_pointer()
rvalue_val = self.rvalue.emit(context)
word_ptr = address_to_llvm_ptr(context, rvalue_val, ptr_type)
# Load from pointer
return context.builder.load(word_ptr)
@ast_node
class ScopeValue(RValue):
"""LValue constructed by dereferencing an address retrieved from the current
scope."""
def reference(self):
return AddressOfScopeValue(name=self.name)
def emit(self, context):
try:
val = context.scope[self.name]
except KeyError:
raise exc.SemanticError(
<|code_end|>
, predict the immediate next line with the help of imports:
from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import (
address_to_llvm_ptr, llvm_ptr_to_address, create_aligned_global, if_else
)
import rbc.exception as exc
and context (classes, functions, sometimes code) from other files:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def address_to_llvm_ptr(context, address_val, ptr_type):
# """Cast a llvm Value representing a word into a pointer. Performs the
# appropriate conversion from word-oriented addresses to llvm's
# byte-oriented addresses. Requires builder to be not None.
#
# This method will arrange that
#
# address_to_llvm_ptr(llvm_ptr_to_address(ptr_val), ptr_type)
#
# is elided into a simple bitcast. This implies that ptr_val must be word
# aligned. It's the responsibility of the code generator to make sure
# that's the case.
#
# """
# # If this address came from a pointer, just return the punned pointer.
# if hasattr(address_val, 'b_ptr'):
# return context.builder.bitcast(address_val.b_ptr, ptr_type)
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.mul(address_val, bpw_const,
# flags=['nuw', 'nsw'])
# ptr_val = context.builder.inttoptr(byte_address, ptr_type)
#
# # HACK: we tag the value with a 'b_address' attribute so that
# # llvm_ptr_to_address() can elide address to pointer followed by pointer
# # to address conversion.
# ptr_val.b_address = address_val
#
# return ptr_val
#
# def llvm_ptr_to_address(context, ptr_val):
# """Cast a llvm Value representing a byte-oriented pointer to a word
# representing a word-oriented address. Requires builder to be not None.
#
# This method will arrange that
#
# llvm_ptr_to_address(address_to_llvm_ptr(address_val, ptr_type))
#
# is elided to address_val irrespective of ptr_type.
#
# """
# # If this pointer came from an address, just return the original address
# # value.
# if hasattr(ptr_val, 'b_address'):
# return ptr_val.b_address
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.ptrtoint(ptr_val, context.word_type)
# address_val = context.builder.udiv(byte_address, bpw_const,
# flags=['exact'])
#
# # HACK: we tag the value with a 'b_ptr' attribute so that
# # address_to_llvm_ptr() can elide pointer to address followed by address
# # to pointer conversion.
# address_val.b_ptr = ptr_val
#
# return address_val
#
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
. Output only the next line. | 'Variable not found in scope: {}'.format(self.name)) |
Based on the snippet: <|code_start|>
@needs_builder
def emit(self, context):
# Convert the rvalue word address into a llvm pointer to a word
ptr_type = context.word_type.as_pointer()
rvalue_val = self.rvalue.emit(context)
word_ptr = address_to_llvm_ptr(context, rvalue_val, ptr_type)
# Load from pointer
return context.builder.load(word_ptr)
@ast_node
class ScopeValue(RValue):
"""LValue constructed by dereferencing an address retrieved from the current
scope."""
def reference(self):
return AddressOfScopeValue(name=self.name)
def emit(self, context):
try:
val = context.scope[self.name]
except KeyError:
raise exc.SemanticError(
'Variable not found in scope: {}'.format(self.name))
return val.emit(context)
# In contrast there are many implementations of rvalues depending on how they're
# calculated.
@ast_node
<|code_end|>
, predict the immediate next line with the help of imports:
from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import (
address_to_llvm_ptr, llvm_ptr_to_address, create_aligned_global, if_else
)
import rbc.exception as exc
and context (classes, functions, sometimes code) from other files:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def address_to_llvm_ptr(context, address_val, ptr_type):
# """Cast a llvm Value representing a word into a pointer. Performs the
# appropriate conversion from word-oriented addresses to llvm's
# byte-oriented addresses. Requires builder to be not None.
#
# This method will arrange that
#
# address_to_llvm_ptr(llvm_ptr_to_address(ptr_val), ptr_type)
#
# is elided into a simple bitcast. This implies that ptr_val must be word
# aligned. It's the responsibility of the code generator to make sure
# that's the case.
#
# """
# # If this address came from a pointer, just return the punned pointer.
# if hasattr(address_val, 'b_ptr'):
# return context.builder.bitcast(address_val.b_ptr, ptr_type)
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.mul(address_val, bpw_const,
# flags=['nuw', 'nsw'])
# ptr_val = context.builder.inttoptr(byte_address, ptr_type)
#
# # HACK: we tag the value with a 'b_address' attribute so that
# # llvm_ptr_to_address() can elide address to pointer followed by pointer
# # to address conversion.
# ptr_val.b_address = address_val
#
# return ptr_val
#
# def llvm_ptr_to_address(context, ptr_val):
# """Cast a llvm Value representing a byte-oriented pointer to a word
# representing a word-oriented address. Requires builder to be not None.
#
# This method will arrange that
#
# llvm_ptr_to_address(address_to_llvm_ptr(address_val, ptr_type))
#
# is elided to address_val irrespective of ptr_type.
#
# """
# # If this pointer came from an address, just return the original address
# # value.
# if hasattr(ptr_val, 'b_address'):
# return ptr_val.b_address
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.ptrtoint(ptr_val, context.word_type)
# address_val = context.builder.udiv(byte_address, bpw_const,
# flags=['exact'])
#
# # HACK: we tag the value with a 'b_ptr' attribute so that
# # address_to_llvm_ptr() can elide pointer to address followed by address
# # to pointer conversion.
# address_val.b_ptr = ptr_val
#
# return address_val
#
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
. Output only the next line. | class AddressOfScopeValue(RValue): |
Next line prediction: <|code_start|> """A convenience wrapper representing a dereferenced RValue. The reference()
method simply returns the dereferenced RValue. This value is an LValue in
that it has a reference() method.
"""
def reference(self):
return self.rvalue
@needs_builder
def emit(self, context):
# Convert the rvalue word address into a llvm pointer to a word
ptr_type = context.word_type.as_pointer()
rvalue_val = self.rvalue.emit(context)
word_ptr = address_to_llvm_ptr(context, rvalue_val, ptr_type)
# Load from pointer
return context.builder.load(word_ptr)
@ast_node
class ScopeValue(RValue):
"""LValue constructed by dereferencing an address retrieved from the current
scope."""
def reference(self):
return AddressOfScopeValue(name=self.name)
def emit(self, context):
try:
val = context.scope[self.name]
except KeyError:
raise exc.SemanticError(
<|code_end|>
. Use current file imports:
(from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import (
address_to_llvm_ptr, llvm_ptr_to_address, create_aligned_global, if_else
)
import rbc.exception as exc)
and context including class names, function names, or small code snippets from other files:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def address_to_llvm_ptr(context, address_val, ptr_type):
# """Cast a llvm Value representing a word into a pointer. Performs the
# appropriate conversion from word-oriented addresses to llvm's
# byte-oriented addresses. Requires builder to be not None.
#
# This method will arrange that
#
# address_to_llvm_ptr(llvm_ptr_to_address(ptr_val), ptr_type)
#
# is elided into a simple bitcast. This implies that ptr_val must be word
# aligned. It's the responsibility of the code generator to make sure
# that's the case.
#
# """
# # If this address came from a pointer, just return the punned pointer.
# if hasattr(address_val, 'b_ptr'):
# return context.builder.bitcast(address_val.b_ptr, ptr_type)
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.mul(address_val, bpw_const,
# flags=['nuw', 'nsw'])
# ptr_val = context.builder.inttoptr(byte_address, ptr_type)
#
# # HACK: we tag the value with a 'b_address' attribute so that
# # llvm_ptr_to_address() can elide address to pointer followed by pointer
# # to address conversion.
# ptr_val.b_address = address_val
#
# return ptr_val
#
# def llvm_ptr_to_address(context, ptr_val):
# """Cast a llvm Value representing a byte-oriented pointer to a word
# representing a word-oriented address. Requires builder to be not None.
#
# This method will arrange that
#
# llvm_ptr_to_address(address_to_llvm_ptr(address_val, ptr_type))
#
# is elided to address_val irrespective of ptr_type.
#
# """
# # If this pointer came from an address, just return the original address
# # value.
# if hasattr(ptr_val, 'b_address'):
# return ptr_val.b_address
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.ptrtoint(ptr_val, context.word_type)
# address_val = context.builder.udiv(byte_address, bpw_const,
# flags=['exact'])
#
# # HACK: we tag the value with a 'b_ptr' attribute so that
# # address_to_llvm_ptr() can elide pointer to address followed by address
# # to pointer conversion.
# address_val.b_ptr = ptr_val
#
# return address_val
#
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
. Output only the next line. | 'Variable not found in scope: {}'.format(self.name)) |
Given the code snippet: <|code_start|>
@ast_node
class DereferencedRValue(RValue):
"""A convenience wrapper representing a dereferenced RValue. The reference()
method simply returns the dereferenced RValue. This value is an LValue in
that it has a reference() method.
"""
def reference(self):
return self.rvalue
@needs_builder
def emit(self, context):
# Convert the rvalue word address into a llvm pointer to a word
ptr_type = context.word_type.as_pointer()
rvalue_val = self.rvalue.emit(context)
word_ptr = address_to_llvm_ptr(context, rvalue_val, ptr_type)
# Load from pointer
return context.builder.load(word_ptr)
@ast_node
class ScopeValue(RValue):
"""LValue constructed by dereferencing an address retrieved from the current
scope."""
def reference(self):
return AddressOfScopeValue(name=self.name)
def emit(self, context):
try:
<|code_end|>
, generate the next line using the imports in this file:
from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import (
address_to_llvm_ptr, llvm_ptr_to_address, create_aligned_global, if_else
)
import rbc.exception as exc
and context (functions, classes, or occasionally code) from other files:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def address_to_llvm_ptr(context, address_val, ptr_type):
# """Cast a llvm Value representing a word into a pointer. Performs the
# appropriate conversion from word-oriented addresses to llvm's
# byte-oriented addresses. Requires builder to be not None.
#
# This method will arrange that
#
# address_to_llvm_ptr(llvm_ptr_to_address(ptr_val), ptr_type)
#
# is elided into a simple bitcast. This implies that ptr_val must be word
# aligned. It's the responsibility of the code generator to make sure
# that's the case.
#
# """
# # If this address came from a pointer, just return the punned pointer.
# if hasattr(address_val, 'b_ptr'):
# return context.builder.bitcast(address_val.b_ptr, ptr_type)
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.mul(address_val, bpw_const,
# flags=['nuw', 'nsw'])
# ptr_val = context.builder.inttoptr(byte_address, ptr_type)
#
# # HACK: we tag the value with a 'b_address' attribute so that
# # llvm_ptr_to_address() can elide address to pointer followed by pointer
# # to address conversion.
# ptr_val.b_address = address_val
#
# return ptr_val
#
# def llvm_ptr_to_address(context, ptr_val):
# """Cast a llvm Value representing a byte-oriented pointer to a word
# representing a word-oriented address. Requires builder to be not None.
#
# This method will arrange that
#
# llvm_ptr_to_address(address_to_llvm_ptr(address_val, ptr_type))
#
# is elided to address_val irrespective of ptr_type.
#
# """
# # If this pointer came from an address, just return the original address
# # value.
# if hasattr(ptr_val, 'b_address'):
# return ptr_val.b_address
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.ptrtoint(ptr_val, context.word_type)
# address_val = context.builder.udiv(byte_address, bpw_const,
# flags=['exact'])
#
# # HACK: we tag the value with a 'b_ptr' attribute so that
# # address_to_llvm_ptr() can elide pointer to address followed by address
# # to pointer conversion.
# address_val.b_ptr = ptr_val
#
# return address_val
#
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
. Output only the next line. | val = context.scope[self.name] |
Based on the snippet: <|code_start|># an value retrieved from the current scope.
@ast_node
class DereferencedRValue(RValue):
"""A convenience wrapper representing a dereferenced RValue. The reference()
method simply returns the dereferenced RValue. This value is an LValue in
that it has a reference() method.
"""
def reference(self):
return self.rvalue
@needs_builder
def emit(self, context):
# Convert the rvalue word address into a llvm pointer to a word
ptr_type = context.word_type.as_pointer()
rvalue_val = self.rvalue.emit(context)
word_ptr = address_to_llvm_ptr(context, rvalue_val, ptr_type)
# Load from pointer
return context.builder.load(word_ptr)
@ast_node
class ScopeValue(RValue):
"""LValue constructed by dereferencing an address retrieved from the current
scope."""
def reference(self):
return AddressOfScopeValue(name=self.name)
def emit(self, context):
<|code_end|>
, predict the immediate next line with the help of imports:
from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import (
address_to_llvm_ptr, llvm_ptr_to_address, create_aligned_global, if_else
)
import rbc.exception as exc
and context (classes, functions, sometimes code) from other files:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def address_to_llvm_ptr(context, address_val, ptr_type):
# """Cast a llvm Value representing a word into a pointer. Performs the
# appropriate conversion from word-oriented addresses to llvm's
# byte-oriented addresses. Requires builder to be not None.
#
# This method will arrange that
#
# address_to_llvm_ptr(llvm_ptr_to_address(ptr_val), ptr_type)
#
# is elided into a simple bitcast. This implies that ptr_val must be word
# aligned. It's the responsibility of the code generator to make sure
# that's the case.
#
# """
# # If this address came from a pointer, just return the punned pointer.
# if hasattr(address_val, 'b_ptr'):
# return context.builder.bitcast(address_val.b_ptr, ptr_type)
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.mul(address_val, bpw_const,
# flags=['nuw', 'nsw'])
# ptr_val = context.builder.inttoptr(byte_address, ptr_type)
#
# # HACK: we tag the value with a 'b_address' attribute so that
# # llvm_ptr_to_address() can elide address to pointer followed by pointer
# # to address conversion.
# ptr_val.b_address = address_val
#
# return ptr_val
#
# def llvm_ptr_to_address(context, ptr_val):
# """Cast a llvm Value representing a byte-oriented pointer to a word
# representing a word-oriented address. Requires builder to be not None.
#
# This method will arrange that
#
# llvm_ptr_to_address(address_to_llvm_ptr(address_val, ptr_type))
#
# is elided to address_val irrespective of ptr_type.
#
# """
# # If this pointer came from an address, just return the original address
# # value.
# if hasattr(ptr_val, 'b_address'):
# return ptr_val.b_address
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.ptrtoint(ptr_val, context.word_type)
# address_val = context.builder.udiv(byte_address, bpw_const,
# flags=['exact'])
#
# # HACK: we tag the value with a 'b_ptr' attribute so that
# # address_to_llvm_ptr() can elide pointer to address followed by address
# # to pointer conversion.
# address_val.b_ptr = ptr_val
#
# return address_val
#
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
. Output only the next line. | try: |
Based on the snippet: <|code_start|> """An RValue cannot be referenced since it does not have an address."""
raise exc.SemanticError('Cannot reference an rvalue.')
# Our implementation is such that that only lvalues are a dereferenced rvalue or
# an value retrieved from the current scope.
@ast_node
class DereferencedRValue(RValue):
"""A convenience wrapper representing a dereferenced RValue. The reference()
method simply returns the dereferenced RValue. This value is an LValue in
that it has a reference() method.
"""
def reference(self):
return self.rvalue
@needs_builder
def emit(self, context):
# Convert the rvalue word address into a llvm pointer to a word
ptr_type = context.word_type.as_pointer()
rvalue_val = self.rvalue.emit(context)
word_ptr = address_to_llvm_ptr(context, rvalue_val, ptr_type)
# Load from pointer
return context.builder.load(word_ptr)
@ast_node
class ScopeValue(RValue):
"""LValue constructed by dereferencing an address retrieved from the current
scope."""
<|code_end|>
, predict the immediate next line with the help of imports:
from llvmlite import ir
from .astnode import ast_node, needs_builder, ASTNode
from .context import (
address_to_llvm_ptr, llvm_ptr_to_address, create_aligned_global, if_else
)
import rbc.exception as exc
and context (classes, functions, sometimes code) from other files:
# Path: rbc/codegen/astnode.py
# def ast_node(cls):
# """Class decorator which registers the AST node in the _NODE_CLASSES map."""
# _NODE_CLASSES[cls.__name__] = cls
# return cls
#
# def needs_builder(emit):
# """A decorator for emit() methods which make use of the context's builder
# attribute. If the builder attribute is None, an InternalCompilerError is
# raised.
#
# """
# @functools.wraps(emit)
# def _wrapped_emit(self, context):
# if context.builder is None:
# raise exc.InternalCompilerError('AST node requires builder.')
# return emit(self, context)
# return _wrapped_emit
#
# class ASTNode(object):
# """An AST node with parameters directly accessible as attributes."""
# def __init__(self, **kwargs):
# # Set attributes on ourself directly from the keyword args.
# for k, v in kwargs.items():
# setattr(self, k, v)
#
# Path: rbc/codegen/context.py
# def address_to_llvm_ptr(context, address_val, ptr_type):
# """Cast a llvm Value representing a word into a pointer. Performs the
# appropriate conversion from word-oriented addresses to llvm's
# byte-oriented addresses. Requires builder to be not None.
#
# This method will arrange that
#
# address_to_llvm_ptr(llvm_ptr_to_address(ptr_val), ptr_type)
#
# is elided into a simple bitcast. This implies that ptr_val must be word
# aligned. It's the responsibility of the code generator to make sure
# that's the case.
#
# """
# # If this address came from a pointer, just return the punned pointer.
# if hasattr(address_val, 'b_ptr'):
# return context.builder.bitcast(address_val.b_ptr, ptr_type)
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.mul(address_val, bpw_const,
# flags=['nuw', 'nsw'])
# ptr_val = context.builder.inttoptr(byte_address, ptr_type)
#
# # HACK: we tag the value with a 'b_address' attribute so that
# # llvm_ptr_to_address() can elide address to pointer followed by pointer
# # to address conversion.
# ptr_val.b_address = address_val
#
# return ptr_val
#
# def llvm_ptr_to_address(context, ptr_val):
# """Cast a llvm Value representing a byte-oriented pointer to a word
# representing a word-oriented address. Requires builder to be not None.
#
# This method will arrange that
#
# llvm_ptr_to_address(address_to_llvm_ptr(address_val, ptr_type))
#
# is elided to address_val irrespective of ptr_type.
#
# """
# # If this pointer came from an address, just return the original address
# # value.
# if hasattr(ptr_val, 'b_address'):
# return ptr_val.b_address
#
# bpw_const = ir.Constant(context.word_type, context.bytes_per_word)
# byte_address = context.builder.ptrtoint(ptr_val, context.word_type)
# address_val = context.builder.udiv(byte_address, bpw_const,
# flags=['exact'])
#
# # HACK: we tag the value with a 'b_ptr' attribute so that
# # address_to_llvm_ptr() can elide pointer to address followed by address
# # to pointer conversion.
# address_val.b_ptr = ptr_val
#
# return address_val
#
# def create_aligned_global(module, type_, name):
# """Construct and return an ir.GlobalVariable instance which is guaranteed to
# have a word-aligned pointer. The symbol name is automatically mangled to
# avoid collision with C symbols.
#
# """
# return _ModifiedGlobalVariable(module, type_, mangle_symbol_name(name))
#
# def if_else(context, cond):
# """Convenience wrapper around llvm.ir.Builder.if_else. Takes a single AST
# node representing an expression which should be treated as a condition and
# evaluates that node.
#
# """
# cond_val = cond.emit(context)
# zero = ir.Constant(context.word_type, 0)
# bool_val = context.builder.icmp_signed('!=', cond_val, zero)
# return context.builder.if_else(bool_val)
. Output only the next line. | def reference(self): |
Predict the next line for this snippet: <|code_start|>
def load_decoders():
dec_modules = dict()
# Walk recursively through all modules and packages.
for loader, module_name, ispkg in pkgutil.walk_packages(decoders.__path__, decoders.__name__ + '.'):
# If current item is a package, skip.
if ispkg:
continue
# Try to import the module, otherwise skip.
try:
module = importlib.import_module(module_name)
except ImportError as e:
print("Unable to import Module {0}: {1}".format(module_name, e))
continue
for mod_name, mod_object in inspect.getmembers(module):
if inspect.isclass(mod_object):
if issubclass(mod_object, Decoder) and mod_object is not Decoder:
dec_modules[mod_object.decoder_name] = dict(obj=mod_object,
decoder_name=mod_object.decoder_name,
decoder_description=mod_object.decoder_description,
decoder_version=mod_object.decoder_version,
<|code_end|>
with the help of current file imports:
import importlib
import inspect
import pkgutil
from malwareconfig.common import Decoder, PreProcessor
from malwareconfig import decoders
from malwareconfig import preprocessors
and context from other files:
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# class PreProcessor(object):
# preprocessor_name = ""
# preprocessor_version = 1
# preprocessor_author = ""
# preprocessor_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def pre_process(self):
# pass
, which may contain function names, class names, or code. Output only the next line. | decoder_author=mod_object.decoder_author |
Next line prediction: <|code_start|>
class ClientMesh(Decoder):
decoder_name = "ClientMesh"
decoder__version = 1
decoder_author = "@kevthehermit"
<|code_end|>
. Use current file imports:
(from base64 import b64decode
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable)
and context including class names, function names, or small code snippets from other files:
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_description = "ClientMesh Decoder" |
Given the code snippet: <|code_start|>
# temp imports
class Mirai(Decoder):
decoder_name = "Mirai"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Mirai decoder with varients"
def __init__(self):
<|code_end|>
, generate the next line using the imports in this file:
import re
import re
import zlib
import uuid
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from binascii import hexlify, unhexlify
from struct import unpack
and context (functions, classes, or occasionally code) from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | self.config = {} |
Given snippet: <|code_start|>
class AAR(Decoder):
decoder_name = "AAR"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Albertino Advanced RAT decoder"
def __init__(self):
self.config = {}
def parse_config(self, clean_config):
sections = clean_config.split('*')
config_dict = {}
if len(sections) == 7:
config_dict['Version'] = '4.x'
config_dict['Domain1'] = sections[0]
config_dict['Domain2'] = sections[1]
config_dict['RegKey1'] = sections[2]
config_dict['RegKey2'] = sections[3]
config_dict['Port1'] = sections[4]
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import re
import binascii
import hashlib
from base64 import b64decode
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
which might include code, classes, or functions. Output only the next line. | config_dict['Port2'] = sections[5] |
Given the following code snippet before the placeholder: <|code_start|>
class AAR(Decoder):
decoder_name = "AAR"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Albertino Advanced RAT decoder"
def __init__(self):
self.config = {}
def parse_config(self, clean_config):
sections = clean_config.split('*')
config_dict = {}
if len(sections) == 7:
config_dict['Version'] = '4.x'
config_dict['Domain1'] = sections[0]
config_dict['Domain2'] = sections[1]
config_dict['RegKey1'] = sections[2]
config_dict['RegKey2'] = sections[3]
config_dict['Port1'] = sections[4]
config_dict['Port2'] = sections[5]
config_dict['Mutex'] = sections[6]
if len(sections) == 5:
config_dict['Version'] = '2.x'
config_dict['Domain1'] = sections[0]
config_dict['Domain2'] = sections[1]
config_dict['Port1'] = sections[2]
config_dict['Port2'] = sections[3]
<|code_end|>
, predict the next line using imports from the current file:
import re
import binascii
import hashlib
from base64 import b64decode
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context including class names, function names, and sometimes code from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | config_dict['AntiDebug'] = sections[4] |
Given the code snippet: <|code_start|>
class Arcom(Decoder):
decoder_name = "Arcom"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Arcom RAT Decoder"
def __init__(self):
<|code_end|>
, generate the next line using the imports in this file:
from base64 import b64decode
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context (functions, classes, or occasionally code) from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | self.config = {} |
Next line prediction: <|code_start|>
class Arcom(Decoder):
decoder_name = "Arcom"
decoder__version = 1
<|code_end|>
. Use current file imports:
(from base64 import b64decode
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable)
and context including class names, function names, or small code snippets from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_author = "@kevthehermit" |
Given snippet: <|code_start|>
class SpyNote(Decoder):
decoder_name = "SpyNote"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "SpyNote and MobiHook RAT Decoder"
def __init__(self):
self.config = {}
@staticmethod
def get_string(str_name, listoflists):
for element in listoflists:
if element[0] == str_name:
return element[1]
else:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import re
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context:
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
which might include code, classes, or functions. Output only the next line. | return None |
Predict the next line for this snippet: <|code_start|>
class BlackNix(Decoder):
decoder_name = "BlackNix"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "BlackNix RAT"
def __init__(self):
self.config = {}
<|code_end|>
with the help of current file imports:
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
, which may contain function names, class names, or code. Output only the next line. | def get_config(self): |
Using the snippet: <|code_start|>
class UPX(PreProcessor):
preprocessor_name = "UPX"
preprocessor__version = 1
<|code_end|>
, determine the next line of code. You have imports:
import os
import subprocess
from malwareconfig.yarascanner import YaraScanner
from malwareconfig.common import PreProcessor
from tempfile import NamedTemporaryFile
and context (class names, function names, or code) available:
# Path: malwareconfig/yarascanner.py
# class YaraScanner:
# def __init__(self):
# # Create the list of rules
# try:
# yara_path = os.path.join(os.path.dirname(__file__), 'yaraRules')
# self.yara_rules = os.listdir(yara_path)
# self.rule_file = os.path.join(yara_path, 'yaraRules.yar')
# self.compiled_rules = yara.compile(self.rule_file)
# self.rule_list = []
# except yara.SyntaxError as e:
# print("Unable to compile rules. Do you have dotnet enabled")
#
# # Yara Scanner Returns the Rule Name
# def yara_scan(self, raw_data):
# matches = self.compiled_rules.match(data=raw_data)
# rule_list = []
#
# for match in matches:
# rule_list.append(match.rule)
# self.rule_list = rule_list
#
# Path: malwareconfig/common.py
# class PreProcessor(object):
# preprocessor_name = ""
# preprocessor_version = 1
# preprocessor_author = ""
# preprocessor_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def pre_process(self):
# pass
. Output only the next line. | preprocessor_author = "@kevthehermit" |
Given snippet: <|code_start|>
class UPX(PreProcessor):
preprocessor_name = "UPX"
preprocessor__version = 1
preprocessor_author = "@kevthehermit"
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import subprocess
from malwareconfig.yarascanner import YaraScanner
from malwareconfig.common import PreProcessor
from tempfile import NamedTemporaryFile
and context:
# Path: malwareconfig/yarascanner.py
# class YaraScanner:
# def __init__(self):
# # Create the list of rules
# try:
# yara_path = os.path.join(os.path.dirname(__file__), 'yaraRules')
# self.yara_rules = os.listdir(yara_path)
# self.rule_file = os.path.join(yara_path, 'yaraRules.yar')
# self.compiled_rules = yara.compile(self.rule_file)
# self.rule_list = []
# except yara.SyntaxError as e:
# print("Unable to compile rules. Do you have dotnet enabled")
#
# # Yara Scanner Returns the Rule Name
# def yara_scan(self, raw_data):
# matches = self.compiled_rules.match(data=raw_data)
# rule_list = []
#
# for match in matches:
# rule_list.append(match.rule)
# self.rule_list = rule_list
#
# Path: malwareconfig/common.py
# class PreProcessor(object):
# preprocessor_name = ""
# preprocessor_version = 1
# preprocessor_author = ""
# preprocessor_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def pre_process(self):
# pass
which might include code, classes, or functions. Output only the next line. | preprocessor_description = "Unpack UPX Samples" |
Using the snippet: <|code_start|> clean_dict['P2PSpread'] = v
if k == 'reg':
clean_dict['Registry Startup'] = v
if k == 'usb':
clean_dict['USB Spread'] = v
if k == 'usbn':
clean_dict['USB Name'] = v
if k == 'victimo':
clean_dict['Campaign'] = v
return clean_dict
@staticmethod
def ver_80(conf):
conf_dict = {}
conf_dict['Domain'] = decrypt_arc4('UniQue OussamiO', unhexlify(conf[1]))
conf_dict['Campaign'] = conf[2]
conf_dict['Enable Startup'] = conf[3]
conf_dict['StartupName'] = conf[4]
conf_dict['FolderName'] = conf[5]
if conf[6] == "D":
conf_dict['Path'] = 'App Data Folder'
elif conf[6] == "W":
conf_dict['Path'] = 'Windows Folder'
if conf[6] == "s":
conf_dict['Path'] = 'System Folder'
conf_dict['Enable Error Message'] = conf[7]
conf_dict['Error Message'] = conf[8]
conf_dict['Disable Firewall'] = conf[9]
#conf_dict[''] = conf[10]
#conf_dict[''] = conf[11]
<|code_end|>
, determine the next line of code. You have imports:
from malwareconfig.crypto import decrypt_arc4
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from binascii import unhexlify
and context (class names, function names, or code) available:
# Path: malwareconfig/crypto.py
# def decrypt_arc4(key, data):
# cipher = ARC4.new(key)
# return cipher.decrypt(data)
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | conf_dict['USB Spread'] = conf[12] |
Using the snippet: <|code_start|> k,v = line.split(' = ')
raw_dict[k.strip('*')] = v.strip('%')
except Exception as e:
continue
return self.config_cleaner(raw_dict)
def config_cleaner(self, raw_dict):
clean_dict = {}
for k,v in raw_dict.items():
if k == 'ip':
clean_dict['Domain'] = decrypt_arc4('oussamio', unhexlify(v))
if k == 'fire':
clean_dict['Firewall Bypass'] = v
if k == 'foder':
clean_dict['InstallPath'] = v
if k == 'mlt':
clean_dict['Melt'] = v
if k == 'msns':
clean_dict['MSN Spread'] = v
if k == 'name':
clean_dict['Reg Key'] = v
if k == 'path':
clean_dict['Reg value'] = v
if k == 'port':
clean_dict['Port'] = v
if k == 'ppp':
clean_dict['P2PSpread'] = v
if k == 'reg':
clean_dict['Registry Startup'] = v
if k == 'usb':
<|code_end|>
, determine the next line of code. You have imports:
from malwareconfig.crypto import decrypt_arc4
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from binascii import unhexlify
and context (class names, function names, or code) available:
# Path: malwareconfig/crypto.py
# def decrypt_arc4(key, data):
# cipher = ARC4.new(key)
# return cipher.decrypt(data)
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | clean_dict['USB Spread'] = v |
Based on the snippet: <|code_start|>
class LuxNet(Decoder):
decoder_name = "LuxNet"
decoder__version = 1
decoder_author = "@kevthehermit"
<|code_end|>
, predict the immediate next line with the help of imports:
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context (classes, functions, sometimes code) from other files:
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_description = "Luxnet RAT Decoder" |
Next line prediction: <|code_start|>
class Adzok(Decoder):
decoder_name = "Adzok"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Adzok Decoder"
def __init__(self):
<|code_end|>
. Use current file imports:
(from xml.etree import ElementTree as ET
from malwareconfig.common import Decoder)
and context including class names, function names, or small code snippets from other files:
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
. Output only the next line. | self.config = {} |
Using the snippet: <|code_start|>
# temp imports
class Plasma(Decoder):
decoder_name = "Plasma"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Plasma decoder for 1.7 This is identical to LuminosityLink"
<|code_end|>
, determine the next line of code. You have imports:
import re
import binascii
import hashlib
import re
import zlib
import uuid
from base64 import b64decode
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from struct import unpack
and context (class names, function names, or code) available:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | def __init__(self): |
Using the snippet: <|code_start|>
# temp imports
class Plasma(Decoder):
decoder_name = "Plasma"
decoder__version = 1
<|code_end|>
, determine the next line of code. You have imports:
import re
import binascii
import hashlib
import re
import zlib
import uuid
from base64 import b64decode
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from struct import unpack
and context (class names, function names, or code) available:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_author = "@kevthehermit" |
Next line prediction: <|code_start|>
# temp imports
class NanoCore(Decoder):
decoder_name = "NanoCore"
decoder__version = 1
<|code_end|>
. Use current file imports:
(from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from binascii import hexlify, unhexlify
from struct import unpack
import re
import zlib
import uuid)
and context including class names, function names, or small code snippets from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_author = "@kevthehermit" |
Based on the snippet: <|code_start|>
# temp imports
class NanoCore(Decoder):
decoder_name = "NanoCore"
decoder__version = 1
decoder_author = "@kevthehermit"
<|code_end|>
, predict the immediate next line with the help of imports:
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from binascii import hexlify, unhexlify
from struct import unpack
import re
import zlib
import uuid
and context (classes, functions, sometimes code) from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_description = "NanoCore decoder for early versions" |
Based on the snippet: <|code_start|>
class CyberGate(Decoder):
decoder_name = "CyberGate"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "CyberGate RAT"
def __init__(self):
self.config = {}
@staticmethod
def xor(data):
decoded = ''
key = 0xBC
for c in data:
decoded += chr(key^c)
return decoded
<|code_end|>
, predict the immediate next line with the help of imports:
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context (classes, functions, sometimes code) from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | def get_config(self): |
Using the snippet: <|code_start|>
class JRat(Decoder):
decoder_name = "JRat"
decoder__version = 1
<|code_end|>
, determine the next line of code. You have imports:
from binascii import unhexlify
from base64 import b64decode
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig import fileparser
and context (class names, function names, or code) available:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/fileparser.py
# class FileParser:
# def __init__(self, file_path=None, rawdata=None):
# def yarascan(self):
# def file_hash(self, hash_type="sha256"):
# def pe_resource_id(self, res_id):
# def modules_callback(data):
# def pe_resource_names(self):
# def pe_resource_by_name(self, resource_name):
# def dotnet_resource_names(self):
# def modules_callback(data):
# def dotnet_resource_by_name(self, resource_name):
# def modules_callback(data):
# def dotnet_guids(self):
# def modules_callback(data):
# def dotnet_user_strings(self):
# def modules_callback(data):
# def ascii_strings(self, min_len=4):
# def unicode_strings(self, min_len=4):
# def file_from_zip(self, filename):
# def zip_namelist(self):
# def parse_apk(self):
# def elf_list_sections(self):
# def modules_callback(data):
# def elf_section_by_name(self, resource_name):
# def modules_callback(data):
. Output only the next line. | decoder_author = "@kevthehermit" |
Predict the next line for this snippet: <|code_start|>
class JRat(Decoder):
decoder_name = "JRat"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Java Based RAT"
<|code_end|>
with the help of current file imports:
from binascii import unhexlify
from base64 import b64decode
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig import fileparser
and context from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/fileparser.py
# class FileParser:
# def __init__(self, file_path=None, rawdata=None):
# def yarascan(self):
# def file_hash(self, hash_type="sha256"):
# def pe_resource_id(self, res_id):
# def modules_callback(data):
# def pe_resource_names(self):
# def pe_resource_by_name(self, resource_name):
# def dotnet_resource_names(self):
# def modules_callback(data):
# def dotnet_resource_by_name(self, resource_name):
# def modules_callback(data):
# def dotnet_guids(self):
# def modules_callback(data):
# def dotnet_user_strings(self):
# def modules_callback(data):
# def ascii_strings(self, min_len=4):
# def unicode_strings(self, min_len=4):
# def file_from_zip(self, filename):
# def zip_namelist(self):
# def parse_apk(self):
# def elf_list_sections(self):
# def modules_callback(data):
# def elf_section_by_name(self, resource_name):
# def modules_callback(data):
, which may contain function names, class names, or code. Output only the next line. | def __init__(self): |
Predict the next line for this snippet: <|code_start|>
class FileParser:
def __init__(self, file_path=None, rawdata=None):
if file_path:
file_object = open(file_path, 'rb')
else:
file_object = io.BytesIO(rawdata)
file_object.name = "DummyFile.ext"
self.file_name = file_object.name
self.file_data = file_object.read()
self.file_size = len(self.file_data)
self.malware_name = ''
self.yarascan()
file_object.close()
def yarascan(self):
scanner = YaraScanner()
scanner.yara_scan(self.file_data)
if len(scanner.rule_list) > 0:
self.malware_name = scanner.rule_list[0]
def file_hash(self, hash_type="sha256"):
filehash = ''
<|code_end|>
with the help of current file imports:
import re
import hashlib
import pefile
import io
import yara
from binascii import hexlify
from androguard.core.bytecodes import apk
from androguard.core.bytecodes import dvm
from androguard import misc
from malwareconfig.yarascanner import YaraScanner
from zipfile import ZipFile
and context from other files:
# Path: malwareconfig/yarascanner.py
# class YaraScanner:
# def __init__(self):
# # Create the list of rules
# try:
# yara_path = os.path.join(os.path.dirname(__file__), 'yaraRules')
# self.yara_rules = os.listdir(yara_path)
# self.rule_file = os.path.join(yara_path, 'yaraRules.yar')
# self.compiled_rules = yara.compile(self.rule_file)
# self.rule_list = []
# except yara.SyntaxError as e:
# print("Unable to compile rules. Do you have dotnet enabled")
#
# # Yara Scanner Returns the Rule Name
# def yara_scan(self, raw_data):
# matches = self.compiled_rules.match(data=raw_data)
# rule_list = []
#
# for match in matches:
# rule_list.append(match.rule)
# self.rule_list = rule_list
, which may contain function names, class names, or code. Output only the next line. | if hash_type == "sha256": |
Predict the next line for this snippet: <|code_start|>
class DarkRAT(Decoder):
decoder_name = "DarkRAT"
decoder__version = 1
<|code_end|>
with the help of current file imports:
from base64 import b64decode
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
, which may contain function names, class names, or code. Output only the next line. | decoder_author = "@kevthehermit" |
Next line prediction: <|code_start|>
class AdWind(Decoder):
decoder_name = "AdWind"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "AdWind Decoder"
def __init__(self):
self.config = {}
@staticmethod
def parse_config(old_config):
if old_config['Version'] == 'Adwind RAT v1.0':
new_config = {}
new_config['Version'] = old_config['Version']
new_config['Delay'] = old_config['delay']
new_config['Domain'] = old_config['dns']
new_config['Install Flag'] = old_config['instalar']
new_config['Jar Name'] = old_config['jarname']
new_config['Reg Key'] = old_config['keyClase']
new_config['Install Folder'] = old_config['nombreCarpeta']
new_config['Password'] = old_config['password']
new_config['Campaign ID'] = old_config['prefijo']
new_config['Port1'] = old_config['puerto1']
new_config['Port2'] = old_config['puerto2']
<|code_end|>
. Use current file imports:
(from xml.etree import ElementTree as ET
from malwareconfig import crypto
from malwareconfig.common import Decoder)
and context including class names, function names, or small code snippets from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
. Output only the next line. | new_config['Reg Value'] = old_config['regname'] |
Next line prediction: <|code_start|>
class AdWind(Decoder):
decoder_name = "AdWind"
decoder__version = 1
decoder_author = "@kevthehermit"
<|code_end|>
. Use current file imports:
(from xml.etree import ElementTree as ET
from malwareconfig import crypto
from malwareconfig.common import Decoder)
and context including class names, function names, or small code snippets from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
. Output only the next line. | decoder_description = "AdWind Decoder" |
Continue the code snippet: <|code_start|> sample_path = "tests/samples/aar"
results = decode_sample(sample_path)
assert results['Version'] == '4.x'
def test_adwind():
sample_path = "tests/samples/adwind"
results = decode_sample(sample_path)
assert results['Version'] == 'Adwind RAT v2.0'
def test_adzok():
sample_path = "tests/samples/adzok"
results = decode_sample(sample_path)
assert results['Registry Key'] == 'Winhttpsvc'
def test_alienspy():
sample_path = "tests/samples/alienspy"
results = decode_sample(sample_path)
assert results['pluginfoldername'] == 'ryfne6pMMZ'
#def test_alina():
# sample_path = "tests/samples/alina"
# results = decode_sample(sample_path)
# assert results['pluginfoldername'] == 'ryfne6pMMZ'
def test_arcom():
sample_path = "tests/samples/arcom"
results = decode_sample(sample_path)
assert results['Install Name'] == 'vlc.exe'
def test_blackshades():
<|code_end|>
. Use current file imports:
import os
from malwareconfig import fileparser
from malwareconfig.modules import __decoders__
and context (classes, functions, or code) from other files:
# Path: malwareconfig/fileparser.py
# class FileParser:
# def __init__(self, file_path=None, rawdata=None):
# def yarascan(self):
# def file_hash(self, hash_type="sha256"):
# def pe_resource_id(self, res_id):
# def modules_callback(data):
# def pe_resource_names(self):
# def pe_resource_by_name(self, resource_name):
# def dotnet_resource_names(self):
# def modules_callback(data):
# def dotnet_resource_by_name(self, resource_name):
# def modules_callback(data):
# def dotnet_guids(self):
# def modules_callback(data):
# def dotnet_user_strings(self):
# def modules_callback(data):
# def ascii_strings(self, min_len=4):
# def unicode_strings(self, min_len=4):
# def file_from_zip(self, filename):
# def zip_namelist(self):
# def parse_apk(self):
# def elf_list_sections(self):
# def modules_callback(data):
# def elf_section_by_name(self, resource_name):
# def modules_callback(data):
#
# Path: malwareconfig/modules.py
# def load_decoders():
# def load_preprocessors():
. Output only the next line. | sample_path = "tests/samples/blackshades" |
Given the following code snippet before the placeholder: <|code_start|>
def test_decoders_import():
assert 'AAR' in __decoders__.keys()
assert 'AdWind' in __decoders__.keys()
assert 'Adzok' in __decoders__.keys()
assert 'AlienSpy' in __decoders__.keys()
assert 'Alina' in __decoders__.keys()
assert 'Arcom' in __decoders__.keys()
assert 'BlackNix' in __decoders__.keys()
assert 'BlackShades' in __decoders__.keys()
assert 'BlueBanana' in __decoders__.keys()
assert 'Bozok' in __decoders__.keys()
assert 'ClientMesh' in __decoders__.keys()
assert 'CyberGate' in __decoders__.keys()
assert 'DarkComet' in __decoders__.keys()
assert 'HawkEye' in __decoders__.keys()
assert 'Jbifrost' in __decoders__.keys()
assert 'JRat' in __decoders__.keys()
assert 'LostDoor' in __decoders__.keys()
assert 'LuminosityLink' in __decoders__.keys()
assert 'NanoCore' in __decoders__.keys()
assert 'njRat' in __decoders__.keys()
assert 'Sakula' in __decoders__.keys()
assert 'Xtreme' in __decoders__.keys()
def decode_sample(sample_path):
file_info = fileparser.FileParser(file_path=sample_path)
if file_info.malware_name in __decoders__:
module = __decoders__[file_info.malware_name]['obj']()
<|code_end|>
, predict the next line using imports from the current file:
import os
from malwareconfig import fileparser
from malwareconfig.modules import __decoders__
and context including class names, function names, and sometimes code from other files:
# Path: malwareconfig/fileparser.py
# class FileParser:
# def __init__(self, file_path=None, rawdata=None):
# def yarascan(self):
# def file_hash(self, hash_type="sha256"):
# def pe_resource_id(self, res_id):
# def modules_callback(data):
# def pe_resource_names(self):
# def pe_resource_by_name(self, resource_name):
# def dotnet_resource_names(self):
# def modules_callback(data):
# def dotnet_resource_by_name(self, resource_name):
# def modules_callback(data):
# def dotnet_guids(self):
# def modules_callback(data):
# def dotnet_user_strings(self):
# def modules_callback(data):
# def ascii_strings(self, min_len=4):
# def unicode_strings(self, min_len=4):
# def file_from_zip(self, filename):
# def zip_namelist(self):
# def parse_apk(self):
# def elf_list_sections(self):
# def modules_callback(data):
# def elf_section_by_name(self, resource_name):
# def modules_callback(data):
#
# Path: malwareconfig/modules.py
# def load_decoders():
# def load_preprocessors():
. Output only the next line. | module.set_file(file_info) |
Predict the next line for this snippet: <|code_start|>
class Sakula(Decoder):
decoder_name = "Sakula"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Sakula Rat"
def __init__(self):
self.config = {}
@staticmethod
def config_v1(config_list):
print("Found Version < 1.3")
config_dict = {}
counter = 1
for config in config_list:
config_dict['Domain'] = config[0].rstrip(b'\x88')
config_dict['URI GET1 Folder'] = config[1].rstrip(b'\x88')
config_dict['URI GET3 File'] = config[2].rstrip(b'\x88')
config_dict['URI GET2 File'] = config[3].rstrip(b'\x88')
config_dict['URI GET3 Arg'] = config[4].rstrip(b'\x88')
config_dict['Copy File Name'] = config[5].rstrip(b'\x88')
config_dict['Service Name'] = config[6].rstrip(b'\x88')
config_dict['Service Description'] = config[7].rstrip(b'\x88')
<|code_end|>
with the help of current file imports:
import re
from struct import unpack
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
, which may contain function names, class names, or code. Output only the next line. | config_dict['Waiting Time'] = unpack('>H', config[8][:2].rstrip(b'\x88'))[0] |
Based on the snippet: <|code_start|>
class Jbifrost(Decoder):
decoder_name = "Jbifrost"
decoder__version = 1
decoder_author = ["@kevthehermit", "Chris"]
decoder_description = "Jbifrost Java RAT"
def __init__(self):
self.config = {}
<|code_end|>
, predict the immediate next line with the help of imports:
import javaobj # sudo pip3 install javaobj-py3
from xml.etree import ElementTree as ET
from malwareconfig import fileparser
from io import BytesIO
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context (classes, functions, sometimes code) from other files:
# Path: malwareconfig/fileparser.py
# class FileParser:
# def __init__(self, file_path=None, rawdata=None):
# def yarascan(self):
# def file_hash(self, hash_type="sha256"):
# def pe_resource_id(self, res_id):
# def modules_callback(data):
# def pe_resource_names(self):
# def pe_resource_by_name(self, resource_name):
# def dotnet_resource_names(self):
# def modules_callback(data):
# def dotnet_resource_by_name(self, resource_name):
# def modules_callback(data):
# def dotnet_guids(self):
# def modules_callback(data):
# def dotnet_user_strings(self):
# def modules_callback(data):
# def ascii_strings(self, min_len=4):
# def unicode_strings(self, min_len=4):
# def file_from_zip(self, filename):
# def zip_namelist(self):
# def parse_apk(self):
# def elf_list_sections(self):
# def modules_callback(data):
# def elf_section_by_name(self, resource_name):
# def modules_callback(data):
#
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | @staticmethod |
Given the following code snippet before the placeholder: <|code_start|>
class Jbifrost(Decoder):
decoder_name = "Jbifrost"
decoder__version = 1
decoder_author = ["@kevthehermit", "Chris"]
<|code_end|>
, predict the next line using imports from the current file:
import javaobj # sudo pip3 install javaobj-py3
from xml.etree import ElementTree as ET
from malwareconfig import fileparser
from io import BytesIO
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context including class names, function names, and sometimes code from other files:
# Path: malwareconfig/fileparser.py
# class FileParser:
# def __init__(self, file_path=None, rawdata=None):
# def yarascan(self):
# def file_hash(self, hash_type="sha256"):
# def pe_resource_id(self, res_id):
# def modules_callback(data):
# def pe_resource_names(self):
# def pe_resource_by_name(self, resource_name):
# def dotnet_resource_names(self):
# def modules_callback(data):
# def dotnet_resource_by_name(self, resource_name):
# def modules_callback(data):
# def dotnet_guids(self):
# def modules_callback(data):
# def dotnet_user_strings(self):
# def modules_callback(data):
# def ascii_strings(self, min_len=4):
# def unicode_strings(self, min_len=4):
# def file_from_zip(self, filename):
# def zip_namelist(self):
# def parse_apk(self):
# def elf_list_sections(self):
# def modules_callback(data):
# def elf_section_by_name(self, resource_name):
# def modules_callback(data):
#
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_description = "Jbifrost Java RAT" |
Given the following code snippet before the placeholder: <|code_start|>
def __init__(self):
self.config = {}
@staticmethod
def parse_xml(xml_string):
# Convert to XML
xml = ET.fromstring(xml_string)
# Read the XML to a config dict
properties_dict = {}
for child in xml:
if child.attrib:
properties_dict[child.attrib['key']] = child.text
return properties_dict
@staticmethod
def extract_rsa_key(java_serialized_data):
deserialized_data = javaobj.loads(java_serialized_data)
rsa_key_bytes = deserialized_data.encoded
rsa_key_string = ''
for b in rsa_key_bytes:
# convert to unsigned int
rsa_key_string += chr(b & 0xff)
return rsa_key_string
<|code_end|>
, predict the next line using imports from the current file:
import javaobj # sudo pip3 install javaobj-py3
from xml.etree import ElementTree as ET
from malwareconfig import fileparser
from io import BytesIO
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context including class names, function names, and sometimes code from other files:
# Path: malwareconfig/fileparser.py
# class FileParser:
# def __init__(self, file_path=None, rawdata=None):
# def yarascan(self):
# def file_hash(self, hash_type="sha256"):
# def pe_resource_id(self, res_id):
# def modules_callback(data):
# def pe_resource_names(self):
# def pe_resource_by_name(self, resource_name):
# def dotnet_resource_names(self):
# def modules_callback(data):
# def dotnet_resource_by_name(self, resource_name):
# def modules_callback(data):
# def dotnet_guids(self):
# def modules_callback(data):
# def dotnet_user_strings(self):
# def modules_callback(data):
# def ascii_strings(self, min_len=4):
# def unicode_strings(self, min_len=4):
# def file_from_zip(self, filename):
# def zip_namelist(self):
# def parse_apk(self):
# def elf_list_sections(self):
# def modules_callback(data):
# def elf_section_by_name(self, resource_name):
# def modules_callback(data):
#
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | def extract_from_droppper(self): |
Continue the code snippet: <|code_start|>
class HawkEye(Decoder):
decoder_name = "HawkEye"
decoder__version = 1
decoder_author = "@kevthehermit"
<|code_end|>
. Use current file imports:
from base64 import b64decode
from binascii import unhexlify, hexlify
from malwareconfig import crypto
from malwareconfig.common import Decoder
and context (classes, functions, or code) from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
. Output only the next line. | decoder_description = "Decoder For Hawkeye Cred Stealer" |
Given the following code snippet before the placeholder: <|code_start|>
class HawkEye(Decoder):
decoder_name = "HawkEye"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Decoder For Hawkeye Cred Stealer"
def __init__(self):
self.config = {}
<|code_end|>
, predict the next line using imports from the current file:
from base64 import b64decode
from binascii import unhexlify, hexlify
from malwareconfig import crypto
from malwareconfig.common import Decoder
and context including class names, function names, and sometimes code from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
. Output only the next line. | def get_config(self): |
Next line prediction: <|code_start|>
prng_seed = 0
class BlackShades(Decoder):
decoder_name = "BlackShades"
decoder__version = 1
decoder_author = "@botnet_hunter, @kevthehermit"
decoder_description = "BlackShades Decoder"
def __init__(self):
self.config = {}
@staticmethod
def is_valid_config(config):
if config[:3] != "\x0c\x0c\x0c":
return False
if config.count("\x0C\x0C\x0C") < 15:
return False
return True
@staticmethod
<|code_end|>
. Use current file imports:
(import re
import binascii
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable)
and context including class names, function names, or small code snippets from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | def get_next_rng_value(): |
Next line prediction: <|code_start|>
class LuminosityLink(Decoder):
decoder_name = "LuminosityLink"
decoder__version = 1
<|code_end|>
. Use current file imports:
(import re
import binascii
import hashlib
from base64 import b64decode
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable)
and context including class names, function names, or small code snippets from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_author = "@kevthehermit" |
Next line prediction: <|code_start|>
class BlueBanana(Decoder):
decoder_name = "BlueBanana"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Decoder for Blue Banana"
def __init__(self):
<|code_end|>
. Use current file imports:
(import binascii
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable)
and context including class names, function names, or small code snippets from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | self.config = {} |
Given the following code snippet before the placeholder: <|code_start|>
class BlueBanana(Decoder):
decoder_name = "BlueBanana"
decoder__version = 1
<|code_end|>
, predict the next line using imports from the current file:
import binascii
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context including class names, function names, and sometimes code from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_author = "@kevthehermit" |
Using the snippet: <|code_start|>
class Bozok(Decoder):
decoder_name = "Bozok"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Bozok Decoder"
def __init__(self):
self.config = {}
<|code_end|>
, determine the next line of code. You have imports:
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context (class names, function names, or code) available:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | def get_config(self): |
Predict the next line after this snippet: <|code_start|>
rule_source = '''
rule opcodes {
meta:
description = "Netwire instruction sequences"
author = "David Cannings"
strings:
$opcodes01 = { 31 C0 88 44 01 08 40 3D 00 01 00 00 75 F4 }
$opcodes02 = { 8A 5C 06 08 88 9C 05 F4 FE FF FF 40 3D 00 01 00 00 75 ED }
$opcodes03 = { 53 81 EC ?? ?? 00 00 C7 ?? ?? ?? ?? 00 00 00 C7 ?? ?? ?? ?? ?? ?? 00 8D ?? ?? ?? FF FF 89 ?? ?? E8 ?? ?? ?? 00 }
<|code_end|>
using the current file's imports:
import pefile
import yara
import struct
from malwareconfig.crypto import decrypt_arc4
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and any relevant context from other files:
# Path: malwareconfig/crypto.py
# def decrypt_arc4(key, data):
# cipher = ARC4.new(key)
# return cipher.decrypt(data)
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | $opcodes04 = { E8 ?? ?? 00 00 C7 44 ?? ?? ?? ?? 00 00 C7 44 ?? ?? ?? ?? ?? 00 89 ?? ?? E8 ?? ?? ?? 00 } |
Given the code snippet: <|code_start|> except Exception as e:
print(e)
pass
@staticmethod
def version_d(enckey, coded_jar):
return AlienSpy.version_c(enckey, coded_jar, rounds=22, P=0xb7e15263, Q=0x9e3779c9)
@staticmethod
def decrypt_XOR(keys, data):
for key in keys:
res = ""
for i in range(len(data)):
res += chr(ord(data[i]) ^ ord(key[i % len(key)]))
if "SERVER" in res:
return res
@staticmethod
def xor_config(data):
config_dict = {}
xor_keys = ["0x999sisosouuqjqhyysuhahyujssddqsad23rhggdsfsdfs",
"VY999sisosouuqjqhyysuhahyujssddqsad22rhggdsfsdfs",
"ABJSIOODKKDIOSKKJDJUIOIKASJIOOQKSJIUDIKDKIAS",
"fkfjgioelsqisoosidiijsdndcbhchyduwiqoqpqwoieweueidjdshsjahshquuiqoaooasisjdhdfh",
"adsdcwegtryhyurtgwefwedwscsdcwsdfcasfwqedfwefsdfasdqwdascfsdfvsdvwergvergerg",
"adsdcwegtryhyurtgwefwedwscsdcwsdfcasfwqedfwefsdfasdqwdascfsdfvsdvwergvergerg",
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"lolskmzzzznzbxbxjxjjzkkzzkiziopoakidqoiwjdiqjhwdiqjwiodjdhjhbhbvhcebucbecercsdsd",
"Zlolskmzzzznzbxbxjxjjzkkzzkiziopoakidqoiwjdiqjhwdiqjwiodjdhjhbhbvhcebucbecercsdsd",
"aaaaaaaaaaaaaaaaaaaaa",
<|code_end|>
, generate the next line using the imports in this file:
import re
import json
from zipfile import ZipFile
from io import BytesIO
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context (functions, classes, or occasionally code) from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | "kevthehermitisacompletegaywhatfuckwithhismotherXDXDXD", |
Predict the next line for this snippet: <|code_start|> config_dict['ConfigKey'] = key
return config_dict
except Exception as e:
print(e)
pass
@staticmethod
def version_d(enckey, coded_jar):
return AlienSpy.version_c(enckey, coded_jar, rounds=22, P=0xb7e15263, Q=0x9e3779c9)
@staticmethod
def decrypt_XOR(keys, data):
for key in keys:
res = ""
for i in range(len(data)):
res += chr(ord(data[i]) ^ ord(key[i % len(key)]))
if "SERVER" in res:
return res
@staticmethod
def xor_config(data):
config_dict = {}
xor_keys = ["0x999sisosouuqjqhyysuhahyujssddqsad23rhggdsfsdfs",
"VY999sisosouuqjqhyysuhahyujssddqsad22rhggdsfsdfs",
"ABJSIOODKKDIOSKKJDJUIOIKASJIOOQKSJIUDIKDKIAS",
"fkfjgioelsqisoosidiijsdndcbhchyduwiqoqpqwoieweueidjdshsjahshquuiqoaooasisjdhdfh",
"adsdcwegtryhyurtgwefwedwscsdcwsdfcasfwqedfwefsdfasdqwdascfsdfvsdvwergvergerg",
"adsdcwegtryhyurtgwefwedwscsdcwsdfcasfwqedfwefsdfasdqwdascfsdfvsdvwergvergerg",
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"lolskmzzzznzbxbxjxjjzkkzzkiziopoakidqoiwjdiqjhwdiqjwiodjdhjhbhbvhcebucbecercsdsd",
<|code_end|>
with the help of current file imports:
import re
import json
from zipfile import ZipFile
from io import BytesIO
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
, which may contain function names, class names, or code. Output only the next line. | "Zlolskmzzzznzbxbxjxjjzkkzzkiziopoakidqoiwjdiqjhwdiqjwiodjdhjhbhbvhcebucbecercsdsd", |
Predict the next line after this snippet: <|code_start|>
# temp imports
class Xtreme(Decoder):
decoder_name = "Xtreme"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Xtreme decoder for 2.9, 3.1, 3.2, 3.5"
def __init__(self):
self.config = {}
def get_unicode_string(self, buf, pos):
out = ''
<|code_end|>
using the current file's imports:
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from binascii import hexlify, unhexlify
from struct import unpack
import re
and any relevant context from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | for i in range(len(buf[pos:])): |
Predict the next line after this snippet: <|code_start|>
# temp imports
class Xtreme(Decoder):
decoder_name = "Xtreme"
decoder__version = 1
decoder_author = "@kevthehermit"
<|code_end|>
using the current file's imports:
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from binascii import hexlify, unhexlify
from struct import unpack
import re
and any relevant context from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_description = "Xtreme decoder for 2.9, 3.1, 3.2, 3.5" |
Given snippet: <|code_start|>
class Remcos(Decoder):
decoder_name = "Remcos"
decoder__version = 1
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from malwareconfig.crypto import decrypt_arc4
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from binascii import hexlify
import re
and context:
# Path: malwareconfig/crypto.py
# def decrypt_arc4(key, data):
# cipher = ARC4.new(key)
# return cipher.decrypt(data)
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
which might include code, classes, or functions. Output only the next line. | decoder_author = "@kevthehermit" |
Based on the snippet: <|code_start|>
class Remcos(Decoder):
decoder_name = "Remcos"
decoder__version = 1
decoder_author = "@kevthehermit"
<|code_end|>
, predict the immediate next line with the help of imports:
from malwareconfig.crypto import decrypt_arc4
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
from binascii import hexlify
import re
and context (classes, functions, sometimes code) from other files:
# Path: malwareconfig/crypto.py
# def decrypt_arc4(key, data):
# cipher = ARC4.new(key)
# return cipher.decrypt(data)
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | decoder_description = "Remcos Decoder" |
Predict the next line after this snippet: <|code_start|>
class DarkComet(Decoder):
decoder_name = "DarkComet"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "DarkComet decoder for all known versions"
def __init__(self):
self.config = {}
@staticmethod
def get_version(raw_data):
if b'#KCMDDC2#' in raw_data:
return '#KCMDDC2#-890'
elif b'#KCMDDC4#' in raw_data:
return '#KCMDDC4#-890'
elif b'#KCMDDC42#' in raw_data:
return '#KCMDDC42#-890'
elif b'#KCMDDC42F#' in raw_data:
return '#KCMDDC42F#-890'
elif b'#KCMDDC5#' in raw_data:
return '#KCMDDC5#-890'
elif b'#KCMDDC51#' in raw_data:
return '#KCMDDC51#-890'
else:
return None
@staticmethod
def parse_v5(file_info, dc_version):
<|code_end|>
using the current file's imports:
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and any relevant context from other files:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | config = {} |
Using the snippet: <|code_start|>
class DarkComet(Decoder):
decoder_name = "DarkComet"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "DarkComet decoder for all known versions"
def __init__(self):
self.config = {}
@staticmethod
def get_version(raw_data):
if b'#KCMDDC2#' in raw_data:
return '#KCMDDC2#-890'
elif b'#KCMDDC4#' in raw_data:
return '#KCMDDC4#-890'
elif b'#KCMDDC42#' in raw_data:
return '#KCMDDC42#-890'
elif b'#KCMDDC42F#' in raw_data:
return '#KCMDDC42F#-890'
<|code_end|>
, determine the next line of code. You have imports:
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context (class names, function names, or code) available:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | elif b'#KCMDDC5#' in raw_data: |
Using the snippet: <|code_start|>
class DarkComet(Decoder):
decoder_name = "DarkComet"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "DarkComet decoder for all known versions"
def __init__(self):
self.config = {}
@staticmethod
def get_version(raw_data):
if b'#KCMDDC2#' in raw_data:
return '#KCMDDC2#-890'
elif b'#KCMDDC4#' in raw_data:
return '#KCMDDC4#-890'
elif b'#KCMDDC42#' in raw_data:
return '#KCMDDC42#-890'
elif b'#KCMDDC42F#' in raw_data:
return '#KCMDDC42F#-890'
elif b'#KCMDDC5#' in raw_data:
return '#KCMDDC5#-890'
<|code_end|>
, determine the next line of code. You have imports:
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
and context (class names, function names, or code) available:
# Path: malwareconfig/crypto.py
# def decrypt_rsa(key, data):
# def decrypt_xor(key, data):
# def decrypt_arc4(key, data):
# def decrypt_des_ecb(key, data, iv=None):
# def decrypt_des_cbc(key, data, iv=None):
# def decrypt_des3(key, data):
# def decrypt_aes(key, data):
# def decrypt_aes_cbc_iv(key, iv, data):
# def decrypt_blowfish(key, data):
# def decrypt_RC6(key, encrypted, P, Q, rounds):
# def rol(a, i):
# def ror(a, i):
# def to_int(bytestring):
# def decrypt_block(block, S):
# def derive_pbkdf2(key, salt, iv_length, key_length, iterations=8):
# T = 2 * rounds + 4
# L = to_int(key)
# S = []
# S = [0 for i in range(T)]
# S[0] = P
# A = 0
# B = 0
# A = S[i] = rol((S[i] + A + B), 3)
# B = L[j] = rol((L[j] + A + B), (A + B))
#
# Path: malwareconfig/common.py
# class Decoder(object):
# decoder_name = ""
# decoder_version = 1
# decoder_author = ""
# decoder_description = ""
# file_info = object
#
# def set_file(self, file_info):
# self.file_info = file_info
#
# def get_config(self):
# pass
#
# Path: malwareconfig/common.py
# def string_printable(line):
# line = str(line)
# new_line = ''
# for c in line:
# if c in string.printable:
# new_line += c
# else:
# new_line += '\\x' + c.encode("utf-8").hex()
# return new_line
. Output only the next line. | elif b'#KCMDDC51#' in raw_data: |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.