def __init__(self) -> None: # note: this is a regular dict, but ordered on Python 3.6 # we use this alias to signify it must be ordered. self._buffers = OrderedDict() # getmany calls next(_TopicBuffer), and does not call iter(), # so the first call to next caches an iterator. self._it = None
def __init__(self, app: AppT, **kwargs: Any) -> None: self.app = app self.data = OrderedDict() self._by_topic = defaultdict(WeakSet) self._agents_started = Event() Service.__init__(self, **kwargs)
def _BUILD_init(cls) -> Callable[[], None]: # generate init function that set field values from arguments, # and that load data from serialized form. # # # The general template that we will be generating is # # def __outer__(Model): # create __init__ closure # __defaults__ = Model._options.defaults # __descr__ = Model._options.descriptors # {% for field in fields_with_defaults %} # _default_{{ field }}_ = __defaults__["{{ field }}"] # {% endfor %} # {% for field in fields_with_init %} # _init_{{ field }}_ = __descr__["{{ field }}"].to_python # # def __init__(self, {{ sig }}, *, __strict__=True, **kwargs): # self.__evaluated_fields__ = set() # if __strict__: # creating model from Python # {% for field in fields %} # self.{{ field }} = {{ field }} # {% endfor %} # if kwargs: # # raise error for additional arguments # else: # {% for field in fields %} # {% if OPTIONAL_FIELD(field) %} # if {{ field }} is not None: # self.{{ field }} = _init_{{ field }}({{ field }}) # else: # self.{{ field }} = _default_{{ field }} # {% else %} # self.{{ field }} = _init_{{ field }}({{ field }} # # any additional kwargs are added as fields # # when loading from serialized data. # self.__dict__.update(kwargs) # self.__post_init__() # return __init__ # options = cls._options field_positions = options.fieldpos optional = options.optionalset needs_validation = options.validation descriptors = options.descriptors has_post_init = hasattr(cls, '__post_init__') closures: Dict[str, str] = { '__defaults__': 'Model._options.defaults', '__descr__': 'Model._options.descriptors', } kwonlyargs = ['*', '__strict__=True', '__faust=None', '**kwargs'] # these are sets, but we care about order as we will # be generating signature arguments in the correct order. # # The order is decided by the order of fields in the class): # # class Foo(Record): # c: int # a: int # # becomes: # # def __init__(self, c, a): # self.c = c # self.a = a optional_fields: Dict[str, bool] = OrderedDict() required_fields: Dict[str, bool] = OrderedDict() def generate_setter(field: str, getval: str) -> str: """Generate code that sets attribute for field in class. Arguments: field: Name of field. getval: Source code that initializes value for field, can be the field name itself for no initialization or for example: ``f"self._prepare_value({field})"``. out: Destination list where new source code lines are added. """ if field in optional: optional_fields[field] = True default_var = f'_default_{field}_' closures[default_var] = f'__defaults__["{field}"]' return (f' self.{field} = {getval} ' f'if {field} is not None else {default_var}') else: required_fields[field] = True return f' self.{field} = {getval}' def generate_prepare_value(field: str) -> str: descriptor = descriptors[field] if descriptor.lazy_coercion: return field # no initialization else: # call descriptor.to_python init_field_var = f'_init_{field}_' closures[init_field_var] = f'__descr__["{field}"].to_python' return f'{init_field_var}({field})' preamble = [ 'self.__evaluated_fields__ = set()', ] data_setters = ['if __strict__:'] + [ generate_setter(field, field) for field in field_positions.values() ] data_rest = [ ' if kwargs:', ' from mode.utils.text import pluralize', ' message = "{} got unexpected {}: {}".format(', ' self.__class__.__name__,', ' pluralize(kwargs.__len__(), "argument"),', ' ", ".join(map(str, sorted(kwargs))))', ' raise TypeError(message)', ] init_setters = ['else:'] if field_positions: init_setters.extend( generate_setter(field, generate_prepare_value(field)) for field in field_positions.values() ) init_setters.append(' self.__dict__.update(kwargs)') postamble = [] if has_post_init: postamble.append('self.__post_init__()') if needs_validation: postamble.append('self.validate_or_raise()') signature = list(chain( ['self'], [f'{field}' for field in required_fields], [f'{field}=None' for field in optional_fields], kwonlyargs, )) sourcecode = codegen.build_closure_source( name='__init__', args=signature, body=list(chain( preamble, data_setters, data_rest, init_setters, postamble, )), closures=closures, outer_args=['Model'], ) # TIP final sourcecode also available # as .__sourcecode__ on returned method # (print(Model.__init__.__sourcecode__) return codegen.build_closure( '__outer__', sourcecode, cls, globals={}, locals={}, )
def __init__(self, app: AppT, **kwargs: Any) -> None: self.app = app self.data = OrderedDict() self._by_topic = defaultdict(WeakSet)