def create_related_fields(instance, related_fields, data): """ Function used to create the related fields when creating a new object. Args: instance (object): The object whose related fields are going to be created related_fields (dict): Dict containing information about the related fields data (dict): Dict containing the actual data for the related fields """ for field in related_fields: for item_data in data.get(field['data_string']): # Remove is_deleted key from dict (so update/create don't give errors) is_deleted = item_data.pop('is_deleted', False) if item_data and not is_deleted: # Websites are different than the other related fields. # For now just have it as an edge case in this function. # In the future we might want to change how websites are setup. if field['model'] == 'Website': model = get_model('accounts', field['model']) model.objects.create(account=instance, **item_data) else: # Get the model if field['model'] == 'SocialMedia': model = get_model('socialmedia', field['model']) else: model = get_model('utils', field['model']) # Create new object from model and add to set field_name = field['data_string'] getattr(instance, field_name).add(model.objects.create(**item_data))
def cron_post_save(sender, instance, **kwargs): """ Finds and schedules tasks for any CronEvents bound to the given instance. Inputs: :sender: Which event type was saved :instance: Specific instance saved """ CronEvent = get_model("myemails", "CronEvent") EmailTask = get_model("myemails", "EmailTask") content_type = ContentType.objects.get_for_model(sender) cron_event_kwargs = { "model": content_type, "owner": instance.product.owner if hasattr(instance, "product") else instance.owner, } # Gets all CronEvents for this company and model... events = list(CronEvent.objects.filter(**cron_event_kwargs)) # ...and all tasks scheduled for this instance. tasks = EmailTask.objects.filter(object_id=instance.pk, object_model=content_type) triggered_events = {task_.related_event for task_ in tasks} for event in triggered_events: if event in events: # If an event is already scheduled, remove it from the list of # events to be scheduled. events.remove(event) for event in events: # Schedule all remaining events. EmailTask.objects.create(act_on=instance, related_event=event).schedule()
def create_user(id, save=True, is_superuser=False): model = get_model("users", "User") domain_member_model = get_model("domains", "DomainMember") domain_model = get_model("domains", "Domain") instance = model( username="******".format(id), email="user{0}@taiga.io".format(id), first_name="Foo{0}".format(id), last_name="Bar{0}".format(id) ) instance.set_password(instance.username) if is_superuser: instance.is_staff = True instance.is_superuser = True instance.save() domain = domain_model.objects.get(pk=1) dm = domain_member_model.objects.create(user=instance, email=instance.email, domain=domain) if id == 1: dm.is_owner = True dm.is_staff = True dm.save() return instance
def __new__(cls, name, bases, attrs): # If this isn't a subclass of Model, don't do anything special. try: if not filter(lambda b: issubclass(b, Model), bases): return super(ModelBase, cls).__new__(cls, name, bases, attrs) except NameError: # 'Model' isn't defined yet, meaning we're looking at Django's own # Model class, defined below. return super(ModelBase, cls).__new__(cls, name, bases, attrs) # Create the class. new_class = type.__new__(cls, name, bases, {'__module__': attrs.pop('__module__')}) new_class.add_to_class('_meta', Options(attrs.pop('Meta', None))) new_class.add_to_class('DoesNotExist', types.ClassType('DoesNotExist', (ObjectDoesNotExist,), {})) # Build complete list of parents for base in bases: # TODO: Checking for the presence of '_meta' is hackish. if '_meta' in dir(base): new_class._meta.parents.append(base) new_class._meta.parents.extend(base._meta.parents) if getattr(new_class._meta, 'app_label', None) is None: # Figure out the app_label by looking one level up. # For 'django.contrib.sites.models', this would be 'sites'. model_module = sys.modules[new_class.__module__] new_class._meta.app_label = model_module.__name__.split('.')[-2] # Bail out early if we have already created this class. m = get_model(new_class._meta.app_label, name, False) if m is not None: return m # Add all attributes to the class. for obj_name, obj in attrs.items(): new_class.add_to_class(obj_name, obj) # Add Fields inherited from parents for parent in new_class._meta.parents: for field in parent._meta.fields: # Only add parent fields if they aren't defined for this class. try: new_class._meta.get_field(field.name) except FieldDoesNotExist: field.contribute_to_class(new_class, field.name) if getattr(new_class._meta, 'row_level_permissions', False): from django.contrib.auth.models import RowLevelPermission gen_rel = django.contrib.contenttypes.generic.GenericRelation(RowLevelPermission, object_id_field="model_id", content_type_field="model_ct") new_class.add_to_class("row_level_permissions", gen_rel) new_class._prepare() register_models(new_class._meta.app_label, new_class) # Because of the way imports happen (recursively), we may or may not be # the first class for this model to register with the framework. There # should only be one class for each model, so we must always return the # registered version. return get_model(new_class._meta.app_label, name, False)
def create_default_tip(self, game): """ Create a default tip for this club for game. """ model = get_model('main', 'Tip') tip = model( club=self, game=game, is_default=True ) tip.save() # Supercoach tips model = get_model('main', 'SupercoachTip') rnd = game.round if not rnd.is_finals: sc_count = constants.Supercoach.SC_COUNT_HOME_AWAY elif rnd.name != 'Grand Final': sc_count = constants.Supercoach.SC_COUNT_GRAND_FINAL else: sc_count = constants.Supercoach.SC_COUNT_FINALS for _ in range(sc_count): sc_tip = model(tip=tip) sc_tip.save()
def _get_track(self, model_track, data_track): ''' model_track is Gene, TSS, CDS, Isoform etc data_track is *data, *diff, etc. ''' track_model = get_model('cuff', model_track) if model_track == 'tss': track_field = 'tss_group' else: track_field = model_track if data_track == 'diffdata': # these are 3 special cases where we have distribution # level diff data if model_track == 'gene': data_model = PromoterDiffData elif model_track == 'tss': data_model = SplicingDiffData elif model_track == 'cds': data_model = CDSDiffData track_field = 'gene' else: data_model = get_model('cuff', '{track}{data}'.format(track=model_track, data=data_track) ) return track_model, data_model, track_field
def _step_3(self, request, app_name=None, model_name=None, temp_file_name=None, extra_context=None ): context = self._get_base_context(request, app_name, model_name) Model = get_model(app_name, model_name) extra_context = extra_context or {} if 'apply' in request.POST: Form = csv_processor_factory(app_name, model_name, temp_file_name) form = Form(request.POST, request.FILES) if form.is_valid(): mapping = self.__get_mapping(form) Model = get_model(app_name, model_name) with open_csv(temp_file_name) as csv: if form.cleaned_data['header']: csv.next() for i, row in enumerate(csv): record, key = self._process_row(row, mapping) try: if key: sample, _ = Model.objects.get_or_create(**key) else: sample = Model() sample = update_model(request, sample, record, mapping) sample.save() except (IntegrityError, ObjectDoesNotExist), e: messages.error(request, str(e)) return redirect('%s:%s_%s_changelist' % (self.name, app_name, model_name.lower()))
def set_value(self, name, value): """ Sets a value """ if self.pk is None: raise ValidationError("Save before storing value.") kwargs = { self.context_model: self, 'name': name, 'value': value } # Run within a savepoint # Else, IntegrityError in Postgres are not recoverable. try: sid = transaction.savepoint() v = get_model(self.context_app, self.context_holder)(**kwargs) v.save() transaction.savepoint_commit(sid) except IntegrityError: transaction.savepoint_rollback(sid) # Now here is some weird behavior in # stored_value.py. Django does not seems to reexecute the get_prep_value code, so we can't overwrite an existing value with a new FK. # Therefore we need to delete it... del kwargs['value'] v = get_model(self.context_app, self.context_holder).objects.get(**kwargs).delete() self.set_value(name, value)
def list_tags(request, tagmodel=None): """ Returns a list of JSON objects with a `name` and a `value` property that all start like your query string `q` (not case sensitive). """ if not tagmodel or tagmodel not in TAG_MODELS: TAG_MODEL = get_model(*TAG_MODELS['default']) else: TAG_MODEL = get_model(*TAG_MODELS[tagmodel]) query = request.GET.get('q', '') limit = request.GET.get('limit', MAX_SUGGESTIONS) try: request.GET.get('limit', MAX_SUGGESTIONS) limit = min(int(limit), MAX_SUGGESTIONS) # max or less except ValueError: limit = MAX_SUGGESTIONS tag_name_qs = TAG_MODEL.objects.filter(name__icontains=query).\ values_list('name', flat=True) if callable(getattr(TAG_MODEL, 'request_filter', None)): tag_name_qs = tag_name_qs.filter(TAG_MODEL.request_filter(request)).distinct() data = [{'name': n, 'value': n} for n in tag_name_qs[:limit]] return HttpResponse(json.dumps(data), content_type='application/json')
def update_role_points(self, user_stories=None): RolePoints = get_model("userstories", "RolePoints") Role = get_model("users", "Role") # Get all available roles on this project roles = self.get_roles().filter(computable=True) if roles.count() == 0: return # Get point instance that represent a null/undefined null_points_value = self.points.get(value=None) # Iter over all project user stories and create # role point instance for new created roles. if user_stories is None: user_stories = self.user_stories.all() for story in user_stories: story_related_roles = Role.objects.filter(role_points__in=story.role_points.all())\ .distinct() new_roles = roles.exclude(id__in=story_related_roles) new_rolepoints = [RolePoints(role=role, user_story=story, points=null_points_value) for role in new_roles] RolePoints.objects.bulk_create(new_rolepoints) # Now remove rolepoints associated with not existing roles. rp_query = RolePoints.objects.filter(user_story__in=self.user_stories.all()) rp_query = rp_query.exclude(role__id__in=roles.values_list("id", flat=True)) rp_query.delete()
def remove_empty_groups(): """Remove empty groups.""" Group = get_model('groups', 'Group') Skill = get_model('groups', 'Skill') for model in [Group, Skill]: model.objects.annotate(mcount=Count('members')).filter(mcount=0).delete()
def get_by_ref(s, callback, module=None, app_label=None, field=None): if '@' in s: model, module_name = s.split('@') if module_name: app_label = None module = module_name if '.' in name: model, field = name.split('.') else: bits = s.rsplit('.', 3) if len(bits) == 1: model = bits[0] elif len(bits) == 2: app_label, model = bits else: app_label, model, field = bits if module and not app_label: app_label = get_app_label(module) if app_label: from django.db.models.loading import get_model model = get_model(app_label, model) else: from django.db.models.loading import get_models for m in get_model(): if m.__name__ == model: model = m break if not model: _pending_reference_lookups.setdefault((app_label, model), []).append((field, callback)) else: _fire_ref_callback(model, field, callback)
def __new__(cls, name, bases, attrs): """Creates a combined appengine and Django model. The resulting model will be known to both the appengine libraries and Django. """ if name == 'BaseModel': # This metaclass only acts on subclasses of BaseModel. return super(PropertiedClassWithDjango, cls).__new__(cls, name, bases, attrs) new_class = super(PropertiedClassWithDjango, cls).__new__(cls, name, bases, attrs) new_class._meta = ModelOptions(new_class) new_class.objects = ModelManager(new_class) new_class._default_manager = new_class.objects new_class.DoesNotExist = types.ClassType('DoesNotExist', (ObjectDoesNotExist,), {}) m = get_model(new_class._meta.app_label, name, False) if m: return m register_models(new_class._meta.app_label, new_class) return get_model(new_class._meta.app_label, name, False)
def get_list_of_child_categories_and_objects(app_label, model_name, cat_slug=None, cat_id=None): from django.db.models.loading import get_model Model=get_model(app_label,model_name) Category=get_model(app_label,'Category') if cat_slug: try: cat=Category.objects.get(slug=cat_slug) except Category.DoesNotExist: return [] elif cat_id: try: cat = Category.objects.get(pk=cat_id) except Category.DoesNotExist: return [] else: raise AttributeError("get_list_of_child_categories_and_objects got nothing to work on (no cat_slug, no cat_id)") mylist=[] # for c in cat.child_set.all(): for c in Category.objects.filter(parent=cat.id): mylist.append({'id':c.id, 'priority':c.priority, 'url':c.get_absolute_url(), 'name':c.name, 'childtype':'Category','object':c}) if model_name != 'Category': # for p in cat.smartpage_set.all(): # There *must* be a nicer way to do this: for p in getattr(cat,model_name.lower()+'_set').all(): mylist.append({'id':p.id, 'priority':p.priority, 'url':p.get_absolute_url(), 'name':p.name, 'childtype':model_name, 'object':p}) mylist.sort(lambda f, s: cmp(f['priority'], s['priority'])) return mylist
def handle(self, *args, **options): """ """ model_spec,trackable_model_spec = (None,None) try: (model_spec,trackable_model_spec) = args except ValueError: raise CommandError("Command takes two arguments") model_cls = get_model(*model_spec.split('.')) trackable_model_cls = get_model(*trackable_model_spec.split('.')) kwargs = {} if options.get('key_fields',{}): kwargs['key_fields'] = dict([ (pair.split(':')[0],pair.split(':')[1]) for pair in options.get('key_fields').split(',') ]) if options.get('update_fields',{}): kwargs['update_fields'] = dict([ (pair.split(':')[0],pair.split(':')[1]) for pair in options.get('update_fields').split(',') ]) if options.get('link_field',''): kwargs['link_field'] = options.get('link_field') if options.get('match_spec',''): kwargs['match_spec'] = options.get('match_spec') if options.get('max_records',0): kwargs['max_records'] = long(options.get('max_records')) if options.get('order_by',[]): kwargs['order_by'] = options.get('order_by').split(',') self.handle_model_data_migration( \ model_cls, trackable_model_cls, **kwargs )
def all(self): return ContentType.objects.get_for_models( get_model('leagues', 'DivisionSettings'), get_model('leagues', 'CupSettings'), get_model('matches', 'CupRound'), get_model('matches', 'DivisionRound') )
def edit_model(request, modelname, id): Model = get_model('admin_center', modelname) if not Model: Model = get_model('mainsite', modelname) if not Model: raise Http404 if id == "add": model = Model() title = 'Добавить: ' + model._meta.verbose_name else: try: model = Model.objects.get(id=id) except Model.DoesNotExist: raise Http404 title = 'Редактировать: ' + model._meta.verbose_name Form = modelform_factory(Model) if request.method == 'POST': form = Form(request.POST, instance=model) if form.is_valid(): form.save() return HttpResponseRedirect(request.session['return_url']) else: request.session['return_url'] = request.GET['return_url'] form = Form(instance=model) form.required_css_class = 'required' return direct_to_template(request, 'edit_model.html', {'form': form, 'id': id, 'title': title, 'modelname': modelname})
def threedee_test(request): cache_key = "threedee_test" response = safe_get_cache(cache_key) if not response: County = get_model("places","county") State = get_model("places","state") mo=State.objects.get(abbr="MO") values = [] for county in County.objects.filter(state=mo)[:35].iterator(): if (not county.population_demographics) or (not county.population_demographics.total) or (not county.area)\ or (not county.socioeco_data) or (not county.socioeco_data.per_capita_income) or (not county.crime_data)\ or (not county.crime_data.violent_crime): continue pop_density = float(county.population_demographics.total)/float(county.area.sq_mi) if pop_density is 0: continue values.append( (pop_density, float(county.socioeco_data.per_capita_income), float(county.crime_data.violent_crime)) ) fig = threed_bar_chart(values,"Population Density","Per-Capita Income", "Violent Crimes") canvas=FigureCanvas(fig) response=HttpResponse(content_type='image/png') canvas.print_png(response) safe_set_cache(cache_key,response,86400) return response
def handle(self, *args, **options): usage = 'Required arguments: email password new_password' if len(args) != 3: raise CommandError(usage) email, curr, new = args Mailbox = get_model(MAILS_VIRTUAL_MAILBOX.split(".")[0], MAILS_VIRTUAL_MAILBOX.split(".")[1]) MailDomain = get_model(MAILS_VIRTUAL_MAILDOMAIN.split(".")[0], MAILS_VIRTUAL_MAILDOMAIN.split(".")[1]) try: user = Mailbox.get_from_email(email) except ValidationError: raise CommandError('Improperly formatted email address.') except MailDomain.DoesNotExist: raise CommandError('Domain does not exist.') except Mailbox.DoesNotExist: raise CommandError('Username does not exist.') authorized = user.check_password(curr) if not authorized: raise CommandError('Incorrect password.') user.set_password(new) user.save() self.stdout.write('Success.\n')
def __new__(cls, name, bases, attrs): # If this isn't a subclass of Model, don't do anything special. try: parents = [b for b in bases if issubclass(b, Model)] if not parents: return super(ModelBase, cls).__new__(cls, name, bases, attrs) except NameError: # 'Model' isn't defined yet, meaning we're looking at Django's own # Model class, defined below. return super(ModelBase, cls).__new__(cls, name, bases, attrs) # Create the class. new_class = type.__new__(cls, name, bases, {'__module__': attrs.pop('__module__')}) new_class.add_to_class('_meta', Options(attrs.pop('Meta', None))) new_class.add_to_class('DoesNotExist', types.ClassType('DoesNotExist', (ObjectDoesNotExist,), {})) new_class.add_to_class('MultipleObjectsReturned', types.ClassType('MultipleObjectsReturned', (MultipleObjectsReturned, ), {})) # Build complete list of parents for base in parents: # Things without _meta aren't functional models, so they're # uninteresting parents. if hasattr(base, '_meta'): new_class._meta.parents.append(base) new_class._meta.parents.extend(base._meta.parents) if getattr(new_class._meta, 'app_label', None) is None: # Figure out the app_label by looking one level up. # For 'django.contrib.sites.models', this would be 'sites'. model_module = sys.modules[new_class.__module__] new_class._meta.app_label = model_module.__name__.split('.')[-2] # Bail out early if we have already created this class. m = get_model(new_class._meta.app_label, name, False) if m is not None: return m # Add all attributes to the class. for obj_name, obj in attrs.items(): new_class.add_to_class(obj_name, obj) # Add Fields inherited from parents for parent in new_class._meta.parents: for field in parent._meta.fields: # Only add parent fields if they aren't defined for this class. try: new_class._meta.get_field(field.name) except FieldDoesNotExist: field.contribute_to_class(new_class, field.name) new_class._prepare() register_models(new_class._meta.app_label, new_class) # Because of the way imports happen (recursively), we may or may not be # the first class for this model to register with the framework. There # should only be one class for each model, so we must always return the # registered version. return get_model(new_class._meta.app_label, name, False)
def test_builder(self): users = get_model('main', 'users') self.assertTrue(users) rooms = get_model('main', 'rooms') self.assertTrue(rooms) rooms = get_model('main', 'room') self.assertFalse(rooms)
def delete(self, *args, **kwargs): DynamicInterface = get_model('cyder', 'dynamicinterface') for interface in DynamicInterface.objects.filter(system=self): interface.delete(delete_system=False, commit=False) StaticInterface = get_model('cyder', 'staticinterface') for interface in StaticInterface.objects.filter(system=self): interface.delete(delete_system=False, commit=False) super(System, self).delete(*args, **kwargs)
def set_actor(self, user, sender, instance, **kwargs): try: app_label, model_name = settings.AUTH_USER_MODEL.split('.') auth_user_model = get_model(app_label, model_name) except: auth_user_model = get_model('auth', 'user') if sender == LogEntry and isinstance(user, auth_user_model) and instance.actor is None: instance.actor = user
def update_related_fields(instance, related_fields, data): """ Function used to create/update/delete the related fields when updating an existing object. Args: instance (object): The object whose related fields are going to be created/updated/deleted related_fields (dict): Dict containing information about the related fields data (dict): Dict containing the actual data for the related fields """ for field in related_fields: # Pop items here so setattr() works for item_data in data.pop(field['data_string'], {}): # In case something went wrong in the front end and an object with # the is_deleted flag wasn't removed we set the object to an empty dict. # So just to be sure we check for empty data. if not item_data: continue # Convert from OrderedDict to regular dict item_data = dict(item_data) # Remove is_deleted key from dict (so update/create don't give errors) is_deleted = item_data.pop('is_deleted', False) if 'id' in item_data: # ID is set, so the object exists. Get that object. # Note that this isn't a single object but a QuerySet. # This is because passing a dict to the .update only works on a QuerySet. field_name = field['data_string'] item_obj = getattr(instance, field_name).filter(pk=item_data['id']) # If the related field was marked as deleted, delete it if is_deleted: item_obj.delete() else: # Otherwise update the object item_obj.update(**item_data) else: # ID wasn't given, so: # 1. Get the model # 2. Get the related field set # 3. Create an new object from the model and add it to the set # Websites are different than the other related fields. # For now just have it as an edge case in this function. # In the future we might want to change how websites are setup. if field['model'] == 'Website': model = get_model('accounts', field['model']) # Websites aren't added to a set, but are given an account item_data.update({ 'account': instance }) model.objects.create(**item_data) else: model = get_model('utils', field['model']) field_name = field['data_string'] getattr(instance, field_name).add(model.objects.create(**item_data))
def _disable_memberships(cls, user): """ Set all membership of given user to MemberStatusField.STATUS_MEMBER_BROKEN :param user: :return: """ get_model('accounts', 'Member').objects.filter(user=user).update( status=MemberStatusField.STATUS_MEMBER_BROKEN)
def filter_by_ctnr(ctnr, objects=None): objects = objects or System.objects DynamicInterface = get_model('cyder', 'dynamicinterface') StaticInterface = get_model('cyder', 'staticinterface') dynamic_query = DynamicInterface.objects.filter( ctnr=ctnr).values_list('system') static_query = StaticInterface.objects.filter( ctnr=ctnr).values_list('system') return objects.filter(Q(id__in=static_query) | Q(id__in=dynamic_query))
def delete_model(request, modelname, id): if request.method == 'POST': Model = get_model('admin_center', modelname) if not Model: Model = get_model('mainsite', modelname) if not Model: raise Http404 model = Model.objects.get(id=id) model.delete() return HttpResponse('')
def add_view_count(id): try: get_model('vehicle', 'car').objects.filter( pk=id).update(view_count=F('view_count') + 1) transaction.commit() except Exception as e: transaction.rollback() logging.error(str(e)) finally: pass
def update_watchers_on_membership_post_delete(sender, instance, using, **kwargs): models = [get_model("userstories", "UserStory"), get_model("tasks", "Task"), get_model("issues", "Issue")] # `user_id` is used beacuse in some momments # instance.user can contain pointer to now # removed object from a database. for model in models: model.watchers.through.objects.filter(user_id=instance.user_id).delete()
def send_added_to_bucket(bucket_membership_id): BucketMembership = get_model('buckets', 'BucketMembership') bucket_membership = BucketMembership.objects.get(id = bucket_membership_id) bucket = bucket_membership.bucket composition = bucket_membership.composition target_user = bucket.owner to_user = [] composition_owner = composition.uploader MailOptions = get_model('accounts', 'MailOptions') owner_mail_options = MailOptions.objects.get(user=composition_owner) if (composition_owner.is_active and not (target_user.id == composition_owner.id) and owner_mail_options.to_bucket): to_user.append(composition_owner.email) composition_artist = composition.artist artist_mail_options = MailOptions.objects.get(user=composition_artist) if composition_artist.is_active and not(composition_owner == composition_artist) and not (target_user.id == composition_artist.id) and artist_mail_options.to_bucket: to_user.append(composition_artist.email) if not to_user: return 'send_added_to_bucket: Counld not find valid recepient for bucket_membership: {0}'.format(bucket_membership.id) to = to_user subject = target_user.name + " added artwork " + composition.title + " to series " + bucket.name from_email = 'ThirdDime <*****@*****.**>' ctx = { 'target_name': target_user.name, 'target_slug': target_user.slug, 'target_picture': target_user.picture.url, 'art_name': composition.title, 'art_slug': composition.slug, 'series_name': bucket.name, 'series_slug': bucket.slug, 'series_owner_slug': bucket.owner.slug, } message = get_template('mails/buckets/to_bucket.html').render(Context(ctx)) msg = EmailMessage(subject, message, to=to, from_email=from_email) msg.content_subtype = 'html' count = 1 while count: try: msg.send(fail_silently=False) break; except: if (count > 3): raise count += count
def _process_results(self, raw_page, highlight=False, query_string='', spelling_query=None, result_class=None): if not self.site: from haystack import site else: site = self.site results = [] # It's important to grab the hits first before slicing. Otherwise, this # can cause pagination failures. hits = len(raw_page) if result_class is None: result_class = SearchResult facets = {} spelling_suggestion = None indexed_models = site.get_indexed_models() for doc_offset, raw_result in enumerate(raw_page): score = raw_page.score(doc_offset) or 0 app_label, model_name = raw_result[DJANGO_CT].split('.') additional_fields = {} model = get_model(app_label, model_name) if model and model in indexed_models: for key, value in raw_result.items(): index = site.get_index(model) string_key = str(key) if string_key in index.fields and hasattr( index.fields[string_key], 'convert'): # Special-cased due to the nature of KEYWORD fields. if index.fields[string_key].is_multivalued: if value is None or len(value) is 0: additional_fields[string_key] = [] else: additional_fields[string_key] = value.split( ',') else: additional_fields[string_key] = index.fields[ string_key].convert(value) else: additional_fields[string_key] = self._to_python(value) del (additional_fields[DJANGO_CT]) del (additional_fields[DJANGO_ID]) if highlight: from whoosh import analysis from whoosh.highlight import highlight, ContextFragmenter, UppercaseFormatter sa = analysis.StemmingAnalyzer() terms = [ term.replace('*', '') for term in query_string.split() ] additional_fields['highlighted'] = { self.content_field_name: [ highlight( additional_fields.get(self.content_field_name), terms, sa, ContextFragmenter(terms), UppercaseFormatter()) ], } result = result_class(app_label, model_name, raw_result[DJANGO_ID], score, searchsite=self.site, **additional_fields) results.append(result) else: hits -= 1 if getattr(settings, 'HAYSTACK_INCLUDE_SPELLING', False): if spelling_query: spelling_suggestion = self.create_spelling_suggestion( spelling_query) else: spelling_suggestion = self.create_spelling_suggestion( query_string) return { 'results': results, 'hits': hits, 'facets': facets, 'spelling_suggestion': spelling_suggestion, }
def _process_results(self, raw_results, highlight=False, result_class=None, distance_point=None, geo_sort=False): from haystack import connections results = [] hits = raw_results.get('hits', {}).get('total', 0) facets = {} spelling_suggestion = None if result_class is None: result_class = SearchResult if self.include_spelling and 'suggest' in raw_results: raw_suggest = raw_results['suggest']['suggest'] spelling_suggestion = ' '.join([word['text'] if len(word['options']) == 0 else word['options'][0]['text'] for word in raw_suggest]) if 'facets' in raw_results: facets = { 'fields': {}, 'dates': {}, 'queries': {}, } for facet_fieldname, facet_info in raw_results['facets'].items(): if facet_info.get('_type', 'terms') == 'terms': facets['fields'][facet_fieldname] = [(individual['term'], individual['count']) for individual in facet_info['terms']] elif facet_info.get('_type', 'terms') == 'date_histogram': # Elasticsearch provides UTC timestamps with an extra three # decimals of precision, which datetime barfs on. facets['dates'][facet_fieldname] = [(datetime.datetime.utcfromtimestamp(individual['time'] / 1000), individual['count']) for individual in facet_info['entries']] elif facet_info.get('_type', 'terms') == 'query': facets['queries'][facet_fieldname] = facet_info['count'] unified_index = connections[self.connection_alias].get_unified_index() indexed_models = unified_index.get_indexed_models() content_field = unified_index.document_field for raw_result in raw_results.get('hits', {}).get('hits', []): source = raw_result['_source'] app_label, model_name = source[DJANGO_CT].split('.') additional_fields = {} model = get_model(app_label, model_name) if model and model in indexed_models: for key, value in source.items(): index = unified_index.get_index(model) string_key = str(key) if string_key in index.fields and hasattr(index.fields[string_key], 'convert'): additional_fields[string_key] = index.fields[string_key].convert(value) else: additional_fields[string_key] = self._to_python(value) del(additional_fields[DJANGO_CT]) del(additional_fields[DJANGO_ID]) if 'highlight' in raw_result: additional_fields['highlighted'] = raw_result['highlight'].get(content_field, '') if distance_point: additional_fields['_point_of_origin'] = distance_point if geo_sort and raw_result.get('sort'): from haystack.utils.geo import Distance additional_fields['_distance'] = Distance(km=float(raw_result['sort'][0])) else: additional_fields['_distance'] = None result = result_class(app_label, model_name, source[DJANGO_ID], raw_result['_score'], **additional_fields) results.append(result) else: hits -= 1 return { 'results': results, 'hits': hits, 'facets': facets, 'spelling_suggestion': spelling_suggestion, }
def ext_pillar( minion_id, # pylint: disable=W0613 pillar, # pylint: disable=W0613 pillar_name, project_path, settings_module, django_app, env=None, env_file=None, *args, # pylint: disable=W0613 **kwargs): # pylint: disable=W0613 ''' Connect to a Django database through the ORM and retrieve model fields :type pillar_name: str :param pillar_name: The name of the pillar to be returned :type project_path: str :param project_path: The full path to your Django project (the directory manage.py is in) :type settings_module: str :param settings_module: The settings module for your project. This can be found in your manage.py file :type django_app: str :param django_app: A dictionary containing your apps, models, and fields :type env: str :param env: The full path to the virtualenv for your Django project :type env_file: str :param env_file: An optional bash file that sets up your environment. The file is run in a subprocess and the changed variables are then added ''' if not os.path.isdir(project_path): log.error( 'Django project dir: {0!r} not a directory!'.format(project_path)) return {} if HAS_VIRTUALENV and env is not None and os.path.isdir(env): for path in virtualenv.path_locations(env): if not os.path.isdir(path): log.error('Virtualenv {0} not a directory!'.format(path)) return {} # load the virtualenv first sys.path.insert( 0, os.path.join(virtualenv.path_locations(env)[1], 'site-packages')) # load the django project sys.path.append(project_path) os.environ['DJANGO_SETTINGS_MODULE'] = settings_module if env_file is not None: import subprocess base_env = {} proc = subprocess.Popen(['bash', '-c', 'env'], stdout=subprocess.PIPE) for line in proc.stdout: (key, _, value) = salt.utils.to_str(line).partition('=') base_env[key] = value command = ['bash', '-c', 'source {0} && env'.format(env_file)] proc = subprocess.Popen(command, stdout=subprocess.PIPE) for line in proc.stdout: (key, _, value) = salt.utils.to_str(line).partition('=') # only add a key if it is different or doesn't already exist if key not in base_env or base_env[key] != value: os.environ[key] = value.rstrip('\n') log.debug('Adding {0} = {1} to Django environment'.format( key, value.rstrip('\n'))) try: from django.db.models.loading import get_model django_pillar = {} for proj_app, models in six.iteritems(django_app): _, _, app = proj_app.rpartition('.') django_pillar[app] = {} for model_name, model_meta in six.iteritems(models): model_orm = get_model(app, model_name) if model_orm is None: raise salt.exceptions.SaltException( "Django model '{0}' not found in app '{1}'.".format( app, model_name)) pillar_for_model = django_pillar[app][model_orm.__name__] = {} name_field = model_meta['name'] fields = model_meta['fields'] if 'filter' in model_meta: qs = (model_orm.objects.filter( **model_meta['filter']).values(*fields)) else: qs = model_orm.objects.values(*fields) for model in qs: # Check that the human-friendly name given is valid (will # be able to pick up a value from the query) and unique # (since we're using it as the key in a dictionary) if name_field not in model: raise salt.exceptions.SaltException( "Name '{0}' not found in returned fields.".format( name_field)) if model[name_field] in pillar_for_model: raise salt.exceptions.SaltException( "Value for '{0}' is not unique: {0}".format( model[name_field])) pillar_for_model[model[name_field]] = model return {pillar_name: django_pillar} except ImportError as e: log.error('Failed to import library: {0}'.format(str(e))) return {} except Exception as e: log.error('Failed on Error: {0}'.format(str(e))) log.debug('django_orm traceback', exc_info=True) return {}
def get_model_by_name(name): return get_model(*name.split('.',1))
def _process_results(self, raw_results, highlight=False, result_class=None, distance_point=None): results = [] hits = raw_results.hits facets = {} stats = {} spelling_suggestion = None if result_class is None: result_class = SearchResult if hasattr(raw_results, 'stats'): stats = raw_results.stats.get('stats_fields', {}) if hasattr(raw_results, 'facets'): facets = { 'fields': raw_results.facets.get('facet_fields', {}), 'dates': raw_results.facets.get('facet_dates', {}), 'queries': raw_results.facets.get('facet_queries', {}), } for key in ['fields']: for facet_field in facets[key]: # Convert to a two-tuple, as Solr's json format returns a list of # pairs. facets[key][facet_field] = list( zip(facets[key][facet_field][::2], facets[key][facet_field][1::2])) if self.include_spelling is True: if hasattr(raw_results, 'spellcheck'): if len(raw_results.spellcheck.get('suggestions', [])): # For some reason, it's an array of pairs. Pull off the # collated result from the end. spelling_suggestion = raw_results.spellcheck.get( 'suggestions')[-1] unified_index = connections[self.connection_alias].get_unified_index() indexed_models = unified_index.get_indexed_models() for raw_result in raw_results.docs: app_label, model_name = raw_result[DJANGO_CT].split('.') additional_fields = {} model = get_model(app_label, model_name) if model and model in indexed_models: for key, value in raw_result.items(): index = unified_index.get_index(model) string_key = str(key) if string_key in index.fields and hasattr( index.fields[string_key], 'convert'): additional_fields[string_key] = index.fields[ string_key].convert(value) else: additional_fields[string_key] = custom_to_python( value, self.conn._to_python) del (additional_fields[DJANGO_CT]) del (additional_fields[DJANGO_ID]) del (additional_fields['score']) if raw_result[ID] in getattr(raw_results, 'highlighting', {}): additional_fields[ 'highlighted'] = raw_results.highlighting[ raw_result[ID]] if distance_point: additional_fields['_point_of_origin'] = distance_point if raw_result.get('__dist__'): from haystack.utils.geo import Distance additional_fields['_distance'] = Distance( km=float(raw_result['__dist__'])) else: additional_fields['_distance'] = None result = result_class(app_label, model_name, raw_result[DJANGO_ID], raw_result['score'], **additional_fields) results.append(result) else: hits -= 1 return { 'results': results, 'hits': hits, 'stats': stats, 'facets': facets, 'spelling_suggestion': spelling_suggestion, }
def get_tenant_model(): return get_model(settings.TENANT_MODEL)
def _get_listing(self, publishable, score): Listing = get_model('core', 'listing') publish_from = from_timestamp(score) return Listing(publishable=publishable, category=publishable.category, publish_from=publish_from)
def test_get_model_with_not_installed(self): self.assertEqual( get_model("not_installed", "NotInstalledModel", only_installed=False), self.not_installed_module.NotInstalledModel)
def get_wepay_model(obj_name): model_name = get_wepay_model_name(obj_name) if model_name is None: return None return get_model(*model_name.split('.'))
def test_get_model_only_returns_installed_models(self): self.assertEqual(get_model("not_installed", "NotInstalledModel"), None)
def get_tenant_domain_model(): return get_model(settings.TENANT_DOMAIN_MODEL)
def get_queryset(self): model = get_model('miscitems', 'Material') self.items = get_list_or_404(model) return self.items
class DeployAPI(BaseAPI): model = get_model('cannula', 'deployment') def _create(self, project, user, oldrev, newrev, conf_oldrev, conf_newrev): self.model.objects.create(project=project, user=user, oldrev=oldrev, newrev=newrev, conf_oldrev=conf_oldrev, conf_newrev=conf_newrev) def deploy(self, project, user, oldrev='old', newrev='new'): user = api.users.get(user) project = api.projects.get(project) if not os.path.isfile(project.appconfig): raise ApiError("Project missing app.yaml file!") # Attempt to get an exclusive lock on the project # file. A way to ensure only one process can deploy # at any single time. This is hard because deployment is # triggered by a git push (which is just an ssh connection) with DeployLock(project, user): with open(project.appconfig) as f: # Store the configuration for this project in git repo # so that we can roll back to previous states conf_dir = Git(project.conf_dir) if not os.path.isdir(project.conf_dir): os.makedirs(project.conf_dir) conf_dir.init() # Add an initial commit, just to make a rollback point. open(project.deployconfig, 'a') conf_dir.add_all() conf_dir.commit("Initial Commit") # Copy the project app.yaml to the conf_dir shutil.copy(project.appconfig, project.deployconfig) # read in the application configuration app = yaml.load(f.read()) # setup any runtime specific things here try: runtime = import_object(app.get('runtime')) except ImportError: raise ApiError("Unsupported runtime!") # runtime bootstrap, setup project environment here runtime.bootstrap(project, app) # Simple counter to make unique names for each handler # and keep them in order handler_position = 0 sections = [] for handler in app.get('handlers', []): if handler.get('worker'): # Setup worker name = '%s_%d' % (project.name, handler_position) # defaults are special, they reference another # section in the app.yaml defaults = handler.pop('defaults', None) if defaults: handler_defaults = app.get(defaults, {}) handler.update(handler_defaults) handle = Handler(name, project, **handler) # write out bash start up scripts handle.write_startup_script() # add handler to vhost_sections sections.append(handle) handler_position += 1 else: # Just pass the dictionary to the proxy vhosts sections.append(handler) # Write out the proxy file to serve this app ctx = { 'sections': sections, 'domain': app.get('domain', 'localhost'), 'runtime': app.get('runtime', 'python'), 'port': app.get('port', 80), 'project_conf_dir': project.conf_dir, 'conf_dir': os.path.join(conf.CANNULA_BASE, 'config'), 'project': project, } api.proxy.write_vhost_conf(project, ctx) api.proc.write_project_conf(project, ctx) # Check if any files changed and check if still valid conf_dir.add_all() _, changed = conf_dir.status() logging.debug(changed) if re.search('vhost.conf', changed): # Vhost file is either new or changed which will require # our proxy server to reload its configuration files. try: api.proxy.restart() except: logging.exception("Error restarting proxy") conf_dir.reset() raise ApiError("Deployment failed") if re.search('supervisor.conf', changed): try: api.proc.reread() except: logging.exception("Error reading supervisor configs") conf_dir.reset() raise ApiError("Deployment failed") # Add the project api.proc.reread(stderr=True) api.proc.add_project(project.name) # Restart the project try: api.proc.restart(project.name, stderr=True) except: logging.exception("Error restarting project") conf_dir.reset() raise ApiError("Deployment failed") # Current revision of conf directory conf_oldrev = conf_dir.head() if changed: # Commit config changes conf_dir.commit("Configuration: %s" % datetime.datetime.now().ctime()) # new revision of conf directory conf_newrev = conf_dir.head() if oldrev is None: oldrev = "Initial Commit" self._create(project, user, oldrev, newrev, conf_oldrev, conf_newrev)
def _get_listing(self, publishable, score): Listing = get_model('core', 'listing') return Listing(publishable=publishable, category=publishable.category)
def can_admin(self, user): if self.backlog_id: return user.is_staff or self.backlog.can_admin(user) elif self.project_id: return user.is_staff or self.project.can_admin(user) else: return False # Enhance User model to add notifications def user_notification_count(self): return AuthorizationAssociation.objects.filter( user=self, is_active=False ).count() get_model(*User.split('.', 1)).notification_count = user_notification_count class Event(models.Model): user = models.ForeignKey(User, verbose_name=_("User"), related_name="events") when = models.DateTimeField(_("When"), auto_now_add=True) project = models.ForeignKey(Project, verbose_name=_("Project"), related_name="events", null=True, on_delete=models.SET_NULL) story = models.ForeignKey(UserStory, verbose_name=_("Story"), blank=True, null=True, related_name="events", on_delete=models.SET_NULL) backlog = models.ForeignKey(Backlog, verbose_name=_("Backlog"), blank=True, null=True, related_name="events", on_delete=models.SET_NULL)
def tuple_to_model(t): return get_model(t[0], t[1])
def get_results(query_string, model_name, fields): query_obj = get_query(query_string, fields) model = get_model('webapp', model_name) if model is None: return [] return [] if query_obj is None else model.objects.filter(query_obj)
def get_queryset(self): model = get_model('miscitems', self.model) self.item = get_object_or_404(model, name_slug=self.kwargs['name_slug']) return self.item
def ListingHandlerClass(): return get_model('core', 'Listing').objects.get_listing_handler( core_settings.REDIS_LISTING_HANDLER)
def get_cached_objects(pks, model=None, timeout=CACHE_TIMEOUT, missing=RAISE): """ Return a list of objects with given PKs using cache. Params: pks - list of Primary Key values to look up or list of content_type_id, pk tuples model - ContentType instance representing the model's class or the model class itself timeout - TTL for the items in cache, defaults to CACHE_TIMEOUT Throws: model.DoesNotExist is propagated from content_type.get_object_for_this_type """ if model is not None: if not isinstance(model, ContentType): model = ContentType.objects.get_for_model(model) pks = [(model, pk) for pk in pks] else: pks = [(ContentType.objects.get_for_id(ct_id), pk) for (ct_id, pk) in pks] keys = [_get_key(KEY_PREFIX, model, pk=pk) for (model, pk) in pks] cached = cache.get_many(keys) # keys not in cache keys_to_set = set(keys) - set(cached.keys()) if keys_to_set: # build lookup to get model and pks from the key lookup = dict(zip(keys, pks)) to_get = {} # group lookups by CT so we can do in_bulk for k in keys_to_set: ct, pk = lookup[k] to_get.setdefault(ct, {})[int(pk)] = k # take out all the publishables publishable_ct = ContentType.objects.get_for_model(get_model('core', 'publishable')) if publishable_ct in to_get: publishable_keys = to_get.pop(publishable_ct) models = publishable_ct.model_class()._default_manager.values('content_type_id', 'id').filter(id__in=publishable_keys.keys()) for m in models: ct = ContentType.objects.get_for_id(m['content_type_id']) pk = m['id'] # and put them back as their native content_type to_get.setdefault(ct, {})[pk] = publishable_keys[pk] to_set = {} # retrieve all the models from DB for ct, vals in to_get.items(): models = ct.model_class()._default_manager.in_bulk(vals.keys()) for pk, m in models.items(): k = vals[pk] cached[k] = to_set[k] = m if not isinstance(cache, DummyCache): # write them into cache cache.set_many(to_set, timeout=timeout) out = [] for k in keys: try: out.append(cached[k]) except KeyError: if missing == NONE: out.append(None) elif missing == SKIP: pass elif missing == RAISE: ct = ContentType.objects.get_for_id(int(k.split(':')[1])) raise ct.model_class().DoesNotExist( '%s matching query does not exist.' % ct.model_class()._meta.object_name) return out
def get_tenant_model(): return get_model(*settings.TENANT_MODEL.split("."))
def test_get_model(self): self.assertEqual(get_model('tests', 'poll'), Poll) self.assertEqual(get_model('tests', 'historicalpoll'), HistoricalPoll)
def get_sms_template_model(): return get_model(*settings.TEMPLATE_MODEL.split('.'))
import datetime from django.contrib import messages from django.core.urlresolvers import reverse from django.db.models.loading import get_model from django.http import HttpResponseRedirect from django.utils.translation import ugettext_lazy as _ from django.views.generic import (ListView, FormView, DetailView, DeleteView) from oscar.core.loading import get_class VoucherForm = get_class('dashboard.vouchers.forms', 'VoucherForm') VoucherSearchForm = get_class('dashboard.vouchers.forms', 'VoucherSearchForm') Voucher = get_model('voucher', 'Voucher') ConditionalOffer = get_model('offer', 'ConditionalOffer') Benefit = get_model('offer', 'Benefit') Condition = get_model('offer', 'Condition') OrderDiscount = get_model('order', 'OrderDiscount') class VoucherListView(ListView): model = Voucher context_object_name = 'vouchers' template_name = 'dashboard/vouchers/voucher_list.html' form_class = VoucherSearchForm description_template = _("%(main_filter)s %(name_filter)s %(code_filter)s") def get_queryset(self): qs = self.model.objects.all().order_by('-date_created') self.description_ctx = { 'main_filter': _('All vouchers'),
def get_output_sms_model(): return get_model(*settings.OUTPUT_SMS_MODEL.split('.'))
from django.db.models.loading import get_model from django.contrib.contenttypes.models import ContentType from django.contrib.admin.views.decorators import staff_member_required from accounts.models import VenueAccount, VenueType, Account from event.models import SingleEvent, FeaturedEvent, Venue from event.services.featured_service import featured_events_for_region from event.services import venue_service as event_venue_service, location_service from venues.forms import VenueAccountForm, NewVenueAccountForm from .services import social_links_services, venue_service from .forms import VenueForm MAX_SUGGESTIONS = getattr(settings, 'TAGGIT_AUTOSUGGEST_MAX_SUGGESTIONS', 10) TAG_MODEL = getattr(settings, 'TAGGIT_AUTOSUGGEST_MODEL', ('taggit', 'Tag')) TAG_MODEL = get_model(*TAG_MODEL) def venues(request, *args, **kwargs): current_venue_type = int(request.GET.get("venue_type", 0)) if not current_venue_type \ and 'extra_params' in kwargs \ and 'venue_type' in kwargs['extra_params']: try: venue_type = VenueType.active_types.get( name=kwargs['extra_params']['venue_type']) except VenueType.DoesNotExist: pass else: current_venue_type = venue_type.id
def get_input_sms_model(): return get_model(*settings.INPUT_SMS_MODEL.split('.'))
from django import forms from django.db.models.loading import get_model from django.utils.translation import ugettext_lazy as _ from oscar.forms import widgets Voucher = get_model('voucher', 'Voucher') Benefit = get_model('offer', 'Benefit') Range = get_model('offer', 'Range') class VoucherForm(forms.Form): """ A specialised form for creating a voucher and offer model. """ name = forms.CharField(label=_("Name")) code = forms.CharField(label=_("Code")) start_date = forms.DateField(label=_("Start date"), widget=widgets.DatePickerInput()) end_date = forms.DateField(label=_("End date"), widget=widgets.DatePickerInput()) usage = forms.ChoiceField(choices=Voucher.USAGE_CHOICES, label=_("Usage")) benefit_range = forms.ModelChoiceField( label=_('Which products get a discount?'), queryset=Range.objects.all(), ) type_choices = ( (Benefit.PERCENTAGE, _('Percentage off of products in range')),
def manage_objects(request, model_name): # logger.info("Welcome to GLUEBOX api") return Epoxy(request).queryset(get_model("glue", model_name).objects.filter(), model_name=model_name).json()
def __new__(cls, name, bases, attrs): super_new = super(ModelBase, cls).__new__ parents = [b for b in bases if isinstance(b, ModelBase)] if not parents: # If this isn't a subclass of Model, don't do anything special. return super_new(cls, name, bases, attrs) # Create the class. module = attrs.pop('__module__') new_class = super_new(cls, name, bases, {'__module__': module}) attr_meta = attrs.pop('Meta', None) abstract = getattr(attr_meta, 'abstract', False) if not attr_meta: meta = getattr(new_class, 'Meta', None) else: meta = attr_meta base_meta = getattr(new_class, '_meta', None) if getattr(meta, 'app_label', None) is None: # Figure out the app_label by looking one level up. # For 'django.contrib.sites.models', this would be 'sites'. model_module = sys.modules[new_class.__module__] kwargs = {"app_label": model_module.__name__.split('.')[-2]} else: kwargs = {} new_class.add_to_class('_meta', Options(meta, **kwargs)) if not abstract: new_class.add_to_class('DoesNotExist', subclass_exception('DoesNotExist', tuple(x.DoesNotExist for x in parents if hasattr(x, '_meta') and not x._meta.abstract) or (ObjectDoesNotExist,), module)) new_class.add_to_class('MultipleObjectsReturned', subclass_exception('MultipleObjectsReturned', tuple(x.MultipleObjectsReturned for x in parents if hasattr(x, '_meta') and not x._meta.abstract) or (MultipleObjectsReturned,), module)) if base_meta and not base_meta.abstract: # Non-abstract child classes inherit some attributes from their # non-abstract parent (unless an ABC comes before it in the # method resolution order). if not hasattr(meta, 'ordering'): new_class._meta.ordering = base_meta.ordering if not hasattr(meta, 'get_latest_by'): new_class._meta.get_latest_by = base_meta.get_latest_by is_proxy = new_class._meta.proxy if getattr(new_class, '_default_manager', None): if not is_proxy: # Multi-table inheritance doesn't inherit default manager from # parents. new_class._default_manager = None new_class._base_manager = None else: # Proxy classes do inherit parent's default manager, if none is # set explicitly. new_class._default_manager = new_class._default_manager._copy_to_model(new_class) new_class._base_manager = new_class._base_manager._copy_to_model(new_class) # Bail out early if we have already created this class. m = get_model(new_class._meta.app_label, name, seed_cache=False, only_installed=False) if m is not None: return m # Add all attributes to the class. for obj_name, obj in attrs.items(): new_class.add_to_class(obj_name, obj) # All the fields of any type declared on this model new_fields = new_class._meta.local_fields + \ new_class._meta.local_many_to_many + \ new_class._meta.virtual_fields field_names = set([f.name for f in new_fields]) # Basic setup for proxy models. if is_proxy: base = None for parent in [cls for cls in parents if hasattr(cls, '_meta')]: if parent._meta.abstract: if parent._meta.fields: raise TypeError("Abstract base class containing model fields not permitted for proxy model '%s'." % name) else: continue if base is not None: raise TypeError("Proxy model '%s' has more than one non-abstract model base class." % name) else: base = parent if base is None: raise TypeError("Proxy model '%s' has no non-abstract model base class." % name) if (new_class._meta.local_fields or new_class._meta.local_many_to_many): raise FieldError("Proxy model '%s' contains model fields." % name) new_class._meta.setup_proxy(base) new_class._meta.concrete_model = base._meta.concrete_model else: new_class._meta.concrete_model = new_class # Do the appropriate setup for any model parents. o2o_map = dict([(f.rel.to, f) for f in new_class._meta.local_fields if isinstance(f, OneToOneField)]) for base in parents: original_base = base if not hasattr(base, '_meta'): # Things without _meta aren't functional models, so they're # uninteresting parents. continue parent_fields = base._meta.local_fields + base._meta.local_many_to_many # Check for clashes between locally declared fields and those # on the base classes (we cannot handle shadowed fields at the # moment). for field in parent_fields: if field.name in field_names: raise FieldError('Local field %r in class %r clashes ' 'with field of similar name from ' 'base class %r' % (field.name, name, base.__name__)) if not base._meta.abstract: # Concrete classes... base = base._meta.concrete_model if base in o2o_map: field = o2o_map[base] elif not is_proxy: attr_name = '%s_ptr' % base._meta.module_name field = OneToOneField(base, name=attr_name, auto_created=True, parent_link=True) new_class.add_to_class(attr_name, field) else: field = None new_class._meta.parents[base] = field else: # .. and abstract ones. for field in parent_fields: new_class.add_to_class(field.name, copy.deepcopy(field)) # Pass any non-abstract parent classes onto child. new_class._meta.parents.update(base._meta.parents) # Inherit managers from the abstract base classes. new_class.copy_managers(base._meta.abstract_managers) # Proxy models inherit the non-abstract managers from their base, # unless they have redefined any of them. if is_proxy: new_class.copy_managers(original_base._meta.concrete_managers) # Inherit virtual fields (like GenericForeignKey) from the parent # class for field in base._meta.virtual_fields: if base._meta.abstract and field.name in field_names: raise FieldError('Local field %r in class %r clashes '\ 'with field of similar name from '\ 'abstract base class %r' % \ (field.name, name, base.__name__)) new_class.add_to_class(field.name, copy.deepcopy(field)) if abstract: # Abstract base models can't be instantiated and don't appear in # the list of models for an app. We do the final setup for them a # little differently from normal models. attr_meta.abstract = False new_class.Meta = attr_meta return new_class new_class._prepare() register_models(new_class._meta.app_label, new_class) # Because of the way imports happen (recursively), we may or may not be # the first time this model tries to register with the framework. There # should only be one class for each model, so we always return the # registered version. return get_model(new_class._meta.app_label, name, seed_cache=False, only_installed=False)