def __init__(self):
    super(Manager, self).__init__()
    self._set_creation_counter()
    self.model = None
    self._inherited = False
    self._db = None

def aggregate(self, *args, **kwargs):
    return self.get_queryset().aggregate(*args, **kwargs)

def all(self):
    return self.get_queryset()

def annotate(self, *args, **kwargs):
    return self.get_queryset().annotate(*args, **kwargs)

def bulk_create(self, *args, **kwargs):
    return self.get_queryset().bulk_create(*args, **kwargs)

def complex_filter(self, *args, **kwargs):
    return self.get_queryset().complex_filter(*args, **kwargs)

def contribute_to_class(self, model, name):
    # TODO: Use weakref because of possible memory leak / circular reference.
    self.model = model
    # Only contribute the manager if the model is concrete
    if model._meta.abstract:
        setattr(model, name, AbstractManagerDescriptor(model))
    elif model._meta.swapped:
        setattr(model, name, SwappedManagerDescriptor(model))
    else:
    # if not model._meta.abstract and not model._meta.swapped:
        setattr(model, name, ManagerDescriptor(self))
    if not getattr(model, '_default_manager', None) or self.creation_counter < model._default_manager.creation_counter:
        model._default_manager = self
    if model._meta.abstract or (self._inherited and not self.model._meta.proxy):
        model._meta.abstract_managers.append((self.creation_counter, name,
                self))
    else:
        model._meta.concrete_managers.append((self.creation_counter, name,
            self))

def count(self):
    return self.get_queryset().count()

def create(self, **kwargs):
    return self.get_queryset().create(**kwargs)

def dates(self, *args, **kwargs):
    return self.get_queryset().dates(*args, **kwargs)

def datetimes(self, *args, **kwargs):
    return self.get_queryset().datetimes(*args, **kwargs)

def db_manager(self, using):
    obj = copy.copy(self)
    obj._db = using
    return obj

def defer(self, *args, **kwargs):
    return self.get_queryset().defer(*args, **kwargs)

def distinct(self, *args, **kwargs):
    return self.get_queryset().distinct(*args, **kwargs)

def earliest(self, *args, **kwargs):
    return self.get_queryset().earliest(*args, **kwargs)

def exclude(self, *args, **kwargs):
    return self.get_queryset().exclude(*args, **kwargs)

def exists(self, *args, **kwargs):
    return self.get_queryset().exists(*args, **kwargs)

def extra(self, *args, **kwargs):
    return self.get_queryset().extra(*args, **kwargs)

def filter(self, *args, **kwargs):
    return self.get_queryset().filter(*args, **kwargs)

def first(self):
    return self.get_queryset().first()

def get(self, **kwargs):
    if kwargs.has_key('public_id'):
        try:
            args = kwargs.copy()
            args['code'] = kwargs['public_id']
            args.pop('public_id')
            return super(CoreManager, self).get(**args)
        except ObjectDoesNotExist:
            args = kwargs.copy()
            args['id'] = kwargs['public_id']
            args.pop('public_id')
            return super(CoreManager, self).get(**args)
    return super(CoreManager, self).get(**kwargs)

def get_or_create(self, **kwargs):
    return self.get_queryset().get_or_create(**kwargs)

def wrapped(*args, **kwargs):
    warnings.warn(
        "`%s.%s` is deprecated, use `%s` instead." %
        (self.class_name, self.old_method_name, self.new_method_name),
        self.deprecation_warning, 2)
    return f(*args, **kwargs)

def get_query_set(self):
    "Return instrument query sets"
    return InstrumentQuerySet(self.model)

def in_bulk(self, *args, **kwargs):
    return self.get_queryset().in_bulk(*args, **kwargs)

def iterator(self, *args, **kwargs):
    return self.get_queryset().iterator(*args, **kwargs)

def last(self):
    return self.get_queryset().last()

def latest(self, *args, **kwargs):
    return self.get_queryset().latest(*args, **kwargs)

def none(self, *args, **kwargs):
    ""
    return self.get_query_set().none(*args, **kwargs)

def only(self, *args, **kwargs):
    return self.get_queryset().only(*args, **kwargs)

def order_by(self, *args, **kwargs):
    return self.get_queryset().order_by(*args, **kwargs)

def prefetch_related(self, *args, **kwargs):
    return self.get_queryset().prefetch_related(*args, **kwargs)

def quick_search(self, *args, **kwargs):
    return self.get_query_set().quick_search(*args, **kwargs)

def raw(self, raw_query, params=None, *args, **kwargs):
    return RawQuerySet(raw_query=raw_query, model=self.model, params=params, using=self._db, *args, **kwargs)

