def enable_router_hints():
    import new
    from django.db import DEFAULT_DB_ALIAS, router
    from landlord.conf import settings

    def _router_func(action):
        def _route_db(self, model, **hints):
            from landlord import landlord

            hints.update({settings.LANDLORD_DEFAULT_NAMESPACE_KEY: landlord.get_current_namespace()})

            chosen_db = None
            for router in self.routers:
                try:
                    method = getattr(router, action)
                except AttributeError:
                    # If the router doesn't have a method, skip to the next one.
                    pass
                else:
                    chosen_db = method(model, **hints)
                    if chosen_db:
                        return chosen_db
            try:
                return hints["instance"]._state.db or DEFAULT_DB_ALIAS
            except KeyError:
                return DEFAULT_DB_ALIAS

        return _route_db

    router.db_for_read = new.instancemethod(_router_func("db_for_read"), router, None)
    router.db_for_write = new.instancemethod(_router_func("db_for_write"), router, None)

def add_filters():
    """Add filters for every choice in ItemToPush.STATUS.

    This filters are mostly useless except if you do a lot of management from
    command line"""
    constants = [c for c in dir(models.ITEM_TO_PUSH_STATUS) if c.isupper() and c not in NOT_CONSTANTS]
    for current_constant in constants:
        method_name = current_constant.lower()
        def get_filter_function(constant):
            def filter_by_status(self):
                value = getattr(models.ITEM_TO_PUSH_STATUS, constant)
                return self.filter(status=value)
            return filter_by_status
        filter_by_status = get_filter_function(current_constant)
        filter_by_status_method = instancemethod(filter_by_status, None, BaseQuerySet)
        setattr(BaseQuerySet, method_name, filter_by_status_method)

        def get_query_function(name):
            def query_by_status(self):
                method = getattr(self.get_query_set(), name)
                return method()
            return query_by_status
        query_by_status = get_query_function(method_name)
        query_by_status_method = instancemethod(query_by_status, None, BaseManager)
        setattr(BaseManager, method_name, query_by_status_method)

    def test_0020_static_file_url(self):
        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()

            file_buffer = buffer('test-content')
            file = self.create_static_file(file_buffer)
            self.assertFalse(file.url)

            app = self.get_app()
            static_file_obj = self.static_file_obj
            with app.test_client() as c:
                # Patch the home page method
                def home_func(self, file_id):
                    return render_template(
                        'home.jinja',
                        static_file_obj=static_file_obj,
                        static_file_id=file_id,
                    )
                home_func = functools.partial(home_func, file_id=file.id)
                c.application.view_functions[
                    'nereid.website.home'] = new.instancemethod(
                    home_func, self.nereid_website_obj
                )
                self.nereid_website_obj.home = new.instancemethod(
                    home_func, self.nereid_website_obj
                )
                rv = c.get('/en_US/')
                self.assertTrue('/en_US/static-file/test/test.png' in rv.data)
                self.assertEqual(rv.status_code, 200)

	def __init__(self, category_algorithm, rank_by, frequency_bins = None):
		if category_algorithm == "frequency-ifos-oninstruments":
			self.category_func = lambda self, on_instruments, participating_instruments, frequency: (on_instruments, participating_instruments, self.frequency_bins[frequency])
		elif category_algorithm == "oninstruments":
			self.category_func = lambda self, on_instruments, participating_instruments, frequency: on_instruments
		else:
			raise ValueError, category_algorithm
		self.category_func = instancemethod(self.category_func, self, self.__class__)

		if rank_by == "snr":
			self.reputation_func = lambda self, snr, uncombined_ifar, likelihood: snr
		elif rank_by == "uncombined-ifar":
			# cast to float so this does the right thing when
			# we get "inf" as a string
			self.reputation_func = lambda self, snr, uncombined_ifar, likelihood: float(uncombined_ifar)
		elif rank_by == "likelihood":
			self.reputation_func = lambda self, snr, uncombined_ifar, likelihood: likelihood
		else:
			raise ValueError, rank_by
		self.rank_by = rank_by
		self.reputation_func = instancemethod(self.reputation_func, self, self.__class__)

		self.frequency_bins = frequency_bins
		self.reputations = {}
		self.cached_livetime = {}
		self.extrapolate = False
		self.extrapolation_coeffs = {}
		self.categories = []

    def __init__(cls, name, bases, cls_dict):
        cls.use_metaclass = 1

        def fake_method(self):
            pass

        new.instancemethod(fake_method, None, cls)

 def __init__(self, link, flash_type):
   self.stopped = False
   self.status = ''
   self.link = link
   self.flash_type = flash_type
   self._waiting_for_callback = False
   self._read_callback_data = []
   self.link.add_callback(ids.FLASH_DONE, self._done_callback)
   self.link.add_callback(ids.FLASH_READ, self._read_callback)
   self.ihx_elapsed_ops = 0 # N operations finished in self.write_ihx
   self.ihx_total_ops = None # Total operations in self.write_ihx call
   if self.flash_type == "STM":
     self.flash_type_byte = 0
     self.addr_sector_map = stm_addr_sector_map
     # Add STM-specific functions.
     self.__dict__['lock_sector'] = \
         new.instancemethod(_stm_lock_sector, self, Flash)
     self.__dict__['unlock_sector'] = \
         new.instancemethod(_stm_unlock_sector, self, Flash)
     self.n_sectors = STM_N_SECTORS
     self.restricted_sectors = STM_RESTRICTED_SECTORS
   elif self.flash_type == "M25":
     self.flash_type_byte = 1
     self.addr_sector_map = m25_addr_sector_map
     # Add M25-specific functions.
     self.__dict__['write_status'] = \
         new.instancemethod(_m25_write_status, self, Flash)
     self.n_sectors = M25_N_SECTORS
     self.restricted_sectors = M25_RESTRICTED_SECTORS
   else:
     raise ValueError("flash_type must be \"STM\" or \"M25\"")

    def __init__(self, api_token, endpoint="https://shreddr.captricity.com/api/backbone/schema", version=None):
        """
        endpoint must be the full url to the API schema document, like `http://127.0.0.1:8000/api/backbone/schema'
        api_token is the unique string associated with your account's profile which allows API access
        """
        self.api_token = api_token
        self.endpoint = endpoint
        self.parsed_endpoint = urlparse.urlparse(self.endpoint)
        self.api_version = version 
        schema_url = self.parsed_endpoint.path
        if version: schema_url = schema_url + '?version=' + version
        self.schema = self._get_data(schema_url)
        self.api_version = self.schema['version']

        for resource in self.schema['resources']:
            if "GET" in resource['allowed_request_methods']:
                read_callable = _generate_read_callable(resource['name'], resource['display_name'], resource['arguments'], resource['regex'], resource['doc'], resource['supported'])
                setattr(self, read_callable.__name__, new.instancemethod(read_callable, self, self.__class__))
            if "PUT" in resource['allowed_request_methods']:
                update_callable = _generate_update_callable(resource['name'], resource['display_name'], resource['arguments'], resource['regex'], resource['doc'], resource['supported'], resource['put_syntaxes'])
                setattr(self, update_callable.__name__, new.instancemethod(update_callable, self, self.__class__))
            if "POST" in resource['allowed_request_methods']:
                create_callable = _generate_create_callable(resource['name'], resource['display_name'], resource['arguments'], resource['regex'], resource['doc'], resource['supported'], resource['post_syntaxes'], resource['is_action'])
                setattr(self, create_callable.__name__, new.instancemethod(create_callable, self, self.__class__))
            if "DELETE" in resource['allowed_request_methods']:
                delete_callable = _generate_delete_callable(resource['name'], resource['display_name'], resource['arguments'], resource['regex'], resource['doc'], resource['supported'])
                setattr(self, delete_callable.__name__, new.instancemethod(delete_callable, self, self.__class__))

    def __init__(self, link, flash_type, sbp_version, max_queued_ops=1):
        """
        Object representing either of the two flashes (STM/M25) on the Piksi,
        including methods to erase, program, and read.

        Parameters
        ----------
        link : sbp.client.handler.Handler
          Handler to send messages to Piksi over and register callbacks with.
        flash_type : string
          Which Piksi flash to interact with ("M25" or "STM").
        sbp_version : (int, int)
          SBP protocol version, used to select messages to send.
        max_queued_ops : int
          Maximum number of Flash read/program operations to queue in device flash.
          (0.5 * ADDRS_PER_OP + SBP packet overhead) * max_queued_ops is how much
          of the device UART RX buffer will be filled by the program/read callback
          messages. A higher value will significantly speed up flashing, but can
          result in RX buffer overflows in other UARTs if the device is receiving
          data on other UARTs.

        Returns
        -------
        out : Flash instance
        """
        self._n_queued_ops = 0
        self.max_queued_ops = max_queued_ops
        self.nqo_lock = Lock()
        self.stopped = False
        self.status = ''
        self.link = link
        self.flash_type = flash_type
        self.sbp_version = sbp_version
        # IntelHex object to store read flash data in that was read from device.
        self._read_callback_ihx = IntelHex()
        self.link.add_callback(self._done_callback, SBP_MSG_FLASH_DONE)
        self.link.add_callback(self._read_callback, SBP_MSG_FLASH_READ_RESP)
        self.ihx_elapsed_ops = 0  # N operations finished in self.write_ihx
        if self.flash_type == "STM":
            self.flash_type_byte = 0
            self.addr_sector_map = stm_addr_sector_map
            # Add STM-specific functions.
            self.__dict__['lock_sector'] = \
                new.instancemethod(_stm_lock_sector, self, Flash)
            self.__dict__['unlock_sector'] = \
                new.instancemethod(_stm_unlock_sector, self, Flash)
            self.n_sectors = STM_N_SECTORS
            self.restricted_sectors = STM_RESTRICTED_SECTORS
        elif self.flash_type == "M25":
            self.flash_type_byte = 1
            self.addr_sector_map = m25_addr_sector_map
            # Add M25-specific functions.
            self.__dict__['write_status'] = \
                new.instancemethod(_m25_write_status, self, Flash)
            self.n_sectors = M25_N_SECTORS
            self.restricted_sectors = M25_RESTRICTED_SECTORS
        else:
            raise ValueError(
                "flash_type must be \"STM\" or \"M25\", got \"%s\"" %
                flash_type)

    def test_template_rendered(self):

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()
            app = self.get_app()

            # Patch the home page method
            def home_func(self):
                return nereid.render_template(
                    'home.jinja', whiskey=42
                )
            app.view_functions['nereid.website.home'] = \
                new.instancemethod(
                    home_func, self.nereid_website_obj
            )
            self.nereid_website_obj.home = new.instancemethod(
                home_func, self.nereid_website_obj
            )

            recorded = []

            def record(sender, template, context):
                recorded.append((template, context))

            flask.template_rendered.connect(record, app)
            try:
                app.test_client().get('/')
                self.assertEqual(len(recorded), 1)
                template, context = recorded[0]
                self.assertEqual(template.name, 'home.jinja')
                self.assertEqual(context['whiskey'], 42)
            finally:
                flask.template_rendered.disconnect(record, app)

    def __init__(self, hardware_obj):
        QObject.__init__(self)

        self.setIn = new.instancemethod(lambda self: None, self)
        self.setOut = self.setIn
        self.getState = new.instancemethod(lambda self: "unknown", self)

        self.dev = hardware_obj

        try:
            sClass = str(self.dev.__class__)
            i, j = re.search("'.*'", sClass).span()
        except BaseException:
            dev_class = sClass
        else:
            dev_class = sClass[i + 1 : j - 1]
        self.devClass = dev_class.split(".")[-1]

        # print "Type is",self.devClass
        if self.devClass == "Device":
            self.devClass = "Procedure"

        if not self.devClass in (
            "WagoPneu",
            "Shutter",
            "SpecMotorWSpecPositions",
            "Procedure",
        ):
            self.devClass = "WagoPneu"

        initFunc = getattr(self, "init%s" % self.devClass)
        initFunc()
        self.setIn = getattr(self, "setIn%s" % self.devClass)
        self.setOut = getattr(self, "setOut%s" % self.devClass)
        self.getState = getattr(self, "getState%s" % self.devClass)

    def test_request_exception_signal(self):
        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()
            app = self.get_app()
            app.config['DEBUG'] = False
            recorded = []

            # Patch the home page method
            def home_func(self):
                1 // 0

            app.view_functions['nereid.website.home'] = \
                new.instancemethod(
                    home_func, self.nereid_website_obj
            )
            self.nereid_website_obj.home = new.instancemethod(
                home_func, self.nereid_website_obj
            )

            def record(sender, exception):
                recorded.append(exception)

            flask.got_request_exception.connect(record, app)
            try:
                self.assertEqual(
                    app.test_client().get('/').status_code, 500
                )
                self.assertEqual(len(recorded), 1)
                assert isinstance(recorded[0], ZeroDivisionError)
            finally:
                flask.got_request_exception.disconnect(record, app)

    def test_0020_static_file_url(self):
        with Transaction().start(testing_proxy.db_name, 1, None) as txn:
            file_id, = self.static_file_obj.search([], limit=1)
            file = self.static_file_obj.browse(file_id)
            self.assertFalse(file.url)

        app = self.get_app()
        with app.test_client() as c:
            # Patch the home page method
            def home_func(self, file_id):
                static_file_obj = Pool().get('nereid.static.file')
                return render_template(
                    'home.jinja', 
                    static_file_obj=static_file_obj,
                    static_file_id=file_id,
                )
            home_func = functools.partial(home_func, file_id=file_id)
            c.application.view_functions[
                'nereid.website.home'] = new.instancemethod(
                    home_func, self.website_obj
            )
            self.website_obj.home = new.instancemethod(
                home_func, self.website_obj
            )
            rv = c.get('/en_US/')
            self.assertTrue('/en_US/static-file/test/test.png' in rv.data)
            self.assertEqual(rv.status_code, 200)

