High level Python client for Elasticsearch

Overview

Elasticsearch DSL

Elasticsearch DSL is a high-level library whose aim is to help with writing and running queries against Elasticsearch. It is built on top of the official low-level client (elasticsearch-py).

It provides a more convenient and idiomatic way to write and manipulate queries. It stays close to the Elasticsearch JSON DSL, mirroring its terminology and structure. It exposes the whole range of the DSL from Python either directly using defined classes or a queryset-like expressions.

It also provides an optional wrapper for working with documents as Python objects: defining mappings, retrieving and saving documents, wrapping the document data in user-defined classes.

To use the other Elasticsearch APIs (eg. cluster health) just use the underlying client.

Installation

pip install elasticsearch-dsl

Examples

Please see the examples directory to see some complex examples using elasticsearch-dsl.

Compatibility

The library is compatible with all Elasticsearch versions since 2.x but you have to use a matching major version:

For Elasticsearch 7.0 and later, use the major version 7 (7.x.y) of the library.

For Elasticsearch 6.0 and later, use the major version 6 (6.x.y) of the library.

For Elasticsearch 5.0 and later, use the major version 5 (5.x.y) of the library.

For Elasticsearch 2.0 and later, use the major version 2 (2.x.y) of the library.

The recommended way to set your requirements in your setup.py or requirements.txt is:

# Elasticsearch 7.x
elasticsearch-dsl>=7.0.0,<8.0.0

# Elasticsearch 6.x
elasticsearch-dsl>=6.0.0,<7.0.0

# Elasticsearch 5.x
elasticsearch-dsl>=5.0.0,<6.0.0

# Elasticsearch 2.x
elasticsearch-dsl>=2.0.0,<3.0.0

The development is happening on master, older branches only get bugfix releases

Search Example

Let's have a typical search request written directly as a dict:

from elasticsearch import Elasticsearch
client = Elasticsearch()

response = client.search(
    index="my-index",
    body={
      "query": {
        "bool": {
          "must": [{"match": {"title": "python"}}],
          "must_not": [{"match": {"description": "beta"}}],
          "filter": [{"term": {"category": "search"}}]
        }
      },
      "aggs" : {
        "per_tag": {
          "terms": {"field": "tags"},
          "aggs": {
            "max_lines": {"max": {"field": "lines"}}
          }
        }
      }
    }
)

for hit in response['hits']['hits']:
    print(hit['_score'], hit['_source']['title'])

for tag in response['aggregations']['per_tag']['buckets']:
    print(tag['key'], tag['max_lines']['value'])

The problem with this approach is that it is very verbose, prone to syntax mistakes like incorrect nesting, hard to modify (eg. adding another filter) and definitely not fun to write.

Let's rewrite the example using the Python DSL:

from elasticsearch import Elasticsearch
from elasticsearch_dsl import Search

client = Elasticsearch()

s = Search(using=client, index="my-index") \
    .filter("term", category="search") \
    .query("match", title="python")   \
    .exclude("match", description="beta")

s.aggs.bucket('per_tag', 'terms', field='tags') \
    .metric('max_lines', 'max', field='lines')

response = s.execute()

for hit in response:
    print(hit.meta.score, hit.title)

for tag in response.aggregations.per_tag.buckets:
    print(tag.key, tag.max_lines.value)

As you see, the library took care of:

  • creating appropriate Query objects by name (eq. "match")
  • composing queries into a compound bool query
  • putting the term query in a filter context of the bool query
  • providing a convenient access to response data
  • no curly or square brackets everywhere

Persistence Example

Let's have a simple Python class representing an article in a blogging system:

from datetime import datetime
from elasticsearch_dsl import Document, Date, Integer, Keyword, Text, connections

# Define a default Elasticsearch client
connections.create_connection(hosts=['localhost'])

class Article(Document):
    title = Text(analyzer='snowball', fields={'raw': Keyword()})
    body = Text(analyzer='snowball')
    tags = Keyword()
    published_from = Date()
    lines = Integer()

    class Index:
        name = 'blog'
        settings = {
          "number_of_shards": 2,
        }

    def save(self, ** kwargs):
        self.lines = len(self.body.split())
        return super(Article, self).save(** kwargs)

    def is_published(self):
        return datetime.now() > self.published_from

