repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1
value | code stringlengths 75 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 | partition stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/filtering/alchemy.py | Node.operator | def operator(self):
"""Get the function operator from his name
:return callable: a callable to make operation on a column
"""
operators = (self.op, self.op + '_', '__' + self.op + '__')
for op in operators:
if hasattr(self.column, op):
return op
... | python | def operator(self):
"""Get the function operator from his name
:return callable: a callable to make operation on a column
"""
operators = (self.op, self.op + '_', '__' + self.op + '__')
for op in operators:
if hasattr(self.column, op):
return op
... | [
"def",
"operator",
"(",
"self",
")",
":",
"operators",
"=",
"(",
"self",
".",
"op",
",",
"self",
".",
"op",
"+",
"'_'",
",",
"'__'",
"+",
"self",
".",
"op",
"+",
"'__'",
")",
"for",
"op",
"in",
"operators",
":",
"if",
"hasattr",
"(",
"self",
".... | Get the function operator from his name
:return callable: a callable to make operation on a column | [
"Get",
"the",
"function",
"operator",
"from",
"his",
"name"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/filtering/alchemy.py#L112-L123 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/filtering/alchemy.py | Node.value | def value(self):
"""Get the value to filter on
:return: the value to filter on
"""
if self.filter_.get('field') is not None:
try:
result = getattr(self.model, self.filter_['field'])
except AttributeError:
raise InvalidFilters("{} h... | python | def value(self):
"""Get the value to filter on
:return: the value to filter on
"""
if self.filter_.get('field') is not None:
try:
result = getattr(self.model, self.filter_['field'])
except AttributeError:
raise InvalidFilters("{} h... | [
"def",
"value",
"(",
"self",
")",
":",
"if",
"self",
".",
"filter_",
".",
"get",
"(",
"'field'",
")",
"is",
"not",
"None",
":",
"try",
":",
"result",
"=",
"getattr",
"(",
"self",
".",
"model",
",",
"self",
".",
"filter_",
"[",
"'field'",
"]",
")"... | Get the value to filter on
:return: the value to filter on | [
"Get",
"the",
"value",
"to",
"filter",
"on"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/filtering/alchemy.py#L126-L142 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/filtering/alchemy.py | Node.related_model | def related_model(self):
"""Get the related model of a relationship field
:return DeclarativeMeta: the related model
"""
relationship_field = self.name
if relationship_field not in get_relationships(self.schema):
raise InvalidFilters("{} has no relationship attribut... | python | def related_model(self):
"""Get the related model of a relationship field
:return DeclarativeMeta: the related model
"""
relationship_field = self.name
if relationship_field not in get_relationships(self.schema):
raise InvalidFilters("{} has no relationship attribut... | [
"def",
"related_model",
"(",
"self",
")",
":",
"relationship_field",
"=",
"self",
".",
"name",
"if",
"relationship_field",
"not",
"in",
"get_relationships",
"(",
"self",
".",
"schema",
")",
":",
"raise",
"InvalidFilters",
"(",
"\"{} has no relationship attribute {}\... | Get the related model of a relationship field
:return DeclarativeMeta: the related model | [
"Get",
"the",
"related",
"model",
"of",
"a",
"relationship",
"field"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/filtering/alchemy.py#L145-L155 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/filtering/alchemy.py | Node.related_schema | def related_schema(self):
"""Get the related schema of a relationship field
:return Schema: the related schema
"""
relationship_field = self.name
if relationship_field not in get_relationships(self.schema):
raise InvalidFilters("{} has no relationship attribute {}".... | python | def related_schema(self):
"""Get the related schema of a relationship field
:return Schema: the related schema
"""
relationship_field = self.name
if relationship_field not in get_relationships(self.schema):
raise InvalidFilters("{} has no relationship attribute {}".... | [
"def",
"related_schema",
"(",
"self",
")",
":",
"relationship_field",
"=",
"self",
".",
"name",
"if",
"relationship_field",
"not",
"in",
"get_relationships",
"(",
"self",
".",
"schema",
")",
":",
"raise",
"InvalidFilters",
"(",
"\"{} has no relationship attribute {}... | Get the related schema of a relationship field
:return Schema: the related schema | [
"Get",
"the",
"related",
"schema",
"of",
"a",
"relationship",
"field"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/filtering/alchemy.py#L158-L168 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/api.py | Api.init_app | def init_app(self, app=None, blueprint=None, additional_blueprints=None):
"""Update flask application with our api
:param Application app: a flask application
"""
if app is not None:
self.app = app
if blueprint is not None:
self.blueprint = blueprint
... | python | def init_app(self, app=None, blueprint=None, additional_blueprints=None):
"""Update flask application with our api
:param Application app: a flask application
"""
if app is not None:
self.app = app
if blueprint is not None:
self.blueprint = blueprint
... | [
"def",
"init_app",
"(",
"self",
",",
"app",
"=",
"None",
",",
"blueprint",
"=",
"None",
",",
"additional_blueprints",
"=",
"None",
")",
":",
"if",
"app",
"is",
"not",
"None",
":",
"self",
".",
"app",
"=",
"app",
"if",
"blueprint",
"is",
"not",
"None"... | Update flask application with our api
:param Application app: a flask application | [
"Update",
"flask",
"application",
"with",
"our",
"api"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/api.py#L35-L59 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/api.py | Api.route | def route(self, resource, view, *urls, **kwargs):
"""Create an api view.
:param Resource resource: a resource class inherited from flask_rest_jsonapi.resource.Resource
:param str view: the view name
:param list urls: the urls of the view
:param dict kwargs: additional options of... | python | def route(self, resource, view, *urls, **kwargs):
"""Create an api view.
:param Resource resource: a resource class inherited from flask_rest_jsonapi.resource.Resource
:param str view: the view name
:param list urls: the urls of the view
:param dict kwargs: additional options of... | [
"def",
"route",
"(",
"self",
",",
"resource",
",",
"view",
",",
"*",
"urls",
",",
"**",
"kwargs",
")",
":",
"resource",
".",
"view",
"=",
"view",
"url_rule_options",
"=",
"kwargs",
".",
"get",
"(",
"'url_rule_options'",
")",
"or",
"dict",
"(",
")",
"... | Create an api view.
:param Resource resource: a resource class inherited from flask_rest_jsonapi.resource.Resource
:param str view: the view name
:param list urls: the urls of the view
:param dict kwargs: additional options of the route | [
"Create",
"an",
"api",
"view",
"."
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/api.py#L61-L91 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/api.py | Api.oauth_manager | def oauth_manager(self, oauth_manager):
"""Use the oauth manager to enable oauth for API
:param oauth_manager: the oauth manager
"""
@self.app.before_request
def before_request():
endpoint = request.endpoint
resource = self.app.view_functions[endpoint].vi... | python | def oauth_manager(self, oauth_manager):
"""Use the oauth manager to enable oauth for API
:param oauth_manager: the oauth manager
"""
@self.app.before_request
def before_request():
endpoint = request.endpoint
resource = self.app.view_functions[endpoint].vi... | [
"def",
"oauth_manager",
"(",
"self",
",",
"oauth_manager",
")",
":",
"@",
"self",
".",
"app",
".",
"before_request",
"def",
"before_request",
"(",
")",
":",
"endpoint",
"=",
"request",
".",
"endpoint",
"resource",
"=",
"self",
".",
"app",
".",
"view_functi... | Use the oauth manager to enable oauth for API
:param oauth_manager: the oauth manager | [
"Use",
"the",
"oauth",
"manager",
"to",
"enable",
"oauth",
"for",
"API"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/api.py#L93-L124 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/api.py | Api.build_scope | def build_scope(resource, method):
"""Compute the name of the scope for oauth
:param Resource resource: the resource manager
:param str method: an http method
:return str: the name of the scope
"""
if ResourceList in inspect.getmro(resource) and method == 'GET':
... | python | def build_scope(resource, method):
"""Compute the name of the scope for oauth
:param Resource resource: the resource manager
:param str method: an http method
:return str: the name of the scope
"""
if ResourceList in inspect.getmro(resource) and method == 'GET':
... | [
"def",
"build_scope",
"(",
"resource",
",",
"method",
")",
":",
"if",
"ResourceList",
"in",
"inspect",
".",
"getmro",
"(",
"resource",
")",
"and",
"method",
"==",
"'GET'",
":",
"prefix",
"=",
"'list'",
"else",
":",
"method_to_prefix",
"=",
"{",
"'GET'",
... | Compute the name of the scope for oauth
:param Resource resource: the resource manager
:param str method: an http method
:return str: the name of the scope | [
"Compute",
"the",
"name",
"of",
"the",
"scope",
"for",
"oauth"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/api.py#L127-L146 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/api.py | Api.permission_manager | def permission_manager(self, permission_manager):
"""Use permission manager to enable permission for API
:param callable permission_manager: the permission manager
"""
self.check_permissions = permission_manager
for resource in self.resource_registry:
if getattr(res... | python | def permission_manager(self, permission_manager):
"""Use permission manager to enable permission for API
:param callable permission_manager: the permission manager
"""
self.check_permissions = permission_manager
for resource in self.resource_registry:
if getattr(res... | [
"def",
"permission_manager",
"(",
"self",
",",
"permission_manager",
")",
":",
"self",
".",
"check_permissions",
"=",
"permission_manager",
"for",
"resource",
"in",
"self",
".",
"resource_registry",
":",
"if",
"getattr",
"(",
"resource",
",",
"'disable_permission'",... | Use permission manager to enable permission for API
:param callable permission_manager: the permission manager | [
"Use",
"permission",
"manager",
"to",
"enable",
"permission",
"for",
"API"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/api.py#L148-L160 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/api.py | Api.has_permission | def has_permission(self, *args, **kwargs):
"""Decorator used to check permissions before to call resource manager method"""
def wrapper(view):
if getattr(view, '_has_permissions_decorator', False) is True:
return view
@wraps(view)
@jsonapi_exception_f... | python | def has_permission(self, *args, **kwargs):
"""Decorator used to check permissions before to call resource manager method"""
def wrapper(view):
if getattr(view, '_has_permissions_decorator', False) is True:
return view
@wraps(view)
@jsonapi_exception_f... | [
"def",
"has_permission",
"(",
"self",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"def",
"wrapper",
"(",
"view",
")",
":",
"if",
"getattr",
"(",
"view",
",",
"'_has_permissions_decorator'",
",",
"False",
")",
"is",
"True",
":",
"return",
"view",
"... | Decorator used to check permissions before to call resource manager method | [
"Decorator",
"used",
"to",
"check",
"permissions",
"before",
"to",
"call",
"resource",
"manager",
"method"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/api.py#L162-L175 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/decorators.py | check_headers | def check_headers(func):
"""Check headers according to jsonapi reference
:param callable func: the function to decorate
:return callable: the wrapped function
"""
@wraps(func)
def wrapper(*args, **kwargs):
if request.method in ('POST', 'PATCH'):
if 'Content-Type' in request.... | python | def check_headers(func):
"""Check headers according to jsonapi reference
:param callable func: the function to decorate
:return callable: the wrapped function
"""
@wraps(func)
def wrapper(*args, **kwargs):
if request.method in ('POST', 'PATCH'):
if 'Content-Type' in request.... | [
"def",
"check_headers",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"wrapper",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"if",
"request",
".",
"method",
"in",
"(",
"'POST'",
",",
"'PATCH'",
")",
":",
"if",
"'Content-Type'",
... | Check headers according to jsonapi reference
:param callable func: the function to decorate
:return callable: the wrapped function | [
"Check",
"headers",
"according",
"to",
"jsonapi",
"reference"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/decorators.py#L15-L48 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/decorators.py | check_method_requirements | def check_method_requirements(func):
"""Check methods requirements
:param callable func: the function to decorate
:return callable: the wrapped function
"""
@wraps(func)
def wrapper(*args, **kwargs):
error_message = "You must provide {error_field} in {cls} to get access to the default {... | python | def check_method_requirements(func):
"""Check methods requirements
:param callable func: the function to decorate
:return callable: the wrapped function
"""
@wraps(func)
def wrapper(*args, **kwargs):
error_message = "You must provide {error_field} in {cls} to get access to the default {... | [
"def",
"check_method_requirements",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"wrapper",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"error_message",
"=",
"\"You must provide {error_field} in {cls} to get access to the default {method} method\""... | Check methods requirements
:param callable func: the function to decorate
:return callable: the wrapped function | [
"Check",
"methods",
"requirements"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/decorators.py#L51-L68 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.create_object | def create_object(self, data, view_kwargs):
"""Create an object through sqlalchemy
:param dict data: the data validated by marshmallow
:param dict view_kwargs: kwargs from the resource view
:return DeclarativeMeta: an object from sqlalchemy
"""
self.before_create_object(... | python | def create_object(self, data, view_kwargs):
"""Create an object through sqlalchemy
:param dict data: the data validated by marshmallow
:param dict view_kwargs: kwargs from the resource view
:return DeclarativeMeta: an object from sqlalchemy
"""
self.before_create_object(... | [
"def",
"create_object",
"(",
"self",
",",
"data",
",",
"view_kwargs",
")",
":",
"self",
".",
"before_create_object",
"(",
"data",
",",
"view_kwargs",
")",
"relationship_fields",
"=",
"get_relationships",
"(",
"self",
".",
"resource",
".",
"schema",
",",
"model... | Create an object through sqlalchemy
:param dict data: the data validated by marshmallow
:param dict view_kwargs: kwargs from the resource view
:return DeclarativeMeta: an object from sqlalchemy | [
"Create",
"an",
"object",
"through",
"sqlalchemy"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L38-L69 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.get_object | def get_object(self, view_kwargs, qs=None):
"""Retrieve an object through sqlalchemy
:params dict view_kwargs: kwargs from the resource view
:return DeclarativeMeta: an object from sqlalchemy
"""
self.before_get_object(view_kwargs)
id_field = getattr(self, 'id_field', i... | python | def get_object(self, view_kwargs, qs=None):
"""Retrieve an object through sqlalchemy
:params dict view_kwargs: kwargs from the resource view
:return DeclarativeMeta: an object from sqlalchemy
"""
self.before_get_object(view_kwargs)
id_field = getattr(self, 'id_field', i... | [
"def",
"get_object",
"(",
"self",
",",
"view_kwargs",
",",
"qs",
"=",
"None",
")",
":",
"self",
".",
"before_get_object",
"(",
"view_kwargs",
")",
"id_field",
"=",
"getattr",
"(",
"self",
",",
"'id_field'",
",",
"inspect",
"(",
"self",
".",
"model",
")",... | Retrieve an object through sqlalchemy
:params dict view_kwargs: kwargs from the resource view
:return DeclarativeMeta: an object from sqlalchemy | [
"Retrieve",
"an",
"object",
"through",
"sqlalchemy"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L71-L100 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.get_collection | def get_collection(self, qs, view_kwargs):
"""Retrieve a collection of objects through sqlalchemy
:param QueryStringManager qs: a querystring manager to retrieve information from url
:param dict view_kwargs: kwargs from the resource view
:return tuple: the number of object and the list ... | python | def get_collection(self, qs, view_kwargs):
"""Retrieve a collection of objects through sqlalchemy
:param QueryStringManager qs: a querystring manager to retrieve information from url
:param dict view_kwargs: kwargs from the resource view
:return tuple: the number of object and the list ... | [
"def",
"get_collection",
"(",
"self",
",",
"qs",
",",
"view_kwargs",
")",
":",
"self",
".",
"before_get_collection",
"(",
"qs",
",",
"view_kwargs",
")",
"query",
"=",
"self",
".",
"query",
"(",
"view_kwargs",
")",
"if",
"qs",
".",
"filters",
":",
"query"... | Retrieve a collection of objects through sqlalchemy
:param QueryStringManager qs: a querystring manager to retrieve information from url
:param dict view_kwargs: kwargs from the resource view
:return tuple: the number of object and the list of objects | [
"Retrieve",
"a",
"collection",
"of",
"objects",
"through",
"sqlalchemy"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L102-L130 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.update_object | def update_object(self, obj, data, view_kwargs):
"""Update an object through sqlalchemy
:param DeclarativeMeta obj: an object from sqlalchemy
:param dict data: the data validated by marshmallow
:param dict view_kwargs: kwargs from the resource view
:return boolean: True if objec... | python | def update_object(self, obj, data, view_kwargs):
"""Update an object through sqlalchemy
:param DeclarativeMeta obj: an object from sqlalchemy
:param dict data: the data validated by marshmallow
:param dict view_kwargs: kwargs from the resource view
:return boolean: True if objec... | [
"def",
"update_object",
"(",
"self",
",",
"obj",
",",
"data",
",",
"view_kwargs",
")",
":",
"if",
"obj",
"is",
"None",
":",
"url_field",
"=",
"getattr",
"(",
"self",
",",
"'url_field'",
",",
"'id'",
")",
"filter_value",
"=",
"view_kwargs",
"[",
"url_fiel... | Update an object through sqlalchemy
:param DeclarativeMeta obj: an object from sqlalchemy
:param dict data: the data validated by marshmallow
:param dict view_kwargs: kwargs from the resource view
:return boolean: True if object have changed else False | [
"Update",
"an",
"object",
"through",
"sqlalchemy"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L132-L169 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.delete_object | def delete_object(self, obj, view_kwargs):
"""Delete an object through sqlalchemy
:param DeclarativeMeta item: an item from sqlalchemy
:param dict view_kwargs: kwargs from the resource view
"""
if obj is None:
url_field = getattr(self, 'url_field', 'id')
... | python | def delete_object(self, obj, view_kwargs):
"""Delete an object through sqlalchemy
:param DeclarativeMeta item: an item from sqlalchemy
:param dict view_kwargs: kwargs from the resource view
"""
if obj is None:
url_field = getattr(self, 'url_field', 'id')
... | [
"def",
"delete_object",
"(",
"self",
",",
"obj",
",",
"view_kwargs",
")",
":",
"if",
"obj",
"is",
"None",
":",
"url_field",
"=",
"getattr",
"(",
"self",
",",
"'url_field'",
",",
"'id'",
")",
"filter_value",
"=",
"view_kwargs",
"[",
"url_field",
"]",
"rai... | Delete an object through sqlalchemy
:param DeclarativeMeta item: an item from sqlalchemy
:param dict view_kwargs: kwargs from the resource view | [
"Delete",
"an",
"object",
"through",
"sqlalchemy"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L171-L195 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.create_relationship | def create_relationship(self, json_data, relationship_field, related_id_field, view_kwargs):
"""Create a relationship
:param dict json_data: the request params
:param str relationship_field: the model attribute used for relationship
:param str related_id_field: the identifier field of t... | python | def create_relationship(self, json_data, relationship_field, related_id_field, view_kwargs):
"""Create a relationship
:param dict json_data: the request params
:param str relationship_field: the model attribute used for relationship
:param str related_id_field: the identifier field of t... | [
"def",
"create_relationship",
"(",
"self",
",",
"json_data",
",",
"relationship_field",
",",
"related_id_field",
",",
"view_kwargs",
")",
":",
"self",
".",
"before_create_relationship",
"(",
"json_data",
",",
"relationship_field",
",",
"related_id_field",
",",
"view_k... | Create a relationship
:param dict json_data: the request params
:param str relationship_field: the model attribute used for relationship
:param str related_id_field: the identifier field of the related model
:param dict view_kwargs: kwargs from the resource view
:return boolean:... | [
"Create",
"a",
"relationship"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L197-L254 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.get_relationship | def get_relationship(self, relationship_field, related_type_, related_id_field, view_kwargs):
"""Get a relationship
:param str relationship_field: the model attribute used for relationship
:param str related_type_: the related resource type
:param str related_id_field: the identifier fi... | python | def get_relationship(self, relationship_field, related_type_, related_id_field, view_kwargs):
"""Get a relationship
:param str relationship_field: the model attribute used for relationship
:param str related_type_: the related resource type
:param str related_id_field: the identifier fi... | [
"def",
"get_relationship",
"(",
"self",
",",
"relationship_field",
",",
"related_type_",
",",
"related_id_field",
",",
"view_kwargs",
")",
":",
"self",
".",
"before_get_relationship",
"(",
"relationship_field",
",",
"related_type_",
",",
"related_id_field",
",",
"view... | Get a relationship
:param str relationship_field: the model attribute used for relationship
:param str related_type_: the related resource type
:param str related_id_field: the identifier field of the related model
:param dict view_kwargs: kwargs from the resource view
:return t... | [
"Get",
"a",
"relationship"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L256-L290 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.delete_relationship | def delete_relationship(self, json_data, relationship_field, related_id_field, view_kwargs):
"""Delete a relationship
:param dict json_data: the request params
:param str relationship_field: the model attribute used for relationship
:param str related_id_field: the identifier field of t... | python | def delete_relationship(self, json_data, relationship_field, related_id_field, view_kwargs):
"""Delete a relationship
:param dict json_data: the request params
:param str relationship_field: the model attribute used for relationship
:param str related_id_field: the identifier field of t... | [
"def",
"delete_relationship",
"(",
"self",
",",
"json_data",
",",
"relationship_field",
",",
"related_id_field",
",",
"view_kwargs",
")",
":",
"self",
".",
"before_delete_relationship",
"(",
"json_data",
",",
"relationship_field",
",",
"related_id_field",
",",
"view_k... | Delete a relationship
:param dict json_data: the request params
:param str relationship_field: the model attribute used for relationship
:param str related_id_field: the identifier field of the related model
:param dict view_kwargs: kwargs from the resource view | [
"Delete",
"a",
"relationship"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L355-L403 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.get_related_object | def get_related_object(self, related_model, related_id_field, obj):
"""Get a related object
:param Model related_model: an sqlalchemy model
:param str related_id_field: the identifier field of the related model
:param DeclarativeMeta obj: the sqlalchemy object to retrieve related object... | python | def get_related_object(self, related_model, related_id_field, obj):
"""Get a related object
:param Model related_model: an sqlalchemy model
:param str related_id_field: the identifier field of the related model
:param DeclarativeMeta obj: the sqlalchemy object to retrieve related object... | [
"def",
"get_related_object",
"(",
"self",
",",
"related_model",
",",
"related_id_field",
",",
"obj",
")",
":",
"try",
":",
"related_object",
"=",
"self",
".",
"session",
".",
"query",
"(",
"related_model",
")",
".",
"filter",
"(",
"getattr",
"(",
"related_mo... | Get a related object
:param Model related_model: an sqlalchemy model
:param str related_id_field: the identifier field of the related model
:param DeclarativeMeta obj: the sqlalchemy object to retrieve related objects from
:return DeclarativeMeta: a related object | [
"Get",
"a",
"related",
"object"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L405-L422 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.apply_relationships | def apply_relationships(self, data, obj):
"""Apply relationship provided by data to obj
:param dict data: data provided by the client
:param DeclarativeMeta obj: the sqlalchemy object to plug relationships to
:return boolean: True if relationship have changed else False
"""
... | python | def apply_relationships(self, data, obj):
"""Apply relationship provided by data to obj
:param dict data: data provided by the client
:param DeclarativeMeta obj: the sqlalchemy object to plug relationships to
:return boolean: True if relationship have changed else False
"""
... | [
"def",
"apply_relationships",
"(",
"self",
",",
"data",
",",
"obj",
")",
":",
"relationships_to_apply",
"=",
"[",
"]",
"relationship_fields",
"=",
"get_relationships",
"(",
"self",
".",
"resource",
".",
"schema",
",",
"model_field",
"=",
"True",
")",
"for",
... | Apply relationship provided by data to obj
:param dict data: data provided by the client
:param DeclarativeMeta obj: the sqlalchemy object to plug relationships to
:return boolean: True if relationship have changed else False | [
"Apply",
"relationship",
"provided",
"by",
"data",
"to",
"obj"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L425-L457 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.filter_query | def filter_query(self, query, filter_info, model):
"""Filter query according to jsonapi 1.0
:param Query query: sqlalchemy query to sort
:param filter_info: filter information
:type filter_info: dict or None
:param DeclarativeMeta model: an sqlalchemy model
:return Query... | python | def filter_query(self, query, filter_info, model):
"""Filter query according to jsonapi 1.0
:param Query query: sqlalchemy query to sort
:param filter_info: filter information
:type filter_info: dict or None
:param DeclarativeMeta model: an sqlalchemy model
:return Query... | [
"def",
"filter_query",
"(",
"self",
",",
"query",
",",
"filter_info",
",",
"model",
")",
":",
"if",
"filter_info",
":",
"filters",
"=",
"create_filters",
"(",
"model",
",",
"filter_info",
",",
"self",
".",
"resource",
")",
"query",
"=",
"query",
".",
"fi... | Filter query according to jsonapi 1.0
:param Query query: sqlalchemy query to sort
:param filter_info: filter information
:type filter_info: dict or None
:param DeclarativeMeta model: an sqlalchemy model
:return Query: the sorted query | [
"Filter",
"query",
"according",
"to",
"jsonapi",
"1",
".",
"0"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L490-L503 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.sort_query | def sort_query(self, query, sort_info):
"""Sort query according to jsonapi 1.0
:param Query query: sqlalchemy query to sort
:param list sort_info: sort information
:return Query: the sorted query
"""
for sort_opt in sort_info:
field = sort_opt['field']
... | python | def sort_query(self, query, sort_info):
"""Sort query according to jsonapi 1.0
:param Query query: sqlalchemy query to sort
:param list sort_info: sort information
:return Query: the sorted query
"""
for sort_opt in sort_info:
field = sort_opt['field']
... | [
"def",
"sort_query",
"(",
"self",
",",
"query",
",",
"sort_info",
")",
":",
"for",
"sort_opt",
"in",
"sort_info",
":",
"field",
"=",
"sort_opt",
"[",
"'field'",
"]",
"if",
"not",
"hasattr",
"(",
"self",
".",
"model",
",",
"field",
")",
":",
"raise",
... | Sort query according to jsonapi 1.0
:param Query query: sqlalchemy query to sort
:param list sort_info: sort information
:return Query: the sorted query | [
"Sort",
"query",
"according",
"to",
"jsonapi",
"1",
".",
"0"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L505-L517 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.paginate_query | def paginate_query(self, query, paginate_info):
"""Paginate query according to jsonapi 1.0
:param Query query: sqlalchemy queryset
:param dict paginate_info: pagination information
:return Query: the paginated query
"""
if int(paginate_info.get('size', 1)) == 0:
... | python | def paginate_query(self, query, paginate_info):
"""Paginate query according to jsonapi 1.0
:param Query query: sqlalchemy queryset
:param dict paginate_info: pagination information
:return Query: the paginated query
"""
if int(paginate_info.get('size', 1)) == 0:
... | [
"def",
"paginate_query",
"(",
"self",
",",
"query",
",",
"paginate_info",
")",
":",
"if",
"int",
"(",
"paginate_info",
".",
"get",
"(",
"'size'",
",",
"1",
")",
")",
"==",
"0",
":",
"return",
"query",
"page_size",
"=",
"int",
"(",
"paginate_info",
".",... | Paginate query according to jsonapi 1.0
:param Query query: sqlalchemy queryset
:param dict paginate_info: pagination information
:return Query: the paginated query | [
"Paginate",
"query",
"according",
"to",
"jsonapi",
"1",
".",
"0"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L519-L534 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.eagerload_includes | def eagerload_includes(self, query, qs):
"""Use eagerload feature of sqlalchemy to optimize data retrieval for include querystring parameter
:param Query query: sqlalchemy queryset
:param QueryStringManager qs: a querystring manager to retrieve information from url
:return Query: the qu... | python | def eagerload_includes(self, query, qs):
"""Use eagerload feature of sqlalchemy to optimize data retrieval for include querystring parameter
:param Query query: sqlalchemy queryset
:param QueryStringManager qs: a querystring manager to retrieve information from url
:return Query: the qu... | [
"def",
"eagerload_includes",
"(",
"self",
",",
"query",
",",
"qs",
")",
":",
"for",
"include",
"in",
"qs",
".",
"include",
":",
"joinload_object",
"=",
"None",
"if",
"'.'",
"in",
"include",
":",
"current_schema",
"=",
"self",
".",
"resource",
".",
"schem... | Use eagerload feature of sqlalchemy to optimize data retrieval for include querystring parameter
:param Query query: sqlalchemy queryset
:param QueryStringManager qs: a querystring manager to retrieve information from url
:return Query: the query with includes eagerloaded | [
"Use",
"eagerload",
"feature",
"of",
"sqlalchemy",
"to",
"optimize",
"data",
"retrieval",
"for",
"include",
"querystring",
"parameter"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L536-L577 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/data_layers/alchemy.py | SqlalchemyDataLayer.retrieve_object_query | def retrieve_object_query(self, view_kwargs, filter_field, filter_value):
"""Build query to retrieve object
:param dict view_kwargs: kwargs from the resource view
:params sqlalchemy_field filter_field: the field to filter on
:params filter_value: the value to filter with
:return... | python | def retrieve_object_query(self, view_kwargs, filter_field, filter_value):
"""Build query to retrieve object
:param dict view_kwargs: kwargs from the resource view
:params sqlalchemy_field filter_field: the field to filter on
:params filter_value: the value to filter with
:return... | [
"def",
"retrieve_object_query",
"(",
"self",
",",
"view_kwargs",
",",
"filter_field",
",",
"filter_value",
")",
":",
"return",
"self",
".",
"session",
".",
"query",
"(",
"self",
".",
"model",
")",
".",
"filter",
"(",
"filter_field",
"==",
"filter_value",
")"... | Build query to retrieve object
:param dict view_kwargs: kwargs from the resource view
:params sqlalchemy_field filter_field: the field to filter on
:params filter_value: the value to filter with
:return sqlalchemy query: a query from sqlalchemy | [
"Build",
"query",
"to",
"retrieve",
"object"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/data_layers/alchemy.py#L579-L587 | train |
miLibris/flask-rest-jsonapi | flask_rest_jsonapi/pagination.py | add_pagination_links | def add_pagination_links(data, object_count, querystring, base_url):
"""Add pagination links to result
:param dict data: the result of the view
:param int object_count: number of objects in result
:param QueryStringManager querystring: the managed querystring fields and values
:param str base_url: ... | python | def add_pagination_links(data, object_count, querystring, base_url):
"""Add pagination links to result
:param dict data: the result of the view
:param int object_count: number of objects in result
:param QueryStringManager querystring: the managed querystring fields and values
:param str base_url: ... | [
"def",
"add_pagination_links",
"(",
"data",
",",
"object_count",
",",
"querystring",
",",
"base_url",
")",
":",
"links",
"=",
"{",
"}",
"all_qs_args",
"=",
"copy",
"(",
"querystring",
".",
"querystring",
")",
"links",
"[",
"'self'",
"]",
"=",
"base_url",
"... | Add pagination links to result
:param dict data: the result of the view
:param int object_count: number of objects in result
:param QueryStringManager querystring: the managed querystring fields and values
:param str base_url: the base url for pagination | [
"Add",
"pagination",
"links",
"to",
"result"
] | ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43 | https://github.com/miLibris/flask-rest-jsonapi/blob/ecc8f2cd2b54cc0bfae7acd6cffcda0ba1140c43/flask_rest_jsonapi/pagination.py#L13-L56 | train |
ethereum/py-evm | eth/tools/fixtures/generation.py | idfn | def idfn(fixture_params: Iterable[Any]) -> str:
"""
Function for pytest to produce uniform names for fixtures.
"""
return ":".join((str(item) for item in fixture_params)) | python | def idfn(fixture_params: Iterable[Any]) -> str:
"""
Function for pytest to produce uniform names for fixtures.
"""
return ":".join((str(item) for item in fixture_params)) | [
"def",
"idfn",
"(",
"fixture_params",
":",
"Iterable",
"[",
"Any",
"]",
")",
"->",
"str",
":",
"return",
"\":\"",
".",
"join",
"(",
"(",
"str",
"(",
"item",
")",
"for",
"item",
"in",
"fixture_params",
")",
")"
] | Function for pytest to produce uniform names for fixtures. | [
"Function",
"for",
"pytest",
"to",
"produce",
"uniform",
"names",
"for",
"fixtures",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/generation.py#L24-L28 | train |
ethereum/py-evm | eth/tools/fixtures/generation.py | get_fixtures_file_hash | def get_fixtures_file_hash(all_fixture_paths: Iterable[str]) -> str:
"""
Returns the MD5 hash of the fixture files. Used for cache busting.
"""
hasher = hashlib.md5()
for fixture_path in sorted(all_fixture_paths):
with open(fixture_path, 'rb') as fixture_file:
hasher.update(fixt... | python | def get_fixtures_file_hash(all_fixture_paths: Iterable[str]) -> str:
"""
Returns the MD5 hash of the fixture files. Used for cache busting.
"""
hasher = hashlib.md5()
for fixture_path in sorted(all_fixture_paths):
with open(fixture_path, 'rb') as fixture_file:
hasher.update(fixt... | [
"def",
"get_fixtures_file_hash",
"(",
"all_fixture_paths",
":",
"Iterable",
"[",
"str",
"]",
")",
"->",
"str",
":",
"hasher",
"=",
"hashlib",
".",
"md5",
"(",
")",
"for",
"fixture_path",
"in",
"sorted",
"(",
"all_fixture_paths",
")",
":",
"with",
"open",
"... | Returns the MD5 hash of the fixture files. Used for cache busting. | [
"Returns",
"the",
"MD5",
"hash",
"of",
"the",
"fixture",
"files",
".",
"Used",
"for",
"cache",
"busting",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/generation.py#L31-L39 | train |
ethereum/py-evm | eth/rlp/transactions.py | BaseTransaction.create_unsigned_transaction | def create_unsigned_transaction(cls,
*,
nonce: int,
gas_price: int,
gas: int,
to: Address,
value: int,
... | python | def create_unsigned_transaction(cls,
*,
nonce: int,
gas_price: int,
gas: int,
to: Address,
value: int,
... | [
"def",
"create_unsigned_transaction",
"(",
"cls",
",",
"*",
",",
"nonce",
":",
"int",
",",
"gas_price",
":",
"int",
",",
"gas",
":",
"int",
",",
"to",
":",
"Address",
",",
"value",
":",
"int",
",",
"data",
":",
"bytes",
")",
"->",
"'BaseUnsignedTransac... | Create an unsigned transaction. | [
"Create",
"an",
"unsigned",
"transaction",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/rlp/transactions.py#L155-L166 | train |
ethereum/py-evm | eth/chains/header.py | HeaderChain.import_header | def import_header(self,
header: BlockHeader
) -> Tuple[Tuple[BlockHeader, ...], Tuple[BlockHeader, ...]]:
"""
Direct passthrough to `headerdb`
Also updates the local `header` property to be the latest canonical head.
Returns an iterable of he... | python | def import_header(self,
header: BlockHeader
) -> Tuple[Tuple[BlockHeader, ...], Tuple[BlockHeader, ...]]:
"""
Direct passthrough to `headerdb`
Also updates the local `header` property to be the latest canonical head.
Returns an iterable of he... | [
"def",
"import_header",
"(",
"self",
",",
"header",
":",
"BlockHeader",
")",
"->",
"Tuple",
"[",
"Tuple",
"[",
"BlockHeader",
",",
"...",
"]",
",",
"Tuple",
"[",
"BlockHeader",
",",
"...",
"]",
"]",
":",
"new_canonical_headers",
"=",
"self",
".",
"header... | Direct passthrough to `headerdb`
Also updates the local `header` property to be the latest canonical head.
Returns an iterable of headers representing the headers that are newly
part of the canonical chain.
- If the imported header is not part of the canonical chain then an
... | [
"Direct",
"passthrough",
"to",
"headerdb"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/chains/header.py#L165-L186 | train |
ethereum/py-evm | eth/rlp/headers.py | BlockHeader.from_parent | def from_parent(cls,
parent: 'BlockHeader',
gas_limit: int,
difficulty: int,
timestamp: int,
coinbase: Address=ZERO_ADDRESS,
nonce: bytes=None,
extra_data: bytes=None,
... | python | def from_parent(cls,
parent: 'BlockHeader',
gas_limit: int,
difficulty: int,
timestamp: int,
coinbase: Address=ZERO_ADDRESS,
nonce: bytes=None,
extra_data: bytes=None,
... | [
"def",
"from_parent",
"(",
"cls",
",",
"parent",
":",
"'BlockHeader'",
",",
"gas_limit",
":",
"int",
",",
"difficulty",
":",
"int",
",",
"timestamp",
":",
"int",
",",
"coinbase",
":",
"Address",
"=",
"ZERO_ADDRESS",
",",
"nonce",
":",
"bytes",
"=",
"None... | Initialize a new block header with the `parent` header as the block's
parent hash. | [
"Initialize",
"a",
"new",
"block",
"header",
"with",
"the",
"parent",
"header",
"as",
"the",
"block",
"s",
"parent",
"hash",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/rlp/headers.py#L170-L203 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.get_block_uncles | def get_block_uncles(self, uncles_hash: Hash32) -> List[BlockHeader]:
"""
Returns an iterable of uncle headers specified by the given uncles_hash
"""
validate_word(uncles_hash, title="Uncles Hash")
if uncles_hash == EMPTY_UNCLE_HASH:
return []
try:
... | python | def get_block_uncles(self, uncles_hash: Hash32) -> List[BlockHeader]:
"""
Returns an iterable of uncle headers specified by the given uncles_hash
"""
validate_word(uncles_hash, title="Uncles Hash")
if uncles_hash == EMPTY_UNCLE_HASH:
return []
try:
... | [
"def",
"get_block_uncles",
"(",
"self",
",",
"uncles_hash",
":",
"Hash32",
")",
"->",
"List",
"[",
"BlockHeader",
"]",
":",
"validate_word",
"(",
"uncles_hash",
",",
"title",
"=",
"\"Uncles Hash\"",
")",
"if",
"uncles_hash",
"==",
"EMPTY_UNCLE_HASH",
":",
"ret... | Returns an iterable of uncle headers specified by the given uncles_hash | [
"Returns",
"an",
"iterable",
"of",
"uncle",
"headers",
"specified",
"by",
"the",
"given",
"uncles_hash"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L175-L189 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.persist_block | def persist_block(self,
block: 'BaseBlock'
) -> Tuple[Tuple[Hash32, ...], Tuple[Hash32, ...]]:
"""
Persist the given block's header and uncles.
Assumes all block transactions have been persisted already.
"""
with self.db.atomic_batch()... | python | def persist_block(self,
block: 'BaseBlock'
) -> Tuple[Tuple[Hash32, ...], Tuple[Hash32, ...]]:
"""
Persist the given block's header and uncles.
Assumes all block transactions have been persisted already.
"""
with self.db.atomic_batch()... | [
"def",
"persist_block",
"(",
"self",
",",
"block",
":",
"'BaseBlock'",
")",
"->",
"Tuple",
"[",
"Tuple",
"[",
"Hash32",
",",
"...",
"]",
",",
"Tuple",
"[",
"Hash32",
",",
"...",
"]",
"]",
":",
"with",
"self",
".",
"db",
".",
"atomic_batch",
"(",
")... | Persist the given block's header and uncles.
Assumes all block transactions have been persisted already. | [
"Persist",
"the",
"given",
"block",
"s",
"header",
"and",
"uncles",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L228-L237 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.persist_uncles | def persist_uncles(self, uncles: Tuple[BlockHeader]) -> Hash32:
"""
Persists the list of uncles to the database.
Returns the uncles hash.
"""
return self._persist_uncles(self.db, uncles) | python | def persist_uncles(self, uncles: Tuple[BlockHeader]) -> Hash32:
"""
Persists the list of uncles to the database.
Returns the uncles hash.
"""
return self._persist_uncles(self.db, uncles) | [
"def",
"persist_uncles",
"(",
"self",
",",
"uncles",
":",
"Tuple",
"[",
"BlockHeader",
"]",
")",
"->",
"Hash32",
":",
"return",
"self",
".",
"_persist_uncles",
"(",
"self",
".",
"db",
",",
"uncles",
")"
] | Persists the list of uncles to the database.
Returns the uncles hash. | [
"Persists",
"the",
"list",
"of",
"uncles",
"to",
"the",
"database",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L273-L279 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.add_receipt | def add_receipt(self, block_header: BlockHeader, index_key: int, receipt: Receipt) -> Hash32:
"""
Adds the given receipt to the provided block header.
Returns the updated `receipts_root` for updated block header.
"""
receipt_db = HexaryTrie(db=self.db, root_hash=block_header.rec... | python | def add_receipt(self, block_header: BlockHeader, index_key: int, receipt: Receipt) -> Hash32:
"""
Adds the given receipt to the provided block header.
Returns the updated `receipts_root` for updated block header.
"""
receipt_db = HexaryTrie(db=self.db, root_hash=block_header.rec... | [
"def",
"add_receipt",
"(",
"self",
",",
"block_header",
":",
"BlockHeader",
",",
"index_key",
":",
"int",
",",
"receipt",
":",
"Receipt",
")",
"->",
"Hash32",
":",
"receipt_db",
"=",
"HexaryTrie",
"(",
"db",
"=",
"self",
".",
"db",
",",
"root_hash",
"=",... | Adds the given receipt to the provided block header.
Returns the updated `receipts_root` for updated block header. | [
"Adds",
"the",
"given",
"receipt",
"to",
"the",
"provided",
"block",
"header",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L292-L300 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.add_transaction | def add_transaction(self,
block_header: BlockHeader,
index_key: int,
transaction: 'BaseTransaction') -> Hash32:
"""
Adds the given transaction to the provided block header.
Returns the updated `transactions_root` for update... | python | def add_transaction(self,
block_header: BlockHeader,
index_key: int,
transaction: 'BaseTransaction') -> Hash32:
"""
Adds the given transaction to the provided block header.
Returns the updated `transactions_root` for update... | [
"def",
"add_transaction",
"(",
"self",
",",
"block_header",
":",
"BlockHeader",
",",
"index_key",
":",
"int",
",",
"transaction",
":",
"'BaseTransaction'",
")",
"->",
"Hash32",
":",
"transaction_db",
"=",
"HexaryTrie",
"(",
"self",
".",
"db",
",",
"root_hash",... | Adds the given transaction to the provided block header.
Returns the updated `transactions_root` for updated block header. | [
"Adds",
"the",
"given",
"transaction",
"to",
"the",
"provided",
"block",
"header",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L302-L313 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.get_block_transactions | def get_block_transactions(
self,
header: BlockHeader,
transaction_class: Type['BaseTransaction']) -> Iterable['BaseTransaction']:
"""
Returns an iterable of transactions for the block speficied by the
given block header.
"""
return self._get_b... | python | def get_block_transactions(
self,
header: BlockHeader,
transaction_class: Type['BaseTransaction']) -> Iterable['BaseTransaction']:
"""
Returns an iterable of transactions for the block speficied by the
given block header.
"""
return self._get_b... | [
"def",
"get_block_transactions",
"(",
"self",
",",
"header",
":",
"BlockHeader",
",",
"transaction_class",
":",
"Type",
"[",
"'BaseTransaction'",
"]",
")",
"->",
"Iterable",
"[",
"'BaseTransaction'",
"]",
":",
"return",
"self",
".",
"_get_block_transactions",
"(",... | Returns an iterable of transactions for the block speficied by the
given block header. | [
"Returns",
"an",
"iterable",
"of",
"transactions",
"for",
"the",
"block",
"speficied",
"by",
"the",
"given",
"block",
"header",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L315-L323 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.get_block_transaction_hashes | def get_block_transaction_hashes(self, block_header: BlockHeader) -> Iterable[Hash32]:
"""
Returns an iterable of the transaction hashes from the block specified
by the given block header.
"""
return self._get_block_transaction_hashes(self.db, block_header) | python | def get_block_transaction_hashes(self, block_header: BlockHeader) -> Iterable[Hash32]:
"""
Returns an iterable of the transaction hashes from the block specified
by the given block header.
"""
return self._get_block_transaction_hashes(self.db, block_header) | [
"def",
"get_block_transaction_hashes",
"(",
"self",
",",
"block_header",
":",
"BlockHeader",
")",
"->",
"Iterable",
"[",
"Hash32",
"]",
":",
"return",
"self",
".",
"_get_block_transaction_hashes",
"(",
"self",
".",
"db",
",",
"block_header",
")"
] | Returns an iterable of the transaction hashes from the block specified
by the given block header. | [
"Returns",
"an",
"iterable",
"of",
"the",
"transaction",
"hashes",
"from",
"the",
"block",
"specified",
"by",
"the",
"given",
"block",
"header",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L325-L330 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.get_receipts | def get_receipts(self,
header: BlockHeader,
receipt_class: Type[Receipt]) -> Iterable[Receipt]:
"""
Returns an iterable of receipts for the block specified by the given
block header.
"""
receipt_db = HexaryTrie(db=self.db, root_hash=heade... | python | def get_receipts(self,
header: BlockHeader,
receipt_class: Type[Receipt]) -> Iterable[Receipt]:
"""
Returns an iterable of receipts for the block specified by the given
block header.
"""
receipt_db = HexaryTrie(db=self.db, root_hash=heade... | [
"def",
"get_receipts",
"(",
"self",
",",
"header",
":",
"BlockHeader",
",",
"receipt_class",
":",
"Type",
"[",
"Receipt",
"]",
")",
"->",
"Iterable",
"[",
"Receipt",
"]",
":",
"receipt_db",
"=",
"HexaryTrie",
"(",
"db",
"=",
"self",
".",
"db",
",",
"ro... | Returns an iterable of receipts for the block specified by the given
block header. | [
"Returns",
"an",
"iterable",
"of",
"receipts",
"for",
"the",
"block",
"specified",
"by",
"the",
"given",
"block",
"header",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L346-L360 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.get_transaction_by_index | def get_transaction_by_index(
self,
block_number: BlockNumber,
transaction_index: int,
transaction_class: Type['BaseTransaction']) -> 'BaseTransaction':
"""
Returns the transaction at the specified `transaction_index` from the
block specified by `b... | python | def get_transaction_by_index(
self,
block_number: BlockNumber,
transaction_index: int,
transaction_class: Type['BaseTransaction']) -> 'BaseTransaction':
"""
Returns the transaction at the specified `transaction_index` from the
block specified by `b... | [
"def",
"get_transaction_by_index",
"(",
"self",
",",
"block_number",
":",
"BlockNumber",
",",
"transaction_index",
":",
"int",
",",
"transaction_class",
":",
"Type",
"[",
"'BaseTransaction'",
"]",
")",
"->",
"'BaseTransaction'",
":",
"try",
":",
"block_header",
"=... | Returns the transaction at the specified `transaction_index` from the
block specified by `block_number` from the canonical chain.
Raises TransactionNotFound if no block | [
"Returns",
"the",
"transaction",
"at",
"the",
"specified",
"transaction_index",
"from",
"the",
"block",
"specified",
"by",
"block_number",
"from",
"the",
"canonical",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L362-L384 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.get_receipt_by_index | def get_receipt_by_index(self,
block_number: BlockNumber,
receipt_index: int) -> Receipt:
"""
Returns the Receipt of the transaction at specified index
for the block header obtained by the specified block number
"""
try:
... | python | def get_receipt_by_index(self,
block_number: BlockNumber,
receipt_index: int) -> Receipt:
"""
Returns the Receipt of the transaction at specified index
for the block header obtained by the specified block number
"""
try:
... | [
"def",
"get_receipt_by_index",
"(",
"self",
",",
"block_number",
":",
"BlockNumber",
",",
"receipt_index",
":",
"int",
")",
"->",
"Receipt",
":",
"try",
":",
"block_header",
"=",
"self",
".",
"get_canonical_block_header_by_number",
"(",
"block_number",
")",
"excep... | Returns the Receipt of the transaction at specified index
for the block header obtained by the specified block number | [
"Returns",
"the",
"Receipt",
"of",
"the",
"transaction",
"at",
"specified",
"index",
"for",
"the",
"block",
"header",
"obtained",
"by",
"the",
"specified",
"block",
"number"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L405-L424 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB._get_block_transaction_data | def _get_block_transaction_data(db: BaseDB, transaction_root: Hash32) -> Iterable[Hash32]:
"""
Returns iterable of the encoded transactions for the given block header
"""
transaction_db = HexaryTrie(db, root_hash=transaction_root)
for transaction_idx in itertools.count():
... | python | def _get_block_transaction_data(db: BaseDB, transaction_root: Hash32) -> Iterable[Hash32]:
"""
Returns iterable of the encoded transactions for the given block header
"""
transaction_db = HexaryTrie(db, root_hash=transaction_root)
for transaction_idx in itertools.count():
... | [
"def",
"_get_block_transaction_data",
"(",
"db",
":",
"BaseDB",
",",
"transaction_root",
":",
"Hash32",
")",
"->",
"Iterable",
"[",
"Hash32",
"]",
":",
"transaction_db",
"=",
"HexaryTrie",
"(",
"db",
",",
"root_hash",
"=",
"transaction_root",
")",
"for",
"tran... | Returns iterable of the encoded transactions for the given block header | [
"Returns",
"iterable",
"of",
"the",
"encoded",
"transactions",
"for",
"the",
"given",
"block",
"header"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L427-L437 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB._get_block_transactions | def _get_block_transactions(
self,
transaction_root: Hash32,
transaction_class: Type['BaseTransaction']) -> Iterable['BaseTransaction']:
"""
Memoizable version of `get_block_transactions`
"""
for encoded_transaction in self._get_block_transaction_data(... | python | def _get_block_transactions(
self,
transaction_root: Hash32,
transaction_class: Type['BaseTransaction']) -> Iterable['BaseTransaction']:
"""
Memoizable version of `get_block_transactions`
"""
for encoded_transaction in self._get_block_transaction_data(... | [
"def",
"_get_block_transactions",
"(",
"self",
",",
"transaction_root",
":",
"Hash32",
",",
"transaction_class",
":",
"Type",
"[",
"'BaseTransaction'",
"]",
")",
"->",
"Iterable",
"[",
"'BaseTransaction'",
"]",
":",
"for",
"encoded_transaction",
"in",
"self",
".",... | Memoizable version of `get_block_transactions` | [
"Memoizable",
"version",
"of",
"get_block_transactions"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L441-L449 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB._remove_transaction_from_canonical_chain | def _remove_transaction_from_canonical_chain(db: BaseDB, transaction_hash: Hash32) -> None:
"""
Removes the transaction specified by the given hash from the canonical
chain.
"""
db.delete(SchemaV1.make_transaction_hash_to_block_lookup_key(transaction_hash)) | python | def _remove_transaction_from_canonical_chain(db: BaseDB, transaction_hash: Hash32) -> None:
"""
Removes the transaction specified by the given hash from the canonical
chain.
"""
db.delete(SchemaV1.make_transaction_hash_to_block_lookup_key(transaction_hash)) | [
"def",
"_remove_transaction_from_canonical_chain",
"(",
"db",
":",
"BaseDB",
",",
"transaction_hash",
":",
"Hash32",
")",
"->",
"None",
":",
"db",
".",
"delete",
"(",
"SchemaV1",
".",
"make_transaction_hash_to_block_lookup_key",
"(",
"transaction_hash",
")",
")"
] | Removes the transaction specified by the given hash from the canonical
chain. | [
"Removes",
"the",
"transaction",
"specified",
"by",
"the",
"given",
"hash",
"from",
"the",
"canonical",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L452-L457 | train |
ethereum/py-evm | eth/db/chain.py | ChainDB.persist_trie_data_dict | def persist_trie_data_dict(self, trie_data_dict: Dict[Hash32, bytes]) -> None:
"""
Store raw trie data to db from a dict
"""
with self.db.atomic_batch() as db:
for key, value in trie_data_dict.items():
db[key] = value | python | def persist_trie_data_dict(self, trie_data_dict: Dict[Hash32, bytes]) -> None:
"""
Store raw trie data to db from a dict
"""
with self.db.atomic_batch() as db:
for key, value in trie_data_dict.items():
db[key] = value | [
"def",
"persist_trie_data_dict",
"(",
"self",
",",
"trie_data_dict",
":",
"Dict",
"[",
"Hash32",
",",
"bytes",
"]",
")",
"->",
"None",
":",
"with",
"self",
".",
"db",
".",
"atomic_batch",
"(",
")",
"as",
"db",
":",
"for",
"key",
",",
"value",
"in",
"... | Store raw trie data to db from a dict | [
"Store",
"raw",
"trie",
"data",
"to",
"db",
"from",
"a",
"dict"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L492-L498 | train |
ethereum/py-evm | eth/vm/forks/frontier/blocks.py | FrontierBlock.from_header | def from_header(cls, header: BlockHeader, chaindb: BaseChainDB) -> BaseBlock:
"""
Returns the block denoted by the given block header.
"""
if header.uncles_hash == EMPTY_UNCLE_HASH:
uncles = [] # type: List[BlockHeader]
else:
uncles = chaindb.get_block_un... | python | def from_header(cls, header: BlockHeader, chaindb: BaseChainDB) -> BaseBlock:
"""
Returns the block denoted by the given block header.
"""
if header.uncles_hash == EMPTY_UNCLE_HASH:
uncles = [] # type: List[BlockHeader]
else:
uncles = chaindb.get_block_un... | [
"def",
"from_header",
"(",
"cls",
",",
"header",
":",
"BlockHeader",
",",
"chaindb",
":",
"BaseChainDB",
")",
"->",
"BaseBlock",
":",
"if",
"header",
".",
"uncles_hash",
"==",
"EMPTY_UNCLE_HASH",
":",
"uncles",
"=",
"[",
"]",
"else",
":",
"uncles",
"=",
... | Returns the block denoted by the given block header. | [
"Returns",
"the",
"block",
"denoted",
"by",
"the",
"given",
"block",
"header",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/forks/frontier/blocks.py#L104-L119 | train |
ethereum/py-evm | eth/vm/logic/arithmetic.py | shl | def shl(computation: BaseComputation) -> None:
"""
Bitwise left shift
"""
shift_length, value = computation.stack_pop(num_items=2, type_hint=constants.UINT256)
if shift_length >= 256:
result = 0
else:
result = (value << shift_length) & constants.UINT_256_MAX
computation.sta... | python | def shl(computation: BaseComputation) -> None:
"""
Bitwise left shift
"""
shift_length, value = computation.stack_pop(num_items=2, type_hint=constants.UINT256)
if shift_length >= 256:
result = 0
else:
result = (value << shift_length) & constants.UINT_256_MAX
computation.sta... | [
"def",
"shl",
"(",
"computation",
":",
"BaseComputation",
")",
"->",
"None",
":",
"shift_length",
",",
"value",
"=",
"computation",
".",
"stack_pop",
"(",
"num_items",
"=",
"2",
",",
"type_hint",
"=",
"constants",
".",
"UINT256",
")",
"if",
"shift_length",
... | Bitwise left shift | [
"Bitwise",
"left",
"shift"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/logic/arithmetic.py#L186-L197 | train |
ethereum/py-evm | eth/vm/logic/arithmetic.py | sar | def sar(computation: BaseComputation) -> None:
"""
Arithmetic bitwise right shift
"""
shift_length, value = computation.stack_pop(num_items=2, type_hint=constants.UINT256)
value = unsigned_to_signed(value)
if shift_length >= 256:
result = 0 if value >= 0 else constants.UINT_255_NEGATIVE... | python | def sar(computation: BaseComputation) -> None:
"""
Arithmetic bitwise right shift
"""
shift_length, value = computation.stack_pop(num_items=2, type_hint=constants.UINT256)
value = unsigned_to_signed(value)
if shift_length >= 256:
result = 0 if value >= 0 else constants.UINT_255_NEGATIVE... | [
"def",
"sar",
"(",
"computation",
":",
"BaseComputation",
")",
"->",
"None",
":",
"shift_length",
",",
"value",
"=",
"computation",
".",
"stack_pop",
"(",
"num_items",
"=",
"2",
",",
"type_hint",
"=",
"constants",
".",
"UINT256",
")",
"value",
"=",
"unsign... | Arithmetic bitwise right shift | [
"Arithmetic",
"bitwise",
"right",
"shift"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/logic/arithmetic.py#L214-L226 | train |
ethereum/py-evm | eth/vm/forks/frontier/headers.py | compute_frontier_difficulty | def compute_frontier_difficulty(parent_header: BlockHeader, timestamp: int) -> int:
"""
Computes the difficulty for a frontier block based on the parent block.
"""
validate_gt(timestamp, parent_header.timestamp, title="Header timestamp")
offset = parent_header.difficulty // DIFFICULTY_ADJUSTMENT_DE... | python | def compute_frontier_difficulty(parent_header: BlockHeader, timestamp: int) -> int:
"""
Computes the difficulty for a frontier block based on the parent block.
"""
validate_gt(timestamp, parent_header.timestamp, title="Header timestamp")
offset = parent_header.difficulty // DIFFICULTY_ADJUSTMENT_DE... | [
"def",
"compute_frontier_difficulty",
"(",
"parent_header",
":",
"BlockHeader",
",",
"timestamp",
":",
"int",
")",
"->",
"int",
":",
"validate_gt",
"(",
"timestamp",
",",
"parent_header",
".",
"timestamp",
",",
"title",
"=",
"\"Header timestamp\"",
")",
"offset",
... | Computes the difficulty for a frontier block based on the parent block. | [
"Computes",
"the",
"difficulty",
"for",
"a",
"frontier",
"block",
"based",
"on",
"the",
"parent",
"block",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/forks/frontier/headers.py#L36-L73 | train |
ethereum/py-evm | eth/vm/forks/frontier/state.py | FrontierTransactionExecutor.build_computation | def build_computation(self,
message: Message,
transaction: BaseOrSpoofTransaction) -> BaseComputation:
"""Apply the message to the VM."""
transaction_context = self.vm_state.get_transaction_context(transaction)
if message.is_create:
... | python | def build_computation(self,
message: Message,
transaction: BaseOrSpoofTransaction) -> BaseComputation:
"""Apply the message to the VM."""
transaction_context = self.vm_state.get_transaction_context(transaction)
if message.is_create:
... | [
"def",
"build_computation",
"(",
"self",
",",
"message",
":",
"Message",
",",
"transaction",
":",
"BaseOrSpoofTransaction",
")",
"->",
"BaseComputation",
":",
"transaction_context",
"=",
"self",
".",
"vm_state",
".",
"get_transaction_context",
"(",
"transaction",
")... | Apply the message to the VM. | [
"Apply",
"the",
"message",
"to",
"the",
"VM",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/forks/frontier/state.py#L107-L140 | train |
ethereum/py-evm | eth/vm/stack.py | Stack.push | def push(self, value: Union[int, bytes]) -> None:
"""
Push an item onto the stack.
"""
if len(self.values) > 1023:
raise FullStack('Stack limit reached')
validate_stack_item(value)
self.values.append(value) | python | def push(self, value: Union[int, bytes]) -> None:
"""
Push an item onto the stack.
"""
if len(self.values) > 1023:
raise FullStack('Stack limit reached')
validate_stack_item(value)
self.values.append(value) | [
"def",
"push",
"(",
"self",
",",
"value",
":",
"Union",
"[",
"int",
",",
"bytes",
"]",
")",
"->",
"None",
":",
"if",
"len",
"(",
"self",
".",
"values",
")",
">",
"1023",
":",
"raise",
"FullStack",
"(",
"'Stack limit reached'",
")",
"validate_stack_item... | Push an item onto the stack. | [
"Push",
"an",
"item",
"onto",
"the",
"stack",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/stack.py#L38-L47 | train |
ethereum/py-evm | eth/vm/stack.py | Stack.pop | def pop(self,
num_items: int,
type_hint: str) -> Union[int, bytes, Tuple[Union[int, bytes], ...]]:
"""
Pop an item off the stack.
Note: This function is optimized for speed over readability.
"""
try:
if num_items == 1:
return n... | python | def pop(self,
num_items: int,
type_hint: str) -> Union[int, bytes, Tuple[Union[int, bytes], ...]]:
"""
Pop an item off the stack.
Note: This function is optimized for speed over readability.
"""
try:
if num_items == 1:
return n... | [
"def",
"pop",
"(",
"self",
",",
"num_items",
":",
"int",
",",
"type_hint",
":",
"str",
")",
"->",
"Union",
"[",
"int",
",",
"bytes",
",",
"Tuple",
"[",
"Union",
"[",
"int",
",",
"bytes",
"]",
",",
"...",
"]",
"]",
":",
"try",
":",
"if",
"num_it... | Pop an item off the stack.
Note: This function is optimized for speed over readability. | [
"Pop",
"an",
"item",
"off",
"the",
"stack",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/stack.py#L49-L63 | train |
ethereum/py-evm | eth/vm/stack.py | Stack.swap | def swap(self, position: int) -> None:
"""
Perform a SWAP operation on the stack.
"""
idx = -1 * position - 1
try:
self.values[-1], self.values[idx] = self.values[idx], self.values[-1]
except IndexError:
raise InsufficientStack("Insufficient stack ... | python | def swap(self, position: int) -> None:
"""
Perform a SWAP operation on the stack.
"""
idx = -1 * position - 1
try:
self.values[-1], self.values[idx] = self.values[idx], self.values[-1]
except IndexError:
raise InsufficientStack("Insufficient stack ... | [
"def",
"swap",
"(",
"self",
",",
"position",
":",
"int",
")",
"->",
"None",
":",
"idx",
"=",
"-",
"1",
"*",
"position",
"-",
"1",
"try",
":",
"self",
".",
"values",
"[",
"-",
"1",
"]",
",",
"self",
".",
"values",
"[",
"idx",
"]",
"=",
"self",... | Perform a SWAP operation on the stack. | [
"Perform",
"a",
"SWAP",
"operation",
"on",
"the",
"stack",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/stack.py#L89-L97 | train |
ethereum/py-evm | eth/vm/stack.py | Stack.dup | def dup(self, position: int) -> None:
"""
Perform a DUP operation on the stack.
"""
idx = -1 * position
try:
self.push(self.values[idx])
except IndexError:
raise InsufficientStack("Insufficient stack items for DUP{0}".format(position)) | python | def dup(self, position: int) -> None:
"""
Perform a DUP operation on the stack.
"""
idx = -1 * position
try:
self.push(self.values[idx])
except IndexError:
raise InsufficientStack("Insufficient stack items for DUP{0}".format(position)) | [
"def",
"dup",
"(",
"self",
",",
"position",
":",
"int",
")",
"->",
"None",
":",
"idx",
"=",
"-",
"1",
"*",
"position",
"try",
":",
"self",
".",
"push",
"(",
"self",
".",
"values",
"[",
"idx",
"]",
")",
"except",
"IndexError",
":",
"raise",
"Insuf... | Perform a DUP operation on the stack. | [
"Perform",
"a",
"DUP",
"operation",
"on",
"the",
"stack",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/stack.py#L99-L107 | train |
ethereum/py-evm | eth/db/header.py | HeaderDB.get_canonical_block_hash | def get_canonical_block_hash(self, block_number: BlockNumber) -> Hash32:
"""
Returns the block hash for the canonical block at the given number.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain.
"""
return self._get_canonical_b... | python | def get_canonical_block_hash(self, block_number: BlockNumber) -> Hash32:
"""
Returns the block hash for the canonical block at the given number.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain.
"""
return self._get_canonical_b... | [
"def",
"get_canonical_block_hash",
"(",
"self",
",",
"block_number",
":",
"BlockNumber",
")",
"->",
"Hash32",
":",
"return",
"self",
".",
"_get_canonical_block_hash",
"(",
"self",
".",
"db",
",",
"block_number",
")"
] | Returns the block hash for the canonical block at the given number.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain. | [
"Returns",
"the",
"block",
"hash",
"for",
"the",
"canonical",
"block",
"at",
"the",
"given",
"number",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/header.py#L97-L104 | train |
ethereum/py-evm | eth/db/header.py | HeaderDB.get_canonical_block_header_by_number | def get_canonical_block_header_by_number(self, block_number: BlockNumber) -> BlockHeader:
"""
Returns the block header with the given number in the canonical chain.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain.
"""
return s... | python | def get_canonical_block_header_by_number(self, block_number: BlockNumber) -> BlockHeader:
"""
Returns the block header with the given number in the canonical chain.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain.
"""
return s... | [
"def",
"get_canonical_block_header_by_number",
"(",
"self",
",",
"block_number",
":",
"BlockNumber",
")",
"->",
"BlockHeader",
":",
"return",
"self",
".",
"_get_canonical_block_header_by_number",
"(",
"self",
".",
"db",
",",
"block_number",
")"
] | Returns the block header with the given number in the canonical chain.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain. | [
"Returns",
"the",
"block",
"header",
"with",
"the",
"given",
"number",
"in",
"the",
"canonical",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/header.py#L120-L127 | train |
ethereum/py-evm | eth/db/header.py | HeaderDB.persist_header_chain | def persist_header_chain(self,
headers: Iterable[BlockHeader]
) -> Tuple[Tuple[BlockHeader, ...], Tuple[BlockHeader, ...]]:
"""
Return two iterable of headers, the first containing the new canonical headers,
the second containing the old ... | python | def persist_header_chain(self,
headers: Iterable[BlockHeader]
) -> Tuple[Tuple[BlockHeader, ...], Tuple[BlockHeader, ...]]:
"""
Return two iterable of headers, the first containing the new canonical headers,
the second containing the old ... | [
"def",
"persist_header_chain",
"(",
"self",
",",
"headers",
":",
"Iterable",
"[",
"BlockHeader",
"]",
")",
"->",
"Tuple",
"[",
"Tuple",
"[",
"BlockHeader",
",",
"...",
"]",
",",
"Tuple",
"[",
"BlockHeader",
",",
"...",
"]",
"]",
":",
"with",
"self",
".... | Return two iterable of headers, the first containing the new canonical headers,
the second containing the old canonical headers | [
"Return",
"two",
"iterable",
"of",
"headers",
"the",
"first",
"containing",
"the",
"new",
"canonical",
"headers",
"the",
"second",
"containing",
"the",
"old",
"canonical",
"headers"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/header.py#L198-L206 | train |
ethereum/py-evm | eth/db/header.py | HeaderDB._set_as_canonical_chain_head | def _set_as_canonical_chain_head(cls, db: BaseDB, block_hash: Hash32
) -> Tuple[Tuple[BlockHeader, ...], Tuple[BlockHeader, ...]]:
"""
Sets the canonical chain HEAD to the block header as specified by the
given block hash.
:return: a tuple of the hea... | python | def _set_as_canonical_chain_head(cls, db: BaseDB, block_hash: Hash32
) -> Tuple[Tuple[BlockHeader, ...], Tuple[BlockHeader, ...]]:
"""
Sets the canonical chain HEAD to the block header as specified by the
given block hash.
:return: a tuple of the hea... | [
"def",
"_set_as_canonical_chain_head",
"(",
"cls",
",",
"db",
":",
"BaseDB",
",",
"block_hash",
":",
"Hash32",
")",
"->",
"Tuple",
"[",
"Tuple",
"[",
"BlockHeader",
",",
"...",
"]",
",",
"Tuple",
"[",
"BlockHeader",
",",
"...",
"]",
"]",
":",
"try",
":... | Sets the canonical chain HEAD to the block header as specified by the
given block hash.
:return: a tuple of the headers that are newly in the canonical chain, and the headers that
are no longer in the canonical chain | [
"Sets",
"the",
"canonical",
"chain",
"HEAD",
"to",
"the",
"block",
"header",
"as",
"specified",
"by",
"the",
"given",
"block",
"hash",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/header.py#L286-L320 | train |
ethereum/py-evm | eth/db/header.py | HeaderDB._add_block_number_to_hash_lookup | def _add_block_number_to_hash_lookup(db: BaseDB, header: BlockHeader) -> None:
"""
Sets a record in the database to allow looking up this header by its
block number.
"""
block_number_to_hash_key = SchemaV1.make_block_number_to_hash_lookup_key(
header.block_number
... | python | def _add_block_number_to_hash_lookup(db: BaseDB, header: BlockHeader) -> None:
"""
Sets a record in the database to allow looking up this header by its
block number.
"""
block_number_to_hash_key = SchemaV1.make_block_number_to_hash_lookup_key(
header.block_number
... | [
"def",
"_add_block_number_to_hash_lookup",
"(",
"db",
":",
"BaseDB",
",",
"header",
":",
"BlockHeader",
")",
"->",
"None",
":",
"block_number_to_hash_key",
"=",
"SchemaV1",
".",
"make_block_number_to_hash_lookup_key",
"(",
"header",
".",
"block_number",
")",
"db",
"... | Sets a record in the database to allow looking up this header by its
block number. | [
"Sets",
"a",
"record",
"in",
"the",
"database",
"to",
"allow",
"looking",
"up",
"this",
"header",
"by",
"its",
"block",
"number",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/header.py#L357-L368 | train |
ethereum/py-evm | eth/_utils/headers.py | compute_gas_limit_bounds | def compute_gas_limit_bounds(parent: BlockHeader) -> Tuple[int, int]:
"""
Compute the boundaries for the block gas limit based on the parent block.
"""
boundary_range = parent.gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
upper_bound = parent.gas_limit + boundary_range
lower_bound = max(GAS_LIMIT_MIN... | python | def compute_gas_limit_bounds(parent: BlockHeader) -> Tuple[int, int]:
"""
Compute the boundaries for the block gas limit based on the parent block.
"""
boundary_range = parent.gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
upper_bound = parent.gas_limit + boundary_range
lower_bound = max(GAS_LIMIT_MIN... | [
"def",
"compute_gas_limit_bounds",
"(",
"parent",
":",
"BlockHeader",
")",
"->",
"Tuple",
"[",
"int",
",",
"int",
"]",
":",
"boundary_range",
"=",
"parent",
".",
"gas_limit",
"//",
"GAS_LIMIT_ADJUSTMENT_FACTOR",
"upper_bound",
"=",
"parent",
".",
"gas_limit",
"+... | Compute the boundaries for the block gas limit based on the parent block. | [
"Compute",
"the",
"boundaries",
"for",
"the",
"block",
"gas",
"limit",
"based",
"on",
"the",
"parent",
"block",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/headers.py#L20-L27 | train |
ethereum/py-evm | eth/_utils/headers.py | compute_gas_limit | def compute_gas_limit(parent_header: BlockHeader, gas_limit_floor: int) -> int:
"""
A simple strategy for adjusting the gas limit.
For each block:
- decrease by 1/1024th of the gas limit from the previous block
- increase by 50% of the total gas used by the previous block
If the value is less... | python | def compute_gas_limit(parent_header: BlockHeader, gas_limit_floor: int) -> int:
"""
A simple strategy for adjusting the gas limit.
For each block:
- decrease by 1/1024th of the gas limit from the previous block
- increase by 50% of the total gas used by the previous block
If the value is less... | [
"def",
"compute_gas_limit",
"(",
"parent_header",
":",
"BlockHeader",
",",
"gas_limit_floor",
":",
"int",
")",
"->",
"int",
":",
"if",
"gas_limit_floor",
"<",
"GAS_LIMIT_MINIMUM",
":",
"raise",
"ValueError",
"(",
"\"The `gas_limit_floor` value must be greater than the \""... | A simple strategy for adjusting the gas limit.
For each block:
- decrease by 1/1024th of the gas limit from the previous block
- increase by 50% of the total gas used by the previous block
If the value is less than the given `gas_limit_floor`:
- increase the gas limit by 1/1024th of the gas limi... | [
"A",
"simple",
"strategy",
"for",
"adjusting",
"the",
"gas",
"limit",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/headers.py#L30-L77 | train |
ethereum/py-evm | eth/_utils/headers.py | generate_header_from_parent_header | def generate_header_from_parent_header(
compute_difficulty_fn: Callable[[BlockHeader, int], int],
parent_header: BlockHeader,
coinbase: Address,
timestamp: Optional[int] = None,
extra_data: bytes = b'') -> BlockHeader:
"""
Generate BlockHeader from state_root and parent_h... | python | def generate_header_from_parent_header(
compute_difficulty_fn: Callable[[BlockHeader, int], int],
parent_header: BlockHeader,
coinbase: Address,
timestamp: Optional[int] = None,
extra_data: bytes = b'') -> BlockHeader:
"""
Generate BlockHeader from state_root and parent_h... | [
"def",
"generate_header_from_parent_header",
"(",
"compute_difficulty_fn",
":",
"Callable",
"[",
"[",
"BlockHeader",
",",
"int",
"]",
",",
"int",
"]",
",",
"parent_header",
":",
"BlockHeader",
",",
"coinbase",
":",
"Address",
",",
"timestamp",
":",
"Optional",
"... | Generate BlockHeader from state_root and parent_header | [
"Generate",
"BlockHeader",
"from",
"state_root",
"and",
"parent_header"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/headers.py#L80-L113 | train |
ethereum/py-evm | eth/tools/_utils/normalization.py | state_definition_to_dict | def state_definition_to_dict(state_definition: GeneralState) -> AccountState:
"""Convert a state definition to the canonical dict form.
State can either be defined in the canonical form, or as a list of sub states that are then
merged to one. Sub states can either be given as dictionaries themselves, or as... | python | def state_definition_to_dict(state_definition: GeneralState) -> AccountState:
"""Convert a state definition to the canonical dict form.
State can either be defined in the canonical form, or as a list of sub states that are then
merged to one. Sub states can either be given as dictionaries themselves, or as... | [
"def",
"state_definition_to_dict",
"(",
"state_definition",
":",
"GeneralState",
")",
"->",
"AccountState",
":",
"if",
"isinstance",
"(",
"state_definition",
",",
"Mapping",
")",
":",
"state_dict",
"=",
"state_definition",
"elif",
"isinstance",
"(",
"state_definition"... | Convert a state definition to the canonical dict form.
State can either be defined in the canonical form, or as a list of sub states that are then
merged to one. Sub states can either be given as dictionaries themselves, or as tuples where
the last element is the value and all others the keys for this valu... | [
"Convert",
"a",
"state",
"definition",
"to",
"the",
"canonical",
"dict",
"form",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/_utils/normalization.py#L183-L231 | train |
ethereum/py-evm | eth/db/journal.py | Journal.record_changeset | def record_changeset(self, custom_changeset_id: uuid.UUID = None) -> uuid.UUID:
"""
Creates a new changeset. Changesets are referenced by a random uuid4
to prevent collisions between multiple changesets.
"""
if custom_changeset_id is not None:
if custom_changeset_id i... | python | def record_changeset(self, custom_changeset_id: uuid.UUID = None) -> uuid.UUID:
"""
Creates a new changeset. Changesets are referenced by a random uuid4
to prevent collisions between multiple changesets.
"""
if custom_changeset_id is not None:
if custom_changeset_id i... | [
"def",
"record_changeset",
"(",
"self",
",",
"custom_changeset_id",
":",
"uuid",
".",
"UUID",
"=",
"None",
")",
"->",
"uuid",
".",
"UUID",
":",
"if",
"custom_changeset_id",
"is",
"not",
"None",
":",
"if",
"custom_changeset_id",
"in",
"self",
".",
"journal_da... | Creates a new changeset. Changesets are referenced by a random uuid4
to prevent collisions between multiple changesets. | [
"Creates",
"a",
"new",
"changeset",
".",
"Changesets",
"are",
"referenced",
"by",
"a",
"random",
"uuid4",
"to",
"prevent",
"collisions",
"between",
"multiple",
"changesets",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L93-L109 | train |
ethereum/py-evm | eth/db/journal.py | Journal.pop_changeset | def pop_changeset(self, changeset_id: uuid.UUID) -> Dict[bytes, Union[bytes, DeletedEntry]]:
"""
Returns all changes from the given changeset. This includes all of
the changes from any subsequent changeset, giving precidence to
later changesets.
"""
if changeset_id not i... | python | def pop_changeset(self, changeset_id: uuid.UUID) -> Dict[bytes, Union[bytes, DeletedEntry]]:
"""
Returns all changes from the given changeset. This includes all of
the changes from any subsequent changeset, giving precidence to
later changesets.
"""
if changeset_id not i... | [
"def",
"pop_changeset",
"(",
"self",
",",
"changeset_id",
":",
"uuid",
".",
"UUID",
")",
"->",
"Dict",
"[",
"bytes",
",",
"Union",
"[",
"bytes",
",",
"DeletedEntry",
"]",
"]",
":",
"if",
"changeset_id",
"not",
"in",
"self",
".",
"journal_data",
":",
"r... | Returns all changes from the given changeset. This includes all of
the changes from any subsequent changeset, giving precidence to
later changesets. | [
"Returns",
"all",
"changes",
"from",
"the",
"given",
"changeset",
".",
"This",
"includes",
"all",
"of",
"the",
"changes",
"from",
"any",
"subsequent",
"changeset",
"giving",
"precidence",
"to",
"later",
"changesets",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L111-L146 | train |
ethereum/py-evm | eth/db/journal.py | Journal.commit_changeset | def commit_changeset(self, changeset_id: uuid.UUID) -> Dict[bytes, Union[bytes, DeletedEntry]]:
"""
Collapses all changes for the given changeset into the previous
changesets if it exists.
"""
does_clear = self.has_clear(changeset_id)
changeset_data = self.pop_changeset(c... | python | def commit_changeset(self, changeset_id: uuid.UUID) -> Dict[bytes, Union[bytes, DeletedEntry]]:
"""
Collapses all changes for the given changeset into the previous
changesets if it exists.
"""
does_clear = self.has_clear(changeset_id)
changeset_data = self.pop_changeset(c... | [
"def",
"commit_changeset",
"(",
"self",
",",
"changeset_id",
":",
"uuid",
".",
"UUID",
")",
"->",
"Dict",
"[",
"bytes",
",",
"Union",
"[",
"bytes",
",",
"DeletedEntry",
"]",
"]",
":",
"does_clear",
"=",
"self",
".",
"has_clear",
"(",
"changeset_id",
")",... | Collapses all changes for the given changeset into the previous
changesets if it exists. | [
"Collapses",
"all",
"changes",
"for",
"the",
"given",
"changeset",
"into",
"the",
"previous",
"changesets",
"if",
"it",
"exists",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L168-L191 | train |
ethereum/py-evm | eth/db/journal.py | JournalDB._validate_changeset | def _validate_changeset(self, changeset_id: uuid.UUID) -> None:
"""
Checks to be sure the changeset is known by the journal
"""
if not self.journal.has_changeset(changeset_id):
raise ValidationError("Changeset not found in journal: {0}".format(
str(changeset_i... | python | def _validate_changeset(self, changeset_id: uuid.UUID) -> None:
"""
Checks to be sure the changeset is known by the journal
"""
if not self.journal.has_changeset(changeset_id):
raise ValidationError("Changeset not found in journal: {0}".format(
str(changeset_i... | [
"def",
"_validate_changeset",
"(",
"self",
",",
"changeset_id",
":",
"uuid",
".",
"UUID",
")",
"->",
"None",
":",
"if",
"not",
"self",
".",
"journal",
".",
"has_changeset",
"(",
"changeset_id",
")",
":",
"raise",
"ValidationError",
"(",
"\"Changeset not found ... | Checks to be sure the changeset is known by the journal | [
"Checks",
"to",
"be",
"sure",
"the",
"changeset",
"is",
"known",
"by",
"the",
"journal"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L354-L361 | train |
ethereum/py-evm | eth/db/journal.py | JournalDB.record | def record(self, custom_changeset_id: uuid.UUID = None) -> uuid.UUID:
"""
Starts a new recording and returns an id for the associated changeset
"""
return self.journal.record_changeset(custom_changeset_id) | python | def record(self, custom_changeset_id: uuid.UUID = None) -> uuid.UUID:
"""
Starts a new recording and returns an id for the associated changeset
"""
return self.journal.record_changeset(custom_changeset_id) | [
"def",
"record",
"(",
"self",
",",
"custom_changeset_id",
":",
"uuid",
".",
"UUID",
"=",
"None",
")",
"->",
"uuid",
".",
"UUID",
":",
"return",
"self",
".",
"journal",
".",
"record_changeset",
"(",
"custom_changeset_id",
")"
] | Starts a new recording and returns an id for the associated changeset | [
"Starts",
"a",
"new",
"recording",
"and",
"returns",
"an",
"id",
"for",
"the",
"associated",
"changeset"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L366-L370 | train |
ethereum/py-evm | eth/db/journal.py | JournalDB.discard | def discard(self, changeset_id: uuid.UUID) -> None:
"""
Throws away all journaled data starting at the given changeset
"""
self._validate_changeset(changeset_id)
self.journal.pop_changeset(changeset_id) | python | def discard(self, changeset_id: uuid.UUID) -> None:
"""
Throws away all journaled data starting at the given changeset
"""
self._validate_changeset(changeset_id)
self.journal.pop_changeset(changeset_id) | [
"def",
"discard",
"(",
"self",
",",
"changeset_id",
":",
"uuid",
".",
"UUID",
")",
"->",
"None",
":",
"self",
".",
"_validate_changeset",
"(",
"changeset_id",
")",
"self",
".",
"journal",
".",
"pop_changeset",
"(",
"changeset_id",
")"
] | Throws away all journaled data starting at the given changeset | [
"Throws",
"away",
"all",
"journaled",
"data",
"starting",
"at",
"the",
"given",
"changeset"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L372-L377 | train |
ethereum/py-evm | eth/db/journal.py | JournalDB.commit | def commit(self, changeset_id: uuid.UUID) -> None:
"""
Commits a given changeset. This merges the given changeset and all
subsequent changesets into the previous changeset giving precidence
to later changesets in case of any conflicting keys.
If this is the base changeset then a... | python | def commit(self, changeset_id: uuid.UUID) -> None:
"""
Commits a given changeset. This merges the given changeset and all
subsequent changesets into the previous changeset giving precidence
to later changesets in case of any conflicting keys.
If this is the base changeset then a... | [
"def",
"commit",
"(",
"self",
",",
"changeset_id",
":",
"uuid",
".",
"UUID",
")",
"->",
"None",
":",
"self",
".",
"_validate_changeset",
"(",
"changeset_id",
")",
"journal_data",
"=",
"self",
".",
"journal",
".",
"commit_changeset",
"(",
"changeset_id",
")",... | Commits a given changeset. This merges the given changeset and all
subsequent changesets into the previous changeset giving precidence
to later changesets in case of any conflicting keys.
If this is the base changeset then all changes will be written to
the underlying database and the J... | [
"Commits",
"a",
"given",
"changeset",
".",
"This",
"merges",
"the",
"given",
"changeset",
"and",
"all",
"subsequent",
"changesets",
"into",
"the",
"previous",
"changeset",
"giving",
"precidence",
"to",
"later",
"changesets",
"in",
"case",
"of",
"any",
"conflicti... | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L379-L408 | train |
ethereum/py-evm | eth/_utils/bn128.py | FQP_point_to_FQ2_point | def FQP_point_to_FQ2_point(pt: Tuple[FQP, FQP, FQP]) -> Tuple[FQ2, FQ2, FQ2]:
"""
Transform FQP to FQ2 for type hinting.
"""
return (
FQ2(pt[0].coeffs),
FQ2(pt[1].coeffs),
FQ2(pt[2].coeffs),
) | python | def FQP_point_to_FQ2_point(pt: Tuple[FQP, FQP, FQP]) -> Tuple[FQ2, FQ2, FQ2]:
"""
Transform FQP to FQ2 for type hinting.
"""
return (
FQ2(pt[0].coeffs),
FQ2(pt[1].coeffs),
FQ2(pt[2].coeffs),
) | [
"def",
"FQP_point_to_FQ2_point",
"(",
"pt",
":",
"Tuple",
"[",
"FQP",
",",
"FQP",
",",
"FQP",
"]",
")",
"->",
"Tuple",
"[",
"FQ2",
",",
"FQ2",
",",
"FQ2",
"]",
":",
"return",
"(",
"FQ2",
"(",
"pt",
"[",
"0",
"]",
".",
"coeffs",
")",
",",
"FQ2",... | Transform FQP to FQ2 for type hinting. | [
"Transform",
"FQP",
"to",
"FQ2",
"for",
"type",
"hinting",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/bn128.py#L34-L42 | train |
ethereum/py-evm | eth/vm/opcode.py | Opcode.as_opcode | def as_opcode(cls: Type[T],
logic_fn: Callable[..., Any],
mnemonic: str,
gas_cost: int) -> Type[T]:
"""
Class factory method for turning vanilla functions into Opcode classes.
"""
if gas_cost:
@functools.wraps(logic_fn)
... | python | def as_opcode(cls: Type[T],
logic_fn: Callable[..., Any],
mnemonic: str,
gas_cost: int) -> Type[T]:
"""
Class factory method for turning vanilla functions into Opcode classes.
"""
if gas_cost:
@functools.wraps(logic_fn)
... | [
"def",
"as_opcode",
"(",
"cls",
":",
"Type",
"[",
"T",
"]",
",",
"logic_fn",
":",
"Callable",
"[",
"...",
",",
"Any",
"]",
",",
"mnemonic",
":",
"str",
",",
"gas_cost",
":",
"int",
")",
"->",
"Type",
"[",
"T",
"]",
":",
"if",
"gas_cost",
":",
"... | Class factory method for turning vanilla functions into Opcode classes. | [
"Class",
"factory",
"method",
"for",
"turning",
"vanilla",
"functions",
"into",
"Opcode",
"classes",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/opcode.py#L52-L80 | train |
ethereum/py-evm | eth/db/account.py | AccountDB._wipe_storage | def _wipe_storage(self, address: Address) -> None:
"""
Wipe out the storage, without explicitly handling the storage root update
"""
account_store = self._get_address_store(address)
self._dirty_accounts.add(address)
account_store.delete() | python | def _wipe_storage(self, address: Address) -> None:
"""
Wipe out the storage, without explicitly handling the storage root update
"""
account_store = self._get_address_store(address)
self._dirty_accounts.add(address)
account_store.delete() | [
"def",
"_wipe_storage",
"(",
"self",
",",
"address",
":",
"Address",
")",
"->",
"None",
":",
"account_store",
"=",
"self",
".",
"_get_address_store",
"(",
"address",
")",
"self",
".",
"_dirty_accounts",
".",
"add",
"(",
"address",
")",
"account_store",
".",
... | Wipe out the storage, without explicitly handling the storage root update | [
"Wipe",
"out",
"the",
"storage",
"without",
"explicitly",
"handling",
"the",
"storage",
"root",
"update"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/account.py#L287-L293 | train |
ethereum/py-evm | eth/tools/fixtures/fillers/common.py | setup_main_filler | def setup_main_filler(name: str, environment: Dict[Any, Any]=None) -> Dict[str, Dict[str, Any]]:
"""
Kick off the filler generation process by creating the general filler scaffold with
a test name and general information about the testing environment.
For tests for the main chain, the `environment` par... | python | def setup_main_filler(name: str, environment: Dict[Any, Any]=None) -> Dict[str, Dict[str, Any]]:
"""
Kick off the filler generation process by creating the general filler scaffold with
a test name and general information about the testing environment.
For tests for the main chain, the `environment` par... | [
"def",
"setup_main_filler",
"(",
"name",
":",
"str",
",",
"environment",
":",
"Dict",
"[",
"Any",
",",
"Any",
"]",
"=",
"None",
")",
"->",
"Dict",
"[",
"str",
",",
"Dict",
"[",
"str",
",",
"Any",
"]",
"]",
":",
"return",
"setup_filler",
"(",
"name"... | Kick off the filler generation process by creating the general filler scaffold with
a test name and general information about the testing environment.
For tests for the main chain, the `environment` parameter is expected to be a dictionary with
some or all of the following keys:
+---------------------... | [
"Kick",
"off",
"the",
"filler",
"generation",
"process",
"by",
"creating",
"the",
"general",
"filler",
"scaffold",
"with",
"a",
"test",
"name",
"and",
"general",
"information",
"about",
"the",
"testing",
"environment",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/fillers/common.py#L114-L138 | train |
ethereum/py-evm | eth/tools/fixtures/fillers/common.py | pre_state | def pre_state(*raw_state: GeneralState, filler: Dict[str, Any]) -> None:
"""
Specify the state prior to the test execution. Multiple invocations don't override
the state but extend it instead.
In general, the elements of `state_definitions` are nested dictionaries of the following form:
.. code-bl... | python | def pre_state(*raw_state: GeneralState, filler: Dict[str, Any]) -> None:
"""
Specify the state prior to the test execution. Multiple invocations don't override
the state but extend it instead.
In general, the elements of `state_definitions` are nested dictionaries of the following form:
.. code-bl... | [
"def",
"pre_state",
"(",
"*",
"raw_state",
":",
"GeneralState",
",",
"filler",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
")",
"->",
"None",
":",
"@",
"wraps",
"(",
"pre_state",
")",
"def",
"_pre_state",
"(",
"filler",
":",
"Dict",
"[",
"str",
",",
... | Specify the state prior to the test execution. Multiple invocations don't override
the state but extend it instead.
In general, the elements of `state_definitions` are nested dictionaries of the following form:
.. code-block:: python
{
address: {
"nonce": <account nonc... | [
"Specify",
"the",
"state",
"prior",
"to",
"the",
"test",
"execution",
".",
"Multiple",
"invocations",
"don",
"t",
"override",
"the",
"state",
"but",
"extend",
"it",
"instead",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/fillers/common.py#L141-L185 | train |
ethereum/py-evm | eth/tools/fixtures/fillers/common.py | expect | def expect(post_state: Dict[str, Any]=None,
networks: Any=None,
transaction: TransactionDict=None) -> Callable[..., Dict[str, Any]]:
"""
Specify the expected result for the test.
For state tests, multiple expectations can be given, differing in the transaction data, gas
limit, an... | python | def expect(post_state: Dict[str, Any]=None,
networks: Any=None,
transaction: TransactionDict=None) -> Callable[..., Dict[str, Any]]:
"""
Specify the expected result for the test.
For state tests, multiple expectations can be given, differing in the transaction data, gas
limit, an... | [
"def",
"expect",
"(",
"post_state",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
"networks",
":",
"Any",
"=",
"None",
",",
"transaction",
":",
"TransactionDict",
"=",
"None",
")",
"->",
"Callable",
"[",
"...",
",",
"Dict",
"[",
"str",
... | Specify the expected result for the test.
For state tests, multiple expectations can be given, differing in the transaction data, gas
limit, and value, in the applicable networks, and as a result also in the post state. VM tests
support only a single expectation with no specified network and no transaction... | [
"Specify",
"the",
"expected",
"result",
"for",
"the",
"test",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/fillers/common.py#L245-L289 | train |
ethereum/py-evm | eth/vm/logic/context.py | calldataload | def calldataload(computation: BaseComputation) -> None:
"""
Load call data into memory.
"""
start_position = computation.stack_pop(type_hint=constants.UINT256)
value = computation.msg.data_as_bytes[start_position:start_position + 32]
padded_value = value.ljust(32, b'\x00')
normalized_value ... | python | def calldataload(computation: BaseComputation) -> None:
"""
Load call data into memory.
"""
start_position = computation.stack_pop(type_hint=constants.UINT256)
value = computation.msg.data_as_bytes[start_position:start_position + 32]
padded_value = value.ljust(32, b'\x00')
normalized_value ... | [
"def",
"calldataload",
"(",
"computation",
":",
"BaseComputation",
")",
"->",
"None",
":",
"start_position",
"=",
"computation",
".",
"stack_pop",
"(",
"type_hint",
"=",
"constants",
".",
"UINT256",
")",
"value",
"=",
"computation",
".",
"msg",
".",
"data_as_b... | Load call data into memory. | [
"Load",
"call",
"data",
"into",
"memory",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/logic/context.py#L39-L49 | train |
ethereum/py-evm | eth/_utils/numeric.py | clamp | def clamp(inclusive_lower_bound: int,
inclusive_upper_bound: int,
value: int) -> int:
"""
Bound the given ``value`` between ``inclusive_lower_bound`` and
``inclusive_upper_bound``.
"""
if value <= inclusive_lower_bound:
return inclusive_lower_bound
elif value >= inclu... | python | def clamp(inclusive_lower_bound: int,
inclusive_upper_bound: int,
value: int) -> int:
"""
Bound the given ``value`` between ``inclusive_lower_bound`` and
``inclusive_upper_bound``.
"""
if value <= inclusive_lower_bound:
return inclusive_lower_bound
elif value >= inclu... | [
"def",
"clamp",
"(",
"inclusive_lower_bound",
":",
"int",
",",
"inclusive_upper_bound",
":",
"int",
",",
"value",
":",
"int",
")",
"->",
"int",
":",
"if",
"value",
"<=",
"inclusive_lower_bound",
":",
"return",
"inclusive_lower_bound",
"elif",
"value",
">=",
"i... | Bound the given ``value`` between ``inclusive_lower_bound`` and
``inclusive_upper_bound``. | [
"Bound",
"the",
"given",
"value",
"between",
"inclusive_lower_bound",
"and",
"inclusive_upper_bound",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/numeric.py#L90-L102 | train |
ethereum/py-evm | eth/_utils/numeric.py | integer_squareroot | def integer_squareroot(value: int) -> int:
"""
Return the integer square root of ``value``.
Uses Python's decimal module to compute the square root of ``value`` with
a precision of 128-bits. The value 128 is chosen since the largest square
root of a 256-bit integer is a 128-bit integer.
"""
... | python | def integer_squareroot(value: int) -> int:
"""
Return the integer square root of ``value``.
Uses Python's decimal module to compute the square root of ``value`` with
a precision of 128-bits. The value 128 is chosen since the largest square
root of a 256-bit integer is a 128-bit integer.
"""
... | [
"def",
"integer_squareroot",
"(",
"value",
":",
"int",
")",
"->",
"int",
":",
"if",
"not",
"isinstance",
"(",
"value",
",",
"int",
")",
"or",
"isinstance",
"(",
"value",
",",
"bool",
")",
":",
"raise",
"ValueError",
"(",
"\"Value must be an integer: Got: {0}... | Return the integer square root of ``value``.
Uses Python's decimal module to compute the square root of ``value`` with
a precision of 128-bits. The value 128 is chosen since the largest square
root of a 256-bit integer is a 128-bit integer. | [
"Return",
"the",
"integer",
"square",
"root",
"of",
"value",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/numeric.py#L105-L128 | train |
ethereum/py-evm | eth/db/atomic.py | AtomicDBWriteBatch._commit_unless_raises | def _commit_unless_raises(cls, write_target_db: BaseDB) -> Iterator['AtomicDBWriteBatch']:
"""
Commit all writes inside the context, unless an exception was raised.
Although this is technically an external API, it (and this whole class) is only intended
to be used by AtomicDB.
"... | python | def _commit_unless_raises(cls, write_target_db: BaseDB) -> Iterator['AtomicDBWriteBatch']:
"""
Commit all writes inside the context, unless an exception was raised.
Although this is technically an external API, it (and this whole class) is only intended
to be used by AtomicDB.
"... | [
"def",
"_commit_unless_raises",
"(",
"cls",
",",
"write_target_db",
":",
"BaseDB",
")",
"->",
"Iterator",
"[",
"'AtomicDBWriteBatch'",
"]",
":",
"readable_write_batch",
"=",
"cls",
"(",
"write_target_db",
")",
"try",
":",
"yield",
"readable_write_batch",
"except",
... | Commit all writes inside the context, unless an exception was raised.
Although this is technically an external API, it (and this whole class) is only intended
to be used by AtomicDB. | [
"Commit",
"all",
"writes",
"inside",
"the",
"context",
"unless",
"an",
"exception",
"was",
"raised",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/atomic.py#L116-L137 | train |
ethereum/py-evm | eth/vm/logic/comparison.py | slt | def slt(computation: BaseComputation) -> None:
"""
Signed Lesser Comparison
"""
left, right = map(
unsigned_to_signed,
computation.stack_pop(num_items=2, type_hint=constants.UINT256),
)
if left < right:
result = 1
else:
result = 0
computation.stack_push(... | python | def slt(computation: BaseComputation) -> None:
"""
Signed Lesser Comparison
"""
left, right = map(
unsigned_to_signed,
computation.stack_pop(num_items=2, type_hint=constants.UINT256),
)
if left < right:
result = 1
else:
result = 0
computation.stack_push(... | [
"def",
"slt",
"(",
"computation",
":",
"BaseComputation",
")",
"->",
"None",
":",
"left",
",",
"right",
"=",
"map",
"(",
"unsigned_to_signed",
",",
"computation",
".",
"stack_pop",
"(",
"num_items",
"=",
"2",
",",
"type_hint",
"=",
"constants",
".",
"UINT2... | Signed Lesser Comparison | [
"Signed",
"Lesser",
"Comparison"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/logic/comparison.py#L39-L53 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | build | def build(obj: Any, *applicators: Callable[..., Any]) -> Any:
"""
Run the provided object through the series of applicator functions.
If ``obj`` is an instances of :class:`~eth.chains.base.BaseChain` the
applicators will be run on a copy of the chain and thus will not mutate the
provided chain inst... | python | def build(obj: Any, *applicators: Callable[..., Any]) -> Any:
"""
Run the provided object through the series of applicator functions.
If ``obj`` is an instances of :class:`~eth.chains.base.BaseChain` the
applicators will be run on a copy of the chain and thus will not mutate the
provided chain inst... | [
"def",
"build",
"(",
"obj",
":",
"Any",
",",
"*",
"applicators",
":",
"Callable",
"[",
"...",
",",
"Any",
"]",
")",
"->",
"Any",
":",
"if",
"isinstance",
"(",
"obj",
",",
"BaseChain",
")",
":",
"return",
"pipe",
"(",
"obj",
",",
"copy",
"(",
")",... | Run the provided object through the series of applicator functions.
If ``obj`` is an instances of :class:`~eth.chains.base.BaseChain` the
applicators will be run on a copy of the chain and thus will not mutate the
provided chain instance. | [
"Run",
"the",
"provided",
"object",
"through",
"the",
"series",
"of",
"applicator",
"functions",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L78-L89 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | name | def name(class_name: str, chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Assign the given name to the chain class.
"""
return chain_class.configure(__name__=class_name) | python | def name(class_name: str, chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Assign the given name to the chain class.
"""
return chain_class.configure(__name__=class_name) | [
"def",
"name",
"(",
"class_name",
":",
"str",
",",
"chain_class",
":",
"Type",
"[",
"BaseChain",
"]",
")",
"->",
"Type",
"[",
"BaseChain",
"]",
":",
"return",
"chain_class",
".",
"configure",
"(",
"__name__",
"=",
"class_name",
")"
] | Assign the given name to the chain class. | [
"Assign",
"the",
"given",
"name",
"to",
"the",
"chain",
"class",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L96-L100 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | chain_id | def chain_id(chain_id: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Set the ``chain_id`` for the chain class.
"""
return chain_class.configure(chain_id=chain_id) | python | def chain_id(chain_id: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Set the ``chain_id`` for the chain class.
"""
return chain_class.configure(chain_id=chain_id) | [
"def",
"chain_id",
"(",
"chain_id",
":",
"int",
",",
"chain_class",
":",
"Type",
"[",
"BaseChain",
"]",
")",
"->",
"Type",
"[",
"BaseChain",
"]",
":",
"return",
"chain_class",
".",
"configure",
"(",
"chain_id",
"=",
"chain_id",
")"
] | Set the ``chain_id`` for the chain class. | [
"Set",
"the",
"chain_id",
"for",
"the",
"chain",
"class",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L104-L108 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | fork_at | def fork_at(vm_class: Type[BaseVM], at_block: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Adds the ``vm_class`` to the chain's ``vm_configuration``.
.. code-block:: python
from eth.chains.base import MiningChain
from eth.tools.builder.chain import build, fork_at
Fro... | python | def fork_at(vm_class: Type[BaseVM], at_block: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Adds the ``vm_class`` to the chain's ``vm_configuration``.
.. code-block:: python
from eth.chains.base import MiningChain
from eth.tools.builder.chain import build, fork_at
Fro... | [
"def",
"fork_at",
"(",
"vm_class",
":",
"Type",
"[",
"BaseVM",
"]",
",",
"at_block",
":",
"int",
",",
"chain_class",
":",
"Type",
"[",
"BaseChain",
"]",
")",
"->",
"Type",
"[",
"BaseChain",
"]",
":",
"if",
"chain_class",
".",
"vm_configuration",
"is",
... | Adds the ``vm_class`` to the chain's ``vm_configuration``.
.. code-block:: python
from eth.chains.base import MiningChain
from eth.tools.builder.chain import build, fork_at
FrontierOnlyChain = build(MiningChain, fork_at(FrontierVM, 0))
# these two classes are functionally equival... | [
"Adds",
"the",
"vm_class",
"to",
"the",
"chain",
"s",
"vm_configuration",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L112-L148 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | enable_pow_mining | def enable_pow_mining(chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Inject on demand generation of the proof of work mining seal on newly
mined blocks into each of the chain's vms.
"""
if not chain_class.vm_configuration:
raise ValidationError("Chain class has no vm_configuration")
... | python | def enable_pow_mining(chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Inject on demand generation of the proof of work mining seal on newly
mined blocks into each of the chain's vms.
"""
if not chain_class.vm_configuration:
raise ValidationError("Chain class has no vm_configuration")
... | [
"def",
"enable_pow_mining",
"(",
"chain_class",
":",
"Type",
"[",
"BaseChain",
"]",
")",
"->",
"Type",
"[",
"BaseChain",
"]",
":",
"if",
"not",
"chain_class",
".",
"vm_configuration",
":",
"raise",
"ValidationError",
"(",
"\"Chain class has no vm_configuration\"",
... | Inject on demand generation of the proof of work mining seal on newly
mined blocks into each of the chain's vms. | [
"Inject",
"on",
"demand",
"generation",
"of",
"the",
"proof",
"of",
"work",
"mining",
"seal",
"on",
"newly",
"mined",
"blocks",
"into",
"each",
"of",
"the",
"chain",
"s",
"vms",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L269-L278 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | disable_pow_check | def disable_pow_check(chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Disable the proof of work validation check for each of the chain's vms.
This allows for block mining without generation of the proof of work seal.
.. note::
blocks mined this way will not be importable on any chain tha... | python | def disable_pow_check(chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Disable the proof of work validation check for each of the chain's vms.
This allows for block mining without generation of the proof of work seal.
.. note::
blocks mined this way will not be importable on any chain tha... | [
"def",
"disable_pow_check",
"(",
"chain_class",
":",
"Type",
"[",
"BaseChain",
"]",
")",
"->",
"Type",
"[",
"BaseChain",
"]",
":",
"if",
"not",
"chain_class",
".",
"vm_configuration",
":",
"raise",
"ValidationError",
"(",
"\"Chain class has no vm_configuration\"",
... | Disable the proof of work validation check for each of the chain's vms.
This allows for block mining without generation of the proof of work seal.
.. note::
blocks mined this way will not be importable on any chain that does not
have proof of work disabled. | [
"Disable",
"the",
"proof",
"of",
"work",
"validation",
"check",
"for",
"each",
"of",
"the",
"chain",
"s",
"vms",
".",
"This",
"allows",
"for",
"block",
"mining",
"without",
"generation",
"of",
"the",
"proof",
"of",
"work",
"seal",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L309-L335 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | genesis | def genesis(chain_class: BaseChain,
db: BaseAtomicDB=None,
params: Dict[str, HeaderParams]=None,
state: GeneralState=None) -> BaseChain:
"""
Initialize the given chain class with the given genesis header parameters
and chain state.
"""
if state is None:
ge... | python | def genesis(chain_class: BaseChain,
db: BaseAtomicDB=None,
params: Dict[str, HeaderParams]=None,
state: GeneralState=None) -> BaseChain:
"""
Initialize the given chain class with the given genesis header parameters
and chain state.
"""
if state is None:
ge... | [
"def",
"genesis",
"(",
"chain_class",
":",
"BaseChain",
",",
"db",
":",
"BaseAtomicDB",
"=",
"None",
",",
"params",
":",
"Dict",
"[",
"str",
",",
"HeaderParams",
"]",
"=",
"None",
",",
"state",
":",
"GeneralState",
"=",
"None",
")",
"->",
"BaseChain",
... | Initialize the given chain class with the given genesis header parameters
and chain state. | [
"Initialize",
"the",
"given",
"chain",
"class",
"with",
"the",
"given",
"genesis",
"header",
"parameters",
"and",
"chain",
"state",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L354-L379 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | mine_block | def mine_block(chain: MiningChain, **kwargs: Any) -> MiningChain:
"""
Mine a new block on the chain. Header parameters for the new block can be
overridden using keyword arguments.
"""
if not isinstance(chain, MiningChain):
raise ValidationError('`mine_block` may only be used on MiningChain... | python | def mine_block(chain: MiningChain, **kwargs: Any) -> MiningChain:
"""
Mine a new block on the chain. Header parameters for the new block can be
overridden using keyword arguments.
"""
if not isinstance(chain, MiningChain):
raise ValidationError('`mine_block` may only be used on MiningChain... | [
"def",
"mine_block",
"(",
"chain",
":",
"MiningChain",
",",
"**",
"kwargs",
":",
"Any",
")",
"->",
"MiningChain",
":",
"if",
"not",
"isinstance",
"(",
"chain",
",",
"MiningChain",
")",
":",
"raise",
"ValidationError",
"(",
"'`mine_block` may only be used on Mini... | Mine a new block on the chain. Header parameters for the new block can be
overridden using keyword arguments. | [
"Mine",
"a",
"new",
"block",
"on",
"the",
"chain",
".",
"Header",
"parameters",
"for",
"the",
"new",
"block",
"can",
"be",
"overridden",
"using",
"keyword",
"arguments",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L386-L395 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | import_block | def import_block(block: BaseBlock, chain: BaseChain) -> BaseChain:
"""
Import the provided ``block`` into the chain.
"""
chain.import_block(block)
return chain | python | def import_block(block: BaseBlock, chain: BaseChain) -> BaseChain:
"""
Import the provided ``block`` into the chain.
"""
chain.import_block(block)
return chain | [
"def",
"import_block",
"(",
"block",
":",
"BaseBlock",
",",
"chain",
":",
"BaseChain",
")",
"->",
"BaseChain",
":",
"chain",
".",
"import_block",
"(",
"block",
")",
"return",
"chain"
] | Import the provided ``block`` into the chain. | [
"Import",
"the",
"provided",
"block",
"into",
"the",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L411-L416 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | copy | def copy(chain: MiningChain) -> MiningChain:
"""
Make a copy of the chain at the given state. Actions performed on the
resulting chain will not affect the original chain.
"""
if not isinstance(chain, MiningChain):
raise ValidationError("`at_block_number` may only be used with 'MiningChain")... | python | def copy(chain: MiningChain) -> MiningChain:
"""
Make a copy of the chain at the given state. Actions performed on the
resulting chain will not affect the original chain.
"""
if not isinstance(chain, MiningChain):
raise ValidationError("`at_block_number` may only be used with 'MiningChain")... | [
"def",
"copy",
"(",
"chain",
":",
"MiningChain",
")",
"->",
"MiningChain",
":",
"if",
"not",
"isinstance",
"(",
"chain",
",",
"MiningChain",
")",
":",
"raise",
"ValidationError",
"(",
"\"`at_block_number` may only be used with 'MiningChain\"",
")",
"base_db",
"=",
... | Make a copy of the chain at the given state. Actions performed on the
resulting chain will not affect the original chain. | [
"Make",
"a",
"copy",
"of",
"the",
"chain",
"at",
"the",
"given",
"state",
".",
"Actions",
"performed",
"on",
"the",
"resulting",
"chain",
"will",
"not",
"affect",
"the",
"original",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L433-L450 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | chain_split | def chain_split(*splits: Iterable[Callable[..., Any]]) -> Callable[[BaseChain], Iterable[BaseChain]]: # noqa: E501
"""
Construct and execute multiple concurrent forks of the chain.
Any number of forks may be executed. For each fork, provide an iterable of
commands.
Returns the resulting chain o... | python | def chain_split(*splits: Iterable[Callable[..., Any]]) -> Callable[[BaseChain], Iterable[BaseChain]]: # noqa: E501
"""
Construct and execute multiple concurrent forks of the chain.
Any number of forks may be executed. For each fork, provide an iterable of
commands.
Returns the resulting chain o... | [
"def",
"chain_split",
"(",
"*",
"splits",
":",
"Iterable",
"[",
"Callable",
"[",
"...",
",",
"Any",
"]",
"]",
")",
"->",
"Callable",
"[",
"[",
"BaseChain",
"]",
",",
"Iterable",
"[",
"BaseChain",
"]",
"]",
":",
"if",
"not",
"splits",
":",
"raise",
... | Construct and execute multiple concurrent forks of the chain.
Any number of forks may be executed. For each fork, provide an iterable of
commands.
Returns the resulting chain objects for each fork.
.. code-block:: python
chain_a, chain_b = build(
mining_chain,
chain... | [
"Construct",
"and",
"execute",
"multiple",
"concurrent",
"forks",
"of",
"the",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L453-L486 | train |
ethereum/py-evm | eth/tools/builder/chain/builders.py | at_block_number | def at_block_number(block_number: BlockNumber, chain: MiningChain) -> MiningChain:
"""
Rewind the chain back to the given block number. Calls to things like
``get_canonical_head`` will still return the canonical head of the chain,
however, you can use ``mine_block`` to mine fork chains.
"""
if ... | python | def at_block_number(block_number: BlockNumber, chain: MiningChain) -> MiningChain:
"""
Rewind the chain back to the given block number. Calls to things like
``get_canonical_head`` will still return the canonical head of the chain,
however, you can use ``mine_block`` to mine fork chains.
"""
if ... | [
"def",
"at_block_number",
"(",
"block_number",
":",
"BlockNumber",
",",
"chain",
":",
"MiningChain",
")",
"->",
"MiningChain",
":",
"if",
"not",
"isinstance",
"(",
"chain",
",",
"MiningChain",
")",
":",
"raise",
"ValidationError",
"(",
"\"`at_block_number` may onl... | Rewind the chain back to the given block number. Calls to things like
``get_canonical_head`` will still return the canonical head of the chain,
however, you can use ``mine_block`` to mine fork chains. | [
"Rewind",
"the",
"chain",
"back",
"to",
"the",
"given",
"block",
"number",
".",
"Calls",
"to",
"things",
"like",
"get_canonical_head",
"will",
"still",
"return",
"the",
"canonical",
"head",
"of",
"the",
"chain",
"however",
"you",
"can",
"use",
"mine_block",
... | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L490-L502 | train |
ethereum/py-evm | eth/tools/fixtures/loading.py | load_json_fixture | def load_json_fixture(fixture_path: str) -> Dict[str, Any]:
"""
Loads a fixture file, caching the most recent files it loaded.
"""
with open(fixture_path) as fixture_file:
file_fixtures = json.load(fixture_file)
return file_fixtures | python | def load_json_fixture(fixture_path: str) -> Dict[str, Any]:
"""
Loads a fixture file, caching the most recent files it loaded.
"""
with open(fixture_path) as fixture_file:
file_fixtures = json.load(fixture_file)
return file_fixtures | [
"def",
"load_json_fixture",
"(",
"fixture_path",
":",
"str",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"with",
"open",
"(",
"fixture_path",
")",
"as",
"fixture_file",
":",
"file_fixtures",
"=",
"json",
".",
"load",
"(",
"fixture_file",
")",
"r... | Loads a fixture file, caching the most recent files it loaded. | [
"Loads",
"a",
"fixture",
"file",
"caching",
"the",
"most",
"recent",
"files",
"it",
"loaded",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/loading.py#L54-L60 | train |
ethereum/py-evm | eth/tools/fixtures/loading.py | load_fixture | def load_fixture(fixture_path: str,
fixture_key: str,
normalize_fn: Callable[..., Any]=identity) -> Dict[str, Any]:
"""
Loads a specific fixture from a fixture file, optionally passing it through
a normalization function.
"""
file_fixtures = load_json_fixture(fixtur... | python | def load_fixture(fixture_path: str,
fixture_key: str,
normalize_fn: Callable[..., Any]=identity) -> Dict[str, Any]:
"""
Loads a specific fixture from a fixture file, optionally passing it through
a normalization function.
"""
file_fixtures = load_json_fixture(fixtur... | [
"def",
"load_fixture",
"(",
"fixture_path",
":",
"str",
",",
"fixture_key",
":",
"str",
",",
"normalize_fn",
":",
"Callable",
"[",
"...",
",",
"Any",
"]",
"=",
"identity",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"file_fixtures",
"=",
"load... | Loads a specific fixture from a fixture file, optionally passing it through
a normalization function. | [
"Loads",
"a",
"specific",
"fixture",
"from",
"a",
"fixture",
"file",
"optionally",
"passing",
"it",
"through",
"a",
"normalization",
"function",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/loading.py#L63-L72 | train |
ethereum/py-evm | eth/_utils/version.py | construct_evm_runtime_identifier | def construct_evm_runtime_identifier() -> str:
"""
Constructs the EVM runtime identifier string
e.g. 'Py-EVM/v1.2.3/darwin-amd64/python3.6.5'
"""
return "Py-EVM/{0}/{platform}/{imp.name}{v.major}.{v.minor}.{v.micro}".format(
__version__,
platform=sys.platform,
v=sys.version_... | python | def construct_evm_runtime_identifier() -> str:
"""
Constructs the EVM runtime identifier string
e.g. 'Py-EVM/v1.2.3/darwin-amd64/python3.6.5'
"""
return "Py-EVM/{0}/{platform}/{imp.name}{v.major}.{v.minor}.{v.micro}".format(
__version__,
platform=sys.platform,
v=sys.version_... | [
"def",
"construct_evm_runtime_identifier",
"(",
")",
"->",
"str",
":",
"return",
"\"Py-EVM/{0}/{platform}/{imp.name}{v.major}.{v.minor}.{v.micro}\"",
".",
"format",
"(",
"__version__",
",",
"platform",
"=",
"sys",
".",
"platform",
",",
"v",
"=",
"sys",
".",
"version_i... | Constructs the EVM runtime identifier string
e.g. 'Py-EVM/v1.2.3/darwin-amd64/python3.6.5' | [
"Constructs",
"the",
"EVM",
"runtime",
"identifier",
"string"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/version.py#L6-L18 | train |
ethereum/py-evm | eth/estimators/gas.py | binary_gas_search | def binary_gas_search(state: BaseState, transaction: BaseTransaction, tolerance: int=1) -> int:
"""
Run the transaction with various gas limits, progressively
approaching the minimum needed to succeed without an OutOfGas exception.
The starting range of possible estimates is:
[transaction.intrinsic... | python | def binary_gas_search(state: BaseState, transaction: BaseTransaction, tolerance: int=1) -> int:
"""
Run the transaction with various gas limits, progressively
approaching the minimum needed to succeed without an OutOfGas exception.
The starting range of possible estimates is:
[transaction.intrinsic... | [
"def",
"binary_gas_search",
"(",
"state",
":",
"BaseState",
",",
"transaction",
":",
"BaseTransaction",
",",
"tolerance",
":",
"int",
"=",
"1",
")",
"->",
"int",
":",
"if",
"not",
"hasattr",
"(",
"transaction",
",",
"'sender'",
")",
":",
"raise",
"TypeErro... | Run the transaction with various gas limits, progressively
approaching the minimum needed to succeed without an OutOfGas exception.
The starting range of possible estimates is:
[transaction.intrinsic_gas, state.gas_limit].
After the first OutOfGas exception, the range is: (largest_limit_out_of_gas, sta... | [
"Run",
"the",
"transaction",
"with",
"various",
"gas",
"limits",
"progressively",
"approaching",
"the",
"minimum",
"needed",
"to",
"succeed",
"without",
"an",
"OutOfGas",
"exception",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/estimators/gas.py#L28-L78 | train |
ethereum/py-evm | eth/db/storage.py | StorageLookup.commit_to | def commit_to(self, db: BaseDB) -> None:
"""
Trying to commit changes when nothing has been written will raise a
ValidationError
"""
self.logger.debug2('persist storage root to data store')
if self._trie_nodes_batch is None:
raise ValidationError(
... | python | def commit_to(self, db: BaseDB) -> None:
"""
Trying to commit changes when nothing has been written will raise a
ValidationError
"""
self.logger.debug2('persist storage root to data store')
if self._trie_nodes_batch is None:
raise ValidationError(
... | [
"def",
"commit_to",
"(",
"self",
",",
"db",
":",
"BaseDB",
")",
"->",
"None",
":",
"self",
".",
"logger",
".",
"debug2",
"(",
"'persist storage root to data store'",
")",
"if",
"self",
".",
"_trie_nodes_batch",
"is",
"None",
":",
"raise",
"ValidationError",
... | Trying to commit changes when nothing has been written will raise a
ValidationError | [
"Trying",
"to",
"commit",
"changes",
"when",
"nothing",
"has",
"been",
"written",
"will",
"raise",
"a",
"ValidationError"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/storage.py#L131-L143 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.