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.ref... | 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><... | 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 KindErro... | 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... | 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><D... | 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)... | 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)<... | 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.tabl... | 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><DE... | 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... | 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_referenc... | 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 rev... | 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 KindErro... | 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, ref... | 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[s... | 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,... | 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._mo... | 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.re... | 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 = geta... | 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_dis... | 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 n... | 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... | 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_... | 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:<E... | 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._conne... | 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:<EO... | 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_L... | 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... | 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.ite... | 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 n... | 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.col... | 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) >... | 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>']] =... | 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
}
...},
...
... | 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_... | 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<... | 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>... | 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>... | 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... | 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('<... | 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 n... | 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._f... | 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><IND... | 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 ... | 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 isinst... | 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:... | 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 ... | 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><INDEN... | 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><DEDE... | 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>... | 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 = t... | 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 c... | 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, actio... | 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... | 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._r... | 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=Non... | 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... | 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>que... | 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, def... | 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, t... | 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... | 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.