def build_class(self, chain_number):
named_fields = [
ast.Name(id=field, ctx=ast.Store()) for field in self.fields
]
field_assignments = [
ast.Assign(targets=[named_field],
value=ast.Name(id='None', ctx=ast.Load()))
for named_field in named_fields
]
class_node = ast.ClassDef(
name=self.name,
bases=self.bases,
body=field_assignments + self.method_nodes +
[ast.Expr(value=ast.Str(s=' --> EXTRACTED <-- '))],
decorator_list=[])
if chain_number > 0:
class_node = ast.ClassDef(
name=self.name,
bases=[
ast.Name(id=self.o_name + str(chain_number - 1),
ctx=ast.Load())
],
body=field_assignments + self.method_nodes +
[ast.Expr(value=ast.Str(s=' --> EXTRACTED <-- '))],
decorator_list=[])
return AstClassWrapper(class_node)
def ClassDef(*,
name,
bases,
keywords,
starargs,
kwargs,
body,
decorator_list,
lineno=None,
col_offset=None):
if flags.PY_VERSION == 2:
# Ignore keywords and starargs, they shouldnt be there in the first place if Py2
return ast.ClassDef(name=name,
bases=bases,
body=body,
decorator_list=decorator_list,
lineno=lineno,
col_offset=col_offset)
elif flags.PY_VERSION == 3:
if flags.PY3_VERSION >= 5:
if starargs is not None:
bases += [ast.Starred(starargs, ast.Load())]
if kwargs is not None:
keywords += [ast.keyword(arg=None, value=kwargs)]
if lineno is not None and col_offset is not None:
return ast.ClassDef(name=name,
bases=bases,
keywords=keywords,
body=body,
decorator_list=decorator_list,
lineno=lineno,
col_offset=col_offset)
else:
return ast.ClassDef(name=name,
bases=bases,
keywords=keywords,
body=body,
decorator_list=decorator_list)
else:
if lineno is not None and col_offset is not None:
return ast.ClassDef(name=name,
bases=bases,
keywords=keywords,
starargs=starargs,
kwargs=kwargs,
body=body,
decorator_list=decorator_list,
lineno=lineno,
col_offset=col_offset)
else:
return ast.ClassDef(name=name,
bases=bases,
keywords=keywords,
starargs=starargs,
kwargs=kwargs,
body=body,
decorator_list=decorator_list)
def conf_schema_from_concrete_type(type_: type, scope: TypeDict) -> ObjDict:
'''
Return a configuration schema for a type with no subclasses.
'''
try:
mod_def = cast(ast.Module, ast.parse(dedent(getsource(type_))))
cls_def = cast(ast.ClassDef, mod_def.body[0])
except (OSError, TypeError):
cls_def = ast.ClassDef('', (), (), [], [])
Conf = getattr(type_, 'Conf', type('', (), {}))
conf_def = ast.ClassDef('', (), (), [], [])
for stmt in cls_def.body:
if isinstance(stmt, ast.ClassDef) and stmt.name == 'Conf':
conf_def = stmt
schema: dict = {
'type': 'object',
'description': [],
'outputDescriptions': {},
'properties': DefaultDict[str, dict](lambda: {})
}
# Collect `description` & `ouputDescriptions`.
for tgt, ann in literal_annotations(cls_def):
if isinstance(ann, str):
if tgt is None:
schema['description'].append(dedent(ann).strip())
else:
schema['outputDescriptions'][tgt] = dedent(ann).strip()
# Collect property type annotations.
for tgt, ann in getattr(Conf, '__annotations__', {}).items():
schema['properties'][tgt].update(schema_from_type_ann(ann, scope))
# Collect property defaults.
for key, val in vars(Conf).items():
if not key.startswith('_'):
schema['properties'][key]['default'] = val
# Collect property descriptions and raw property schema.
for tgt, ann in literal_annotations(conf_def):
tgt_schema = schema if tgt is None else schema['properties'][tgt]
tgt_schema.update(schema_from_literal_ann(ann))
# Define required properties.
schema['required'] = [
key for key, val in schema['properties'].items()
if 'default' not in val
]
schema['description'] = '\n\n'.join(schema['description'])
schema['properties'] = dict(schema['properties'])
return schema
def build_classdef_node(self, n):
return ast.ClassDef(
name=self.name + str(n),
bases=[],
body=[],
decorator_list=[]
)
def enum_to_class(enum: Enum) -> ResolvedClassResult:
"""Convert Enum into AST class definition."""
enum_import = ast.Import(names=[ast.alias(name='enum', asname=None)])
class_body = []
if enum.doc:
class_body.append(docstring_declaration(enum.doc))
members = [
ast.Expr(value=ast.Assign(targets=[render_enum_name(symbol)],
value=ast.Str(s=symbol)))
for symbol in enum.symbols
]
class_body.extend(sorted(members, key=lambda e: e.value.value.s))
enum_class = ast.ClassDef(
name=enum.name,
bases=[ast.Attribute(value=ast.Name(id='enum'), attr='Enum')],
keywords=[],
body=class_body,
decorator_list=[
ast.Attribute(value=ast.Name(id='enum'), attr='unique')
] # just for signalling purposes
)
return ResolvedClassResult(
resolved_class=enum_class,
imports=[enum_import],
new_frontier=[],
)
def new_class_def():
node = ast.ClassDef(
name='Conf',
bases=[ast.Name(id='object', ctx=ast.Load())],
body=[
ast.FunctionDef(
name='__init__',
args=ast.arguments(args=[ast.Name(id='self', ctx=ast.Param())],
vararg=None,
kwarg=None,
defaults=[]),
body=[
ast.Assign(targets=[
ast.Attribute(value=ast.Name(id='self',
ctx=ast.Load()),
attr='AA',
ctx=ast.Store())
],
value=ast.List(elts=[], ctx=ast.Load())),
ast.Assign(targets=[
ast.Attribute(value=ast.Name(id='self',
ctx=ast.Load()),
attr='BB',
ctx=ast.Store())
],
value=ast.Num(n=2))
],
decorator_list=[])
],
decorator_list=[])
return node
def visitClassDef(self, n, *args):
bases = self.reduce(n.bases, *args)
starargs = self.dispatch(n.starargs, *args) if getattr(
n, 'starargs', None) else None
kwargs = self.dispatch(n.kwargs, *args) if getattr(n, 'kwargs',
None) else None
declst = []
for dec in self.reduce(n.decorator_list, *args):
if isinstance(dec, ast.Call) and \
isinstance(dec.func, ast.Name) and \
dec.func.id == 'fields':
continue
else:
declst.append(dec)
decorator_list = self.reduce(n.decorator_list, *args)
body = self.dispatch_statements(n.body, *args)
keywords = [ast.keyword(k.arg, self.dispatch(k.value, *args)) for k in \
getattr(n, 'keywords', [])]
return ast.ClassDef(name=n.name,
bases=bases,
keywords=keywords,
starargs=starargs,
kwargs=kwargs,
body=body,
decorator_list=declst)
def create_enum(self, resource):
"""Create an Enum class.
class ChannelRoleEnum(enum.Enum):
INVENTORY_SUPPLY = 'InventorySupply'
PRODUCT_DISTRIBUTION = 'ProductDistribution'
ORDER_EXPORT = 'OrderExport'
ORDER_IMPORT = 'OrderImport'
PRIMARY = 'Primary'
"""
self.add_import_statement(resource.package_name, "enum")
bases = [ast.Name(id="enum.Enum")]
class_node = ast.ClassDef(
name=resource.name,
bases=bases,
keywords=[],
decorator_list=[],
body=[
ast.Assign(targets=[ast.Name(id=enum_attr(val))],
value=ast.Str(s=val)) for val in resource.enum
],
)
if not class_node.body:
class_node.body.append(ast.Pass())
return class_node
def visit_ClassDef(self, node):
unique_class_name = self.unique_scoped_name(node.name)
self.namespace_map[self.namespace_list[-1]][
node.name] = unique_class_name
self.namespace_list.append(node.name)
self.namespace_map[node.name] = {}
tmp_scope = self.current_scope_is_class
self.current_scope_is_class = True
new_body = self.if_exists(node.body, self.visit_list)
new_bases = self.if_exists(node.bases, self.visit_list)
new_keywords = self.if_exists(node.keywords, self.visit_list)
new_decorator_list = self.if_exists(node.decorator_list,
self.visit_list)
return_list = self.new_stmts + [
ast.copy_location(
ast.ClassDef(unique_class_name, new_bases, new_keywords,
new_body, new_decorator_list), node)
]
self.new_stmts.clear()
self.namespace_list.pop()
del self.namespace_map[node.name]
self.current_scope_is_class = tmp_scope
return return_list
def stubs_for_pydantic(models: Collection[Type[pd.BaseModel]],
clsname: str = None) -> ast.Module:
""" Generate stubs for Pydantic models
Example:
ast.unparse(stubs_for_models([db.User]))
"""
model_infos = [ModelInfo.from_pydantic_model(model) for model in models]
ast_models = [model_info.to_ast() for model_info in model_infos]
ast_imports = merge_imports(model_infos).to_ast()
if clsname:
ast_models = [
ast.ClassDef(clsname,
bases=[],
decorator_list=[],
keywords=[],
body=ast_models)
]
return ast.Module([
ast.ImportFrom('__future__', [ast.alias('annotations')], level=0),
ast.Import([ast.alias('pydantic')]),
ast_imports,
ast.parse('NoneType = type(None)'),
*ast_models,
],
type_ignores=[])
def update_module_with_section(module_node, section, section_types, testbases):
section_html = html.tostring(section).decode()
doc = html2text(section_html)
rewrite_doc(module_node, doc)
testcases = cases_dict(section, section_types)
for node in module_node.body[3:]:
if isinstance(node, ast.ClassDef) and node.name in testcases:
#rewrite docs for existing methods in existing case
docs_transformer = AppendDocToMethods(testcases[node.name])
docs_transformer.visit(node)
#append uncreated methods to existing case
for (testmethod, doc) in docs_transformer.testmethods.items():
node.body.append(create_testmethod(testmethod, doc))
del testcases[node.name]
#create uncreated testcases
for testcase, testmethods in testcases.items():
if not testmethods:
continue
casedef = ast.ClassDef( name=testcase,
body=[],
bases=(ast.Name(base, ast.Load()) for base in testbases),
decorator_list=[])
for testmethod, doc in testmethods.items():
casedef.body.append(create_testmethod(testmethod, doc))
module_node.body.append(casedef)
return module_node
def _transform_to_example_group(self, node, name):
context_expr = self._context_expr_for(node)
example_name = self._human_readable_context_expr(context_expr)
if name in self.SHARED_EXAMPLE_GROUPS:
self.shared_contexts[example_name] = node.body
if name in self.EXPORTED_EXAMPLE_GROUPS:
self.__class__.exported_contexts[example_name] = node.body
return ast.copy_location(
ast.ClassDef(
name=self._prefix_with_sequence(example_name),
bases=[],
keywords=[],
body=node.body,
decorator_list=[
self._set_attribute('_example_group', True),
self._set_attribute('_example_name', example_name),
self._set_attribute('_tags', self._tags_from(context_expr, name)),
self._set_attribute('_pending', name in self.PENDING_EXAMPLE_GROUPS),
self._set_attribute('_shared', name in self.SHARED_EXAMPLE_GROUPS),
self._set_attribute('_exported', name in self.EXPORTED_EXAMPLE_GROUPS)
]
),
node
)
def add_dict_field_definition(self, resource, module_name):
base_class = ast.Name(id="marshmallow.fields.Dict")
# Define the base class
class_node = ast.ClassDef(
name=resource.name + "Field",
bases=[base_class],
keywords=[],
decorator_list=[],
body=[],
)
class_node.body.append(
ast.FunctionDef(
name="_deserialize",
args=ast.arguments(
args=[
ast.arg(arg="self", annotation=None),
ast.arg(arg="value", annotation=None),
ast.arg(arg="attr", annotation=None),
ast.arg(arg="data", annotation=None),
],
vararg=None,
kwonlyargs=[],
kw_defaults=[],
kwarg=ast.arg(arg="kwargs", annotation=None),
defaults=[],
),
body=[
ast.Assign(
targets=[ast.Name(id="result")],
value=ast.Call(
func=ast.Attribute(
value=ast.Call(func=ast.Name(id="super"),
args=[],
keywords=[]),
attr="_deserialize",
),
args=[
ast.Name(id="value"),
ast.Name(id="attr"),
ast.Name(id="data"),
],
kwarg=ast.arg(arg="kwargs", annotation=None),
keywords=[],
),
),
ast.Return(value=ast.Call(
func=ast.Name(id="types." + resource.name),
args=[],
keywords=[
ast.keyword(arg=None, value=ast.Name(id="result"))
],
)),
],
decorator_list=[],
returns=None,
))
self._field_nodes[module_name].append(class_node)
def _create_trait_schema(trait: TraitInfo) -> ast.ClassDef:
"""Create a Marshmallow Schema class for a Trait.
This for example creates the QuerySchema or the PriceSelectingSchema.
"""
if not trait.params:
return
schema_name = trait.class_name + "Schema"
schema_node = ast.ClassDef(
name=schema_name,
bases=[
ast.Name(id="marshmallow.Schema"),
ast.Name(id="RemoveEmptyValuesMixin"),
],
keywords=[],
decorator_list=[],
body=[],
)
# Marshmallow field definitions
schema_methods = []
for param in trait.params:
node, methods, imports = _create_schema_field(param)
if node:
schema_methods.extend(methods)
schema_node.body.append(node)
schema_node.body.extend(schema_methods)
return schema_node
def classdef_statement_visitor(
node: concat.parse.ClassdefStatementNode,
) -> ast.ClassDef:
py_body = [
correct_magic_signature(statementfy(node))
for node in All(
alt(visitors['word'], visitors['statement'])
).visit(node)
]
py_decorators = [
to_python_decorator(word, visitors) for word in node.decorators
]
py_decorators.reverse()
py_bases = []
for base in node.bases:
quotation = to_transpiled_quotation(base, node.location, visitors)
py_base = pack_expressions([quotation, pop_stack()])
py_bases.append(py_base)
py_keywords = []
for keyword_arg in node.keyword_args:
py_word = visitors['word'].visit(keyword_arg[1])
stack = ast.Name(id='stack', ctx=ast.Load())
stash = ast.Name(id='stash', ctx=ast.Load())
py_word_call = ast.Call(py_word, args=[stack, stash], keywords=[])
py_keyword_value = pack_expressions([py_word_call, pop_stack()])
py_keyword = ast.keyword(keyword_arg[0], py_keyword_value)
py_keywords.append(py_keyword)
return ast.ClassDef(
node.class_name,
bases=py_bases,
keywords=py_keywords,
body=py_body,
decorator_list=py_decorators,
)
def p_classdef(p):
'''classdef : TAG_CLASS NAME suite
| TAG_CLASS NAME "(" testlist ")" suite
| TAG_CLASS NAME "(" ")" suite'''
p[0] = ast.ClassDef(name=p[2],
bases=[],
body=None,
decorator_list=[],
lineno=p.get_item(1).lineno,
col_offset=p.get_item(1).lexpos)
if len(p) == 4:
p[0].body = p[3]
elif len(p) == 7:
base = p[4]
if not isinstance(base, list):
base = [
base,
]
p[0].bases = base
p[0].body = p[6]
elif len(p) == 6:
p[0].body = p[5]
return
def visit_ClassDef(self, node):
#print node.id
global classes
classes += [node.name]
return ast.ClassDef(name=(rename(node.name)),
bases=[self.visit(i) for i in node.bases],
body=[self.visit(i) for i in node.body],
decorator_list=node.decorator_list)
def codebase_tokens():
function_token = ast.FunctionDef()
setattr(function_token, 'name', 'foo_bar')
class_token = ast.ClassDef()
setattr(class_token, 'name', 'TestMySelf')
return [function_token, class_token]
def visit_ClassDef(self, node):
body = []
for e in node.body:
flatten(body, self.visit(e))
cls = ast.ClassDef()
cls.body = body
cls.name = node.name
return cls
def build(self):
# Define the base class. If the resource is a scalar type (str, int)
# then we
bases = []
assert not self.resource.is_scalar_type
if self.resource.base and self.resource.base.name not in ("any",
"object"):
bases.append(ast.Name(id=self.resource.base.name))
if self.resource.package_name != self.resource.base.package_name:
self.generator.import_resource(
self.resource.package_name,
self.resource.base.package_name,
self.resource.base.name,
)
# Create the class node
class_node = ast.ClassDef(
name=self.resource.name,
bases=bases,
keywords=[],
decorator_list=[
ast.Call(
func=ast.Attribute(value=ast.Name(id="attr"), attr="s"),
args=[],
keywords=[
ast.keyword(arg="auto_attribs",
value=ast.NameConstant(value=True)),
ast.keyword(arg="init",
value=ast.NameConstant(value=False)),
ast.keyword(arg="repr",
value=ast.NameConstant(value=False)),
],
)
],
body=[],
)
# Docstring
doc_string = f"Corresponding marshmallow schema is :class:`commercetools.schemas.{self.resource.name}Schema`."
class_node.body.append(ast.Expr(value=ast.Str(s=doc_string)))
# Add the properties for the attr class
for prop in self.resource.properties:
node = self._create_property(prop)
if node:
value = self._create_property_docstring(prop)
class_node.body.append(
ast.Expr(value=ast.Name(id=f"#: {value}")))
class_node.body.append(node)
init_func = self._create_init_method(class_node)
if not init_func.body:
init_func.body.append(ast.Pass())
class_node.body.append(init_func)
repr_func = self._create_repr_method()
class_node.body.append(repr_func)
return class_node
def setUp(self):
class_node = ast.ClassDef(name='Class',
bases=[],
keywords=[],
body=[ast.Expr(value=ast.Str(s='Class docstrings')),
ast.FunctionDef(name='__init__',
args=ast.arguments(args=[ast.arg(arg='self',
annotation=None)],
vararg=None,
kwonlyargs=[],
kw_defaults=[],
kwarg=None,
defaults=[]),
body=[ast.Expr(value=ast.Str(s="Constructor's docstrings")),
ast.Pass()],
decorator_list=[],
returns=None),
ast.FunctionDef(name='_private_func',
args=ast.arguments(args=[ast.arg(arg='self',
annotation=None),
ast.arg(arg='arg',
annotation=None)],
vararg=None,
kwonlyargs=[],
kw_defaults=[],
kwarg=None,
defaults=[]),
body=[ast.Pass()],
decorator_list=[],
returns=None),
ast.FunctionDef(name='func_without_args',
args=ast.arguments(args=[],
vararg=None,
kwonlyargs=[],
kw_defaults=[],
kwarg=None,
defaults=[]),
body=[ast.Expr(value=ast.Str(s='Func docstrings')),
ast.Pass()],
decorator_list=[ast.Name(id='staticmethod',
ctx=ast.Load())],
returns=None),
ast.FunctionDef(name='func_with_args',
args=ast.arguments(args=[ast.arg(arg='self',
annotation=None),
ast.arg(arg='a', annotation=None),
ast.arg(arg='b', annotation=None),
ast.arg(arg='c', annotation=None)],
kwonlyargs=[],
kw_defaults=[],
kwarg=None,
defaults=[]),
body=[ast.Pass()],
decorator_list=[],
returns=None)],
decorator_list=[])
self.class_lister = Class_Visitor()
self.class_lister.visit(class_node)
def _create_type(self, name, base, fields):
stub = ast.ClassDef(
name=name,
bases=[ast.Name(base, ast.Load())],
keywords=[],
body=fields,
decorator_list=[],
)
self._add_stub(name, stub)
def visit_ClassDef(self, node):
bases = [py_ast.Name(i) for i in node.bases]
return py_ast.ClassDef(
name=node.name,
bases=[],
keywords=[],
body=wrapNodes([self.visit(i) for i in node.body]),
decorator_list=[],
)
def class_def(name, bases, body, decorators, keywords=None):
"""Create ClassDef Node on both python 2 and 3"""
keywords = keywords or []
constructor = [name, bases]
if sys.version_info > (3, 0):
constructor.append(keywords)
constructor.append(body)
constructor.append(decorators)
return ast.ClassDef(*constructor)
def __call__(self, *body):
return ast.ClassDef(name=self.name,
bases=list(self.bases),
keywords=[
ast.keyword(arg=arg, value=to_node(value))
for arg, value in self.keywords.items()
],
body=to_list(body),
decorator_list=[])
def 类定义(名称, 各基准类, 主体, 片段):
return ast.ClassDef(name=名称,
bases=各基准类,
keywords=[],
body=主体,
decorator_list=[],
starargs=None,
kwargs=None,
lineno=语法树.取行号(片段),
col_offset=语法树.取列号(片段))
def visit_ClassDef(self, node):
new_node = ast.ClassDef(
self._visit(node.name),
self._visit(node.bases),
self._visit(node.body),
self._visit(node.decorator_list),
)
ast.copy_location(new_node, node)
return new_node
def gen_classdef(self):
return ast.ClassDef(
name='TestAPIRequests',
bases=[],
body=[self.gen_test_method()],
keywords=[],
starargs=None,
kwargs=None,
decorator_list=[],
)
def cls(bases=None, keywords=None, body=None, decorator_list=None):
if bases is None:
bases = []
if keywords is None:
keywords = []
if body is None:
body = [ast.Pass()]
if decorator_list is None:
decorator_list = []
return ast.ClassDef("myclass", bases, keywords,
body, decorator_list, None)
def __init__(self, compiled_proto_path, class_name):
self.module = ast.Module(body=[
ast.Import(
names=[ast.alias(name=compiled_proto_path, asname=class_name)
]),
ast.Import(names=[ast.alias(name='asyncio', asname=None)])
])
self.root_class = ast.ClassDef(name=class_name,
body=[],
bases=[],
decorator_list=[])
