signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def __set__(self, model_instance, value):
|
value = self.validate(value)<EOL>if value is not None:<EOL><INDENT>if not isinstance(value, Model):<EOL><INDENT>setattr(model_instance, self._attr_name(), value)<EOL>setattr(model_instance, self._resolved_attr_name(), None)<EOL><DEDENT>else:<EOL><INDENT>setattr(model_instance, self._attr_name(), getattr(value, self.reference_fieldname))<EOL>setattr(model_instance, self._resolved_attr_name(), value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>setattr(model_instance, self._attr_name(), None)<EOL>setattr(model_instance, self._resolved_attr_name(), None)<EOL><DEDENT>
|
Set reference.
|
f5808:c45:m6
|
def validate(self, value):
|
if value == '<STR_LIT>':<EOL><INDENT>if self.kwargs.get('<STR_LIT>', __nullable__):<EOL><INDENT>value = None<EOL><DEDENT>else:<EOL><INDENT>value = <NUM_LIT:0><EOL><DEDENT><DEDENT>if not isinstance(value, Model):<EOL><INDENT>return super(ReferenceProperty, self).validate(value)<EOL><DEDENT>if not value.is_saved():<EOL><INDENT>raise BadValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % self.reference_class.__class__.__name__)<EOL><DEDENT>if not isinstance(value, self.reference_class):<EOL><INDENT>raise KindError('<STR_LIT>' %<EOL>(self.name, self.reference_class.__class__.__name__))<EOL><DEDENT>return value<EOL>
|
Validate reference.
Returns:
A valid value.
Raises:
BadValueError for the following reasons:
- Value is not saved.
- Object not of correct model type for reference.
|
f5808:c45:m7
|
def _id_attr_name(self):
|
return self.reference_fieldname<EOL>
|
Get attribute of referenced id.
|
f5808:c45:m8
|
def _resolved_attr_name(self):
|
return '<STR_LIT>' + self._attr_name()<EOL>
|
Get attribute of resolved attribute.
The resolved attribute is where the actual loaded reference instance is
stored on the referring model instance.
Returns:
Attribute name of where to store resolved reference model instance.
|
f5808:c45:m9
|
def __property_config__(self, model_class, property_name):
|
<EOL>super(ReferenceProperty, self).__property_config__(model_class, property_name)<EOL>if not (<EOL>(isinstance(self.reference_class, type) and issubclass(self.reference_class, Model)) or<EOL>self.reference_class is _SELF_REFERENCE or<EOL>valid_model(self.reference_class, self.engine_name)):<EOL><INDENT>raise KindError('<STR_LIT>' % self.reference_class)<EOL><DEDENT>if self.reference_class is _SELF_REFERENCE:<EOL><INDENT>self.reference_class = self.data_type = model_class<EOL><DEDENT>else:<EOL><INDENT>self.reference_class = get_model(self.reference_class, self.engine_name,<EOL>signal=False)<EOL><DEDENT>self.reference_fieldname = self.reference_fieldname or self.reference_class._primary_field<EOL>self.collection_name = self._collection_name<EOL>if self.collection_name is None:<EOL><INDENT>self.collection_name = '<STR_LIT:%s>' % (model_class.tablename)<EOL><DEDENT>setattr(self.reference_class, self.collection_name,<EOL>_OneToOneReverseReferenceProperty(model_class, property_name,<EOL>self._id_attr_name(), self.collection_name))<EOL>self.reference_class._onetoone[self.collection_name] = model_class<EOL>
|
Loads all of the references that point to this model.
|
f5808:c46:m1
|
def get_fields(self):
|
columns = self.columns<EOL>model = self.model<EOL>fields = []<EOL>for col in columns:<EOL><INDENT>if isinstance(col, str):<EOL><INDENT>v = col.split('<STR_LIT:.>')<EOL>if len(v) > <NUM_LIT:1>:<EOL><INDENT>field = get_model(v[<NUM_LIT:0>], engine_name=self.model.get_engine_name(),<EOL>signal=False).properties(v[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>field = model.properties[col]<EOL><DEDENT><DEDENT>elif isinstance(col, Column):<EOL><INDENT>field = get_model(col.table.name, engine_name=self.model.get_engine_name(),<EOL>signal=False).properties[col.name]<EOL><DEDENT>else:<EOL><INDENT>field = col<EOL><DEDENT>fields.append(field)<EOL><DEDENT>return fields<EOL>
|
get property instance according self.columns
|
f5808:c47:m4
|
def empty(self):
|
return self.filter(false())<EOL>
|
return empty query set
|
f5808:c47:m7
|
def count(self):
|
if self._group_by or self._join or self.distinct_field:<EOL><INDENT>return self.do_(self.get_query().limit(None).order_by(None).offset(None).alias().count()).scalar()<EOL><DEDENT>else:<EOL><INDENT>return self.do_(self.get_query().with_only_columns([func.count()]).limit(None).order_by(None).offset(None)).scalar()<EOL><DEDENT>
|
If result is True, then the count will process result set , if
result if False, then only use condition to count
|
f5808:c47:m10
|
def filter(self, *condition):
|
if not condition:<EOL><INDENT>return self<EOL><DEDENT>cond = true()<EOL>for c in condition:<EOL><INDENT>if c is not None:<EOL><INDENT>if isinstance(c, str):<EOL><INDENT>c = text(c)<EOL><DEDENT>cond = and_(c, cond)<EOL><DEDENT><DEDENT>if self.condition is not None:<EOL><INDENT>self.condition = and_(cond, self.condition)<EOL><DEDENT>else:<EOL><INDENT>self.condition = cond<EOL><DEDENT>return self<EOL>
|
If there are multple condition, then treats them *and* relastion.
|
f5808:c47:m12
|
def distinct(self, field=None):
|
if field is None:<EOL><INDENT>self.funcs.append(('<STR_LIT>', (), {}))<EOL><DEDENT>else:<EOL><INDENT>self.distinct_field = field<EOL><DEDENT>return self<EOL>
|
If field is None, then it means that it'll create:
select distinct *
and if field is not None, for example: 'name', it'll create:
select distinc(name),
|
f5808:c47:m19
|
def update(self, **kwargs):
|
if self.condition is not None:<EOL><INDENT>self.result = self.do_(self.model.table.update().where(self.condition).values(**kwargs))<EOL><DEDENT>else:<EOL><INDENT>self.result = self.do_(self.model.table.update().values(**kwargs))<EOL><DEDENT>return self.result<EOL>
|
Execute update table set field = field+1 like statement
|
f5808:c47:m22
|
def save_file(self, filename, encoding='<STR_LIT:utf8>', headers=None,<EOL>convertors=None, display=True, **kwargs):
|
global save_file<EOL>convertors = convertors or {}<EOL>headers = headers or []<EOL>fields = self.get_fields()<EOL>_header = []<EOL>for i, column in enumerate(fields):<EOL><INDENT>if column.name not in convertors:<EOL><INDENT>if display:<EOL><INDENT>def f(value, data):<EOL><INDENT>return column.get_display_value(value)<EOL><DEDENT>convertors[column.name] = f<EOL><DEDENT><DEDENT>flag = False<EOL>for j in headers:<EOL><INDENT>if not isinstance(j, dict):<EOL><INDENT>raise ValueError("<STR_LIT>".format(type(j)))<EOL><DEDENT>if j['<STR_LIT:name>'] == column.name:<EOL><INDENT>_header.append(j)<EOL>flag = True<EOL>break<EOL><DEDENT><DEDENT>if not flag:<EOL><INDENT>d = {'<STR_LIT:name>':column.name}<EOL>if display:<EOL><INDENT>d['<STR_LIT:title>'] = column.verbose_name or column.name<EOL><DEDENT>else:<EOL><INDENT>d['<STR_LIT:title>'] = column.name<EOL><DEDENT>_header.append(d)<EOL><DEDENT><DEDENT>return save_file(self.run(), filename, encoding=encoding,<EOL>headers=_header, convertors=convertors, **kwargs)<EOL>
|
save result to a csv file.
display = True will convert value according choices value
|
f5808:c47:m25
|
def for_update(self, flag=True):
|
self.kwargs['<STR_LIT>'] = flag<EOL>return self<EOL>
|
please see http://docs.sqlalchemy.org/en/latest/core/expression_api.html search for update
|
f5808:c47:m29
|
def clear(self, *objs):
|
if objs:<EOL><INDENT>keys = get_objs_columns(objs)<EOL>self.do_(self.model.table.delete(self.condition & self.model.table.c[self.model._primary_field].in_(keys)))<EOL><DEDENT>else:<EOL><INDENT>self.do_(self.model.table.delete(self.condition))<EOL><DEDENT>
|
Clear the third relationship table, but not the ModelA or ModelB
|
f5808:c48:m4
|
def __init__(self, modela, instance, property_name, modelb, <EOL>table, fielda, fieldb, realfielda, realfieldb, valuea,<EOL>before_save=None,<EOL>default_condition=None,<EOL>through_model=None):
|
self.modela = modela<EOL>self.instance = instance<EOL>self.property_name = property_name<EOL>self.modelb = modelb<EOL>self.table = table <EOL>self.fielda = fielda<EOL>self.fieldb = fieldb<EOL>self.realfielda = realfielda<EOL>self.realfieldb = realfieldb<EOL>self.valuea = valuea<EOL>self.columns = list(self.modelb.table.c)<EOL>self.condition = '<STR_LIT>'<EOL>self.funcs = []<EOL>self.result = None<EOL>self.with_relation_name = None<EOL>self.through_model = through_model<EOL>self.default_query_flag = True<EOL>self._group_by = None<EOL>self._having = None<EOL>self._join = []<EOL>self._limit = None<EOL>self._offset = None<EOL>self.distinct_field = None<EOL>self._values_flag = False<EOL>self.connection = self.modela.get_session()<EOL>self.before_save = before_save<EOL>self.default_condition = default_condition<EOL>self.kwargs = {}<EOL>
|
modela will define property_name = ManyToMany(modelb) relationship.
instance will be modela instance
|
f5808:c49:m0
|
def all(self, cache=False):
|
if cache:<EOL><INDENT>return [get_object(self.modelb, obj_id, cache=True, use_local=True) for obj_id in self.keys(True)]<EOL><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT>
|
can use cache to return objects
|
f5808:c49:m1
|
def update(self, *objs):
|
keys = list(self.keys())<EOL>new_keys = get_objs_columns(objs, self.realfieldb)<EOL>modified = False<EOL>for v in new_keys:<EOL><INDENT>if v in keys: <EOL><INDENT>keys.remove(v)<EOL><DEDENT>else:<EOL><INDENT>d = {self.fielda:self.valuea, self.fieldb:v}<EOL>if self.before_save:<EOL><INDENT>self.before_save(d)<EOL><DEDENT>if self.through_model:<EOL><INDENT>obj = self.through_model(**d)<EOL>obj.save()<EOL><DEDENT>else:<EOL><INDENT>self.do_(self.table.insert().values(**d))<EOL><DEDENT>modified = True<EOL><DEDENT><DEDENT>if keys: <EOL><INDENT>self.clear(*keys)<EOL>modified = True<EOL><DEDENT>setattr(self.instance, self.store_key, new_keys)<EOL>return modified<EOL>
|
Update the third relationship table, but not the ModelA or ModelB
|
f5808:c49:m8
|
def clear(self, *objs):
|
if objs:<EOL><INDENT>keys = get_objs_columns(objs, self.realfieldb)<EOL>self.do_(self.table.delete(self.get_default_condition() & (self.table.c[self.fieldb].in_(keys))))<EOL><DEDENT>else:<EOL><INDENT>self.do_(self.table.delete(self.get_default_condition()))<EOL><DEDENT>setattr(self.instance, self.store_key, Lazy)<EOL>
|
Clear the third relationship table, but not the ModelA or ModelB
|
f5808:c49:m9
|
def with_relation(self, relation_name=None):
|
if not relation_name:<EOL><INDENT>relation_name = '<STR_LIT>'<EOL><DEDENT>if hasattr(self.modelb, relation_name):<EOL><INDENT>raise Error("<STR_LIT>" % (relation_name, self.modelb.__name__))<EOL><DEDENT>if not self.through_model:<EOL><INDENT>raise Error("<STR_LIT>" % self.modelb.__name__)<EOL><DEDENT>self.with_relation_name = relation_name<EOL>return self<EOL>
|
if relation is not None, when fetch manytomany result, also
fetch relation record and saved them to manytomany object,
and named them as relation.
If relation_name is not given, then default value is 'relation'
|
f5808:c49:m16
|
def __init__(self, reference_class=None, label=None, collection_name=None,<EOL>reference_fieldname=None, reversed_fieldname=None, required=False, through=None, <EOL>through_reference_fieldname=None, through_reversed_fieldname=None,<EOL>before_save=None, default_condition=None,<EOL>**attrs):
|
super(ManyToMany, self).__init__(reference_class=reference_class,<EOL>label=label, collection_name=collection_name,<EOL>reference_fieldname=reference_fieldname, required=required, **attrs)<EOL>self.reversed_fieldname = reversed_fieldname<EOL>self.through = through<EOL>self.through_reference_fieldname = through_reference_fieldname<EOL>self.through_reversed_fieldname = through_reversed_fieldname<EOL>self.index_reverse = attrs['<STR_LIT>'] if '<STR_LIT>' in attrs else __manytomany_index_reverse__<EOL>self.before_save = before_save<EOL>self.default_condition = default_condition<EOL>
|
Definition of ManyToMany property
:param reference_fieldname: relative to field of B
:param reversed_fieldname: relative to field of A
:param through_reference_fieldname: through model relative to field of B
:param through_reversed_fieldname: throught model relative to field of A
:param index_reverse: create index reversed
|
f5808:c50:m0
|
def __property_config__(self, model_class, property_name):
|
<EOL>super(ReferenceProperty, self).__property_config__(model_class, property_name)<EOL>if not (<EOL>(isinstance(self.reference_class, type) and issubclass(self.reference_class, Model)) or<EOL>self.reference_class is _SELF_REFERENCE or<EOL>valid_model(self.reference_class, self.engine_name)):<EOL><INDENT>raise KindError('<STR_LIT>' % self.reference_class)<EOL><DEDENT>if self.reference_class is _SELF_REFERENCE or self.reference_class is None:<EOL><INDENT>self.reference_class = self.data_type = model_class<EOL><DEDENT>else:<EOL><INDENT>self.reference_class = get_model(self.reference_class, self.engine_name,<EOL>signal=False)<EOL><DEDENT>self.reference_fieldname = self.reference_fieldname or self.reference_class._primary_field<EOL>self.reversed_fieldname = self.reversed_fieldname or model_class._primary_field<EOL>self.tablename = '<STR_LIT>' % (model_class.tablename, self.reference_class.tablename, property_name)<EOL>self.collection_name = self.reference_class.get_collection_name(model_class.tablename, self._collection_name, model_class.tablename)<EOL>setattr(self.reference_class, self.collection_name,<EOL>_ManyToManyReverseReferenceProperty(self, self.collection_name))<EOL>
|
Loads all of the references that point to this model.
|
f5808:c50:m6
|
def __get__(self, model_instance, model_class):
|
self.init_through()<EOL>if model_instance:<EOL><INDENT>reference_id = getattr(model_instance, self.reversed_fieldname, None)<EOL>x = ManyResult(self.model_class, model_instance, self.property_name, self.reference_class, self.table,<EOL>self.fielda, self.fieldb, self.reversed_fieldname,<EOL>self.reference_fieldname, reference_id, through_model=self.through,<EOL>before_save=self.before_save, default_condition=self.default_condition)<EOL>return x<EOL><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT>
|
Get reference object.
This method will fetch unresolved entities from the datastore if
they are not already loaded.
Returns:
ReferenceProperty to Model object if property is set, else None.
|
f5808:c50:m8
|
def get_value_for_datastore(self, model_instance, cached=False):
|
value = getattr(model_instance, self._attr_name(), None)<EOL>if not cached:<EOL><INDENT>value = list(getattr(model_instance, self.property_name).keys())<EOL>setattr(model_instance, self._attr_name(), value)<EOL><DEDENT>return value<EOL>
|
Get key of reference rather than reference itself.
|
f5808:c50:m10
|
def in_(self, *objs):
|
if not objs:<EOL><INDENT>return self.table.c[self.fielda]!=self.table.c[self.fielda]<EOL><DEDENT>else:<EOL><INDENT>keys = get_objs_columns(objs, self.reference_fieldname)<EOL>sub_query = select([self.table.c[self.fielda]], (self.table.c[self.fieldb] == self.reference_class.c[self.reference_fieldname]) & (self.table.c[self.fieldb].in_(keys)))<EOL>condition = self.model_class.c[self.reversed_fieldname].in_(sub_query)<EOL>return condition<EOL><DEDENT>
|
Create a condition
|
f5808:c50:m12
|
def join_in(self, *objs):
|
if not objs:<EOL><INDENT>return self.table.c[self.fielda]!=self.table.c[self.fielda]<EOL><DEDENT>else:<EOL><INDENT>keys = get_objs_columns(objs, self.reference_fieldname)<EOL>return (self.table.c[self.fielda] == self.model_class.c[self.reversed_fieldname]) & (self.table.c[self.fieldb].in_(keys))<EOL><DEDENT>
|
Create a join condition, connect A and C
|
f5808:c50:m13
|
def join_right_in(self, *objs):
|
if not objs:<EOL><INDENT>return self.table.c[self.fielda]!=self.table.c[self.fielda]<EOL><DEDENT>else:<EOL><INDENT>keys = get_objs_columns(objs, self.reference_fieldname)<EOL>return (self.table.c[self.fieldb] == self.reference_class.c[self.reference_fieldname]) & (self.table.c[self.fielda].in_(keys))<EOL><DEDENT>
|
Create a join condition, connect B and C
|
f5808:c50:m14
|
def __init__(self, model, reference_id, reversed_id, collection_name):
|
self._model = model <EOL>self._reference_id = reference_id <EOL>self._reversed_id = reversed_id <EOL>self.verbose_name = '<STR_LIT>'<EOL>self.label = '<STR_LIT>'<EOL>self.name = collection_name<EOL>self._collection_name = collection_name<EOL>self.choices = None<EOL>
|
Constructor for reverse reference.
Constructor does not take standard values of other property types.
|
f5808:c51:m0
|
def __get__(self, model_instance, model_class):
|
if model_instance is not None: <EOL><INDENT>_id = getattr(model_instance, self._reversed_id, None)<EOL>if _id is not None:<EOL><INDENT>a_id = self._reference_id<EOL>a_field = self._model.c[self._reference_id]<EOL>return ReverseResult(self._model, a_field==_id, self._reference_id, model_class.table, model_instance, self._reversed_id)<EOL><DEDENT>else:<EOL><INDENT>return Result()<EOL>
|
Fetches collection of model instances of this collection property.
|
f5808:c51:m1
|
def __set__(self, model_instance, value):
|
raise BadValueError('<STR_LIT>')<EOL>
|
Not possible to set a new collection.
|
f5808:c51:m2
|
def get_value_for_datastore(self, model_instance, cached=False):
|
value = getattr(model_instance, self._attr_name(), None)<EOL>if not cached:<EOL><INDENT>value = list(getattr(model_instance, self._collection_name).keys())<EOL>setattr(model_instance, self._attr_name(), value)<EOL><DEDENT>return value<EOL>
|
Get key of reference rather than reference itself.
|
f5808:c51:m3
|
def __init__(self, model, reference_id, reversed_id, collection_name):
|
self._model = model<EOL>self._reference_id = reference_id <EOL>self._reversed_id = reversed_id <EOL>self._collection_name = collection_name<EOL>
|
Constructor for reverse reference.
Constructor does not take standard values of other property types.
|
f5808:c52:m0
|
def __get__(self, model_instance, model_class):
|
if model_instance:<EOL><INDENT>_id = getattr(model_instance, self._reversed_id, None)<EOL>if _id is not None:<EOL><INDENT>resolved = getattr(model_instance, self._resolved_attr_name(), None)<EOL>if resolved is not None:<EOL><INDENT>return resolved<EOL><DEDENT>else:<EOL><INDENT>b_id = self._reference_id<EOL>d = self._model.c[self._reference_id]<EOL>instance = self._model.get(d==_id)<EOL>if not instance:<EOL><INDENT>instance = self._model(**{b_id:_id})<EOL>instance.save()<EOL><DEDENT>setattr(model_instance, self._resolved_attr_name(), instance)<EOL>return instance<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT>
|
Fetches collection of model instances of this collection property.
|
f5808:c52:m1
|
def _resolved_attr_name(self):
|
return '<STR_LIT>' + self._collection_name<EOL>
|
Get attribute of resolved attribute.
The resolved attribute is where the actual loaded reference instance is
stored on the referring model instance.
Returns:
Attribute name of where to store resolved reference model instance.
|
f5808:c52:m2
|
def __init__(self, reference_property, collection_name):
|
self.reference_property = reference_property<EOL>self._collection_name = collection_name<EOL>
|
Constructor for reverse reference.
Constructor does not take standard values of other property types.
|
f5808:c53:m0
|
def __get__(self, model_instance, model_class):
|
self.reference_property.init_through()<EOL>self._reversed_id = self.reference_property.reference_fieldname<EOL>if model_instance:<EOL><INDENT>reference_id = getattr(model_instance, self._reversed_id, None)<EOL>x = ManyResult(self.reference_property.reference_class, model_instance,<EOL>self._collection_name,<EOL>self.reference_property.model_class, self.reference_property.table,<EOL>self.reference_property.fieldb, self.reference_property.fielda, <EOL>self.reference_property.reference_fieldname,<EOL>self.reference_property.reversed_fieldname, reference_id, <EOL>through_model=self.reference_property.through,<EOL>before_save=self.reference_property.before_save,<EOL>default_condition=self.reference_property.default_condition)<EOL>return x<EOL><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT>
|
Fetches collection of model instances of this collection property.
|
f5808:c53:m1
|
def to_display(self, fields=None, manytomany=False, dicttype=dict, prefix='<STR_LIT>'):
|
d = dicttype()<EOL>fields = fields or list(self.properties.keys())<EOL>for k in fields:<EOL><INDENT>v = self.properties.get(k)<EOL>if not v: continue<EOL>if prefix:<EOL><INDENT>field_name = prefix+k<EOL><DEDENT>else:<EOL><INDENT>field_name = k<EOL><DEDENT>if not isinstance(v, ManyToMany):<EOL><INDENT>field_value = getattr(self, k)<EOL>d[k] = v.get_value_for_datastore(self)<EOL>d[field_name] = self.get_display_value(k, field_value)<EOL><DEDENT>else:<EOL><INDENT>if manytomany:<EOL><INDENT>field_value = getattr(self, v._lazy_value(), [])<EOL>d[k] = getattr(self, v._lazy_value(), [])<EOL>d[field_name] = '<STR_LIT:U+002CU+0020>'.join([str(x) in field_value])<EOL><DEDENT><DEDENT><DEDENT>return d<EOL>
|
Create display dict for instance of Model
:param fields:
:param manytomany:
:param dicttype:
:param prefix: add prefix to fieldname, e.g.
prefix='dis_'
fieldname = 'name' will become 'dis_name'
:return:
|
f5808:c55:m2
|
def _get_data(self, fields=None, compare=True):
|
fields = fields or []<EOL>if self._key is None or self._key == '<STR_LIT>' or self._key == <NUM_LIT:0>:<EOL><INDENT>d = {}<EOL>for k, v in list(self.properties.items()):<EOL><INDENT>if fields and k not in fields:<EOL><INDENT>continue<EOL>
|
Get the changed property, it'll be used to save the object
If compare is False, then it'll include all data not only changed property
|
f5808:c55:m5
|
def save(self, insert=False, changed=None, saved=None,<EOL>send_dispatch=True, version=False, version_fieldname=None, <EOL>version_exception=True):
|
_saved = False<EOL>created = False<EOL>version_fieldname = version_fieldname or '<STR_LIT:version>'<EOL>d = self._get_data()<EOL>if d or not self._saved or insert:<EOL><INDENT>_id = d.get(self._primary_field, None)<EOL>if insert or not self._saved or not _id:<EOL><INDENT>created = True<EOL>old = d.copy()<EOL>if get_dispatch_send() and self.__dispatch_enabled__:<EOL><INDENT>dispatch.call(self.__class__, '<STR_LIT>', instance=self, created=True, data=d, old_data=self._old_values, signal=self.tablename)<EOL><DEDENT>_manytomany = {}<EOL>for k, v in list(self.properties.items()):<EOL><INDENT>if v.property_type == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(v, ManyToMany):<EOL><INDENT>if isinstance(v, DateTimeProperty) and v.auto_now_add and k not in d:<EOL><INDENT>d[k] = v.now()<EOL><DEDENT>elif (not k in d) and v.auto_add:<EOL><INDENT>d[k] = v.default_value()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if k in d:<EOL><INDENT>_manytomany[k] = d.pop(k)<EOL><DEDENT><DEDENT><DEDENT>if d:<EOL><INDENT>if callable(changed):<EOL><INDENT>changed(self, created, self._old_values, d)<EOL>old.update(d)<EOL><DEDENT>obj = do_(self.table.insert().values(**d), self.get_session())<EOL>_saved = True<EOL>if obj.inserted_primary_key and self._primary_field:<EOL><INDENT>setattr(self, self._primary_field, obj.inserted_primary_key[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>if _manytomany:<EOL><INDENT>for k, v in list(_manytomany.items()):<EOL><INDENT>if v:<EOL><INDENT>_saved = getattr(self, k).update(v) or _saved<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>_id = d.pop(self._primary_field)<EOL>if d:<EOL><INDENT>old = d.copy()<EOL>if get_dispatch_send() and self.__dispatch_enabled__:<EOL><INDENT>dispatch.call(self.__class__, '<STR_LIT>', instance=self, created=False, data=d, old_data=self._old_values, signal=self.tablename)<EOL><DEDENT>_manytomany = {}<EOL>for k, v in list(self.properties.items()):<EOL><INDENT>if v.property_type == '<STR_LIT>' or k == self._primary_field:<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(v, ManyToMany):<EOL><INDENT>if isinstance(v, DateTimeProperty) and v.auto_now and k not in d:<EOL><INDENT>d[k] = v.now()<EOL><DEDENT>elif (not k in d) and v.auto:<EOL><INDENT>d[k] = v.default_value()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if k in d:<EOL><INDENT>_manytomany[k] = d.pop(k)<EOL><DEDENT><DEDENT><DEDENT>if d:<EOL><INDENT>_cond = self.table.c[self._primary_field] == self._key<EOL>if version:<EOL><INDENT>version_field = self.table.c.get(version_fieldname)<EOL>if version_field is None:<EOL><INDENT>raise KindError("<STR_LIT>" % (version_fieldname, self.__class__.__name__))<EOL><DEDENT>_version_value = getattr(self, version_fieldname, <NUM_LIT:0>)<EOL>d[version_fieldname] = _version_value+<NUM_LIT:1><EOL>_cond = (version_field == _version_value) & _cond<EOL><DEDENT>if callable(changed):<EOL><INDENT>changed(self, created, self._old_values, d)<EOL>old.update(d)<EOL><DEDENT>result = do_(self.table.update(_cond).values(**d), self.get_session())<EOL>_saved = True<EOL>if version:<EOL><INDENT>if result.rowcount == <NUM_LIT:0>:<EOL><INDENT>_saved = False<EOL>if version_exception:<EOL><INDENT>raise SaveError("<STR_LIT>".format(<EOL>self.tablename, self._key, _version_value))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>setattr(self, version_fieldname, d[version_fieldname])<EOL><DEDENT><DEDENT>elif result.rowcount == <NUM_LIT:0>:<EOL><INDENT>_saved = False<EOL><DEDENT><DEDENT>if _manytomany:<EOL><INDENT>for k, v in list(_manytomany.items()):<EOL><INDENT>if v is not None:<EOL><INDENT>_saved = getattr(self, k).update(v) or _saved<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if _saved:<EOL><INDENT>for k, v in list(d.items()):<EOL><INDENT>x = self.properties[k].get_value_for_datastore(self)<EOL>if self.field_str(x) != self.field_str(v):<EOL><INDENT>setattr(self, k, v)<EOL><DEDENT><DEDENT>if send_dispatch and get_dispatch_send() and self.__dispatch_enabled__:<EOL><INDENT>dispatch.call(self.__class__, '<STR_LIT>', instance=self, created=created, data=old, old_data=self._old_values, signal=self.tablename)<EOL><DEDENT>self.set_saved()<EOL>if callable(saved):<EOL><INDENT>saved(self, created, self._old_values, old)<EOL><DEDENT><DEDENT><DEDENT>return _saved<EOL>
|
If insert=True, then it'll use insert() indead of update()
changed will be callback function, only when the non manytomany properties
are saved, the signature is:
def changed(obj, created, old_data, diff_data):
if flag is true, then it means the record is changed
you can change new_data, and the new_data will be saved to database
version = Optimistic Concurrency Control
version_fieldname default is 'version'
if check_many, it'll auto check if manytomany value need to save,
only available in UPDATE
|
f5808:c55:m8
|
def delete(self, manytomany=True, delete_fieldname=None, send_dispatch=True,<EOL>onetoone=True, **kwargs):
|
if get_dispatch_send() and self.__dispatch_enabled__:<EOL><INDENT>dispatch.call(self.__class__, '<STR_LIT>', instance=self, signal=self.tablename)<EOL><DEDENT>if manytomany:<EOL><INDENT>for k, v in list(self._manytomany.items()):<EOL><INDENT>getattr(self, k).clear()<EOL><DEDENT><DEDENT>if onetoone:<EOL><INDENT>for k, v in list(self._onetoone.items()):<EOL><INDENT>row = getattr(self, k)<EOL>if row:<EOL><INDENT>row.delete()<EOL><DEDENT><DEDENT><DEDENT>if delete_fieldname:<EOL><INDENT>if delete_fieldname is True:<EOL><INDENT>delete_fieldname = '<STR_LIT>'<EOL><DEDENT>if not hasattr(self, delete_fieldname):<EOL><INDENT>raise KeyError("<STR_LIT>" % delete_fieldname)<EOL><DEDENT>setattr(self, delete_fieldname, True)<EOL>self.save()<EOL><DEDENT>else:<EOL><INDENT>do_(self.table.delete(self.table.c[self._primary_field]==self._key), self.get_session())<EOL>self._key = None<EOL>self._old_values = {}<EOL><DEDENT>if send_dispatch and get_dispatch_send() and self.__dispatch_enabled__:<EOL><INDENT>dispatch.call(self.__class__, '<STR_LIT>', instance=self, signal=self.tablename)<EOL><DEDENT>
|
Delete current obj
:param manytomany: if also delete all manytomany relationships
:param delete_fieldname: if True then it'll use 'deleted', others will
be the property name
|
f5808:c55:m10
|
def create_sql(self, insert=False, version=False, version_fieldname=None,<EOL>fields=None, ec=None, compare=False):
|
version_fieldname = version_fieldname or '<STR_LIT:version>'<EOL>if not self._key or insert:<EOL><INDENT>d = self._get_data(fields, compare=compare)<EOL>if d:<EOL><INDENT>return rawsql(self.table.insert().values(**d),<EOL>ec or self.get_engine_name()) + '<STR_LIT:;>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>d = self._get_data(fields, compare=compare)<EOL>_key = d.pop(self._primary_field)<EOL>if d:<EOL><INDENT>_cond = self.table.c[self._primary_field] == self._key<EOL>if version:<EOL><INDENT>version_field = self.table.c.get(version_fieldname)<EOL>if version_field is None:<EOL><INDENT>raise KindError("<STR_LIT>" % (version_fieldname, self.__class__.__name__))<EOL><DEDENT>_version_value = getattr(self, version_fieldname, <NUM_LIT:0>)<EOL>d[version_fieldname] = _version_value+<NUM_LIT:1><EOL>_cond = (version_field == _version_value) & _cond<EOL><DEDENT>return rawsql(self.table.update(_cond).values(**d),<EOL>ec or self.get_engine_name()) + '<STR_LIT:;>'<EOL><DEDENT><DEDENT>return '<STR_LIT>'<EOL>
|
Create sql statement, do not process manytomany
|
f5808:c55:m11
|
@classmethod<EOL><INDENT>def get_collection_name(cls, from_class_name, collection_name=None, prefix=None):<DEDENT>
|
if not collection_name:<EOL><INDENT>collection_name = prefix + '<STR_LIT>'<EOL>if hasattr(cls, collection_name):<EOL><INDENT>collection_name = prefix + '<STR_LIT>' + str(cls._collection_set_id)<EOL>cls._collection_set_id += <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>if collection_name in cls._collection_names:<EOL><INDENT>if cls._collection_names.get(collection_name) != from_class_name:<EOL><INDENT>raise DuplicatePropertyError("<STR_LIT>" % (cls.__name__, collection_name))<EOL><DEDENT><DEDENT>if collection_name in cls.properties:<EOL><INDENT>raise DuplicatePropertyError("<STR_LIT>" % (cls.__name__, collection_name))<EOL><DEDENT><DEDENT>return collection_name<EOL>
|
Get reference collection_name, if the collection_name is None
then make sure the collection_name is not conflict, but
if the collection_name is not None, then check if the collection_name
is already exists, if existed then raise Exception.
|
f5808:c55:m19
|
@classmethod<EOL><INDENT>def _use(cls, ec):<DEDENT>
|
<EOL>ConnectModel = type(cls.__name__, (cls,), {})<EOL>ConnectModel.tablename = cls.tablename<EOL>ConnectModel._base_class = cls<EOL>if isinstance(ec, str):<EOL><INDENT>ConnectModel._engine_name = ec<EOL><DEDENT>elif isinstance(ec, Session):<EOL><INDENT>ConnectModel._engine_name = ec.engine_name<EOL>ConnectModel._connection = ec<EOL><DEDENT>return ConnectModel<EOL>
|
underly implement of use
|
f5808:c55:m27
|
@classmethod<EOL><INDENT>def use(cls, ec):<DEDENT>
|
if isinstance(ec, str):<EOL><INDENT>m = get_model(cls._alias, ec, signal=False)<EOL><DEDENT>else:<EOL><INDENT>m = cls._use(ec)<EOL><DEDENT>return m<EOL>
|
use will duplicate a new Model class and bind ec
ec is Engine name or Sesstion object
|
f5808:c55:m28
|
@classmethod<EOL><INDENT>def get(cls, id=None, condition=None, fields=None, cache=False, engine_name=None, **kwargs):<DEDENT>
|
if id is None and condition is None:<EOL><INDENT>return None<EOL><DEDENT>can_cacheable = (cache or getattr(cls, '<STR_LIT>', None)) andisinstance(id, (int, str))<EOL>if can_cacheable:<EOL><INDENT>obj = dispatch.get(cls, '<STR_LIT>', id)<EOL>if obj:<EOL><INDENT>return obj<EOL><DEDENT><DEDENT>if condition is not None:<EOL><INDENT>_cond = condition<EOL><DEDENT>else:<EOL><INDENT>if is_condition(id):<EOL><INDENT>_cond = id<EOL><DEDENT>else:<EOL><INDENT>_cond = cls.c[cls._primary_field] == id<EOL><DEDENT><DEDENT>obj = cls.filter(_cond, **kwargs).fields(*(fields or [])).one()<EOL>if obj and cache or getattr(cls, '<STR_LIT>', None):<EOL><INDENT>dispatch.call(cls, '<STR_LIT>', instance=obj)<EOL><DEDENT>return obj<EOL>
|
Get object from Model, if given fields, then only fields will be loaded
into object, other properties will be Lazy
if cache is True or defined __cacheable__=True in Model class, it'll use cache first
|
f5808:c55:m31
|
@classmethod<EOL><INDENT>def get_tree(cls, *condition, **kwargs):<DEDENT>
|
parent_field = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>parent = kwargs.pop('<STR_LIT>', None)<EOL>parent_order_by = kwargs.pop('<STR_LIT>', None)<EOL>current = kwargs.pop('<STR_LIT>', None)<EOL>order_by = kwargs.pop('<STR_LIT>', None)<EOL>id_field = kwargs.pop('<STR_LIT>', '<STR_LIT:id>')<EOL>mode = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>if mode not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise Exception("<STR_LIT>".format(mode))<EOL><DEDENT>def _f(parent):<EOL><INDENT>query = cls.filter(cls.c[parent_field]==parent, *condition)<EOL>if order_by is not None:<EOL><INDENT>query.order_by(order_by)<EOL><DEDENT>for row in query:<EOL><INDENT>if mode == '<STR_LIT>':<EOL><INDENT>yield row<EOL><DEDENT>for _row in _f(getattr(row, id_field)):<EOL><INDENT>yield _row<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>yield row<EOL><DEDENT><DEDENT><DEDENT>if current:<EOL><INDENT>query = cls.filter(cls.c[id_field]==current)<EOL><DEDENT>else:<EOL><INDENT>if is_condition(parent):<EOL><INDENT>query = cls.filter(parent)<EOL><DEDENT>else:<EOL><INDENT>query = cls.filter(cls.c[parent_field]==parent)<EOL><DEDENT><DEDENT>if parent_order_by is not None:<EOL><INDENT>query.order_by(parent_order_by)<EOL><DEDENT>for row in query:<EOL><INDENT>if mode == '<STR_LIT>':<EOL><INDENT>yield row<EOL><DEDENT>for r in _f(getattr(row, id_field)):<EOL><INDENT>yield r<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>yield row<EOL><DEDENT><DEDENT>
|
parent is root parent value, default is None
current is current value
condition is extra condition for select root records
mode is search method, value is 'wide' or 'deep'
|
f5808:c55:m41
|
@classmethod<EOL><INDENT>def get_choices(cls, condition=None, order_by=None, query=None, value_field=None, text_field=None):<DEDENT>
|
result = []<EOL>if query is None:<EOL><INDENT>query = cls.filter(condition).order_by(order_by)<EOL><DEDENT>for row in query:<EOL><INDENT>if not value_field:<EOL><INDENT>value = row._key<EOL><DEDENT>else:<EOL><INDENT>value = getattr(row, value_field)<EOL><DEDENT>if not text_field:<EOL><INDENT>text = str(row)<EOL><DEDENT>else:<EOL><INDENT>text = getattr(row, text_field)<EOL><DEDENT>result.append((value, text))<EOL><DEDENT>return result<EOL>
|
Get [(value, text),...] list
:param condition:
:param value_field: default is primary_key
:param text_field: default is unicode(obj)
:return:
|
f5808:c55:m44
|
def refresh(self, fields=None, **kwargs):
|
cond = self.c[self._primary_field]==self._key<EOL>query = self.filter(cond, **kwargs)<EOL>if not fields:<EOL><INDENT>fields = list(self.table.c)<EOL><DEDENT>v = query.values_one(*fields)<EOL>if not v:<EOL><INDENT>raise NotFound('<STR_LIT>'.format(self.tablename, self._key))<EOL><DEDENT>d = self._data_prepare(list(v.items()))<EOL>self.update(**d)<EOL>self.set_saved()<EOL>
|
Re get the instance of current id
|
f5808:c55:m46
|
def dump(self, fields=None, exclude=None):
|
exclude = exclude or []<EOL>d = {}<EOL>if fields and self._primary_field not in fields:<EOL><INDENT>fields = list(fields)<EOL>fields.append(self._primary_field)<EOL><DEDENT>for k, v in list(self.properties.items()):<EOL><INDENT>if ((not fields) or (k in fields)) and (not exclude or (k not in exclude)):<EOL><INDENT>if not isinstance(v, ManyToMany):<EOL><INDENT>t = v.get_value_for_datastore(self)<EOL>if t is Lazy:<EOL><INDENT>self.refresh()<EOL>t = v.get_value_for_datastore(self)<EOL><DEDENT>if isinstance(t, Model):<EOL><INDENT>t = t._key<EOL><DEDENT>d[k] = v.to_str(t)<EOL><DEDENT>else:<EOL><INDENT>if fields:<EOL><INDENT>d[k] = '<STR_LIT:U+002C>'.join([str(x) for x in getattr(self, v._lazy_value(), [])])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if self._primary_field and d and self._primary_field not in d:<EOL><INDENT>d[self._primary_field] = str(self._key)<EOL><DEDENT>return d<EOL>
|
Dump current object to dict, but the value is string
for manytomany fields will not automatically be dumpped, only when
they are given in fields parameter
|
f5808:c55:m48
|
@classmethod<EOL><INDENT>def clear_relation(cls):<DEDENT>
|
for k, v in list(cls.properties.items()):<EOL><INDENT>if isinstance(v, ReferenceProperty):<EOL><INDENT>if hasattr(v, '<STR_LIT>') and hasattr(v.reference_class, v.collection_name):<EOL><INDENT>delattr(v.reference_class, v.collection_name)<EOL>if isinstance(v, OneToOne):<EOL><INDENT>del v.reference_class._onetoone[v.collection_name]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>
|
Clear relation properties for reference Model, such as OneToOne, Reference,
ManyToMany
|
f5808:c55:m50
|
def put(self, _name, **values):
|
try:<EOL><INDENT>sql = self.sqles[_name]<EOL>data = sql['<STR_LIT:data>']<EOL>if sql['<STR_LIT>']:<EOL><INDENT>d = [values[k] for k, v in list(sql['<STR_LIT>'].items())]<EOL><DEDENT>else:<EOL><INDENT>d = {v:values[k] for k, v in list(sql['<STR_LIT>'].items())}<EOL><DEDENT>data.append(d)<EOL>if self.size and len(data) >= self.size:<EOL><INDENT>do_(sql['<STR_LIT>'], args=data)<EOL>sql['<STR_LIT:data>'] = []<EOL><DEDENT><DEDENT>except:<EOL><INDENT>if self.transcation:<EOL><INDENT>Rollback(self.engine)<EOL><DEDENT>raise<EOL><DEDENT>
|
Put data to cach, if reached size value, it'll execute at once.
|
f5808:c56:m4
|
def make_field(type, **kwargs):
|
cls = get_field_cls(type)<EOL>return cls(**kwargs)<EOL>
|
According field information creating Field instance
|
f5814:m4
|
def make_form(fields=None, layout=None, layout_class=None, base_class=None,<EOL>get_form_field=None, name=None, rules=None, **kwargs):
|
from uliweb.utils.sorteddict import SortedDict<EOL>get_form_field = get_form_field or (lambda name, f:None)<EOL>props = SortedDict({})<EOL>for f in fields or []:<EOL><INDENT>if isinstance(f, BaseField):<EOL><INDENT>props[f.name] = get_form_field(f.name, f) or f<EOL><DEDENT>else:<EOL><INDENT>props[f['<STR_LIT:name>']] = get_form_field(f['<STR_LIT:name>'], f) or make_field(**f)<EOL><DEDENT><DEDENT>if layout:<EOL><INDENT>props['<STR_LIT>'] = layout<EOL><DEDENT>if layout_class:<EOL><INDENT>props['<STR_LIT>'] = layout_class<EOL><DEDENT>if rules:<EOL><INDENT>props['<STR_LIT>'] = rules<EOL><DEDENT>layout_class_args = kwargs.pop('<STR_LIT>', None)<EOL>if layout_class_args:<EOL><INDENT>props['<STR_LIT>'] = layout_class_args<EOL><DEDENT>cls = type(name or '<STR_LIT>', (base_class or Form,), props)<EOL>return cls<EOL>
|
Make a from according dict data:
{'fields':[
{'name':'name', 'type':'str', 'label':'label,
'rules':{
'required':
'email'
'required:back|front' #back means server side, front means front side
}
...},
...
],
#layout_class should be defined in settings.ini, just like
#[FORM_LAYOUT_CLASSES]
#bs3 = '#{appname}.form_help.Bootstrap3Layout'
#is also can be a Layout Class
#default is BootstrapLayout
'layout_class':'bs3',
'layout':{
'rows':[
'-- legend title --',
'field_name',
['group_fieldname', 'group_fieldname']
{'name':'name', 'colspan':3}
],
}
'base_class':'form class if not existed, then use Form'
}
get_form_field is a callback function, used to defined customized field class
if has name then it'll be cached
|
f5814:m5
|
def get_form(formcls):
|
from uliweb.utils.common import get_configrable_object<EOL>return get_configrable_object(formcls, '<STR_LIT>', Form)<EOL>
|
get form class according form class path or form class object
|
f5814:m6
|
def get_form_layout_class(form_layout_class):
|
from uliweb.utils.common import get_configrable_object<EOL>return get_configrable_object(form_layout_class, '<STR_LIT>', Layout)<EOL>
|
Get form layout class according form_layout_class path or layout class object
|
f5814:m7
|
def to_python(self, data):
|
if data is None:<EOL><INDENT>return data<EOL><DEDENT>if self.datatype:<EOL><INDENT>return self.datatype(data)<EOL><DEDENT>else:<EOL><INDENT>return data<EOL><DEDENT>
|
Convert a data to python format.
|
f5814:c4:m4
|
def html(self, data='<STR_LIT>', py=True):
|
if py:<EOL><INDENT>value = self.to_html(data)<EOL><DEDENT>else:<EOL><INDENT>value = data<EOL><DEDENT>if self.static:<EOL><INDENT>return str('<STR_LIT>' % safe_str(value))<EOL><DEDENT>else:<EOL><INDENT>if self.hidden:<EOL><INDENT>build = Hidden<EOL><DEDENT>else:<EOL><INDENT>build = self.build<EOL><DEDENT>self._get_http_attrs()<EOL>return str(build(name=self.name, value=value, id=self.id, **self.html_attrs))<EOL><DEDENT>
|
Convert data to html value format.
|
f5814:c4:m5
|
def validate(self, data, all_data=None):
|
all_data = all_data or {}<EOL>if hasattr(data, '<STR_LIT>'):<EOL><INDENT>data.file = data.stream<EOL><DEDENT>if hasattr(data, '<STR_LIT:file>'):<EOL><INDENT>if data.file:<EOL><INDENT>v = data.filename<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' % type(data))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>v = data<EOL>
|
if 'rule' in kwargs, then validate extra rules
e.g.:
rule= {'required':True, 'minlength':6}
|
f5814:c4:m13
|
def to_python(self, data):
|
if data is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if isinstance(data, str):<EOL><INDENT>data = data.encode(DEFAULT_ENCODING)<EOL><DEDENT>else:<EOL><INDENT>data = str(data)<EOL><DEDENT>return data<EOL>
|
Convert a data to python format.
|
f5814:c5:m1
|
def to_python(self, data):
|
if data is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if isinstance(data, str):<EOL><INDENT>return data<EOL><DEDENT>else:<EOL><INDENT>return str(data, DEFAULT_ENCODING)<EOL><DEDENT>
|
Convert a data to python format.
|
f5814:c6:m1
|
def to_python(self, data):
|
if data is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if isinstance(data, self.datatype):<EOL><INDENT>return data<EOL><DEDENT>if self.datatype is str:<EOL><INDENT>return str(data, DEFAULT_ENCODING)<EOL><DEDENT>else:<EOL><INDENT>return data.encode(DEFAULT_ENCODING)<EOL><DEDENT>
|
Convert a data to python format.
|
f5814:c10:m2
|
def validate(self, data, all_data=None):
|
if data is None:<EOL><INDENT>return True, False<EOL><DEDENT>else:<EOL><INDENT>return super(BooleanField, self).validate(data, all_data)<EOL><DEDENT>
|
None data means False, so BooleanField need to override validate()
|
f5814:c12:m4
|
def __init__(self, value=None, kvio=False):
|
self._kvio = kvio<EOL>self._fields = []<EOL>self.update(value or {})<EOL>
|
SortedDict will implement Key Insertion Order (KIO: updates of values
do not affect the position of the key), Key Value Insertion Order (KVIO,
an existing key's position is removed and put at the back)
|
f5818:c0:m0
|
def __iter__(self):
|
for k in self._fields:<EOL><INDENT>yield k<EOL><DEDENT>
|
od.__iter__() <==> iter(od)
|
f5818:c0:m3
|
def __reversed__(self):
|
for k in reversed(self._fields):<EOL><INDENT>yield k<EOL><DEDENT>
|
od.__reversed__() <==> reversed(od)
|
f5818:c0:m4
|
def __eq__(self, other):
|
if isinstance(other, SortedDict):<EOL><INDENT>return dict.__eq__(self, other) and all(_imap(_eq, self, other))<EOL><DEDENT>return dict.__eq__(self, other)<EOL>
|
od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
while comparison to a regular mapping is order-insensitive.
|
f5818:c0:m21
|
def __ne__(self, other):
|
return not self == other<EOL>
|
od.__ne__(y) <==> od!=y
|
f5818:c0:m22
|
def __init__(self, inifile='<STR_LIT>', commentchar=None, encoding=None,<EOL>env=None, convertors=None, lazy=False, writable=False, raw=False,<EOL>import_env=True, basepath='<STR_LIT:.>', pre_variables=None):
|
super(Ini, self).__init__()<EOL>if isinstance(inifile, dict):<EOL><INDENT>self._inifile = '<STR_LIT>'<EOL>data = inifile<EOL><DEDENT>else:<EOL><INDENT>self._inifile = inifile<EOL>data = None<EOL><DEDENT>self._basepath = basepath<EOL>self._commentchar = commentchar or __default_env__.get('<STR_LIT>', '<STR_LIT:#>')<EOL>self._encoding = encoding or __default_env__.get('<STR_LIT>', '<STR_LIT:utf-8>')<EOL>self._env = __default_env__.get('<STR_LIT>', {}).copy()<EOL>self._env.update(env or {})<EOL>self._env['<STR_LIT>'] = set<EOL>self.update(self._env)<EOL>self._globals = SortedDict()<EOL>self._pre_variables = pre_variables or {}<EOL>self._import_env = import_env<EOL>if self._import_env:<EOL><INDENT>self._globals.update(os.environ)<EOL><DEDENT>self._convertors = __default_env__.get('<STR_LIT>', {}).copy()<EOL>self._convertors.update(convertors or {})<EOL>self._lazy = lazy<EOL>self._writable = writable<EOL>self._raw = raw<EOL>if lazy:<EOL><INDENT>self._globals.update(self._env.copy())<EOL><DEDENT>if self._inifile:<EOL><INDENT>self.read(self._inifile)<EOL><DEDENT>if data:<EOL><INDENT>for k, v in list(data.items()):<EOL><INDENT>s = self.add(k)<EOL>for _k, _v in list(v.items()):<EOL><INDENT>s[_k] = _v<EOL><DEDENT><DEDENT><DEDENT>
|
lazy is used to parse first but not deal at time, and only when
the user invoke finish() function, it'll parse the data.
import_env will import all environment variables
if inifile is dict, then automatically add to ini object
|
f5819:c5:m0
|
def _pre_var(self, value):
|
def sub_(m):<EOL><INDENT>return self._pre_variables.get(m.group()[<NUM_LIT:2>:-<NUM_LIT:1>].strip(), '<STR_LIT>')<EOL><DEDENT>return r_pre_var.sub(sub_, value)<EOL>
|
replace predefined variables, the format is #{name}
|
f5819:c5:m5
|
def __read_line(self, f):
|
g = tokenize.generate_tokens(f.readline)<EOL>buf = []<EOL>time = <NUM_LIT:0><EOL>iden_existed = False<EOL>while <NUM_LIT:1>:<EOL><INDENT>v = next(g)<EOL>tokentype, t, start, end, line = v<EOL>if tokentype == <NUM_LIT>:<EOL><INDENT>continue<EOL><DEDENT>if tokentype in (token.INDENT, token.DEDENT, tokenize.COMMENT):<EOL><INDENT>continue<EOL><DEDENT>if tokentype == token.NAME:<EOL><INDENT>iden_existed = True<EOL><DEDENT>if tokentype == token.NEWLINE:<EOL><INDENT>return '<STR_LIT>'.join(buf), iden_existed<EOL><DEDENT>else:<EOL><INDENT>if t == '<STR_LIT:=>' and time == <NUM_LIT:0>:<EOL><INDENT>time += <NUM_LIT:1><EOL>continue<EOL><DEDENT>buf.append(t)<EOL><DEDENT><DEDENT>
|
Get logic line according the syntax not the physical line
It'll return the line text and if there is identifier existed
return line, bool
|
f5819:c5:m8
|
def freeze(self):
|
self._lazy = False<EOL>for k, v in list(self.items()):<EOL><INDENT>if k in self._env:<EOL><INDENT>continue<EOL><DEDENT>for _k, _v in list(v.items()):<EOL><INDENT>if isinstance(_v, Lazy):<EOL><INDENT>if self.writable:<EOL><INDENT>_v.get()<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>v.__setitem__(_k, _v.get(), replace=True)<EOL><DEDENT>except:<EOL><INDENT>print("<STR_LIT>", _k)<EOL>raise<EOL><DEDENT>del _v<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self._globals = SortedDict()<EOL>
|
Process all EvalValue to real value
|
f5819:c5:m18
|
def get_sort_field(model=None, sort_field='<STR_LIT>', order_name='<STR_LIT>'):
|
from uliweb import request<EOL>if request.values.getlist('<STR_LIT>'):<EOL><INDENT>sort_fields = request.values.getlist('<STR_LIT>')<EOL>order_by = []<EOL>orders = request.values.getlist('<STR_LIT>')<EOL>for i, f in enumerate(sort_fields):<EOL><INDENT>_order = '<STR_LIT>'<EOL>if not orders:<EOL><INDENT>if f.endswith('<STR_LIT>') or f.endswith('<STR_LIT>'):<EOL><INDENT>f, _order = f.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>field = get_column(f, model)<EOL>if field is not None:<EOL><INDENT>if orders:<EOL><INDENT>_order = orders[i]<EOL><DEDENT>if _order == '<STR_LIT>':<EOL><INDENT>order_by.append(field)<EOL><DEDENT>else:<EOL><INDENT>order_by.append(field.desc())<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>order_by = None<EOL><DEDENT>return order_by<EOL>
|
Get sort column info according request, the data format just likes:
?sort=fieldA.asc&sort=fieldB.desc
or:
?sort=fieldA&sort=fieldB&order=asc&order=desc
default order is 'asc'. `field` can be just like `model.field`
:param model: default model, if no model existed in field
:param sort_field: sort field name in request
:param order_name: order field name in request, the order direction can be
set in field, just like `model.field.asc` or `field.asc`, etc.
:return:
|
f5821:m1
|
def get_fields(model, fields, meta=None):
|
model = get_model(model)<EOL>if fields is not None:<EOL><INDENT>f = fields<EOL><DEDENT>elif meta and hasattr(model, meta):<EOL><INDENT>m = getattr(model, meta)<EOL>if hasattr(m, '<STR_LIT>'):<EOL><INDENT>f = m.fields<EOL><DEDENT>else:<EOL><INDENT>f = model._fields_list<EOL><DEDENT><DEDENT>else:<EOL><INDENT>f = model._fields_list<EOL><DEDENT>fields_list = []<EOL>for x in f:<EOL><INDENT>field = {}<EOL>if isinstance(x, str): <EOL><INDENT>field['<STR_LIT:name>'] = x<EOL><DEDENT>elif isinstance(x, tuple):<EOL><INDENT>field['<STR_LIT:name>'] = x[<NUM_LIT:0>]<EOL>field['<STR_LIT>'] = x[<NUM_LIT:1>]<EOL><DEDENT>elif isinstance(x, dict):<EOL><INDENT>field = x.copy()<EOL><DEDENT>else:<EOL><INDENT>raise UliwebError('<STR_LIT>'.format(x))<EOL><DEDENT>if '<STR_LIT>' not in field:<EOL><INDENT>if hasattr(model, field['<STR_LIT:name>']):<EOL><INDENT>field['<STR_LIT>'] = getattr(model, field['<STR_LIT:name>'])<EOL><DEDENT>else:<EOL><INDENT>field['<STR_LIT>'] = None<EOL><DEDENT><DEDENT>fields_list.append((field['<STR_LIT:name>'], field))<EOL><DEDENT>return fields_list<EOL>
|
Acording to model and fields to get fields list
Each field element is a two elements tuple, just like:
(name, field_obj)
|
f5821:m2
|
def get_columns(model=None, fields=None, meta=None):
|
if model:<EOL><INDENT>M = get_model(model)<EOL><DEDENT>else:<EOL><INDENT>M = None<EOL><DEDENT>if fields is not None:<EOL><INDENT>f = fields<EOL><DEDENT>if M:<EOL><INDENT>if meta and hasattr(M, meta):<EOL><INDENT>m = getattr(model, meta)<EOL>if hasattr(m, '<STR_LIT>'):<EOL><INDENT>f = m.fields<EOL><DEDENT>else:<EOL><INDENT>f = M._fields_list<EOL><DEDENT><DEDENT>else:<EOL><INDENT>f = M._fields_list<EOL><DEDENT><DEDENT>columns = []<EOL>for x in f:<EOL><INDENT>if isinstance(x, str): <EOL><INDENT>field_name = x<EOL><DEDENT>elif isinstance(x, dict):<EOL><INDENT>field_name = x['<STR_LIT:name>']<EOL><DEDENT>else:<EOL><INDENT>raise UliwebError("<STR_LIT>")<EOL><DEDENT>if '<STR_LIT:.>' in field_name:<EOL><INDENT>model_name, field_name = field_name.split('<STR_LIT:.>')<EOL>M = get_model(model_name)<EOL><DEDENT>if not M:<EOL><INDENT>raise UliwebError("<STR_LIT>")<EOL><DEDENT>if field_name in M.c:<EOL><INDENT>columns.append(M.c[field_name])<EOL><DEDENT><DEDENT>return columns<EOL>
|
Get model columns list
|
f5821:m3
|
def get_model_columns(model, fields=None, meta='<STR_LIT>'):
|
from copy import deepcopy<EOL>fields = fields or []<EOL>model = functions.get_model(model)<EOL>if not fields:<EOL><INDENT>if hasattr(model, meta):<EOL><INDENT>fields = getattr(model, meta).fields<EOL><DEDENT>else:<EOL><INDENT>fields = [x for x, y in model._fields_list]<EOL><DEDENT><DEDENT>fields_list = []<EOL>for x in fields:<EOL><INDENT>if isinstance(x, str):<EOL><INDENT>f = get_grid_column(model, x)<EOL><DEDENT>elif isinstance(x, dict):<EOL><INDENT>name = x['<STR_LIT:name>']<EOL>f = deepcopy(x)<EOL>if '<STR_LIT>' in x:<EOL><INDENT>f['<STR_LIT:title>'] = x['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT:title>' not in f:<EOL><INDENT>f.update(get_grid_column(model, name))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError("<STR_LIT>".format(x))<EOL><DEDENT>fields_list.append(f)<EOL><DEDENT>return fields_list<EOL>
|
Get fields info according model class, the fields just like ListView fields definition
:param fields: A list
:param meta: if no fields, it'll use meta
|
f5821:m7
|
def get_field(name, model=None):
|
if '<STR_LIT:.>' in name:<EOL><INDENT>m, name = name.split('<STR_LIT:.>')<EOL>model = get_model(m)<EOL><DEDENT>if model:<EOL><INDENT>return getattr(model, name, None)<EOL><DEDENT>
|
get model field according to name, the name can be like `model.column`
|
f5821:m9
|
def get_column(name, model=None):
|
if '<STR_LIT:.>' in name:<EOL><INDENT>m, name = name.split('<STR_LIT:.>')<EOL>model = get_model(m)<EOL><DEDENT>if model:<EOL><INDENT>return model.c.get(name)<EOL><DEDENT>
|
get table column according to name, the name can be like `model.column`
|
f5821:m10
|
def get_field_model(name, model=None):
|
if '<STR_LIT:.>' in name:<EOL><INDENT>m, name = name.split('<STR_LIT:.>')<EOL>model = get_model(m)<EOL><DEDENT>if model:<EOL><INDENT>return getattr(model, name, None), model<EOL><DEDENT>else:<EOL><INDENT>return None, None<EOL><DEDENT>
|
get model field according to name
|
f5821:m11
|
def get_column_model(name, model=None):
|
if '<STR_LIT:.>' in name:<EOL><INDENT>m, name = name.split('<STR_LIT:.>')<EOL>model = get_model(m)<EOL><DEDENT>if model:<EOL><INDENT>return model.c.get(name), model<EOL><DEDENT>else:<EOL><INDENT>return None, None<EOL><DEDENT>
|
get model field according to name
|
f5821:m12
|
def make_form_field(field, model=None, field_cls=None,<EOL>use_default_value=True,<EOL>builds_args_map=None):
|
import uliweb.form as form<EOL>from uliweb.form.validators import TEST_MAXLENGTH<EOL>builds_args_map = builds_args_map or {}<EOL>if model:<EOL><INDENT>model = get_model(model)<EOL><DEDENT>if isinstance(field, BaseField):<EOL><INDENT>return field<EOL><DEDENT>if isinstance(field, dict) and '<STR_LIT>' in field and isinstance(field['<STR_LIT>'], BaseField):<EOL><INDENT>return field['<STR_LIT>']<EOL><DEDENT>field_type = None<EOL>prop = None <EOL>if isinstance(field, str):<EOL><INDENT>field = {'<STR_LIT:name>':field}<EOL><DEDENT>if isinstance(field, dict):<EOL><INDENT>prop = field.get('<STR_LIT>')<EOL>if not prop and model:<EOL><INDENT>field_name = field.get('<STR_LIT>') or field['<STR_LIT:name>']<EOL>prop = get_model_property(model, field_name)<EOL>if not prop and not field_cls:<EOL><INDENT>raise UliwebError("<STR_LIT>" %<EOL>(field_name, model.__name__))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise UliwebError("<STR_LIT>" % type(field))<EOL><DEDENT>default_kwargs = {}<EOL>if prop:<EOL><INDENT>default_kwargs = {<EOL>'<STR_LIT:label>':prop.label or prop.property_name,<EOL>'<STR_LIT>':prop.hint,<EOL>'<STR_LIT>':prop.placeholder,<EOL>'<STR_LIT>':prop.extra.get('<STR_LIT>', {}),<EOL>'<STR_LIT>':prop.required,<EOL>}<EOL><DEDENT>kwargs = {<EOL>'<STR_LIT:label>':field.get('<STR_LIT:label>') or field.get('<STR_LIT>') or default_kwargs.get('<STR_LIT:label>'),<EOL>'<STR_LIT>':field.get('<STR_LIT>') or field.get('<STR_LIT>') or default_kwargs.get('<STR_LIT>'),<EOL>'<STR_LIT>':field.get('<STR_LIT>') or default_kwargs.get('<STR_LIT>'),<EOL>'<STR_LIT>':field.get('<STR_LIT>', {}).get('<STR_LIT>', {}) or default_kwargs.get('<STR_LIT>'),<EOL>'<STR_LIT>':field.get('<STR_LIT>', False) if '<STR_LIT>' in field else default_kwargs.get('<STR_LIT>', False)<EOL>}<EOL>if '<STR_LIT>' in field:<EOL><INDENT>kwargs['<STR_LIT>']['<STR_LIT>'] = field['<STR_LIT>']<EOL><DEDENT>if use_default_value:<EOL><INDENT>v = prop.default_value()<EOL>kwargs['<STR_LIT:default>'] = v<EOL><DEDENT>if field.get('<STR_LIT>'):<EOL><INDENT>field_type = form.StringField<EOL>kwargs['<STR_LIT>'] = False<EOL>kwargs['<STR_LIT>'] = True<EOL>if prop.choices is not None:<EOL><INDENT>kwargs['<STR_LIT>'] = prop.get_choices()<EOL><DEDENT><DEDENT>if field.get('<STR_LIT>'):<EOL><INDENT>field_type = form.HiddenField<EOL><DEDENT>if field_cls:<EOL><INDENT>field_type = field_cls<EOL><DEDENT>elif not field_type:<EOL><INDENT>cls = prop.__class__<EOL>type_name = prop.type_name<EOL>if type_name == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>elif type_name in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>field_type = form.TextField<EOL><DEDENT>elif type_name in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if prop.choices is not None:<EOL><INDENT>field_type = form.SelectField<EOL>kwargs['<STR_LIT>'] = prop.get_choices()<EOL><DEDENT>else:<EOL><INDENT>if cls.__name__ == '<STR_LIT>':<EOL><INDENT>field_type = form.FileField<EOL>kwargs['<STR_LIT>'] = prop.upload_to<EOL>kwargs['<STR_LIT>'] = prop.upload_to_sub<EOL><DEDENT>else:<EOL><INDENT>field_type = form.UnicodeField<EOL><DEDENT><DEDENT><DEDENT>elif type_name == '<STR_LIT>':<EOL><INDENT>field_type = form.BooleanField<EOL><DEDENT>elif type_name == '<STR_LIT>':<EOL><INDENT>if not prop.auto_now and not prop.auto_now_add:<EOL>
|
make form field according field value
:param field: such as: str, Form Field instance, dict
if field is str type, it'll fetch property from model or str is like 'model.name'
it'll fetch property `name` from `model`
:param model: if field is str type, it'll may use model value to fetch property
:param field_cls: if not applied, it'll fetch from property, field_cls sould be Field class
:param builds_args_map:
:return: Field instance
|
f5821:m14
|
def make_view_field(field, obj=None, types_convert_map=None, fields_convert_map=None, <EOL>value=__default_value__, auto_convert=True):
|
from uliweb.utils.textconvert import text2html<EOL>from uliweb.core.html import Tag<EOL>old_value = value<EOL>types_convert_map = types_convert_map or {}<EOL>fields_convert_map = fields_convert_map or {}<EOL>default_convert_map = {orm.TextProperty:lambda v,o:text2html(v)}<EOL>if isinstance(field, dict):<EOL><INDENT>if '<STR_LIT>' in field and field.get('<STR_LIT>'):<EOL><INDENT>prop = field['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>prop = field<EOL><DEDENT>name = field.get('<STR_LIT:name>')<EOL><DEDENT>else:<EOL><INDENT>prop = field<EOL>name = prop.property_name<EOL><DEDENT>if not isinstance(prop, orm.Property): <EOL><INDENT>if old_value is __default_value__:<EOL><INDENT>value = prop.get('<STR_LIT:value>', '<STR_LIT>')<EOL><DEDENT>display = prop.get('<STR_LIT>', value)<EOL>label = prop.get('<STR_LIT:label>', '<STR_LIT>') or prop.get('<STR_LIT>', '<STR_LIT>')<EOL>convert = prop.get('<STR_LIT>', None)<EOL><DEDENT>else:<EOL><INDENT>if old_value is __default_value__:<EOL><INDENT>if isinstance(obj, Model):<EOL><INDENT>value = prop.get_value_for_datastore(obj)<EOL>if value is Lazy:<EOL><INDENT>getattr(obj, prop.property_name)<EOL>value = prop.get_value_for_datastore(obj)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value = obj[name]<EOL><DEDENT><DEDENT>if auto_convert or prop.choices:<EOL><INDENT>display = prop.get_display_value(value)<EOL><DEDENT>else:<EOL><INDENT>display = value<EOL><DEDENT>if isinstance(field, dict):<EOL><INDENT>initial = field.get('<STR_LIT>', None)<EOL><DEDENT>else:<EOL><INDENT>initial = '<STR_LIT>'<EOL><DEDENT>label = initial or prop.verbose_name or name<EOL><DEDENT>if name in fields_convert_map:<EOL><INDENT>convert = fields_convert_map.get(name, None)<EOL><DEDENT>else:<EOL><INDENT>if isinstance(prop, orm.Property):<EOL><INDENT>convert = types_convert_map.get(prop.__class__, None)<EOL>if not convert:<EOL><INDENT>convert = default_convert_map.get(prop.__class__, None)<EOL><DEDENT><DEDENT><DEDENT>convert_result = None<EOL>if convert:<EOL><INDENT>convert_result = convert(value, obj)<EOL><DEDENT>if convert_result is None:<EOL><INDENT>if value is not None:<EOL><INDENT>if isinstance(prop, orm.ManyToMany):<EOL><INDENT>s = []<EOL>if old_value is not __default_value__:<EOL><INDENT>if prop.reference_fieldname == '<STR_LIT:id>':<EOL><INDENT>query = []<EOL>for _id in old_value:<EOL><INDENT>_v = functions.get_cached_object(prop.reference_class, _id)<EOL>query.append(_v)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>query = prop.reference_class.filter(prop.reference_class.c[prop.reversed_fieldname].in_(old_value))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if prop.reference_fieldname == '<STR_LIT:id>':<EOL><INDENT>query = []<EOL>_ids = prop.get_value_for_datastore(obj, cached=True)<EOL>for _id in _ids:<EOL><INDENT>_v = functions.get_cached_object(prop.reference_class, _id)<EOL>if not _v:<EOL><INDENT>log.debug("<STR_LIT>" % (prop.reference_class.__name__, _id))<EOL>_v = _id<EOL><DEDENT>query.append(_v)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>query = getattr(obj, prop.property_name).all()<EOL><DEDENT><DEDENT>for x in query:<EOL><INDENT>if isinstance(x, orm.Model):<EOL><INDENT>s.append(get_obj_url(x))<EOL><DEDENT>else:<EOL><INDENT>s.append(str(x))<EOL><DEDENT><DEDENT>display = '<STR_LIT:U+0020>'.join(s)<EOL><DEDENT>elif isinstance(prop, orm.ReferenceProperty) or isinstance(prop, orm.OneToOne):<EOL><INDENT>try:<EOL><INDENT>if old_value is not __default_value__:<EOL><INDENT>d = prop.reference_class.c[prop.reference_fieldname]<EOL>if prop.reference_fieldname == '<STR_LIT:id>':<EOL><INDENT>v = functions.get_cached_object(prop.reference_class, old_value)<EOL><DEDENT>else:<EOL><INDENT>v = prop.reference_class.get(d==old_value)<EOL><DEDENT><DEDENT>if not isinstance(obj, Model):<EOL><INDENT>d = prop.reference_class.c[prop.reference_fieldname]<EOL>if prop.reference_fieldname == '<STR_LIT:id>':<EOL><INDENT>v = functions.get_cached_object(prop.reference_class, value)<EOL><DEDENT>else:<EOL><INDENT>v = prop.reference_class.get(d==value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if prop.reference_fieldname == '<STR_LIT:id>':<EOL><INDENT>v = functions.get_cached_object(prop.reference_class, obj.get_datastore_value(prop.property_name))<EOL><DEDENT>else:<EOL><INDENT>v = functions.get_cached_object(prop.reference_class,<EOL>condition=prop.reference_class.c[prop.reference_fieldname]==obj.get_datastore_value(prop.property_name))<EOL><DEDENT><DEDENT><DEDENT>except orm.Error:<EOL><INDENT>display = prop.get_datastore_value(obj) or '<STR_LIT>'<EOL>v = None<EOL><DEDENT>if isinstance(v, Model):<EOL><INDENT>display = get_obj_url(v)<EOL><DEDENT>else:<EOL><INDENT>display = str(v if v is not None else '<STR_LIT>')<EOL><DEDENT><DEDENT>elif isinstance(prop, orm.FileProperty):<EOL><INDENT>url = functions.get_href(value)<EOL>if url:<EOL><INDENT>display = str(Tag('<STR_LIT:a>', value, href=url))<EOL><DEDENT>else:<EOL><INDENT>display = '<STR_LIT>'<EOL>
|
If auto_convert, then all values will be converted to string format, otherwise
remain the orignal value
|
f5821:m15
|
def __init__(self, verbose_name=None, table_fieldname='<STR_LIT>', <EOL>object_fieldname='<STR_LIT>', **attrs):
|
super(GenericReference, self).__init__(<EOL>verbose_name=verbose_name, **attrs)<EOL>self.table_fieldname = table_fieldname<EOL>self.object_fieldname = object_fieldname<EOL>self.table = get_model('<STR_LIT>')<EOL>
|
Definition of GenericReference property
|
f5821:c5:m0
|
def __property_config__(self, model_class, property_name):
|
super(GenericReference, self).__property_config__(model_class, property_name)<EOL>
|
Loads all of the references that point to this model.
|
f5821:c5:m3
|
def __get__(self, model_instance, model_class):
|
if model_instance:<EOL><INDENT>table_id, object_id = self.get_value_for_datastore(model_instance)<EOL>if not table_id and not object_id:<EOL><INDENT>return None<EOL><DEDENT>model = self.table.get_model(table_id)<EOL>return model.get(object_id)<EOL><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT>
|
Get reference object.
This method will fetch unresolved entities from the datastore if
they are not already loaded.
Returns:
ReferenceProperty to Model object if property is set, else None.
|
f5821:c5:m5
|
def get_value_for_datastore(self, model_instance):
|
table_id = getattr(model_instance, self.table_fieldname, None)<EOL>object_id = getattr(model_instance, self.object_fieldname, None)<EOL>return table_id, object_id<EOL>
|
Get key of reference rather than reference itself.
|
f5821:c5:m7
|
def __init__(self, model, reference_fieldname='<STR_LIT>', **attrs):
|
super(GenericRelation, self).__init__(**attrs)<EOL>self._model = model<EOL>self.reference_fieldname = reference_fieldname<EOL>self.table = get_model('<STR_LIT>')<EOL>
|
Constructor for reverse reference.
Constructor does not take standard values of other property types.
|
f5821:c6:m0
|
def __get__(self, model_instance, model_class):
|
if model_instance is not None: <EOL><INDENT>table_id = self.table.get_table(self.model_class.tablename).id<EOL>model = get_model(self._model)<EOL>return model.filter(model.c[self.reference_fieldname]==table_id)<EOL><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT>
|
Fetches collection of model instances of this collection property.
|
f5821:c6:m2
|
def __set__(self, model_instance, value):
|
raise ValueError('<STR_LIT>')<EOL>
|
Not possible to set a new collection.
|
f5821:c6:m3
|
def prepare_static_data(self, data):
|
d = data.copy()<EOL>for f in self.get_fields():<EOL><INDENT>if f['<STR_LIT>'] and f['<STR_LIT:name>'] in d:<EOL><INDENT>d[f['<STR_LIT:name>']] = make_view_field(f, None, self.types_convert_map, self.fields_convert_map, d[f['<STR_LIT:name>']])['<STR_LIT>']<EOL><DEDENT><DEDENT>return d<EOL>
|
If user defined static fields, then process them with visiable value
|
f5821:c7:m3
|
def _process_file(self, obj, fobj, field):
|
from uliweb import settings<EOL>paths = []<EOL>upload_to = self.upload_to or self._get_upload_path(field, '<STR_LIT>', obj)<EOL>if upload_to:<EOL><INDENT>self.fileserving.to_path = upload_to<EOL><DEDENT>upload_to_sub = self.upload_to_sub or self._get_upload_path(field, '<STR_LIT>', obj)<EOL>if upload_to_sub:<EOL><INDENT>paths.append(upload_to_sub)<EOL><DEDENT>paths.append(fobj['<STR_LIT:filename>'])<EOL>return self.fileserving.save_file(os.path.join(*paths), <EOL>fobj['<STR_LIT:file>'], replace=self.file_replace, <EOL>convert=self.file_convert)<EOL>
|
obj is record object
fobj is data
field is FileField instance
|
f5821:c7:m7
|
def prepare_static_data(self, data):
|
d = self.obj.to_dict()<EOL>d.update(data.copy())<EOL>for f in self.get_fields():<EOL><INDENT>if f['<STR_LIT>'] and f['<STR_LIT:name>'] in d:<EOL><INDENT>v = make_view_field(f, self.obj, self.types_convert_map, self.fields_convert_map, d[f['<STR_LIT:name>']])<EOL>d[f['<STR_LIT:name>']] = v['<STR_LIT>']<EOL><DEDENT><DEDENT>return d<EOL>
|
If user defined static fields, then process them with visiable value
|
f5821:c8:m5
|
def __init__(self, fields=None, query=None, <EOL>pageno=<NUM_LIT:0>, rows_per_page=<NUM_LIT:10>, id='<STR_LIT>', fields_convert_map=None, <EOL>table_class_attr='<STR_LIT>', table_width=False, pagination=True, total_fields=None, <EOL>template_data=None, default_column_width=<NUM_LIT:100>, total=None, manual=False, <EOL>render=None, record_render=None, post_record_render=None, before_record_render=None):
|
self.fields = fields<EOL>self._query = query<EOL>self.pageno = pageno<EOL>self.rows_per_page = rows_per_page<EOL>self.rows_num = <NUM_LIT:0><EOL>self.id = id<EOL>self.table_class_attr = table_class_attr<EOL>self.fields_convert_map = fields_convert_map or {}<EOL>self.total = total or <NUM_LIT:0><EOL>self.table_width = table_width<EOL>self.pagination = pagination<EOL>self.create_total_infos(total_fields)<EOL>self.template_data = template_data or {}<EOL>self.default_column_width = default_column_width<EOL>self.manual = manual<EOL>self.downloader = GenericFileServing()<EOL>self.render_func = render<EOL>self.record_render = record_render<EOL>self.post_record_render = post_record_render<EOL>self.before_record_render = before_record_render<EOL>self.init()<EOL>
|
Pass a data structure to fields just like:
[
{'name':'field_name', 'verbose_name':'Caption', 'width':100},
...
]
total_fields definition:
['field1', 'field2']
or
[{'name':'fields', 'cal':'sum' or 'avg' or None, #if None then don't
#calculate at each row iterate, default cal = sum
'render':str function(value, total_sum)]
|
f5821:c15:m0
|
def count(self, query):
|
if self.manual:<EOL><INDENT>return self.total<EOL><DEDENT>if isinstance(query, Select):<EOL><INDENT>q = query.with_only_columns([func.count()]).order_by(None).limit(None).offset(None)<EOL>return do_(q).scalar()<EOL><DEDENT>return query.count()<EOL>
|
If query is Select object, this function will try to get count of select
|
f5821:c15:m9
|
def download(self, filename, timeout=<NUM_LIT>, action=None, query=None,<EOL>fields_convert_map=None, type=None, domain=None,<EOL>template_filename='<STR_LIT>', sheet_name='<STR_LIT>', **kwargs):
|
from uliweb import settings<EOL>fields_convert_map = fields_convert_map or self.fields_convert_map<EOL>t_filename = self.get_real_file(filename)<EOL>if os.path.exists(t_filename):<EOL><INDENT>if timeout and os.path.getmtime(t_filename) + timeout > time.time():<EOL><INDENT>return self.downloader.download(filename, action)<EOL><DEDENT><DEDENT>if query is None:<EOL><INDENT>query = self.query_all()<EOL><DEDENT>if not type:<EOL><INDENT>type = os.path.splitext(filename)[<NUM_LIT:1>]<EOL>if type:<EOL><INDENT>type = type[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>type = '<STR_LIT>'<EOL><DEDENT><DEDENT>if type in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if not domain:<EOL><INDENT>domain = settings.get_var('<STR_LIT>')<EOL><DEDENT>return self.download_xlt(filename, query, action, fields_convert_map, domain, not_tempfile=bool(timeout), **kwargs)<EOL><DEDENT>if type in ('<STR_LIT>',):<EOL><INDENT>if not domain:<EOL><INDENT>domain = settings.get_var('<STR_LIT>')<EOL><DEDENT>return self.download_xlsx(filename, query, action, fields_convert_map, domain,<EOL>not_tempfile=bool(timeout), template_filename=template_filename,<EOL>sheet_name=sheet_name, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>return self.download_csv(filename, query, action, fields_convert_map, not_tempfile=bool(timeout), **kwargs)<EOL><DEDENT>
|
Default domain option is PARA/DOMAIN
:param template_filename: Excel template filename, it'll xltools to writer it, only can be used
in xlsx
|
f5821:c15:m10
|
def get_data(self, query, fields_convert_map, encoding='<STR_LIT:utf-8>', auto_convert=True,<EOL>include_hidden=False, header=None):
|
fields_convert_map = fields_convert_map or {}<EOL>d = self.fields_convert_map.copy() <EOL>d.update(fields_convert_map)<EOL>if isinstance(query, Select):<EOL><INDENT>query = do_(query)<EOL><DEDENT>for record in query:<EOL><INDENT>self._cal_sum(record)<EOL>row = []<EOL>record = self._get_record(record)<EOL>if self.before_record_render:<EOL><INDENT>self.before_record_render(record)<EOL><DEDENT>if isinstance(record, orm.Model):<EOL><INDENT>model = record.__class__<EOL><DEDENT>else:<EOL><INDENT>model = None<EOL><DEDENT>for i, x in enumerate(self.table_info['<STR_LIT>']):<EOL><INDENT>field = get_field(x['<STR_LIT:name>'], model)<EOL>if not field:<EOL><INDENT>field = {'<STR_LIT:name>':x['<STR_LIT:name>']}<EOL><DEDENT>else:<EOL><INDENT>field = {'<STR_LIT:name>':x['<STR_LIT:name>'], '<STR_LIT>':field}<EOL><DEDENT>if not include_hidden and x.get('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>if isinstance(record, orm.Model):<EOL><INDENT>v = make_view_field(field, record, fields_convert_map=d, <EOL>auto_convert=auto_convert)<EOL><DEDENT>else:<EOL><INDENT>v = make_view_field(field, record, fields_convert_map=d, <EOL>auto_convert=auto_convert, value=record[x['<STR_LIT:name>']])<EOL><DEDENT>value = v['<STR_LIT>']<EOL>row.append(value)<EOL><DEDENT>if header:<EOL><INDENT>ret = dict(list(zip(header, row)))<EOL><DEDENT>else:<EOL><INDENT>ret = row<EOL><DEDENT>yield ret<EOL><DEDENT>total = self._get_sum()<EOL>if total:<EOL><INDENT>row = []<EOL>for x in total:<EOL><INDENT>v = x<EOL>if isinstance(x, str):<EOL><INDENT>v = safe_unicode(x, encoding)<EOL><DEDENT>row.append(v)<EOL><DEDENT>if header:<EOL><INDENT>ret = dict(list(zip(header, row)))<EOL><DEDENT>else:<EOL><INDENT>ret = row<EOL><DEDENT>yield ret<EOL><DEDENT>
|
If convert=True, will convert field value
|
f5821:c15:m13
|
def objects(self, json_result=False):
|
self.rows_num = <NUM_LIT:0><EOL>query = self.query()<EOL>if not isinstance(query, (orm.Result, list, dict)):<EOL><INDENT>query = do_(query)<EOL><DEDENT>for record in query:<EOL><INDENT>self.rows_num += <NUM_LIT:1><EOL>r = self.object(record, json_result)<EOL>self._cal_sum(record)<EOL>yield r<EOL><DEDENT>total = self._render_sum(True)<EOL>if total:<EOL><INDENT>yield total<EOL><DEDENT>
|
Return a generator of all processed data, it just like render
but it'll not return a table or json format data but just
data. And the data will be processed by fields_convert_map if passed.
|
f5821:c15:m22
|
def __init__(self, model, condition=None, query=None, pageno=<NUM_LIT:0>, order_by=None,<EOL>group_by=None, having=None,<EOL>fields=None, rows_per_page=<NUM_LIT:10>, types_convert_map=None, pagination=True,<EOL>fields_convert_map=None, id='<STR_LIT>', table_class_attr='<STR_LIT>', table_width=True,<EOL>total_fields=None, template_data=None, default_column_width=<NUM_LIT:100>, <EOL>meta='<STR_LIT>', render=None, total=<NUM_LIT:0>, manual=False,<EOL>record_render=None, post_record_render=None, before_record_render=None):
|
self.model = model and get_model(model)<EOL>self.meta = meta<EOL>self.condition = condition<EOL>self.pageno = pageno<EOL>self.order_by = order_by<EOL>self.group_by = group_by<EOL>self.having = having<EOL>self.fields = fields<EOL>self.rows_per_page = rows_per_page<EOL>self.types_convert_map = types_convert_map or {}<EOL>self.fields_convert_map = fields_convert_map or {}<EOL>self.id = id<EOL>self.rows_num = <NUM_LIT:0><EOL>self._query = query<EOL>self.table_width = table_width<EOL>self.table_class_attr = table_class_attr<EOL>self.total = total or <NUM_LIT:0><EOL>self.pagination = pagination<EOL>self.create_total_infos(total_fields)<EOL>self.template_data = template_data or {}<EOL>self.default_column_width = default_column_width<EOL>self.downloader = GenericFileServing()<EOL>self.render_func = render<EOL>self.manual = manual<EOL>self.record_render=record_render<EOL>self.post_record_render=post_record_render<EOL>self.before_record_render = before_record_render<EOL>self.init()<EOL>
|
If pageno is None, then the ListView will not paginate
|
f5821:c16:m0
|
def query_all(self):
|
return self.query_model(self.model, self.condition, order_by=self.order_by,<EOL>group_by=self.group_by, having=self.having)<EOL>
|
Query all records without limit and offset.
|
f5821:c16:m4
|
def query_model(self, model, condition=None, offset=None, limit=None,<EOL>order_by=None, group_by=None, having=None, fields=None):
|
from uliweb import settings, request<EOL>from uliweb.utils.common import log<EOL>from uliweb.orm import rawsql<EOL>if self._query is not None:<EOL><INDENT>query = self._query<EOL>if condition is not None and isinstance(query, Result):<EOL><INDENT>query = query.filter(condition)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>query = self.model.filter(condition)<EOL><DEDENT>if request.GET.get('<STR_LIT>'):<EOL><INDENT>log.info(rawsql(query.get_query()))<EOL><DEDENT>if self.pagination:<EOL><INDENT>if offset is not None:<EOL><INDENT>query = query.offset(int(offset))<EOL><DEDENT>if limit is not None:<EOL><INDENT>query = query.limit(int(limit))<EOL><DEDENT><DEDENT>if order_by is not None:<EOL><INDENT>if isinstance(order_by, (tuple, list)):<EOL><INDENT>query = query.order_by(*order_by)<EOL><DEDENT>else:<EOL><INDENT>query = query.order_by(order_by)<EOL><DEDENT><DEDENT>if group_by is not None:<EOL><INDENT>if isinstance(group_by, (tuple, list)):<EOL><INDENT>query = query.group_by(*group_by)<EOL><DEDENT>else:<EOL><INDENT>query = query.group_by(group_by)<EOL><DEDENT>if having is not None:<EOL><INDENT>query = query.having(having)<EOL><DEDENT><DEDENT>return query<EOL>
|
Query all records with limit and offset, it's used for pagination query.
|
f5821:c16:m5
|
def __init__(self, model=None, fields=None, condition=None, query=None, pageno=<NUM_LIT:0>, order_by=None, <EOL>rows_per_page=<NUM_LIT:10>, types_convert_map=None, pagination=True,<EOL>fields_convert_map=None, id='<STR_LIT>', table_class_attr='<STR_LIT>', table_width=True,<EOL>total_fields=None, template_data=None, default_column_width=<NUM_LIT:100>, meta='<STR_LIT>',<EOL>render=None, total=<NUM_LIT:0>, manual=False, record_render=None, post_record_render=None,<EOL>before_record_render=None):
|
super(SelectListView, self).__init__(model=model, condition=condition,<EOL>query=query, pageno=pageno, order_by=order_by, fields=fields,<EOL>rows_per_page=rows_per_page, types_convert_map=types_convert_map,<EOL>pagination=pagination, fields_convert_map=fields_convert_map,<EOL>id=id, table_class_attr=table_class_attr, table_width=table_width,<EOL>total_fields=total_fields, template_data=template_data, <EOL>default_column_width=default_column_width, meta=meta,<EOL>render=render, total=total, manual=manual, record_render=record_render,<EOL>post_record_render=post_record_render, before_record_render=before_record_render)<EOL>self._field_labels = []<EOL>for f in self.table_info['<STR_LIT>']:<EOL><INDENT>if '<STR_LIT:.>' in f:<EOL><INDENT>self._field_labels.append((f, f.replace('<STR_LIT:.>', '<STR_LIT:_>')))<EOL><DEDENT>else:<EOL><INDENT>self._field_labels.append((f, f))<EOL><DEDENT><DEDENT>
|
If pageno is None, then the ListView will not paginate
|
f5821:c17:m0
|
def query_model(self, model, condition=None, offset=None, limit=None,<EOL>group_by=None, having=None, order_by=None, fields=None):
|
if self._query is not None:<EOL><INDENT>query = self._query<EOL><DEDENT>else:<EOL><INDENT>query = self.get_select()<EOL><DEDENT>if condition is not None:<EOL><INDENT>if isinstance(query, Result):<EOL><INDENT>query = query.filter(condition)<EOL><DEDENT>else:<EOL><INDENT>query = query.where(condition)<EOL><DEDENT><DEDENT>if self.pagination:<EOL><INDENT>if offset is not None:<EOL><INDENT>query = query.offset(int(offset))<EOL><DEDENT>if limit is not None:<EOL><INDENT>query = query.limit(int(limit))<EOL><DEDENT><DEDENT>if order_by is not None:<EOL><INDENT>if isinstance(order_by, (tuple, list)):<EOL><INDENT>for order in order_by:<EOL><INDENT>query = query.order_by(order)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>query = query.order_by(order_by)<EOL><DEDENT><DEDENT>if group_by is not None:<EOL><INDENT>if isinstance(group_by, (tuple, list)):<EOL><INDENT>query = query.group_by(*group_by)<EOL><DEDENT>else:<EOL><INDENT>query = query.group_by(group_by)<EOL><DEDENT>if having is not None:<EOL><INDENT>query = query.having(having)<EOL><DEDENT><DEDENT>return query<EOL>
|
Query all records with limit and offset, it's used for pagination query.
|
f5821:c17:m3
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.