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=[])