Python xapian.inmemory_open函数代码示例

def add_from_purchased_but_needs_reinstall_data(purchased_but_may_need_reinstall_list, db, cache):
    """Add application that have been purchased but may require a reinstall

    This adds a inmemory database to the main db with the special
    PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME channel prefix

    :return: a xapian query to get all the apps that need reinstall
    """
    # magic
    db_purchased = xapian.inmemory_open()
    # go over the items we have
    for item in purchased_but_may_need_reinstall_list:
        # FIXME: what to do with duplicated entries? we will end
        #        up with two xapian.Document, one for the for-pay
        #        and one for the availalbe one from s-c-agent
        #try:
        #    db.get_xapian_document(item.name,
        #                           item.package_name)
        #except IndexError:
        #    # item is not in the xapian db
        #    pass
        #else:
        #    # ignore items we already have in the db, ignore
        #    continue
        # index the item
        try:
            parser = SCAPurchasedApplicationParser(item)
            index_app_info_from_parser(parser, db_purchased, cache)
        except Exception as e:
            LOG.exception("error processing: %s " % e)
    # add new in memory db to the main db
    db.add_database(db_purchased)
    # return a query
    query = xapian.Query("AH"+PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME)
    return query

 def test_build_from_software_center_agent(self, mock_find_oauth):
     # pretend we have no token
     mock_find_oauth.return_value = None
     db = xapian.inmemory_open()
     cache = apt.Cache()
     # monkey patch distro to ensure we get data
     distro = softwarecenter.distro.get_distro()
     distro.get_codename = lambda: "natty"
     # we test against the real https://software-center.ubuntu.com here
     # so we need network
     res = update_from_software_center_agent(db, cache, ignore_cache=True)
     # check results
     self.assertTrue(res)
     self.assertTrue(db.get_doccount() > 1)
     for p in db.postlist(""):
         doc = db.get_document(p.docid)
         ppa = doc.get_value(XapianValues.ARCHIVE_PPA)
         self.assertTrue(
             ppa.startswith("commercial-ppa") and ppa.count("/") == 1, "ARCHIVE_PPA value incorrect, got '%s'" % ppa
         )
         self.assertTrue("-icon-" in doc.get_value(XapianValues.ICON))
         # check support url in the DB
         url = doc.get_value(XapianValues.SUPPORT_SITE_URL)
         if url:
             self.assertTrue(url.startswith("http") or url.startswith("mailto:"))

    def test_reinstall_purchased_xapian(self, mock_helper, mock_agent):
        small_available =  [ self.available[0] ]
        mock_agent.return_value = self._make_fake_scagent(
            small_available, self.available_for_me)

        db = xapian.inmemory_open()
        cache = get_test_pkg_info()

        # now create purchased debs xapian index (in memory because
        # we store the repository passwords in here)
        old_db_len = db.get_doccount()
        update_from_software_center_agent(db, cache)
        # ensure we have the new item
        self.assertEqual(db.get_doccount(), old_db_len+2)
        # query
        query = get_reinstall_previous_purchases_query()
        enquire = xapian.Enquire(db)
        enquire.set_query(query)
        matches = enquire.get_mset(0, db.get_doccount())
        self.assertEqual(len(matches), 1)
        distroseries = platform.dist()[2]
        for m in matches:
            doc = db.get_document(m.docid)
            self.assertEqual(doc.get_value(XapianValues.PKGNAME), "photobomb")
            self.assertEqual(
                doc.get_value(XapianValues.ARCHIVE_SIGNING_KEY_ID),
                "1024R/75254D99")
            self.assertEqual(doc.get_value(XapianValues.ARCHIVE_DEB_LINE),
                "deb https://username:[email protected]"
                 "private-ppa.launchpad.net/commercial-ppa-uploaders"
                 "/photobomb/ubuntu %s main" % distroseries)

 def test_update_from_json_string(self):
     db = xapian.inmemory_open()
     cache = apt.Cache()
     p = os.path.join(DATA_DIR, "app-info-json", "apps.json")
     res = update_from_json_string(db, cache, open(p).read(), origin=p)
     self.assertTrue(res)
     self.assertEqual(db.get_doccount(), 1)

