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
