Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
args=ExpressionMakeTuple(
elements=(
ExpressionCaughtExceptionTypeRef(source_ref=with_exit_source_ref),
ExpressionCaughtExceptionValueRef(source_ref=with_exit_source_ref),
ExpressionCaughtExceptionTracebackRef(source_ref=source_ref),
),
source_ref=source_ref,
),
source_ref=with_exit_source_ref,
)
exit_value_no_exception = ExpressionCallNoKeywords(
called=ExpressionTempVariableRef(
variable=tmp_exit_variable, source_ref=source_ref
),
args=makeConstantRefNode(constant=(None, None, None), source_ref=source_ref),
source_ref=with_exit_source_ref,
)
# For "async with", await the entered value and exit value must be awaited.
if not sync:
enter_value = ExpressionYieldFromWaitable(
expression=ExpressionAsyncWaitEnter(
expression=enter_value, source_ref=source_ref
),
source_ref=source_ref,
)
exit_value_exception = ExpressionYieldFromWaitable(
expression=ExpressionAsyncWaitExit(
expression=exit_value_exception, source_ref=source_ref
),
source_ref=source_ref,
import_nodes = []
for import_desc in import_names:
module_name, local_name = import_desc
module_topname = module_name.split('.')[0]
# Note: The "level" of import is influenced by the future absolute
# imports.
level = makeConstantRefNode(0, source_ref, True) if _future_specs[-1].isAbsoluteImport() else None
import_node = ExpressionBuiltinImport(
name = makeConstantRefNode(module_name, source_ref, True),
globals_arg = ExpressionBuiltinGlobals(source_ref),
locals_arg = makeConstantRefNode(None, source_ref, True),
fromlist = makeConstantRefNode(None, source_ref, True),
level = level,
source_ref = source_ref
)
if local_name:
# If is gets a local name, the real name must be used as a
# temporary value only, being looked up recursively.
for import_name in module_name.split('.')[1:]:
import_node = ExpressionImportName(
module = import_node,
import_name = import_name,
level = None,
source_ref = source_ref
)
# If a name was given, use the one provided, otherwise the import gives
if constant:
# Unless told otherwise, create the dictionary in its full size, so
# that no growing occurs and the constant becomes as similar as possible
# before being marshaled.
result = makeConstantRefNode(
constant=Constants.createConstantDict(
keys=keys, values=[value.getConstant() for value in values]
),
user_provided=True,
source_ref=source_ref,
)
else:
result = ExpressionMakeDict(
pairs=[
ExpressionKeyValuePair(
key=makeConstantRefNode(
constant=key,
source_ref=value.getSourceReference(),
user_provided=True,
),
value=value,
source_ref=value.getSourceReference(),
)
for key, value in zip(keys, values)
],
source_ref=source_ref,
)
if values:
result.setCompatibleSourceReference(
source_ref=values[-1].getCompatibleSourceReference()
)
def _makeRaiseDuplicationItem(called_variable, tmp_key_variable):
return StatementRaiseException(
exception_type=ExpressionBuiltinMakeException(
exception_name="TypeError",
args=(
makeBinaryOperationNode(
operator="Mod",
left=makeConstantRefNode(
constant="""\
%s got multiple values for keyword argument '%s'""",
source_ref=internal_source_ref,
user_provided=True,
),
right=ExpressionMakeTuple(
elements=(
ExpressionFunctionCall(
function=ExpressionFunctionCreation(
function_ref=ExpressionFunctionRef(
function_body=getCallableNameDescBody(),
source_ref=internal_source_ref,
),
defaults=(),
kw_defaults=None,
annotations=None,
)
statements += [
makeTryFinallyStatement(
provider=provider,
tried=makeTryExceptSingleHandlerNodeWithPublish(
provider=provider,
tried=with_body,
exception_name="BaseException",
handler_body=StatementsSequence(
statements=(
# Prevents final block from calling __exit__ as
# well.
StatementAssignmentVariable(
variable=tmp_indicator_variable,
source=makeConstantRefNode(
constant=False, source_ref=source_ref
),
source_ref=source_ref,
),
makeStatementConditional(
condition=exit_value_exception,
no_branch=makeReraiseExceptionStatement(
source_ref=with_exit_source_ref
),
yes_branch=None,
source_ref=with_exit_source_ref,
),
),
source_ref=source_ref,
),
public_exc=python_version >= 270,
source_ref=source_ref,
),
),
source_ref=source_ref,
).asStatement(),
source_ref=source_ref,
),
)
statements += [
StatementAssignmentVariable(
variable=tmp_metaclass,
source=ExpressionSelectMetaclass(
metaclass=ExpressionConditional(
condition=ExpressionDictOperationIn(
key=makeConstantRefNode(
constant="metaclass",
source_ref=source_ref,
user_provided=True,
),
dict_arg=ExpressionTempVariableRef(
variable=tmp_class_decl_dict, source_ref=source_ref
),
source_ref=source_ref,
),
expression_yes=ExpressionDictOperationGet(
dict_arg=ExpressionTempVariableRef(
variable=tmp_class_decl_dict, source_ref=source_ref
),
key=makeConstantRefNode(
constant="metaclass",
source_ref=source_ref,
dict_arg=ExpressionTempVariableRef(
variable=tmp_result_variable, source_ref=internal_source_ref
),
value=ExpressionTempVariableRef(
variable=tmp_item_variable, source_ref=internal_source_ref
),
source_ref=internal_source_ref,
),
exception_name="AttributeError",
handler_body=StatementRaiseException(
exception_type=ExpressionBuiltinMakeException(
exception_name="TypeError",
args=(
makeBinaryOperationNode(
operator="Mod",
left=makeConstantRefNode(
constant="""\
'%s' object is not a mapping""",
source_ref=internal_source_ref,
user_provided=True,
),
right=ExpressionMakeTuple(
elements=(
ExpressionAttributeLookup(
source=ExpressionBuiltinType1(
value=ExpressionTempVariableRef(
variable=tmp_item_variable,
source_ref=internal_source_ref,
),
source_ref=internal_source_ref,
),
attribute_name="__name__",
def __init__(self, value, base, source_ref):
if value is None and self.base_only_value:
value = makeConstantRefNode(
constant="0", source_ref=source_ref, user_provided=True
)
ExpressionSpecBasedComputationBase.__init__(
self, values={"value": value, "base": base}, source_ref=source_ref
)
def makeBasesRef():
return makeConstantRefNode(constant=(), source_ref=source_ref)