Python index.exists_in函数代码示例

    def test_resetsearchindexes_command_individual_index(self, getdefaultlocale_mock):
        self.options['indexes'] = 'user'

        with self.settings(WIRECLOUD_INDEX_DIR=self.new_index_dir):
            call_command('resetsearchindexes', **self.options)

        self.options['stdout'].seek(0)
        self.options['stderr'].seek(0)

        for search_index in get_available_search_engines():
            if search_index.indexname != 'user':
                self.assertFalse(index.exists_in(self.new_index_dir, indexname=search_index.indexname))

        self.assertTrue(index.exists_in(self.new_index_dir, indexname='user'))

    def __init__(self, indexname=IDX_NAME, index_location=None,
                 repo_location=None, sa=None, repo_list=None,
                 repo_update_list=None):
        self.indexname = indexname

        self.index_location = index_location
        if not index_location:
            raise Exception('You have to provide index location')

        self.repo_location = repo_location
        if not repo_location:
            raise Exception('You have to provide repositories location')

        self.repo_paths = ScmModel(sa).repo_scan(self.repo_location)

        #filter repo list
        if repo_list:
            #Fix non-ascii repo names to unicode
            repo_list = map(safe_unicode, repo_list)
            self.filtered_repo_paths = {}
            for repo_name, repo in self.repo_paths.items():
                if repo_name in repo_list:
                    self.filtered_repo_paths[repo_name] = repo

            self.repo_paths = self.filtered_repo_paths

        #filter update repo list
        self.filtered_repo_update_paths = {}
        if repo_update_list:
            self.filtered_repo_update_paths = {}
            for repo_name, repo in self.repo_paths.items():
                if repo_name in repo_update_list:
                    self.filtered_repo_update_paths[repo_name] = repo
            self.repo_paths = self.filtered_repo_update_paths

        self.initial = True
        if not os.path.isdir(self.index_location):
            os.makedirs(self.index_location)
            log.info('Cannot run incremental index since it does not '
                     'yet exist running full build')
        elif not exists_in(self.index_location, IDX_NAME):
            log.info('Running full index build as the file content '
                     'index does not exist')
        elif not exists_in(self.index_location, CHGSET_IDX_NAME):
            log.info('Running full index build as the changeset '
                     'index does not exist')
        else:
            self.initial = False

def index_exists(dirname=INDEXDIR, indexname=INDEXNAME):
    """
    index_exists([dirname="index", indexname="MAIN"])
    
    Verifica se o índice :attr:`indexname` existe no diretório :attr:`dirname`.
    
    .. code-block:: python
    
        from storyline.engine.index import index_exists
        
        # Exemplo em que existe o diretório index com índice MAIN.
        >>> index_exists() 
        True
        >>> index_exists("index")
        True
        >>> index_exists("index", "indexname")
        False
        
    :param dirname: Nome do diretório do índice.
    :type dirname: str
    :param indexname: Nome do índice.
    :tyoe indexname: str
    :returns: True ou False.
    """
    return index.exists_in(dirname, indexname.upper())

def get_index(config):
    """
    Return the current index object if there is one.
    If not attempt to open the index in wsearch.indexdir.
    If there isn't one in the dir, create one. If there is
    not dir, create the dir.
    """
    index_dir = config.get('wsearch.indexdir',
            SEARCH_DEFAULTS['wsearch.indexdir'])
    if not os.path.isabs(index_dir):
        index_dir = os.path.join(config.get('root_dir', ''), index_dir)

    if exists_in(index_dir):
        # For now don't trap exceptions, as we don't know what they
        # will be and so we want them to raise destructively.
        index = open_dir(index_dir)
    else:
        try:
            os.mkdir(index_dir)
        except OSError:
            pass
        schema = config.get('wsearch.schema',
                SEARCH_DEFAULTS['wsearch.schema'])
        index = create_in(index_dir, Schema(**schema))
    return index