# create the mappings in elasticsearch
Article.init()

# create and save and article
article = Article(meta={'id': 42}, title='Hello world!', tags=['test'])
article.body = ''' looong text '''
article.published_from = datetime.now()
article.save()

article = Article.get(id=42)
print(article.is_published())

# Display cluster health
print(connections.get_connection().cluster.health())

In this example you can see:

  • providing a default connection
  • defining fields with mapping configuration
  • setting index name
  • defining custom methods
  • overriding the built-in .save() method to hook into the persistence life cycle
  • retrieving and saving the object into Elasticsearch
  • accessing the underlying client for other APIs

You can see more in the persistence chapter of the documentation.

Migration from elasticsearch-py

You don't have to port your entire application to get the benefits of the Python DSL, you can start gradually by creating a Search object from your existing dict, modifying it using the API and serializing it back to a dict:

body = {...} # insert complicated query here

# Convert to Search object
s = Search.from_dict(body)

# Add some filters, aggregations, queries, ...
s.filter("term", tags="python")

# Convert back to dict to plug back into existing code
body = s.to_dict()

Development

Activate Virtual Environment (virtualenvs):

$ virtualenv venv
$ source venv/bin/activate

To install all of the dependencies necessary for development, run:

$ pip install -e '.[develop]'

To run all of the tests for elasticsearch-dsl-py, run:

$ python setup.py test

Alternatively, it is possible to use the run_tests.py script in test_elasticsearch_dsl, which wraps pytest, to run subsets of the test suite. Some examples can be seen below:

# Run all of the tests in `test_elasticsearch_dsl/test_analysis.py`
$ ./run_tests.py test_analysis.py

# Run only the `test_analyzer_serializes_as_name` test.
$ ./run_tests.py test_analysis.py::test_analyzer_serializes_as_name

pytest will skip tests from test_elasticsearch_dsl/test_integration unless there is an instance of Elasticsearch on which a connection can occur. By default, the test connection is attempted at localhost:9200, based on the defaults specified in the elasticsearch-py Connection class. Because running the integration tests will cause destructive changes to the Elasticsearch cluster, only run them when the associated cluster is empty. As such, if the Elasticsearch instance at localhost:9200 does not meet these requirements, it is possible to specify a different test Elasticsearch server through the TEST_ES_SERVER environment variable.

$ TEST_ES_SERVER=my-test-server:9201 ./run_tests

Documentation

Documentation is available at https://elasticsearch-dsl.readthedocs.io.

Contribution Guide

Want to hack on Elasticsearch DSL? Awesome! We have Contribution-Guide.

License