def reverse(self, *args, **kwargs):
    return self.get_queryset().reverse(*args, **kwargs)

def select_for_update(self, *args, **kwargs):
    return self.get_queryset().select_for_update(*args, **kwargs)

def select_related(self, *args, **kwargs):
    return self.get_queryset().select_related(*args, **kwargs)

def update(self, *args, **kwargs):
    return self.get_queryset().update(*args, **kwargs)

def using(self, *args, **kwargs):
    return self.get_queryset().using(*args, **kwargs)

def values(self, *args, **kwargs):
    return self.get_queryset().values(*args, **kwargs)

def values_list(self, *args, **kwargs):
    return self.get_queryset().values_list(*args, **kwargs)

def __init__(self, model=None, query=None, using=None):
    self.model = model
    self._db = using
    self.query = query or sql.Query(self.model)
    self._result_cache = None
    self._sticky_filter = False
    self._for_write = False
    self._prefetch_related_lookups = []
    self._prefetch_done = False
    self._known_related_objects = {}        # {rel_field, {pk: rel_obj}}

def aggregate(self, *args, **kwargs):
    """
    Returns a dictionary containing the calculations (aggregation)
    over the current queryset
    If args is present the expression is passed as a kwarg using
    the Aggregate object's default alias.
    """
    if self.query.distinct_fields:
        raise NotImplementedError("aggregate() + distinct(fields) not implemented.")
    for arg in args:
        kwargs[arg.default_alias] = arg
    query = self.query.clone()
    for (alias, aggregate_expr) in kwargs.items():
        query.add_aggregate(aggregate_expr, self.model, alias,
            is_summary=True)
    return query.get_aggregation(using=self.db)

def all(self):
    """
    Returns a new QuerySet that is a copy of the current one. This allows a
    QuerySet to proxy for a model manager in some cases.
    """
    return self._clone()

def annotate(self, *args, **kwargs):
    """
    Return a query set in which the returned objects have been annotated
    with data aggregated from related fields.
    """
    for arg in args:
        if arg.default_alias in kwargs:
            raise ValueError("The named annotation '%s' conflicts with the "
                             "default name for another annotation."
                             % arg.default_alias)
        kwargs[arg.default_alias] = arg
    names = getattr(self, '_fields', None)
    if names is None:
        names = set(self.model._meta.get_all_field_names())
    for aggregate in kwargs:
        if aggregate in names:
            raise ValueError("The annotation '%s' conflicts with a field on "
                "the model." % aggregate)
    obj = self._clone()
    obj._setup_aggregate_query(list(kwargs))
    # Add the aggregates to the query
    for (alias, aggregate_expr) in kwargs.items():
        obj.query.add_aggregate(aggregate_expr, self.model, alias,
            is_summary=False)
    return obj

def bulk_create(self, objs, batch_size=None):
    """
    Inserts each of the instances into the database. This does *not* call
    save() on each of the instances, does not send any pre/post save
    signals, and does not set the primary key attribute if it is an
    autoincrement field.
    """
    # So this case is fun. When you bulk insert you don't get the primary
    # keys back (if it's an autoincrement), so you can't insert into the
    # child tables which references this. There are two workarounds, 1)
    # this could be implemented if you didn't have an autoincrement pk,
    # and 2) you could do it by doing O(n) normal inserts into the parent
    # tables to get the primary keys back, and then doing a single bulk
    # insert into the childmost table. Some databases might allow doing
    # this by using RETURNING clause for the insert query. We're punting
    # on these for now because they are relatively rare cases.
    assert batch_size is None or batch_size > 0
    if self.model._meta.parents:
        raise ValueError("Can't bulk create an inherited model")
    if not objs:
        return objs
    self._for_write = True
    connection = connections[self.db]
    fields = self.model._meta.local_concrete_fields
    with transaction.commit_on_success_unless_managed(using=self.db):
        if (connection.features.can_combine_inserts_with_and_without_auto_increment_pk
            and self.model._meta.has_auto_field):
            self._batched_insert(objs, fields, batch_size)
        else:
            objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
            if objs_with_pk:
                self._batched_insert(objs_with_pk, fields, batch_size)
            if objs_without_pk:
                fields= [f for f in fields if not isinstance(f, AutoField)]
                self._batched_insert(objs_without_pk, fields, batch_size)
    return objs

