class ShrewdManager(BaseManager.from_queryset(ShrewdQuerySet)): ''' Shrewd manager for models. Manages only objects of the model which are __not in__ the recycle bin. ''' pass
class NewBaseManager(BaseManager.from_queryset(QuerySetEx)): def get(self, *args, **kwargs): data = None selfmodel = self.model # print selfmodel memcache_obj = selfmodel.memcached() query_key = memcache_obj.cache_query_key(**kwargs) # print querykey,"querycache====" if query_key: data_key = memcache_obj.get(query_key) if data_key: data = memcache_obj.get(data_key) if not data: data = super(NewBaseManager, self).get(*args, **kwargs) data.set_cache_db_key() else: data = super(NewBaseManager, self).get(*args, **kwargs) data_key = data.set_cache_db_key() memcache_obj.set(query_key, data_key, 60 * 3) else: data = super(NewBaseManager, self).get(*args, **kwargs) return data def get_queryset(self): return super(NewBaseManager, self).get_queryset()
class NaiveManager(BaseManager.from_queryset(NaiveQuerySet)): ''' Naive manager for models. Manages __all__ the objects of the model in the database. ''' pass
class Person(models.Model): GENDER_MALE = "m" GENDER_FEMALE = "f" GENDER_CHOICES = ( (GENDER_MALE, "Male"), (GENDER_FEMALE, "Female"), ) id = models.CharField(primary_key=True, max_length=10) subid = models.IntegerField() name = models.CharField(max_length=80, blank=True, null=True) country = models.ForeignKey( Country, max_length=50, null=True, on_delete=models.DO_NOTHING, ) gender = models.CharField(max_length=1, choices=GENDER_CHOICES, blank=True, null=True) objects = BaseManager.from_queryset(PersonQuerySet)() class Meta: unique_together = (("id", "subid"), ) base_manager_name = "objects"
class RecycleBinManager(BaseManager.from_queryset(RecycleBinQuerySet)): ''' Recycle bin manager for models. Manages only objects of the model which are __in__ the recycle bin. ''' pass
class TranslationManager(BaseManager.from_queryset(TranslationQuerySet)): def get_translation_model(self): return self.model.get_translation_model() def get_translation_model_reverse_query_name(self): return self.model.get_translation_model_reverse_query_name() def get_translation_model_field_names(self, reverse=False, m2m=False, own=True): return self.model.get_translation_model_field_names(reverse, m2m, own) def get_annotate_params(self): reverse_name = self.get_translation_model_reverse_query_name() fields = self.get_translation_model_field_names() annotate_params = {} for f in fields: annotate_params[f] = models.F('{}__{}'.format(reverse_name, f)) return annotate_params def get_queryset(self): q = super(TranslationManager, self).get_queryset() q = q.annotate(**self.get_annotate_params()) return q.all()
class LetterManager(BaseManager.from_queryset(LetterQuerySet)): def get_queryset(self): return ( super() .get_queryset() .filter(is_spam__in=[Letter.SPAM.unknown, Letter.SPAM.non_spam]) )
class ModelManager(BaseManager.from_queryset(QuerySet)): def __init__(self): super().__init__() self.instance = None # False 이면 self 가 source, True 이면 self 가 target (is_source 는 self 가 아니라 subfield 의 속성) self.reverse = None self.rel_type = None self.multiplicity = None self.target_field_name = None # for avoid pycharm warning self.subfield = None self.related_subfield = None def process_queryset(self, qs): types = self.model.types if types: qs = qs.filter(type__in=types) return qs def get_queryset(self): qs = super().get_queryset().filter(status__in=(Status.NORMAL, Status.WORKING)) return self.process_queryset(qs) def get_deleted(self, *args, **kwargs): kwargs = self.model.resolve_subfield_filters(**kwargs) assert kwargs["id"], "get_deleted() 호출 시에는 id 값을 넘겨야 합니다." qs = DjangoQuerySet(self.model) qs = qs.filter(status=Status.DELETED) qs = self.process_queryset(qs) instance = qs.get(*args, **kwargs) if instance.status != Status.DELETED: raise instance.__class__.DoesNotExist instance._old_status = Status.DELETED return instance def create(self, **kwargs): model = self.model kwargs = model.resolve_subfield_filters(**kwargs) obj = model(**kwargs) self._for_write = True assert obj.status in (Status.CREATING, Status.NEW), "인스턴스 생성이 최종 완료되기 전에 다른 곳에서 save() 가 먼저 호출되었습니다." obj.save() return obj def get_or_create(self, is_update_if_exist=False, **kwargs): model = self.model kwargs = model.resolve_subfield_filters(**kwargs) keys = {} for key in model.UNIQUE_KEY_SUBFIELD_NAMES + model.PSEUDO_KEY_SUBFIELD_NAMES: if key in kwargs: keys[key] = kwargs.pop(key) try: instance, is_create = self.get(**keys), False if is_update_if_exist: instance.patch(**kwargs) instance.save() except model.DoesNotExist: # uname 이 DerivedUnameSubfield 인 경우 kwargs 에 의해 계산되기 때문에 keys 보다 kwargs 가 먼저 전달되어야 한다. instance, is_create = self.create(**kwargs, **keys), True return instance, is_create
class ConversationMessageManager( BaseManager.from_queryset(ConversationMessageQuerySet)): def create(self, **kwargs): obj = super().create(**kwargs) # clear cached value if obj.thread and hasattr(obj.thread, '_replies_count'): del obj.thread._replies_count return obj
class base_manager_class(BaseManager.from_queryset(NodbQuerySet), Manager): """in DRF 3, rest_framework.relations.RelatedField#get_queryset checks: >>> isinstance(queryset, Manager) This is unfortunate, but we have to inherent from `Manager`, too! """ pass
class BasicContentManager(QueryManager, BaseManager.from_queryset(BasicContentQuerySet)): """ 初始化时支持传入过滤参数 https://django-model-utils.readthedocs.io/en/stable/managers.html#querymanager """ def get_queryset(self): return super().get_queryset().filter(is_removed=False)
class PandasDataFrameManager(BaseManager.from_queryset(DataFrame)): _queryset_class = PandasQuerySet def get_queryset(self): kwargs = {'model': self.model, 'using': self._db} if hasattr(self, '_hints'): kwargs['hints'] = self._hints return self._queryset_class(**kwargs)
class CustomManager(BaseManager.from_queryset(CustomQuerySet)): def get_queryset(self): """ Return a new QuerySet object. Subclasses can override this method to customize the behavior of the Manager. """ return self._queryset_class(model=self.model, using=self._db, hints=self._hints, query=CustomQuery(self.model))
class DataMartManager(BaseManager.from_queryset(DataMartQuerySet)): def truncate(self, reset=True): if reset: restart = 'RESTART IDENTITY' else: restart = '' with connections['default'].cursor() as cursor: cursor.execute('TRUNCATE TABLE "{0}" {1} CASCADE;'.format(self.model._meta.db_table, restart))
class DataStore(models.Model): key = models.CharField( max_length=255, primary_key=True, ) value = JSONField(default=dict, blank=False) objects = BaseManager.from_queryset(DataStoreQuerySet)() class Meta: ordering = ['key']
class BaseModelMange(BaseManager.from_queryset(CustomQuerySet)): def all(self): return self.filter().all() def filter(self, *args, **kwargs): fields = {i.name for i in self.model._meta.fields} if 'is_active' in fields and not kwargs.get('is_active'): kwargs['is_active'] = True elif 'status' in fields and not kwargs.get('status'): kwargs['status'] = 0 return super().filter(*args, **kwargs)
class NotificationManager(BaseManager.from_queryset(NotificationQuerySet)): def create_for_pickup_collectors(self, collectors, type): for collector in collectors: pickup = collector.pickupdate super().create(user=collector.user, type=type, context={ 'group': pickup.group.id, 'place': pickup.place.id, 'pickup': pickup.id, 'pickup_collector': collector.id, })
class NotificationManager(BaseManager.from_queryset(NotificationQuerySet)): def create_for_activity_participants(self, participants, type): for participant in participants: activity = participant.activity super().create(user=participant.user, type=type, context={ 'group': activity.group.id, 'place': activity.place.id, 'activity': activity.id, 'activity_participant': participant.id, })
class IndexEntryManager(BaseManager.from_queryset(SearchQuerySet)): def contribute_to_class(self, cls, name, **kwargs): super().contribute_to_class(cls, name, **kwargs) IndexManager.register(cls) @property def target_model(self): try: return self.model._meta.get_field( self.model.object_field).remote_field.model except FieldDoesNotExist: return None def get_or_prepare(self, obj): model = self.get_index_model(obj._meta.model) if not model: raise RuntimeError( f"Index for {obj._meta.model_name} is not configured.") try: indexed = model._meta.default_manager.get( **{model.object_field: obj}) setattr(indexed, model.object_field, obj) return indexed except model.DoesNotExist: return model(object=obj) def get_index_model(self, model): if model == self.target_model: return self.model for subcls in self.model.__subclasses__(): index = subcls._meta.default_manager.get_index_model(model) if index: return index return None def refresh(self, objects, break_on_failure=False): for obj in objects: try: self.get_or_prepare(obj).save() except Exception: logger.exception( f"Exception raised when updating index for '{obj}'") if break_on_failure: raise def rebuild(self): if self.target_model: return self.refresh(self.model.get_index_queryset()) for subcls in self.model.__subclasses__(): subcls._meta.default_manager.rebuild()
class ConversationMessageManager(BaseManager.from_queryset(ConversationMessageQuerySet)): def create(self, **kwargs): if 'thread' not in kwargs: # make sure author is participant (to receive notifications) conversation = kwargs.get('conversation') author = kwargs.get('author') conversation.conversationparticipant_set.get_or_create(user=author) obj = super().create(**kwargs) # clear cached value if obj.thread and hasattr(obj.thread, '_replies_count'): del obj.thread._replies_count return obj
class TransactionManager(BaseManager.from_queryset(TransactionQuerySet)): """ Custom manager """ def get_for_token(self, tidb64, token): transaction = None try: tid = urlsafe_base64_decode(tidb64).decode() transaction = Transaction.objects.get(pk=tid) if not default_token_generator.check_token(transaction, token): transaction = None except (TypeError, ValueError, OverflowError, ObjectDoesNotExist, ValidationError): pass return transaction
class ExchangeRate(models.Model): source = models.PositiveSmallIntegerField( choices=currency_exchange_choices, help_text=_('Where the exchange data comes from'), ) base_currency = models.CharField(max_length=3, db_index=True) rates = models.JSONField(default=dict) last_updated_at = models.DateTimeField(auto_now=True, db_index=True) objects = BaseManager.from_queryset(ExchangeRateQuerySet)() class Meta: ordering = ['base_currency', '-last_updated_at'] def __repr__(self): return 'Exchange rate for {0}'.format(self.base_currency)
class EntityManager(BaseManager.from_queryset(EavQuerySet)): """ Our custom manager, overrides ``models.Manager``. """ _queryset_class = EavQuerySet def create(self, **kwargs): """ Parse eav attributes out of *kwargs*, then try to create and save the object, then assign and save it's eav attributes. """ config_cls = getattr(self.model, '_eav_config_cls', None) if not config_cls or config_cls.manager_only: return super(EntityManager, self).create(**kwargs) prefix = '%s__' % config_cls.eav_attr new_kwargs = {} eav_kwargs = {} for key, value in kwargs.items(): if key.startswith(prefix): eav_kwargs.update({key[len(prefix):]: value}) else: new_kwargs.update({key: value}) obj = self.model(**new_kwargs) obj_eav = getattr(obj, config_cls.eav_attr) for key, value in eav_kwargs.items(): setattr(obj_eav, key, value) obj.save() return obj def get_or_create(self, **kwargs): """ Reproduces the behavior of get_or_create, eav friendly. """ try: return self.get(**kwargs), False except self.model.DoesNotExist: return self.create(**kwargs), True
class SerializableManager(BaseManager.from_queryset(SerializableQuerySet)): def __init__(self, *, select_related=None, prefetch_related=None, default_serializer=BaseSerializer): super().__init__() self.default_serializer = default_serializer( select_related=select_related, prefetch_related=prefetch_related, ) def to_serialize(self, serializer=None): if serializer is None: serializer = self.default_serializer return self.get_queryset().to_serialize(serializer) @classmethod def from_queryset(cls, queryset_class, class_name=None): if not hasattr(queryset_class, 'to_serialize'): queryset_class = type( f'SerializableQuerySet__{queryset_class.__name__}', (SerializableQuerySet, queryset_class), {}) return super().from_queryset(queryset_class, class_name=class_name)
class EntryManager(BaseManager.from_queryset(EntryQuerySet)): use_for_related_fields = True
class AccountManager(BaseManager.from_queryset(AccountQuerySet)): use_for_related_fields = True
class PIDManager(BaseManager.from_queryset(PIDQuerySet)): pass
class JobManager(BaseManager.from_queryset(JobQueryset)): """ Custom manager from queryset """ pass
class GroupManager(BaseManager.from_queryset(GroupQuerySet)): use_for_related_fields = True
class TaskManager(BaseManager.from_queryset(TaskQuerySet)): use_for_related_fields = True
name = models.CharField(max_length=100) slug = models.SlugField() class Meta: ordering = ['name'] def __str__(self): return self.name class DoesNotExistQuerySet(QuerySet): def get(self, *args, **kwargs): raise Author.DoesNotExist DoesNotExistBookManager = BaseManager.from_queryset(DoesNotExistQuerySet) class Book(models.Model): name = models.CharField(max_length=300) slug = models.SlugField() pages = models.IntegerField() authors = models.ManyToManyField(Author) pubdate = models.DateField() objects = models.Manager() does_not_exist = DoesNotExistBookManager() class Meta: ordering = ['-pubdate']
def get_manager(cls): return type('DictManager', (BaseManager.from_queryset(cls)), {})