Copyright 2013 Elasticsearch

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Issues
  • Querying a nested object

    Querying a nested object

    What is the proper way to query a nested object? Example: s = Search(using=es).index("my_index").query("nested", path="features", query=Q("term", features__name="foo"))

    The code expects keyword parameters, but specifying a nested field like 'features.name' as keyword parameter is not possible and 'features__name' is not converted into 'features.name'.

    If it's not supported, I could add some code that will properly replace double underscores with periods.

    enhancement 
    opened by adriaant 27
  • Can't paginate using elasticsearch_dsl

    Can't paginate using elasticsearch_dsl

    When I want to paginate through the search results, not iterate as the scan does from elasticsearch.helpers.

    My current workaround is something like this

    search = Search()
    ...
    # construct your search query
    ...
    result = search.params(search_type='scan', scroll='1m').execute()
    scroll_id = result.scroll_id
    # Now start using scroll_id to do the pagination,
    # but I have to use Elasticsearch.scroll which returns dictionaries not a Result object
    client = connections.get_connection()
    while data_to_paginate:
      result = Response(client.scroll(scroll_id, scroll='1m'))
    

    There probably should be a helper function that should abstract at least the following part

    client = connections.get_connection()
    result = Response(client.scroll(scroll_id, scroll='1m'))
    

    Maybe even getting the scroll_id from the result. Basically the user probably shouldn't be getting a client and manually constructing a Response object.

    @HonzaKral what do you think? If we agree on the interface I could implement that since I am probably going to do that for my project.

    opened by mamikonyana 26
  • sort results to check if the field exits

    sort results to check if the field exits

    hi, when i sort the search results with sort(), some documents don't exit, so it goes error. a way is to use filter() to check if the documents have the filed to sort. but how to use filter to check if the field exits in the documents?

    thanks

    opened by wdfsinap 24
  • Feature Request: Sliced Scroll

    Feature Request: Sliced Scroll

    Correct me if I am wrong, but I don't see an option in the DSL for a scan with sliced scroll.

    https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-request-scroll.html#sliced-scroll

    This would be helpful to return queries faster in specific cases.

    Any current plans to support this?

    enhancement discuss 
    opened by bfgoodrich 22
  • Querying for a range of dates.

    Querying for a range of dates.

    Hello Honza, I'm hoping you might be able to help me out with one last issue i'm having. I need to query for all articles that have 404 errors as a response field and I also need to find all of them from withing the lasts 15 inutes. The issues show up inside of Kibana but they are not showing in my queries.

    I've been having a really hard time getting this to work and there aren't any clear examples of querying in a specific range of time in the docs. Here's my script.

    s = Search(using=es, index= "_all") \
            .query("match", response = "404")\
            .filter('range', timestamp={'from': datetime.datetime.now() - datetime.timedelta(minutes=15), 'to' : datetime.datetime.now() }) #, 'lte': datetime(2010, 10, 9)})
            #.filter("range", '@timestamp': {"gte": "now-15m", "lte": "now"}) #, "lt" : "2014-12-31 1:00:00"}) 
            #filter is for a range of possible times. 
            #.filter("range", timestamp={ "gt":"now -5m","lt":"now" })
    response = s.execute()
    
    opened by davidawad 22
  • Add Async I/O Support

    Add Async I/O Support

    NOTE: This commit message is outdated and will be updated before merging.

    This commit adds support for async I/O that mirrors the support added to elasticsearch-py in elastic/elasticsearch-py#1203.

    Changes:

    • A new client argument was added to elasticsearch_dsl.connections.create_connection to allow users to provide the elasticsearch._async.AsyncElasticsearch as their preferred client class. Passing AsyncElasticsearch will enable asynchronous behavior in elasticsearch_dsl.
    • Async versions of the FacetedSearch, Index, Mapping, Search, and UpdateByQuery classes have been added to elasticsearch_dsl._async. The paths for these classes mirror the paths for their sync versions. These classes defer to their respective sync classes for all methods that don't perform I/O.
    • Async versions of Document.delete, .get, .init, .mget, .save, and .update have been added to the AsyncDocument class:
      • Document.delete -> AsyncDocument.delete_async
      • Document.get -> AsyncDocument.get_async
      • Document.init -> AsyncDocument.init_async
      • Document.mget -> AsyncDocument.mget_async
      • Document.save -> AsyncDocument.save_async
      • Document.update -> AsyncDocument.update_async
      • NOTE: Why did I choose delete_async over async def delete? Because I felt that async calls should be optional, even when using AsyncDocument. Ideally, these functions would exist directly on the Document class, but the async/await syntax was introduced in Python 3.6 and causes problems for lower versions. Putting the async/await features in a separate file and including that file conditionally based on the Python version solves these problems.
    • Where possible, the existing methods have been refactored to re-use their existing implementation instead of creating duplication.

    Closes #1355.

    opened by lolripgg 20
  • How to get all results back from search?

    How to get all results back from search?

    After executing a search, the Search hits.total is over 9000. However, when I check the length of hits.hits it is only 10:

    >>> client = Elasticsearch(['http://nightly.apinf.io:14002'])
    >>> search = Search(using=client)
    >>> results = search.execute()
    >>> results.hits.total
    9611
    >>> len(results.hits.hits)
    10
    

    How do I get back all 9611 search results?

    opened by brylie 20
  • Integration of official async ES client into DSL library

    Integration of official async ES client into DSL library

    Hi team,

    Great effort on contributing and maintaining a great layer on top of ES access.

    While there are some discussions around the async integration into the official DSL library like #704 and #556 I did not find any conclusion on that. I did my research and also found there isn't anything existing. While there are some prototypes and suggestions like here I did not see an implementation.

    I was presuming, it could be due to two reasons: Either its really not there and no body has raised a PR yet, (or) this could be a trivial implementation so most users took care by overriding the parent classes.

    In any case, I needed the integration of the official async python library into DSL. I was experimenting many ways, and something simple yet required to duplicate was to create async_xyz classes on top of the low level APIs that were accessing the es client functions and eventually not awaiting the coroutines from async ES client.

    That said, here is a very basic working/and tested implementation in my fork https://github.com/elastic/elasticsearch-dsl-py/compare/master...vaidsu:master

    Please consider this as a basic prototype implementation and I just started writing tests. I am not sure, if this is good to go, or not. Then if yes, need to understand how far I need to write tests, I am just planning to make all the sync tests runnable on async calls.

    Please let me know. If you like the thought, but have suggestions, also feel free to share -- I am open to contribute back.

    Thanks

    opened by vaidsu 19
  • Allow index settings in Meta.index

    Allow index settings in Meta.index

    Currently, when defining a new DocType you have to create a separate Index object if you wish to configure any index-level settings. With the deprecation of multiple types in elasticsearch 6.0 it might make more sense to just allow the index settings to configurable on the DocType itself in some fashion.

    This would then allow even for situations where given DocType is present in multiple indices (time-based indices for example) meaning its Meta.index would specify a wildcard (products-* for example) and provide settings which would then allow it to generate and save an IndeTemplate and/or create any particular index via the init classmethod.

    Any ideas and feedback is more than welcome!

    Inspired by @3lnc's comment: https://github.com/elastic/elasticsearch-dsl-py/issues/779#issuecomment-350047587

    enhancement discuss 
    opened by HonzaKral 19
  • How to create a geo_point

    How to create a geo_point

    I am testing an index with geo_point. The mapping is like the following "city": { "properties": { "city": {"type": "string"}, "state": {"type": "string"}, "location": {"type": "geo_point"} } }

    I cannot find the type to import from elasticsearch_dsl. Is "geo_point" supported? If it is, how can I declare a class with attribute of type "geo_point" and create an object of "geo_point"? Thanks.

    opened by Al77056 17
  • problem to save a doctype and the doctype has a field like as String(index='not_analyzed', multi=True)

    problem to save a doctype and the doctype has a field like as String(index='not_analyzed', multi=True)

    Hi

    Nowadays I have a problemm, I would like to use the DocType class and one of its parameters save as a list of strings, so I defined this:

    class application(DocType):

    short_name = String(index='not_analyzed')
    lic_servers = String(index='not_analyzed', multi=True)
    
    updated_at = Date()
    
    
    class Meta:
        id = ''
    
    
    def save(self, ** kwargs):
        self.meta.id = self.short_name
        self.updated_at = datetime.now()
        return super(application,self).save(** kwargs)
    

    It was to save in elastic searc a document in this form:

    api = application.get(id=my_ID,index=my_index,ignore=404)

    if api == None: api = application(short_name = m)

    api.lic_servers.append('lic_server_0')

    res = api.save()

    But I have the problemm that when I have more than one lic_server in this way for example:

    api.lic_servers =>['lic_server1' , 'lic_server2', 'lic_server3', ...... 'lic_serverN']

    I have the problem to save because:

    res = api.save()

    And res = FALSE.

    Could somebody tell me something about this?

    Thanks in advance.

    opened by juandasgandaras 17
  • Reevaluate global expand_to__dot settings.

    Reevaluate global expand_to__dot settings.

    By default I would like to set expand_to__dot to False, however, once the application import a Query/Q the global settings is not reevaluated again in the initialization.

    opened by diegosperes 0
  • Add AttrList.to_list()

    Add AttrList.to_list()

    AttrDict has to_dict() but AttrList does not have to_list().

    AttrList does not work for PyDantic as a data type. It's good if anyone can convert AttrList to list easily.

    Thanks,

    opened by kujiy 2
  • Read timeout on UpdateByQuery.script

    Read timeout on UpdateByQuery.script

    I am using elasticsearch7-dsl with elasticsearch7 with an ES server version 7.13.4

    I am running a script (which requires quite some time to run) via UpdateByQuery like so

    byq = UpdateByQuery(index=args.i).using(esclient).script(source=SCRIPT)
    response = byq.execute()
    

    This throws an exception:

    Traceback (most recent call last):
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/urllib3/connectionpool.py", line 445, in _make_request
        six.raise_from(e, None)
      File "<string>", line 3, in raise_from
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/urllib3/connectionpool.py", line 440, in _make_request
        httplib_response = conn.getresponse()
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/http/client.py", line 1348, in getresponse
        response.begin()
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/http/client.py", line 316, in begin
        version, status, reason = self._read_status()
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/http/client.py", line 277, in _read_status
        line = str(self.fp.readline(_MAXLINE + 1), "iso-8859-1")
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/socket.py", line 669, in readinto
        return self._sock.recv_into(b)
    socket.timeout: timed out
    
    During handling of the above exception, another exception occurred:
    
    Traceback (most recent call last):
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/elasticsearch7/connection/http_urllib3.py", line 255, in perform_request
        response = self.pool.urlopen(
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/urllib3/connectionpool.py", line 755, in urlopen
        retries = retries.increment(
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/urllib3/util/retry.py", line 507, in increment
        raise six.reraise(type(error), error, _stacktrace)
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/urllib3/packages/six.py", line 770, in reraise
        raise value
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/urllib3/connectionpool.py", line 699, in urlopen
        httplib_response = self._make_request(
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/urllib3/connectionpool.py", line 447, in _make_request
        self._raise_timeout(err=e, url=url, timeout_value=read_timeout)
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/urllib3/connectionpool.py", line 336, in _raise_timeout
        raise ReadTimeoutError(
    urllib3.exceptions.ReadTimeoutError: HTTPConnectionPool(host='THEHOST', port=9999): Read timed out. (read timeout=10)
    
    During handling of the above exception, another exception occurred:
    
    Traceback (most recent call last):
      File "../python/project_fcdo/es-add-orig-time.py", line 26, in <module>
        response = byq.execute()
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/elasticsearch7_dsl/update_by_query.py", line 158, in execute
        es.update_by_query(index=self._index, body=self.to_dict(), **self._params),
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/elasticsearch7/client/utils.py", line 347, in _wrapped
        return func(*args, params=params, headers=headers, **kwargs)
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/elasticsearch7/client/__init__.py", line 2218, in update_by_query
        return self.transport.perform_request(
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/elasticsearch7/transport.py", line 466, in perform_request
        raise e
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/elasticsearch7/transport.py", line 427, in perform_request
        status, headers_response, data = connection.perform_request(
      File "/home/johann/software/anaconda3/envs/fcdo/lib/python3.8/site-packages/elasticsearch7/connection/http_urllib3.py", line 279, in perform_request
        raise ConnectionTimeout("TIMEOUT", str(e), e)
    elasticsearch7.exceptions.ConnectionTimeout: ConnectionTimeout caused by - ReadTimeoutError(HTTPConnectionPool(host='THEHOST', port=9999): Read timed out. (read timeout=10))
    

    The documentation at https://elasticsearch-dsl.readthedocs.io/en/latest/api.html#update-by-query does not mention any parameter or method to set the timeout. Is there a way to set the timeout specifically for this operation without setting it for all operations? If not, what would be the correct way to set the timeout when creating the esclient? The documentation of the elasticsearch package unfortunately never mentions this anywhere either.

    opened by johann-petrak 1
  • Export queries MatchAll and MatchNone

    Export queries MatchAll and MatchNone

    It would be great if the (already existing) queries MatchAll and MatchNone would be exported.


    I have multiple queries and want all entries from elasticsearch that match at least one of them. Those queries are only known at runtime.

    if scanners:
        q1 = Q("terms", scanner=scanners)
    if operations:
        q2 = Q("terms", operation=operations)
    if lines:
        q3 = Q("terms", line=lines)
    resulting_query= Q('bool', should=[q1, q2, q3])
    

    I would prefer to write it like this (because it does not use elasticsearch's confusing should/must keywords):

    resulting_query = MatchNone
    if scanners:
        resulting_query = resulting_query | Q("terms", scanner=scanners)
    if operations:
        resulting_query = resulting_query | Q("terms", operation=operations)
    if lines:
        resulting_query = resulting_query | Q("terms", line=lines)
    
    opened by Kaligule 0
  • Is the latest 7.4 version dsl available for communication with ES 7.10 server

    Is the latest 7.4 version dsl available for communication with ES 7.10 server

    I would like to know whether the existing latest version of dsl is universal to any version of ES 7.x, including the officially released version 7.17, thank you

    opened by qinghuan1998 0
Releases(v7.4.0)
esguard provides a Python decorator that waits for processing while monitoring the load of Elasticsearch.

esguard esguard provides a Python decorator that waits for processing while monitoring the load of Elasticsearch. Quick Start You need to launch elast

po3rin 5 Dec 8, 2021
A real-time tech course finder, created using Elasticsearch, Python, React+Redux, Docker, and Kubernetes.

A real-time tech course finder, created using Elasticsearch, Python, React+Redux, Docker, and Kubernetes.

Dinesh Sonachalam 119 May 9, 2022
A library for fast import of Windows NT Registry(REGF) into Elasticsearch.

A library for fast import of Windows NT Registry(REGF) into Elasticsearch.

S.Nakano 3 Apr 1, 2022
A library for fast parse & import of Windows Prefetch into Elasticsearch.

prefetch2es Fast import of Windows Prefetch(.pf) into Elasticsearch. prefetch2es uses C library libscca. Usage When using from the commandline interfa

S.Nakano 6 Apr 1, 2022
Es-schema - Common Data Schemas for Elasticsearch

Common Data Schemas for Elasticsearch The Common Data Schema for Elasticsearch i

Tim Schnell 2 Jan 25, 2022
Pysolr — Python Solr client

pysolr pysolr is a lightweight Python client for Apache Solr. It provides an interface that queries the server and returns results based on the query.

Haystack Search 616 Apr 25, 2022
Whoosh indexing capabilities for Flask-SQLAlchemy, Python 3 compatibility fork.

Flask-WhooshAlchemy3 Whoosh indexing capabilities for Flask-SQLAlchemy, Python 3 compatibility fork. Performance improvements and suggestions are read

Blake VandeMerwe 27 Mar 10, 2022
Senginta is All in one Search Engine Scrapper for used by API or Python Module. It's Free!

Senginta is All in one Search Engine Scrapper. With traditional scrapping, Senginta can be powerful to get result from any Search Engine, and convert to Json. Now support only for Google Product Search Engine (GShop, GVideo and many too) and Baidu Search Engine.

null 30 Oct 23, 2021
a Telegram bot writen in Python for searching files in Drive. Based on SearchX-bot

Drive Search Bot This is a Telegram bot writen in Python for searching files in Drive. Based on SearchX-bot How to deploy? Clone this repo: git clone

Hafitz Setya 22 Jan 24, 2022
Simple algorithm search engine like google in python using function

Mini-Search-Engine-Like-Google I have created the simple algorithm search engine like google in python using function. I am matching every word with w

Sachin Vinayak Dabhade 5 Sep 24, 2021
User-friendly, tiny source code searcher written by pure Python.

User-friendly, tiny source code searcher written in pure Python. Example Usages Cat is equivalent in the regular expression as '^Cat$' bor class Cat

Furkan Onder 101 Apr 19, 2022
This is a Telegram Bot written in Python for searching data on Google Drive.

This is a Telegram Bot written in Python for searching data on Google Drive. Supports multiple Shared Drives (TDs). Manual Guide for deploying the bot

Levi 75 May 18, 2022
Pythonic Lucene - A simplified python impelementaiton of Apache Lucene

A simplified python impelementaiton of Apache Lucene, mabye helps to understand how an enterprise search engine really works.

Mahdi Sadeghzadeh Ghamsary 2 Jan 3, 2022
A Python web searcher library with different search engines

Robert A simple Python web searcher library with different search engines. Install pip install roberthelper Usage from robert import GoogleSearcher

null 1 Dec 23, 2021
A fast, efficiency python package for searching and getting search results with many different search engines

search A fast, efficiency python package for searching and getting search results with many different search engines. Installation To install the pack

Neurs 1 Jan 22, 2022
High level Python client for Elasticsearch

Elasticsearch DSL Elasticsearch DSL is a high-level library whose aim is to help with writing and running queries against Elasticsearch. It is built o

elastic 3.5k May 13, 2022
High level Python client for Elasticsearch

Elasticsearch DSL Elasticsearch DSL is a high-level library whose aim is to help with writing and running queries against Elasticsearch. It is built o

elastic 3.5k May 21, 2022
Official Python low-level client for Elasticsearch

Python Elasticsearch Client Official low-level client for Elasticsearch. Its goal is to provide common ground for all Elasticsearch-related code in Py

elastic 3.6k May 15, 2022
esguard provides a Python decorator that waits for processing while monitoring the load of Elasticsearch.

esguard esguard provides a Python decorator that waits for processing while monitoring the load of Elasticsearch. Quick Start You need to launch elast

po3rin 5 Dec 8, 2021
A real-time tech course finder, created using Elasticsearch, Python, React+Redux, Docker, and Kubernetes.

A real-time tech course finder, created using Elasticsearch, Python, React+Redux, Docker, and Kubernetes.

Dinesh Sonachalam 119 May 9, 2022
asyncio compatible driver for elasticsearch

asyncio client library for elasticsearch aioes is a asyncio compatible library for working with Elasticsearch The project is abandoned aioes is not su

null 99 Apr 18, 2022
:mag: Transformers at scale for question answering & neural search. Using NLP via a modular Retriever-Reader-Pipeline. Supporting DPR, Elasticsearch, HuggingFace's Modelhub...

Haystack is an end-to-end framework for Question Answering & Neural search that enables you to ... ... ask questions in natural language and find gran

deepset 4.7k May 16, 2022
:mag: End-to-End Framework for building natural language search interfaces to data by utilizing Transformers and the State-of-the-Art of NLP. Supporting DPR, Elasticsearch, HuggingFace’s Modelhub and much more!

Haystack is an end-to-end framework that enables you to build powerful and production-ready pipelines for different search use cases. Whether you want

deepset 1.4k Feb 18, 2021
Cải thiện Elasticsearch trong bài toán semantic search sử dụng phương pháp Sentence Embeddings

Cải thiện Elasticsearch trong bài toán semantic search sử dụng phương pháp Sentence Embeddings Trong bài viết này mình sẽ sử dụng pretrain model SimCS

Vo Van Phuc 15 Apr 27, 2022
A library for fast import of Windows NT Registry(REGF) into Elasticsearch.

A library for fast import of Windows NT Registry(REGF) into Elasticsearch.

S.Nakano 3 Apr 1, 2022
Django x Elasticsearch Templates

Django x Elasticsearch Requirements Python > 3.7 Django >= 3 Elasticsearch 7.15 Setup Elasticsearch Install via brew Install brew tap elastic/tap brew

Aji Pratama 1 Oct 22, 2021
A pytest plugin that enables you to test your code that relies on a running Elasticsearch search engine

pytest-elasticsearch What is this? This is a pytest plugin that enables you to test your code that relies on a running Elasticsearch search engine. It

Clearcode 57 May 4, 2022
X-news - Pipeline data use scrapy, kafka, spark streaming, spark ML and elasticsearch, Kibana

X-news - Pipeline data use scrapy, kafka, spark streaming, spark ML and elasticsearch, Kibana

Nguyễn Quang Huy 3 May 9, 2022
A library for fast parse & import of Windows Prefetch into Elasticsearch.

prefetch2es Fast import of Windows Prefetch(.pf) into Elasticsearch. prefetch2es uses C library libscca. Usage When using from the commandline interfa

S.Nakano 6 Apr 1, 2022