def complex_filter(self, filter_obj):
    """
    Returns a new QuerySet instance with filter_obj added to the filters.
    filter_obj can be a Q object (or anything with an add_to_query()
    method) or a dictionary of keyword lookup arguments.
    This exists to support framework features such as 'limit_choices_to',
    and usually it will be more natural to use other methods.
    """
    if isinstance(filter_obj, Q) or hasattr(filter_obj, 'add_to_query'):
        clone = self._clone()
        clone.query.add_q(filter_obj)
        return clone
    else:
        return self._filter_or_exclude(None, **filter_obj)

def count(self):
    """
    Performs a SELECT COUNT() and returns the number of records as an
    integer.
    If the QuerySet is already fully cached this simply returns the length
    of the cached results set to avoid multiple SELECT COUNT(*) calls.
    """
    if self._result_cache is not None:
        return len(self._result_cache)
    return self.query.get_count(using=self.db)

def create(self, **kwargs):
    """
    Creates a new object with the given kwargs, saving it to the database
    and returning the created object.
    """
    obj = self.model(**kwargs)
    self._for_write = True
    obj.save(force_insert=True, using=self.db)
    return obj

def dates(self, field_name, kind, order='ASC'):
    """
    Returns a list of date objects representing all available dates for
    the given field_name, scoped to 'kind'.
    """
    assert kind in ("year", "month", "day"), \
            "'kind' must be one of 'year', 'month' or 'day'."
    assert order in ('ASC', 'DESC'), \
            "'order' must be either 'ASC' or 'DESC'."
    return self._clone(klass=DateQuerySet, setup=True,
            _field_name=field_name, _kind=kind, _order=order)

def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
    """
    Returns a list of datetime objects representing all available
    datetimes for the given field_name, scoped to 'kind'.
    """
    assert kind in ("year", "month", "day", "hour", "minute", "second"), \
            "'kind' must be one of 'year', 'month', 'day', 'hour', 'minute' or 'second'."
    assert order in ('ASC', 'DESC'), \
            "'order' must be either 'ASC' or 'DESC'."
    if settings.USE_TZ:
        if tzinfo is None:
            tzinfo = timezone.get_current_timezone()
    else:
        tzinfo = None
    return self._clone(klass=DateTimeQuerySet, setup=True,
            _field_name=field_name, _kind=kind, _order=order, _tzinfo=tzinfo)

def defer(self, *fields):
    """
    Defers the loading of data for certain fields until they are accessed.
    The set of fields to defer is added to any existing set of deferred
    fields. The only exception to this is if None is passed in as the only
    parameter, in which case all deferrals are removed (None acts as a
    reset option).
    """
    clone = self._clone()
    if fields == (None,):
        clone.query.clear_deferred_loading()
    else:
        clone.query.add_deferred_loading(fields)
    return clone

def delete(self):
    CHUNK=1024
    objects = self.model._meta.get_all_related_objects()
    ii = self.count()
    values = self.values_list('pk')
    for related in objects:
        i = 0
        while i < ii:
            ids = [v[0] for v in values[i:i + CHUNK]]
            filter = {related.field.name + '__pk__in': ids}
            q = related.model.objects.filter(**filter)
            if isinstance(related.field, WeakForeignKey):
                update = {related.field.name: None}
                q.update(**update)
            else:
                q.delete()
            i += CHUNK
    super(EnhancedQuerySet, self).delete()

def distinct(self, *field_names):
    """
    Returns a new QuerySet instance that will select only distinct results.
    """
    assert self.query.can_filter(), \
            "Cannot create distinct fields once a slice has been taken."
    obj = self._clone()
    obj.query.add_distinct_fields(*field_names)
    return obj

def earliest(self, field_name=None):
    return self._earliest_or_latest(field_name=field_name, direction="")

def exclude(self, *args, **kwargs):
    """
    Returns a new QuerySet instance with NOT (args) ANDed to the existing
    set.
    """
    return self._filter_or_exclude(True, *args, **kwargs)

def exists(self):
    if self._result_cache is None:
        return self.query.has_results(using=self.db)
    return bool(self._result_cache)

def extra(self, select=None, where=None, params=None, tables=None,
          order_by=None, select_params=None):
    """
    Adds extra SQL fragments to the query.
    """
    assert self.query.can_filter(), \
            "Cannot change a query once a slice has been taken"
    clone = self._clone()
    clone.query.add_extra(select, select_params, where, params, tables, order_by)
    return clone

def filter(self, *args, **kwargs):
    """
    Returns a new QuerySet instance with the args ANDed to the existing
    set.
    """
    return self._filter_or_exclude(False, *args, **kwargs)

def first(self):
    """
    Returns the first object of a query, returns None if no match is found.
    """
    qs = self if self.ordered else self.order_by('pk')
    try:
        return qs[0]
    except IndexError:
        return None