def createIndex():
    if not os.path.exists(index_dir):
        os.mkdir(index_dir)

    if not index.exists_in(index_dir):
        schema = Schema(title=TEXT(stored=True), body=TEXT(stored=True), link=TEXT(stored=True))
        ix = create_in(index_dir, schema)
    else:
        ix = index.open_dir(index_dir)

    writer = ix.writer()
    for feed in source_dn_all.entries:
        description = feed.summary.split("<img")
        title = feed.title.encode('utf-8')
        if checkIfDocExists(title, 'DN') is False:
            with open('dn_news.txt', 'a') as news_file:
                news_file.write(feed.title.encode('utf-8')+' \n')
            writer.add_document(title=feed.title, body=description[0], link=feed['feedburner_origlink'])

    for feed in source_jn_all.entries:
        description = feed.summary.split("<img")
        title = feed.title.encode('utf-8')
        if checkIfDocExists(title, 'JN') is False:
            with open('jn_news.txt', 'a') as news_file:
                news_file.write(feed.title.encode('utf-8')+' \n')
            writer.add_document(title=feed.title, body=description[0], link=feed['feedburner_origlink'])
    writer.commit()

def get_index(index_dir, schema=doc_schema):
    lib.ensure_dir(index_dir)
    if index.exists_in(index_dir):
        ix = index.open_dir(index_dir)
    else:
        ix = index.create_in(index_dir, schema)
    return ix

	def run(self):
		# open index
		self.buffer = deque(maxlen=BUFFERLINES)
		if not exists(self.indexdir):
			makedirs(self.indexdir)
			self.ix = create_in(self.indexdir, SCHEMA)
		else:
			if exists_in(self.indexdir): self.ix = open_dir(self.indexdir)
			else: self.ix = create_in(self.indexdir, SCHEMA)
		self.qp = QueryParser("content", self.ix.schema)
		self.searcher = self.ix.searcher()
		index_p = self.index_p
		while True:
			try:
				# check index_p
				try:
					type, data = index_p.recv()
				except EOFError: break
				try:
					if type == QUERY: self._processSearch(data)
					elif type == LOG: self._processLog(data)
					elif type == RENAME: self._processRename(data)
					else:
						prnt("Unexpected data in logindexsearch.")
				except:
					print_exc()
					prnt("EXCEPTION in logindexsearch process.")
			except KeyboardInterrupt:
				break
		self._dumpBuffer(self.buffer)
		self.searcher.close()
		self.ix.close()	

    def open_index(self, index_folder, create_new=False):
        self.index_folder = index_folder
        if create_new:
            if os.path.exists(index_folder):
                shutil.rmtree(index_folder)
                print "deleted index folder: " + index_folder

        if not os.path.exists(index_folder):
            os.mkdir(index_folder)

        exists = index.exists_in(index_folder)
        stemming_analyzer = StemmingAnalyzer()

        schema = Schema(
            path=ID(stored=True, unique=True)
            , filename=TEXT(stored=True, field_boost=100.0)
            , tags=KEYWORD(stored=True, scorable=True, field_boost=80.0)
            , headlines=KEYWORD(stored=True, scorable=True, field_boost=60.0)
            , doubleemphasiswords=KEYWORD(stored=True, scorable=True, field_boost=40.0)
            , emphasiswords=KEYWORD(stored=True, scorable=True, field_boost=20.0)
            , content=TEXT(stored=True, analyzer=stemming_analyzer)
            , time=STORED
        )
        if not exists:
            self.ix = index.create_in(index_folder, schema)
        else:
            self.ix = index.open_dir(index_folder)

 def _get_index(index_path, schema):
     if index.exists_in(index_path):
             return index.open_dir(index_path)
     else:
         if not os.path.exists(index_path):
             os.mkdir(index_path)
         return index.create_in(index_path, schema)

