def _make_from_pb_fn(fields: List[Field]): globals = {'MISSING': MISSING, '_HAS_DEFAULT_FACTORY': _HAS_DEFAULT_FACTORY} locals = {f'_type_{f.name}': f.type for f in fields} globals.update({f'_pb_type_{f.name}': f.default_factory for f in fields if f.default_factory != MISSING}) body_lines = [] for field in fields: field_type_name = getattr(field.type, "_name", None) if field_type_name == "List": if field.default_factory != MISSING: body_lines.append( "{}=[_pb_type_{}.from_pb(_pb) for _pb in {}.{}],".format(field.name, field.name, _PB_PARAM, field.name)) else: body_lines.append("{}=[i for i in {}.{}],".format(field.name, _PB_PARAM, field.name)) elif getattr(field.type, _FROM_PB, None): if field.default_factory == MISSING: raise ValueError("from pb class must provide a default factory") else: body_lines.append( "{}=_pb_type_{}.from_pb({}.{}),".format(field.name, field.name, _PB_PARAM, field.name)) else: body_lines.append("{}={}.{},".format(field.name, _PB_PARAM, field.name)) body_lines.insert(0, "return cls(") body_lines.append(")") return _create_fn("from_pb", ["cls", _PB_PARAM], body_lines, globals=globals, locals=locals)
def dataclasses_init_fn_with_kwargs(fields, frozen, has_post_init, self_name, globals): # fields contains both real fields and InitVar pseudo-fields. # Make sure we don't have fields without defaults following fields # with defaults. This actually would be caught when exec-ing the # function source code, but catching it here gives a better error # message, and future-proofs us in case we build up the function # using ast. seen_default = False for f in fields: # Only consider fields in the __init__ call. if f.init: if not (f.default is MISSING and f.default_factory is MISSING): seen_default = True elif seen_default: raise TypeError(f'non-default argument {f.name!r} ' 'follows default argument') locals = {f'_type_{f.name}': f.type for f in fields} locals.update({ 'MISSING': MISSING, '_HAS_DEFAULT_FACTORY': _HAS_DEFAULT_FACTORY, }) body_lines = [] for f in fields: line = _field_init(f, frozen, locals, self_name) # line is None means that this field doesn't require # initialization (it's a pseudo-field). Just skip it. if line: body_lines.append(line) # Does this class have a post-init function? if has_post_init: params_str = ','.join(f.name for f in fields if f._field_type is _FIELD_INITVAR) body_lines.append( f'{self_name}.{_POST_INIT_NAME}({params_str}{", " if params_str else ""} **kwargs)' ) # If no body lines, use 'pass'. if not body_lines: body_lines = ['pass'] return _create_fn('__init__', [self_name] + [_init_param(f) for f in fields if f.init] + ["**kwargs"], body_lines, locals=locals, globals=globals, return_type=None)
def __add_serialize(cls: type, model: bool, enforced_serializable: list, skip_fields: list) -> object: """ Adds __serialize__ method. Args: cls: class to enchant Returns (object): __serialize__ method body """ fields_to_serialize = list( filter(lambda el: el.name not in skip_fields, fields(cls))) sonosco_self = '__sonosco_self__' if 'self' in fields_to_serialize else 'self' serialize_body = __create_serialize_body(fields_to_serialize, model, enforced_serializable) return _create_fn('__serialize__', [sonosco_self], serialize_body, return_type=dict)
def update_event(self, inp=-1): self.set_output_val( 0, dataclasses._create_fn(self.input(0), self.input(1), self.input(2)))