def get_test_db_from_app_install_data(datadir):
    db = xapian.inmemory_open()
    cache = get_pkg_info()
    cache.open()
    res = update_from_app_install_data(db, cache, datadir)
    if res is False:
        raise AssertionError("Failed to build db from '%s'" % datadir)
    return db

 def test_update_from_appstream_xml(self):
     db = xapian.inmemory_open()
     res = update_from_appstream_xml(db, self.cache, os.path.join(DATA_DIR, "app-info"))
     self.assertTrue(res)
     self.assertEqual(db.get_doccount(), 1)
     # FIXME: improve tests
     for p in db.postlist(""):
         doc = db.get_document(p.docid)
         for term in doc.termlist():
             self.assertIsInstance(term, xapian.TermListItem)
             self.assertIsInstance(term.term, basestring)
         for value in doc.values():
             self.assertIsInstance(value, xapian.ValueItem)
             self.assertIsInstance(value.num, long)
             self.assertIsInstance(value.value, basestring)

    def test_for_purchase_apps_date_published(self, mock_find_oauth):
        # pretend we have no token
        mock_find_oauth.return_value = None
        # os.environ["SOFTWARE_CENTER_DEBUG_HTTP"] = "1"
        # os.environ["SOFTWARE_CENTER_AGENT_HOST"] = "http://sc.staging.ubuntu.com/"
        # staging does not have a valid cert
        os.environ["PISTON_MINI_CLIENT_DISABLE_SSL_VALIDATION"] = "1"
        cache = get_test_pkg_info()
        db = xapian.inmemory_open()
        res = update_from_software_center_agent(db, cache, ignore_cache=True)
        self.assertTrue(res)

        for p in db.postlist(""):
            doc = db.get_document(p.docid)
            date_published = doc.get_value(XapianValues.DATE_PUBLISHED)
            # make sure that a date_published value is provided
            self.assertNotEqual(date_published, "")
            self.assertNotEqual(date_published, None)

def make_catalog(uri, fields):
    """Creates a new and empty catalog in the given uri.

       If uri=None the catalog is made "in memory".
       fields must be a dict. It contains some informations about the
       fields in the database.
       By example:
       fields = {'id': Integer(is_key_field=True, is_stored=True,
                               is_indexed=True), ...}
    """
    # In memory
    if uri is None:
        db = inmemory_open()
        return Catalog(db, fields, asynchronous_mode=False)

    # In the local filesystem
    path = lfs.get_absolute_path(uri)
    db = WritableDatabase(path, DB_CREATE)
    return Catalog(db, fields)

def add_from_purchased_but_needs_reinstall_data(purchased_but_may_need_reinstall_list, db, cache):
    """Add application that have been purchased but may require a reinstall
    
    This adds a inmemory database to the main db with the special
    PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME channel prefix

    :return: a xapian query to get all the apps that need reinstall
    """
    # magic
    db_purchased = xapian.inmemory_open()
    # go over the items we have
    for item in purchased_but_may_need_reinstall_list:
        # FIXME: what to do with duplicated entries? we will end
        #        up with two xapian.Document, one for the for-pay
        #        and one for the availalbe one from s-c-agent
        #try:
        #    db.get_xapian_document(item.name,
        #                           item.package_name)
        #except IndexError:
        #    # item is not in the xapian db
        #    pass
        #else:
        #    # ignore items we already have in the db, ignore
        #    continue
        # index the item
        try:
            # we fake a channel here
            item.channel = PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME
            # and empty category to make the parser happy
            item.categories = ""
            # WARNING: item.name needs to be different than
            #          the item.name in the DB otherwise the DB
            #          gets confused about (appname, pkgname) duplication
            item.name = utf8(_("%s (already purchased)")) % utf8(item.name)
            parser = SoftwareCenterAgentParser(item)
            index_app_info_from_parser(parser, db_purchased, cache)
        except Exception as e:
            LOG.exception("error processing: %s " % e)
    # add new in memory db to the main db
    db.add_database(db_purchased)
    # return a query
    query = xapian.Query("AH"+PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME)
    return query