def get(self, *args, **kwargs):
    """
    Performs the query and returns a single object matching the given
    keyword arguments.
    """
    clone = self.filter(*args, **kwargs)
    if self.query.can_filter():
        clone = clone.order_by()
    num = len(clone)
    if num == 1:
        return clone._result_cache[0]
    if not num:
        raise self.model.DoesNotExist(
            "%s matching query does not exist." %
            self.model._meta.object_name)
    raise self.model.MultipleObjectsReturned(
        "get() returned more than one %s -- it returned %s!" %
        (self.model._meta.object_name, num))

def get_or_create(self, **kwargs):
    """
    Looks up an object with the given kwargs, creating one if necessary.
    Returns a tuple of (object, created), where created is a boolean
    specifying whether an object was created.
    """
    defaults = kwargs.pop('defaults', {})
    lookup = kwargs.copy()
    for f in self.model._meta.fields:
        if f.attname in lookup:
            lookup[f.name] = lookup.pop(f.attname)
    try:
        self._for_write = True
        return self.get(**lookup), False
    except self.model.DoesNotExist:
        try:
            params = dict((k, v) for k, v in kwargs.items() if LOOKUP_SEP not in k)
            params.update(defaults)
            obj = self.model(**params)
            with transaction.atomic(using=self.db):
                obj.save(force_insert=True, using=self.db)
            return obj, True
        except DatabaseError:
            exc_info = sys.exc_info()
            try:
                return self.get(**lookup), False
            except self.model.DoesNotExist:
                # Re-raise the DatabaseError with its original traceback.
                six.reraise(*exc_info)

def in_bulk(self, id_list):
    """
    Returns a dictionary mapping each of the given IDs to the object with
    that ID.
    """
    assert self.query.can_filter(), \
            "Cannot use 'limit' or 'offset' with in_bulk"
    if not id_list:
        return {}
    qs = self.filter(pk__in=id_list).order_by()
    return dict([(obj._get_pk_val(), obj) for obj in qs])

def iterator(self):
    """
    An iterator over the results from applying this QuerySet to the
    database.
    """
    fill_cache = False
    if connections[self.db].features.supports_select_related:
        fill_cache = self.query.select_related
    if isinstance(fill_cache, dict):
        requested = fill_cache
    else:
        requested = None
    max_depth = self.query.max_depth
    extra_select = list(self.query.extra_select)
    aggregate_select = list(self.query.aggregate_select)
    only_load = self.query.get_loaded_field_names()
    if not fill_cache:
        fields = self.model._meta.concrete_fields
    load_fields = []
    # If only/defer clauses have been specified,
    # build the list of fields that are to be loaded.
    if only_load:
        for field, model in self.model._meta.get_concrete_fields_with_model():
            if model is None:
                model = self.model
            try:
                if field.name in only_load[model]:
                    # Add a field that has been explicitly included
                    load_fields.append(field.name)
            except KeyError:
                # Model wasn't explicitly listed in the only_load table
                # Therefore, we need to load all fields from this model
                load_fields.append(field.name)
    index_start = len(extra_select)
    aggregate_start = index_start + len(load_fields or self.model._meta.concrete_fields)
    skip = None
    if load_fields and not fill_cache:
        # Some fields have been deferred, so we have to initialise
        # via keyword arguments.
        skip = set()
        init_list = []
        for field in fields:
            if field.name not in load_fields:
                skip.add(field.attname)
            else:
                init_list.append(field.attname)
        model_cls = deferred_class_factory(self.model, skip)
    # Cache db and model outside the loop
    db = self.db
    model = self.model
    compiler = self.query.get_compiler(using=db)
    if fill_cache:
        klass_info = get_klass_info(model, max_depth=max_depth,
                                    requested=requested, only_load=only_load)
    for row in compiler.results_iter():
        if fill_cache:
            obj, _ = get_cached_row(row, index_start, db, klass_info,
                                    offset=len(aggregate_select))
        else:
            # Omit aggregates in object creation.
            row_data = row[index_start:aggregate_start]
            if skip:
                obj = model_cls(**dict(zip(init_list, row_data)))
            else:
                obj = model(*row_data)
            # Store the source database of the object
            obj._state.db = db
            # This object came from the database; it's not being added.
            obj._state.adding = False
        if extra_select:
            for i, k in enumerate(extra_select):
                setattr(obj, k, row[i])
        # Add the aggregates to the model
        if aggregate_select:
            for i, aggregate in enumerate(aggregate_select):
                setattr(obj, aggregate, row[i + aggregate_start])
        # Add the known related objects to the model, if there are any
        if self._known_related_objects:
            for field, rel_objs in self._known_related_objects.items():
                # Avoid overwriting objects loaded e.g. by select_related
                if hasattr(obj, field.get_cache_name()):
                    continue
                pk = getattr(obj, field.get_attname())
                try:
                    rel_obj = rel_objs[pk]
                except KeyError:
                    pass               # may happen in qs1 | qs2 scenarios
                else:
                    setattr(obj, field.name, rel_obj)
        yield obj