def search_files(index_dir, content):
    """
	search file content in index 
	if not hit: return False
	if hit: return results
	"""
    index_exist = index.exists_in(index_dir)
    if not index_exist:
        print ("index not exist")
        return False
    ix = index.open_dir(index_dir)
    content = unicode(content)
    with ix.searcher() as searcher:
        parser = QueryParser("content", ix.schema)
        query = parser.parse(content)
        # whoosh.searching.Results
        results = searcher.search(query)
        print (type(results))
        l = len(results)
        print l
        for h in results:
            # whoosh.searching.Hit
            print type(h)
            print h
        return results
    return False

    def _init_index(self, reset=False):
        index_path = os.path.join(jupyter_data_dir(), "index")

        # clear out old index if requested
        if reset:
            shutil.rmtree(index_path, True)

        # make sure there's a path to store the index data
        if not os.path.exists(index_path):
            os.makedirs(index_path)

        if not exists_in(index_path):
            # create an index with the current schema
            analyzer = ChineseAnalyzer()
            schema = Schema(
                basename=TEXT(stored=True, field_boost=5.0, analyzer=analyzer),
                dirname=ID(stored=True, analyzer=analyzer),
                path=ID(stored=True, unique=True, analyzer=analyzer),
                content=TEXT(stored=False, analyzer=analyzer),
                time=STORED,
            )
            self.ix = create_in(index_path, schema)
        else:
            # open the existing index
            self.ix = open_dir(index_path)

        # build a query parser based on the current schema
        self.query_parser = MultifieldParser(["content", "basename", "dirname"], self.ix.schema)

    def __init__(self):
        self.directory = os.path.join(edocuments.root_folder, '.index')
        self.dirty = False
        schema = Schema(**{
            PATH: ID(stored=True, unique=True),
            CONTENT: TEXT(stored=True),
            DATE: STORED,
            DIRECTORY: STORED,
            MD5: TEXT(stored=True),
        })
        self.parser_path = QueryParser("path_id", schema)
        self.parser_content = QueryParser("content", schema)

        if not exists_in(self.directory):
            os.makedirs(self.directory)
            self.index = create_in(self.directory, schema)
        else:
            self.index = open_dir(self.directory)
            if 'path' in self.index.schema.names():
                with self.index.writer() as writer:
                    writer.remove_field('path')
            if 'directory' not in self.index.schema.names():
                with self.index.writer() as writer:
                    writer.add_field('directory', STORED)
            if 'md5' not in self.index.schema.names():
                with self.index.writer() as writer:
                    writer.add_field('md5', TEXT(stored=True))
            print(
                'Field length:\npath: %i\ncontent: %i\nmd5: %i' % (
                    self.index.field_length("path_id"),
                    self.index.field_length("content"),
                    self.index.field_length("md5"),
                )
            )

def search_documents(filter):
    results = None

    # Check for existing index
    dir_path = os.path.join(DATA_DIR, 'index')

    if not os.path.exists(dir_path) or not Index.exists_in(dir_path):
        return None

    index = Index.open_dir(dir_path)

    if filter.startswith('tags:'):
        fields = ['tags']
        filter = filter[5:]
    else:
        fields = ['path', 'content']

    parser = MultifieldParser(fields, schema=index.schema)
    search_query = parser.parse(unicode(filter))

    # Try documents search
    try:
        searcher = index.searcher(closereader=False)

        return searcher.search(search_query,
            collapse=[sorting.FieldFacet('path'), sorting.FieldFacet('content')],
            collapse_order=sorting.FieldFacet('revision', reverse=True),
            sortedby=[sorting.FieldFacet('path'), sorting.FieldFacet('date', reverse=True)]
        )
    finally:
        searcher.close()

    return results

 def __init__(self, db_path):
     ensuredir(db_path)
     if index.exists_in(db_path):
         self.index = index.open_dir(db_path)
     else:
         self.index = index.create_in(db_path, schema=self.schema)
     self.qparser = QueryParser('text', self.schema)

 def _get_index(self):
     index_directory = "%s/%s" % (current_app.config.get("WHOOSH_BASE"), self.__class__.__name__)
     if not Path(index_directory).exists():
         Path(index_directory).mkdir()
     model_index = None
     if not index.exists_in(index_directory):
         return create_in(index_directory, self._get_schema())
     return index.open_dir(index_directory)