def override_replace(target, name, func, combiner=replacement, reverse=False):
    obj = target
    cls = target.__class__

    is_derived = False
    # The function is defined in the superclass (which we don't override)
    if not name in cls.__dict__:
        is_derived = True
        # Bind the call to the superclass function
        orig_func = new.instancemethod(lambda self, *args, **named: getattr(super(cls, self), name).__call__(*args,**named), obj, cls)
    else:
        orig_func = getattr(obj, name)
    if not hasattr(orig_func, "stacked"):
        stacked_func = stacked_function(orig_func, combiner=combiner, reverse=reverse)
        setattr(target, name, stacked_func)
    else: stacked_func = orig_func
    # Add the replacement effect along with the card name (in case of multiple effects)
    new_func = [new.instancemethod(func, obj, cls), name, False] #card.name, False]
    stacked_func.add_func(new_func)
    def restore(stacked_func=stacked_func):
        stacked_func.remove_func(new_func)
        if not stacked_func.stacking():
            setattr(target, name, stacked_func.funcs[0])
            del stacked_func
    func.expire = restore
    return restore

 def decorator(orig):
     if isinstance(orig, (new.classobj, type)):
         cls2 = orig
         class Before(object): pass
         b = Before()
         setattr(cls, "Before" + cls2.__name__, b)
         setattr(cls2, "super", b)
         for k, v in cls2.__dict__.items():
             if isinstance(v, new.function):
                 f = decorator(v)
                 setattr(b, f.func_name, f.__original__)
                 v.__original__ = f.__original__
         return cls2
     else:
         f = orig
         func_name = f.func_name
         replacement_method = new.instancemethod(f, None, cls)
         def monkeypatch(*a, **k):
             return replacement_method(*a, **k)
         f = monkeypatch
         f.func_name = func_name
         method = getattr(cls, func_name, None)
         f.__original__ = method
         setattr(cls, func_name,
                 new.instancemethod(f, None, cls))
         return f

	def __call__( cls, *args, **kwargs ):
		instance = cls.__new__( cls )
		instance.__init__( *args, **kwargs )

		setUpMethods    = []
		tearDownMethods = []

		for _cls in reversed( cls.__mro__ ):
			setUp    = getattr( _cls, 'setUp', None )
			tearDown = getattr( _cls, 'tearDown', None )

			if setUp:
				if not len( setUpMethods ) or setUp != setUpMethods[-1]:
					setUpMethods.append( setUp )

			if tearDown:
				if not len( tearDownMethods ) or tearDown != tearDownMethods[0]:
					tearDownMethods.insert( 0, tearDown )

		def chain( methods ):
			def fun( self ):
				for method in methods:
					method( self )
			return fun

		instance.setUp    = new.instancemethod( chain( setUpMethods ), instance, cls )
		instance.tearDown = new.instancemethod( chain( tearDownMethods ), instance, cls )

		return instance 

 def __init__(self, filename=None, mirror=False):
     if filename:
         self.load(filename)
     self.mirror = mirror
     self.plot_stretch = new.instancemethod(_make_plotting_func(self.stretch_density, "Stretching"), self)
     self.plot_bend = new.instancemethod(_make_plotting_func(self.bend_density, "Bending"), self)
     self.plot_height = new.instancemethod(_make_plotting_func(lambda: self.f_z, "Height"), self)

