def get_cls_attrs(self, cls): attr = DefaultAttrDict([(k, getattr(cls.Attributes, k)) for k in dir(cls.Attributes) if not k.startswith('__')]) if cls.Attributes.prot_attrs: attr.update(cls.Attributes.prot_attrs.get(self.__class__, {})) attr.update(cls.Attributes.prot_attrs.get(self, {})) return attr
def get_cls_attrs(self, cls): attr = self._attrcache.get(cls, None) if attr is not None: return attr self._attrcache[cls] = attr = DefaultAttrDict([ (k, getattr(cls.Attributes, k)) for k in dir(cls.Attributes) + META_ATTR if not k.startswith('__')]) if cls.Attributes.prot_attrs: cls_attrs = cls.Attributes.prot_attrs.get(self.__class__, {}) # logger.debug("%r cls attr %r", cls, cls_attrs) attr.update(cls_attrs) inst_attrs = cls.Attributes.prot_attrs.get(self, {}) # logger.debug("%r inst attr %r", cls, cls_attrs) attr.update(inst_attrs) return attr
def __init__(self, function, in_message, out_message, doc, is_callback, is_async, mtom, in_header, out_header, faults, parent_class, port_type, no_ctx, udd, class_key, aux, patterns, body_style, args, operation_name, no_self, translations, when, static_when, service_class, href, internal_key_suffix, default_on_null, event_managers, logged): self.__real_function = function """The original callable for the user code.""" self.reset_function() self.operation_name = operation_name """The base name of an operation without the request suffix, as generated by the ``@srpc`` decorator.""" self.internal_key_suffix = internal_key_suffix """A string that is appended to the internal key string. Helpful when generating services programmatically.""" self.in_message = in_message """A :class:`spyne.model.complex.ComplexModel` subclass that defines the input signature of the user function and that was automatically generated by the ``@srpc`` decorator.""" self.name = None """The public name of the function. Equals to the type_name of the in_message.""" if body_style is BODY_STYLE_BARE: self.name = in_message.Attributes.sub_name if self.name is None: self.name = self.in_message.get_type_name() self.out_message = out_message """A :class:`spyne.model.complex.ComplexModel` subclass that defines the output signature of the user function and that was automatically generated by the ``@srpc`` decorator.""" self.doc = doc """The function docstring.""" # these are not working, so they are not documented. self.is_callback = is_callback self.is_async = is_async self.mtom = mtom #"""Flag to indicate whether to use MTOM transport with SOAP.""" self.port_type = port_type #"""The portType this function belongs to.""" self.in_header = in_header """An iterable of :class:`spyne.model.complex.ComplexModel` subclasses to denote the types of header objects that this method can accept.""" self.out_header = out_header """An iterable of :class:`spyne.model.complex.ComplexModel` subclasses to denote the types of header objects that this method can emit along with its return value.""" self.faults = faults """An iterable of :class:`spyne.model.fault.Fault` subclasses to denote the types of exceptions that this method can throw.""" self.no_ctx = no_ctx """no_ctx: Boolean flag to denote whether the user code gets an implicit :class:`spyne.MethodContext` instance as first argument.""" self.udd = DefaultAttrDict(**udd) """Short for "User Defined Data", this is an empty DefaultAttrDict that can be updated by the user to pass arbitrary metadata via the ``@rpc`` decorator.""" self.class_key = class_key """ The identifier of this method in its parent :class:`spyne.service.Service` subclass.""" self.aux = aux """Value to indicate what kind of auxiliary method this is. (None means primary) Primary methods block the request as long as they're running. Their return values are returned to the client. Auxiliary ones execute asyncronously after the primary method returns, and their return values are ignored by the rpc layer. """ self.patterns = patterns """This list stores patterns which will match this callable using various elements of the request protocol. Currently, the only object supported here is the :class:`spyne.protocol.http.HttpPattern` object. """ self.body_style = body_style """One of (BODY_STYLE_EMPTY, BODY_STYLE_BARE, BODY_STYLE_WRAPPED).""" self.args = args """A sequence of the names of the exposed arguments, or None.""" self.no_self = no_self """When False, this passes self as first argument (before ctx) to the decorated function. This is what separates ``@rpc`` and ``@mrpc``.""" self.service_class = service_class """The Service subclass the method belongs to. If not None for ``@mrpc`` methods, a Service subclass for anything else.""" self.parent_class = parent_class """The ComplexModel subclass the method belongs to. Only set for ``@mrpc`` methods.""" self.default_on_null = default_on_null if parent_class is None and not (default_on_null is False): raise LogicError("default_on_null is only to be used inside @mrpc") # HATEOAS Stuff self.translations = translations """None or a dict of locale-translation pairs.""" self.href = href """None or a dict of locale-translation pairs.""" self.when = when """None or a callable that takes an object instance and a :class:`MethodContext` and returns a boolean value. If this callable returns ``True``, the object can process that action. """ self.static_when = static_when """None or a callable that takes an :class:`Application` instance and returns a boolean value. If true, the object can have that action registered in the interface document. """ self.event_managers = event_managers """Event managers registered with this method.""" self.logged = logged """Denotes the logging style for this method.""" if self.service_class is not None: self.event_managers.append(self.service_class.event_manager)