def last(self):
    """
    Returns the last object of a query, returns None if no match is found.
    """
    qs = self.reverse() if self.ordered else self.order_by('-pk')
    try:
        return qs[0]
    except IndexError:
        return None

def latest(self, field_name=None):
    return self._earliest_or_latest(field_name=field_name, direction="-")

def none(self): # redundant with none() in recent Django svn
    "Return an empty result set"
    return self.extra(where = ["0 = 1"])

def only(self, *fields):
    """
    Essentially, the opposite of defer. Only the fields passed into this
    method and that are not already specified as deferred are loaded
    immediately when the queryset is evaluated.
    """
    if fields == (None,):
        # Can only pass None to defer(), not only(), as the rest option.
        # That won't stop people trying to do this, so let's be explicit.
        raise TypeError("Cannot pass None as an argument to only().")
    clone = self._clone()
    clone.query.add_immediate_loading(fields)
    return clone

def order_by(self, *field_names):
    """
    Returns a new QuerySet instance with the ordering changed.
    """
    assert self.query.can_filter(), \
            "Cannot reorder a query once a slice has been taken."
    obj = self._clone()
    obj.query.clear_ordering(force_empty=False)
    obj.query.add_ordering(*field_names)
    return obj

def prefetch_related(self, *lookups):
    """
    Returns a new QuerySet instance that will prefetch the specified
    Many-To-One and Many-To-Many related objects when the QuerySet is
    evaluated.
    When prefetch_related() is called more than once, the list of lookups to
    prefetch is appended to. If prefetch_related(None) is called, the
    the list is cleared.
    """
    clone = self._clone()
    if lookups == (None,):
        clone._prefetch_related_lookups = []
    else:
        clone._prefetch_related_lookups.extend(lookups)
    return clone

def quick_search(self, pattern):
    "Perform a quick search on text and char fields"
    from telemeta.models.instrument import Instrument
    mod = Instrument()
    pattern = pattern.strip()
    q = Q(code__contains=pattern)
    fields = mod.to_dict()
    keys =  fields.keys()
    for field in keys:
        field_str = str(mod._meta.get_field(field))
        if 'CharField' in field_str or 'TextField' in field_str:
            q = q | word_search_q(field, pattern)
    return self.filter(q)

def reverse(self):
    """
    Reverses the ordering of the QuerySet.
    """
    clone = self._clone()
    clone.query.standard_ordering = not clone.query.standard_ordering
    return clone

def select_for_update(self, **kwargs):
    """
    Returns a new QuerySet instance that will select objects with a
    FOR UPDATE lock.
    """
    # Default to false for nowait
    nowait = kwargs.pop('nowait', False)
    obj = self._clone()
    obj._for_write = True
    obj.query.select_for_update = True
    obj.query.select_for_update_nowait = nowait
    return obj

def select_related(self, *fields, **kwargs):
    """
    Returns a new QuerySet instance that will select related objects.
    If fields are specified, they must be ForeignKey fields and only those
    related objects are included in the selection.
    If select_related(None) is called, the list is cleared.
    """
    if 'depth' in kwargs:
        warnings.warn('The "depth" keyword argument has been deprecated.\n'
                'Use related field names instead.', DeprecationWarning, stacklevel=2)
    depth = kwargs.pop('depth', 0)
    if kwargs:
        raise TypeError('Unexpected keyword arguments to select_related: %s'
                % (list(kwargs),))
    obj = self._clone()
    if fields == (None,):
        obj.query.select_related = False
    elif fields:
        if depth:
            raise TypeError('Cannot pass both "depth" and fields to select_related()')
        obj.query.add_select_related(fields)
    else:
        obj.query.select_related = True
    if depth:
        obj.query.max_depth = depth
    return obj

def update(self, **kwargs):
    """
    Updates all elements in the current QuerySet, setting all the given
    fields to the appropriate values.
    """
    assert self.query.can_filter(), \
            "Cannot update a query once a slice has been taken."
    self._for_write = True
    query = self.query.clone(sql.UpdateQuery)
    query.add_update_values(kwargs)
    with transaction.commit_on_success_unless_managed(using=self.db):
        rows = query.get_compiler(self.db).execute_sql(None)
    self._result_cache = None
    return rows