def test_preserve_enquire_sorter():
    """Test preservation of sorter set on enquire.

    """
    db = xapian.inmemory_open()
    doc = xapian.Document()
    doc.add_term("foo")
    doc.add_value(1, "1")
    db.add_document(doc)
    db.add_document(doc)

    def make_enq1(db):
        enq = xapian.Enquire(db)
        sorter = xapian.MultiValueSorter()
        enq.set_sort_by_key(sorter, True)
        del sorter
        return enq

    enq = make_enq1(db)
    enq.set_query(xapian.Query("foo"))
    enq.get_mset(0, 10)

    def make_enq2(db):
        enq = xapian.Enquire(db)
        sorter = xapian.MultiValueSorter()
        enq.set_sort_by_key_then_relevance(sorter, True)
        del sorter
        return enq

    enq = make_enq2(db)
    enq.set_query(xapian.Query("foo"))
    enq.get_mset(0, 10)

    def make_enq3(db):
        enq = xapian.Enquire(db)
        sorter = xapian.MultiValueSorter()
        enq.set_sort_by_relevance_then_key(sorter, True)
        del sorter
        return enq

    enq = make_enq3(db)
    enq.set_query(xapian.Query("foo"))
    enq.get_mset(0, 10)

    def _database(self, writable=False):
        """
        Private method that returns a xapian.Database for use.

        Optional arguments:
            ``writable`` -- Open the database in read/write mode (default=False)

        Returns an instance of a xapian.Database or xapian.WritableDatabase
        """
        if settings.HAYSTACK_XAPIAN_PATH == MEMORY_DB_NAME:
            if not SearchBackend.inmemory_db:
                SearchBackend.inmemory_db = xapian.inmemory_open()
            return SearchBackend.inmemory_db
        if writable:
            database = xapian.WritableDatabase(settings.HAYSTACK_XAPIAN_PATH, xapian.DB_CREATE_OR_OPEN)
        else:
            try:
                database = xapian.Database(settings.HAYSTACK_XAPIAN_PATH)
            except xapian.DatabaseOpeningError:
                raise InvalidIndexError(u"Unable to open index at %s" % settings.HAYSTACK_XAPIAN_PATH)

        return database

    def _database(self, writable=False):
        """
        Private method that returns a xapian.Database for use.

        Optional arguments:
            ``writable`` -- Open the database in read/write mode (default=False)

        Returns an instance of a xapian.Database or xapian.WritableDatabase
        """
        if self.path == MEMORY_DB_NAME:
            if not self.inmemory_db:
                self.inmemory_db = xapian.inmemory_open()
            return self.inmemory_db
        if writable:
            database = xapian.WritableDatabase(self.path, xapian.DB_CREATE_OR_OPEN)
        else:
            try:
                database = xapian.Database(self.path)
            except xapian.DatabaseOpeningError:
                raise InvalidIndexError(u'Unable to open index at %s' % self.path)

        return database

    def _database(self, writable=False):
        """
        Private method that returns a xapian.Database for use.

        Optional arguments:
            ``writable`` -- Open the database in read/write mode (default=False)

        Returns an instance of a xapian.Database or xapian.WritableDatabase
        """
        if isinstance(settings.HAYSTACK_XAPIAN_PATH, basestring):

            if self.path == MEMORY_DB_NAME:
                if not self.inmemory_db:
                    self.inmemory_db = xapian.inmemory_open()
                return self.inmemory_db
            if writable:
                database = xapian.WritableDatabase(self.path, xapian.DB_CREATE_OR_OPEN)
            else:
                try:
                    database = xapian.Database(self.path)
                except xapian.DatabaseOpeningError:
                    raise InvalidIndexError(u'Unable to open index at %s' % self.path)
        else:
            try:
                host, port = settings.HAYSTACK_XAPIAN_PATH
            except ValueError:
                raise InvalidIndexError(u'Unable to open index at %s' % settings.HAYSTACK_XAPIAN_PATH)

            if writable:
                database = xapian.remote_open_writable(host, port)
                database = xapian.WritableDatabase(database)
            else:
                try:
                    database = xapian.remote_open(host, port)
                    database = xapian.Database(database)
                except xapian.DatabaseOpeningError:
                    raise InvalidIndexError(u'Unable to open index at %s' % settings.HAYSTACK_XAPIAN_PATH)

        return database

def setup_database():
    """Set up and return an inmemory database with 5 documents.

    """
    db = xapian.inmemory_open()

    doc = xapian.Document()
    doc.set_data("is it cold?")
    doc.add_term("is")
    doc.add_posting("it", 1)
    doc.add_posting("cold", 2)
    db.add_document(doc)

    doc = xapian.Document()
    doc.set_data("was it warm?")
    doc.add_posting("was", 1)
    doc.add_posting("it", 2)
    doc.add_posting("warm", 3)
    db.add_document(doc)
    doc.set_data("was it warm? two")
    doc.add_term("two", 2)
    doc.add_value(0, xapian.sortable_serialise(2))
    db.add_document(doc)
    doc.set_data("was it warm? three")
    doc.add_term("three", 3)
    doc.add_value(0, xapian.sortable_serialise(1.5))
    db.add_document(doc)
    doc.set_data("was it warm? four it")
    doc.add_term("four", 4)
    doc.add_term("it", 6)
    doc.add_posting("it", 7)
    doc.add_value(5, "five")
    doc.add_value(9, "nine")
    doc.add_value(0, xapian.sortable_serialise(2))
    db.add_document(doc)

    expect(db.get_doccount(), 5)
    return db

 def test_update_from_var_lib_apt_lists(self):
     # ensure we index with german locales to test i18n
     os.environ["LANGUAGE"] = "de"
     db = xapian.inmemory_open()
     res = update_from_var_lib_apt_lists(db, self.cache, listsdir=os.path.join(DATA_DIR, "app-info"))
     self.assertTrue(res)
     self.assertEqual(db.get_doccount(), 1)
     # test if Name-de was picked up
     i = 0
     for it in db.postlist("AAFestplattenbelegung analysieren"):
         i += 1
     self.assertEqual(i, 1)
     # test if gettext worked
     found_gettext_translation = False
     for it in db.postlist("AAFestplattenbelegung analysieren"):
         doc = db.get_document(it.docid)
         for term_iter in doc.termlist():
             # a german term from the app-info file to ensure that
             # it got indexed in german
             if term_iter.term == "festplattenbelegung":
                 found_gettext_translation = True
                 break
     self.assertTrue(found_gettext_translation)