def setup_logging(increase_padding=False):
    """
    Setup overall logging engine and add 2 more levels of logging lower than
    DEBUG, TRACE and GARBAGE.
    """
    import logging

    if increase_padding and logging.getLoggerClass() is not Logging:
        logging.setLoggerClass(Logging)

    if not hasattr(LoggingLoggerClass, 'trace'):
        def trace(cls, msg, *args, **kwargs):
            return cls.log(5, msg, *args, **kwargs)

        logging.addLevelName(5, 'TRACE')
        LoggingLoggerClass.trace = new.instancemethod(
            trace, None, LoggingLoggerClass
        )

    if not hasattr(LoggingLoggerClass, 'garbage'):
        def garbage(cls, msg, *args, **kwargs):
            return cls.log(1, msg, *args, **kwargs)

        logging.addLevelName(1, 'GARBAGE')
        LoggingLoggerClass.garbage = new.instancemethod(
            garbage, None, LoggingLoggerClass
        )

    # Set the root logger at the lowest level possible
    logging.getLogger().setLevel(1)

    def _configFeature(self, ftr, obj):
        global loadedFeatures

        if type(ftr) == str:
            modName, ftrName = ftr.split('.')

            ftrClsName = "%s_Feature" % ftrName

            mod = __import__('indico.tests.python.unit.%s' % modName,
                             globals(), locals(), [ftrClsName])
            ftr = mod.__dict__[ftrClsName]
        else:
            pass

        for name, func in ftr.__dict__.iteritems():
            if name.startswith('_action_'):
                setattr(obj, name[7:], new.instancemethod(func, obj, obj.__class__))

            elif name.startswith('_context_'):
                setattr(obj, name, new.instancemethod(func, obj, obj.__class__))

        ftrObj = ftr()

        if ftr not in loadedFeatures:
            ftrObj.start(obj)
            loadedFeatures.append(ftr)

        return ftrObj

 def __get__(self, obj, t = None):
   if t is None:
     raise NotImplementedError # I don't know what to do here
   if obj is None:
     return new.instancemethod(self.__func__, t, type(t))
   else:
     return new.instancemethod(self.__func__, obj, t)

    def setup_wiki_handlers(self):
        """
            Have the MoinMoin formatter handle markup when it makes sense. These
            are portions of the document that do not contain reST specific
            markup. This allows these portions of the document to look
            consistent with other wiki pages.

            Setup dispatch routines to handle basic document markup. The
            hanlders dict is the html4css1 handler name followed by the wiki
            handler name.
        """
        handlers = {
            # Text Markup
            'emphasis': 'emphasis',
            'strong': 'strong',
            'literal': 'code',
            # Blocks
            'literal_block': 'preformatted',
            # Simple Lists
            # bullet-lists are handled completely by docutils because it uses
            # the node context to decide when to make a compact list
            # (no <p> tags).
            'list_item': 'listitem',
            # Definition List
            'definition_list': 'definition_list',
        }
        for rest_func, moin_func in handlers.items():
            visit_func, depart_func = self.create_wiki_functor(moin_func)
            visit_func = new.instancemethod(visit_func, self, MoinTranslator)
            depart_func = new.instancemethod(depart_func, self, MoinTranslator)
            setattr(self, 'visit_%s' % (rest_func), visit_func)
            setattr(self, 'depart_%s' % (rest_func), depart_func)