def _persistent_id(obj): if isinstance(obj, PersistentObject): return "instance: %s %s" % (get_full_name(type(obj)), str(obj.id)) if isinstance(obj, Member) and obj.schema: return "member: %s.%s" % (get_full_name(obj.schema), obj.name) return None
def decorator(func): try: class_name = get_full_name(cls) except: class_name = cls.__name__ self.definitions[class_name + ".instance"] = func return func
def model(self): source_instance = self.source_instance if source_instance is not None \ and isinstance(source_instance, schema.SchemaObject): return source_instance.__class__ return schema.Schema(get_full_name(self.__class__))
def get_schema_aliases(self): if not self.controller: return [] return [ get_full_name(cls) + "." + self.__class__.__name__ for cls in self.controller.__class__.__mro__ if cls is not FormProcessor and issubclass(cls, FormProcessor) ]
def translate_member(member, suffix="", qualified=False, include_type_default=True, **kwargs): if qualified: return translations("cocktail.schema.qualified_member", member=member) if suffix is None: suffix = "" if member.custom_translation_key: translation = translations(member.custom_translation_key + suffix, member=member, **kwargs) if translation: return translation if member.schema: if member.name: schema_name = getattr(member.schema, "full_name", member.schema.name) if schema_name: key = (schema_name + ".members." + member.name + suffix) translation = translations(key, member=member, **kwargs) if translation: return translation for schema_alias in member.schema.schema_aliases: key = (schema_alias + ".members." + member.name + suffix) translation = translations(key, member=member, **kwargs) if translation: return translation if member.source_member: translation = translations(member.source_member, suffix=suffix, include_type_default=False, **kwargs) if translation: return translation if include_type_default: for member_type in member.__class__.__mro__: if issubclass(member_type, Member): translation = translations(get_full_name(member_type) + ".default_member_translation" + suffix, member=member, **kwargs) if translation: return translation return None
def __init__(cls, name, bases, members): cls._declared = False type.__init__(cls, name, bases, members) Schema.__init__(cls) cls.name = name cls.full_name = members.get("full_name") or get_full_name(cls) cls.__derived_schemas = [] cls.members_order = members.get("members_order") # Give each class its own groups_order property groups_order = members.get("groups_order") if groups_order is None: groups_order = cls.groups_order groups_order = list(groups_order) if groups_order else [] cls.groups_order = groups_order # Inherit base schemas for base in bases: if SchemaObject \ and base is not SchemaObject \ and isinstance(base, SchemaClass): cls.inherit(base) # Create a translation schema for the class, to hold its translated # members. Note that for most regular schemas (that is, all of them # except for SchemaObject, PersistentObject, etc) the translation # schema is always created, regardless of wether the source schema # actually contains any translated member at all. This ensures that # adding translated members to a base class won't break its inheritors, # whose translation schemas would be inheriting from the wrong schema. if members.get("_generates_translation_schema", True): cls._create_translation_schema({}) # Fill the schema with members declared as class attributes for name, member in members.items(): if isinstance(member, Member) \ and not isinstance(member, SchemaClass): member.name = name cls.add_member(member) register_schema(cls, cls.full_name) cls._declared = True if cls.translation: cls.translation._declared = True cls.declared() if cls.translation_source is None: bundle_path = cls.full_name.rsplit(".", 1)[0] translations.request_bundle(bundle_path)
def __iter_class_names(self, cls): mro = getattr(cls, "__mro__", None) if mro is None: mro = (cls, ) for cls in mro: try: class_name = get_full_name(cls) except: class_name = cls.__name__ yield class_name
def process_items_after_commit(self, callback, item, item_data=None, mapping_type=dict): id = get_full_name(callback) items_key = id + ".items" items = self.get_transaction_value(items_key) if items is None: items = mapping_type() self.set_transaction_value(items_key, items) items[item] = item_data self.unique_after_commit_hook(id, callback, items)
def translate_grouping_value(self, value, language=None, **kwargs): if value is not None: for cls in self.__class__.__mro__: translation = translations(get_full_name(cls) + ".value", language, grouping=self, value=value, **kwargs) if translation: return translation if cls is MemberGrouping: break return translations(value, language, **kwargs)
def translate_schema(schema, suffix=None, include_type_default=True, **kwargs): if suffix is None: suffix = "" schema_name = getattr(schema, "full_name", schema.name) if schema_name: translation = translations(schema_name + suffix, member=schema, **kwargs) if translation: return translation for schema_alias in schema.schema_aliases: translation = translations(schema_alias + suffix, member=schema, **kwargs) if translation: return translation if schema.source_member: translation = translations(schema.source_member, suffix=suffix, include_type_default=False, **kwargs) if translation: return translation if schema.custom_translation_key: translation = translations(schema.custom_translation_key + suffix, member=schema, **kwargs) if translation: return translation if include_type_default: for member_type in schema.__class__.__mro__: if issubclass(member_type, Member): translation = translations(get_full_name(member_type) + ".default_member_translation" + suffix, member=schema, **kwargs) if translation: return translation return None
def translate_grouping_variant(cls, variant, language=None): if not variant: variant = "default" for grouping_class in cls.__mro__: variant_translation = translations( get_full_name(grouping_class) + ".%s_variant" % variant, language) if variant_translation: return variant_translation if cls is MemberGrouping: break return ""
def translate_error(self, error, language=None, **kwargs): for error_class in error.__class__.__mro__: try: error_class_name = get_full_name(error.__class__) except Exception as ex: error_class_name = error.__class__.__name__ error_translation = translations(self, suffix=".errors." + error_class_name, error=error, language=language) if error_translation: return error_translation # No custom translation for the error, return the stock description return translations(error, language=language, **kwargs)
def export_value(self, value): if isinstance(value, Item): return value.global_id elif isinstance(value, datetime.datetime): return value.strftime(self.datetime_format) elif isinstance(value, datetime.date): return value.strftime(self.date_format) elif isinstance(value, datetime.time): return value.strftime(self.time_format) elif isinstance(value, Decimal): return str(value) elif isinstance(value, Fraction): return str(value) elif isinstance(value, tuple): return [self.export_value(item) for item in value] elif isinstance(value, (ListWrapper, SetWrapper, DictWrapper)): return self.export_value(value._items) elif isinstance(value, RegExp): return base64.b64encode(value.pattern) elif isinstance(value, schema.SchemaClass): return get_full_name(value) else: return value
def handle_request(self): # Set the starting MIME type for the response (handlers may change it # uppon invocation) response_type = self.choose_response_type() if response_type: cherrypy.response.headers["Content-Type"] = response_type # Handle CORS if self.should_handle_cors(): self.handle_cors() # Fire the 'before_reading_input' event for handler in self.iter_handlers_from_root(): handler.before_reading_input(handler=self) # Assign arguments in the path args = getattr(cherrypy.request, "arguments", None) self.arguments = args if args else {} # Process query string parameters if self.parameters: # Collect values from the query string, applying the proper # deserialization procedure (see cocktail.controllers.parameters) self.values = {} for parameter in self.parameters: try: value = cherrypy.request.params[parameter.name] except KeyError: value = parameter.produce_default() else: try: value = parameter.parse(value) except ValueError: pass if self.parameter_coercion is not Coercion.FAIL: value = parameter.coerce( value, self.parameter_coercion, **self.parameter_validation_options ) self.values[parameter.name] = value # If parameter coercion was set to FAIL, apply the delayed # validation now that all parameters have been collected if self.parameter_coercion is Coercion.FAIL: parameters_schema = Schema( name = get_full_name(self.__node.__class__) + "." + self.method_name, members=self.parameters ) parameters_schema.coerce( self.values, Coercion.FAIL, **self.parameter_validation_options ) # Process the request body if self.request_body: self.data = self.request_body.process() # Fire the 'responding' event for handler in self.iter_handlers_from_root(): handler.responding(handler=self) # Invoke the method's logic response_data = self.respond() # Automatically format responses (ie. JSON and YAML) if self.format_response: response_data = format_response(response_data) # Automatically encode unicode responses if self.response_encoding and isinstance(response_data, str): response_data = response_data.encode(self.response_encoding) return response_data
def __init_subclass__(cls, **kwargs): super().__init_subclass__(**kwargs) cls.full_name = get_full_name(cls) translations.request_bundle(cls.full_name.rsplit(".", 1)[0])
def _get_schema(name): for schema in PersistentObject.derived_schemas(): if name == get_full_name(schema): return schema
def get_schema_name(self): if self.controller: return (get_full_name(self.controller.__class__) + "." + self.__class__.__name__) else: return get_full_name(self.__class__)
def view_name(cls): if cls._view_name is None: cls._view_name = get_view_full_name(get_full_name(cls)) return cls._view_name