atomicshop 2.7.4__py3-none-any.whl → 2.7.6__py3-none-any.whl

atomicshop/__init__.py

@@ -1,4 +1,4 @@
 """Atomic Basic functions and classes to make developer life easier"""
 
 __author__ = "Den Kras"
-__version__ = '2.7.4'
+__version__ = '2.7.6'

atomicshop/filesystem.py

@@ -871,3 +871,22 @@ def convert_windows_to_linux_path(
         linux_path = windows_path_obj.as_posix()
 
     return str(linux_path)
+
+
+def get_directory_size(directory_path: str):
+    """
+    The function returns the size of the directory in bytes.
+    This is one of the fastest ways to get the size of a directory.
+
+    :param directory_path:
+    :return:
+    """
+
+    total_size = 0
+    with os.scandir(directory_path) as it:
+        for entry in it:
+            if entry.is_file():
+                total_size += entry.stat().st_size
+            elif entry.is_dir():
+                total_size += get_directory_size(entry.path)
+    return total_size

atomicshop/uuids.py

@@ -0,0 +1,45 @@
+import uuid
+
+
+"""
+Choosing Between UUID Versions
+UUID1: Use it if you need to trace back the machine that generated the UUID.
+UUID4: Use it for almost everything else, where you need a unique ID without any other implications.
+UUID3 and UUID5: Use them if you need consistent UUIDs generated from the same namespace and name.
+
+Most of the time, uuid4() is preferred due to its simplicity and randomness, 
+ensuring a very low probability of ID collision without depending on the machine's identity or the exact timestamp.
+
+Collisions:
+The number of random version-4 UUIDs which need to be generated in order to have a 50% probability of at least 
+one collision is 2.71 quintillion. This number is equivalent to generating 1 billion UUIDs per second for about
+85 years. The probability of one collision would be approximately 50% if every person on earth owns 600 million UUIDs.
+https://en.wikipedia.org/wiki/Universally_unique_identifier#Random_UUID_probability_of_duplicates
+"""
+
+
+def generate_uuid4_random(convert_to_hex: bool = True) -> str:
+    """
+    Generate a random UUID4.
+
+    The hex attribute of a UUID object in Python returns the hexadecimal representation of the UUID as a
+    string of 32 hexadecimal digits. This is a more compact form compared to the standard string representation
+    returned by str(uuid.uuid4()), which includes hyphens.
+
+    Here's a comparison:
+    With Hyphens (Default String Representation): The default string representation of a UUID includes hyphens,
+    separating it into five groups, such as 12345678-1234-5678-1234-567812345678.
+    This format is easy to read and is often used in textual representations where readability is a concern.
+
+    Hexadecimal (Compact Representation): The hex attribute removes the hyphens and returns the UUID as a continuous
+    string of 32 hexadecimal characters, like 12345678123456781234567812345678.
+    This compact form might be preferred when you need a shorter version of the UUID for systems that
+    don't accept hyphens or when saving space is a priority.
+
+    :return:
+    """
+
+    if convert_to_hex:
+        return uuid.uuid4().hex
+    else:
+        return str(uuid.uuid4())

atomicshop/wrappers/elasticsearchw/elasticsearchw.py

@@ -59,6 +59,28 @@ def test_connection(elastic_wrapper: Elasticsearch = None):
         return False
 
 
+def get_stats_db_size(elastic_wrapper: Elasticsearch = None):
+    """
+    The function returns the size of the Elasticsearch database.
+
+    :param elastic_wrapper: Elasticsearch, the Elasticsearch wrapper.
+    :return: int, the size of the Elasticsearch database in bytes.
+
+    Usage:
+        res = get_stats_db_size()
+    """
+
+    if elastic_wrapper is None:
+        elastic_wrapper = get_elastic_wrapper()
+
+    # Get stats for all indices
+    stats = elastic_wrapper.indices.stats()
+
+    total_size_in_bytes = stats['_all']['total']['store']['size_in_bytes']
+
+    return total_size_in_bytes
+
+
 def index(
         index_name: str,
         doc: dict,
@@ -101,14 +123,17 @@ def index(
     return res
 
 
-def search(index_name: str, query: dict, elastic_wrapper: Elasticsearch = None, get_hits_only: bool = True):
+def search(
+        index_name: str,
+        query: dict,
+        elastic_wrapper: Elasticsearch = None,
+):
     """
     The function searches for documents in the Elasticsearch server.
 
     :param index_name: str, the name of the index.
     :param query: dict, the query to be used for searching the documents.
     :param elastic_wrapper: Elasticsearch, the Elasticsearch wrapper.
-    :param get_hits_only: bool, if True, only the hits are returned.
     :return: dict, the result of the search operation.
 
     Usage:
@@ -125,10 +150,13 @@ def search(index_name: str, query: dict, elastic_wrapper: Elasticsearch = None,
 
     res = elastic_wrapper.search(index=index_name, body=query)
 
-    if get_hits_only:
-        return get_response_hits(res)
-    else:
-        return res
+    hits_only: list = get_response_hits(res)
+
+    aggregations: dict = dict()
+    if 'aggregations' in res:
+        aggregations: dict = get_all_aggregation_hits(res)
+
+    return res, hits_only, aggregations
 
 
 def count(index_name: str, query: dict, elastic_wrapper: Elasticsearch = None):
@@ -169,3 +197,37 @@ def get_response_hits(response: dict):
     """
 
     return [hit['_source'] for hit in response['hits']['hits']]
+
+
+def get_specific_aggregation_hits(response: dict, aggregation_name: str):
+    """
+    The function returns the hits of an aggregation from the response.
+
+    :param response: dict, the response from the Elasticsearch server.
+    :param aggregation_name: str, the name of the aggregation.
+    :return: list, the hits of the aggregation from the response.
+
+    Usage:
+        res = get_aggregation_hits(response, aggregation_name)
+    """
+
+    return [bucket['key'] for bucket in response['aggregations'][aggregation_name]['buckets']]
+
+
+def get_all_aggregation_hits(response: dict):
+    """
+    The function returns all the hits of all the aggregations from the response.
+
+    :param response: dict, the response from the Elasticsearch server.
+    :return: dict, the hits of all the aggregations from the response.
+
+    Usage:
+        res = get_all_aggregation_hits(response)
+    """
+
+    all_aggregations = {}
+
+    for agg_name, agg_content in response['aggregations'].items():
+        all_aggregations[agg_name] = [bucket['key'] for bucket in agg_content['buckets']]
+
+    return all_aggregations

atomicshop/wrappers/elasticsearchw/queries/__init__.py

@@ -0,0 +1 @@
+from . import aggregation, pagination, query_multi, query_single, size, sort

atomicshop/wrappers/elasticsearchw/queries/aggregation.py

@@ -0,0 +1,45 @@
+def get_unique_values(field_name: str, aggregation_name: str, size: int = 10):
+    """
+    Create an aggregation query for Elasticsearch to get the unique values of a field.
+    This query will return the unique values of the field 'field_name'.
+
+    :param field_name: str, the name of the field to get the unique values of.
+    :param aggregation_name: str, the name of the aggregation.
+        If you want to get the aggregation hits, you will do it by this aggregation name.
+
+
+
+        Example:
+        aggregation_name = 'unique_vendors'
+
+        body = {
+            "size": 0,  # We don't need the actual documents, just the aggregation
+            "aggs": {
+                aggregation_name: {
+                    "terms": {
+                        "field": f"{field_name}.keyword",
+                        "size": size
+                    }
+                }
+            }
+        }
+
+        res = es.search(index=index_name, body=body)
+        unique_vendors = [bucket['key'] for bucket in res['aggregations'][aggregation_name]['buckets']]
+    :param size: int, the maximum number of unique values to return.
+    :return: dict, the aggregation query.
+    """
+
+    return {
+        "size": 0,  # We don't need the actual documents, just the aggregation
+        "aggs": {
+            aggregation_name: {
+                "terms": {
+                    # When doing the aggregation on a text field, we need to use the '.keyword' version of the field.
+                    "field": f"{field_name}.keyword",
+                    # The default terms aggregation size is 10 in elastic. If you need more, specify it.
+                    "size": size
+                }
+            }
+        }
+    }

atomicshop/wrappers/elasticsearchw/queries/info.py

@@ -0,0 +1,58 @@
+"""
+Query types:
+
+Term Query
+Usage: The term query is used for exact matches. It looks for the exact term in the inverted index and doesn’t analyze the query string. This is useful for searching on fields that are exact values (like IDs, tags, etc.).
+Example: If your field value is "Quick Brown Fox" and you search with a term query for "quick" or "Quick", it will not match because it looks for the exact term in the field.
+
+Match Query
+Usage: The match query is more flexible. It analyzes the query string before executing the search. This means it will consider things like tokenization and stemming. It’s suitable for full-text search.
+Example: Using the match query for "quick" or "Quick" on the field with "Quick Brown Fox" will likely return a match because it analyzes and tokenizes the string.
+
+Match Phrase Query
+Usage: The match_phrase query is like the match query but it also takes the order of the words into account. It is used when you want to find exact phrases or words in a specific order.
+Example: If you search for "Quick Brown" with a match_phrase query on a field with the value "The Quick Brown Fox", it will match. However, searching for "Brown Quick" won't match.
+
+Additional Query Types
+Bool Query: This allows you to combine multiple queries using boolean logic (like must, should, must_not).
+Range Query: Useful for finding numbers or dates in a given range.
+Wildcard Query: For searches with wildcards, useful when the exact value is partially known.
+Prefix Query: Finds documents containing terms that start with the specified prefix.
+Fuzzy Query: Useful for dealing with typos and spelling variations.
+"""
+
+
+"""
+AND OR:
+"must" is AND
+"should" is OR
+"must_not" is NOT
+
+Example with AND and OR:
+You want to find all files with file_path = "/home/test1/test2/final_archive.zip" and
+file_path = "test4.zip" or file_path = "_test4.zip"
+Meaning you want to find all files with file_path = "/home/test1/test2/final_archive.zip/test4.zip" or
+file_path = "/home/test1/test2/final_archive.zip/_test4.zip"
+Since your file can be both "test4.zip" and "_test4.zip" at the same time, you need to use AND and OR.
+
+query = {
+    "query": {
+        "bool": {
+            "must": [
+                {"match_phrase": {"file_path": "/home/test1/test2/final_archive.zip"}},
+                {
+                    "bool": {
+                        "should": [
+                            {"match_phrase": {"file_path": "test4.zip"}},
+                            {"match_phrase": {"file_path": "_test4.zip"}}
+                        ]
+                    }
+                }
+            ]
+        }
+    }
+}
+
+This is similar to Kibana KQL:
+file_path : "/home/test1/test2/final_archive.zip" and (file_path : "test4.zip") or (file_path : "_test4.zip")
+"""

atomicshop/wrappers/elasticsearchw/queries/pagination.py

@@ -0,0 +1,18 @@
+def pagination(page: int, size: int) -> dict:
+    """
+    Create the pagination query for Elasticsearch.
+
+    :param page: int, the page number.
+    :param size: int, the number of results per page.
+    :return: dict, the pagination query.
+    """
+
+    # Calculate the "from" parameter for Elasticsearch
+    start_from = (page - 1) * size
+    # Add the pagination to the query.
+    pagination_dict: dict = {
+        "from": start_from,
+        "size": size
+    }
+
+    return pagination_dict

atomicshop/wrappers/elasticsearchw/queries/query_multi.py

@@ -0,0 +1,40 @@
+def match_and_booleans(search_terms: dict) -> dict:
+    """
+    Generates an Elasticsearch query based on the provided search terms.
+
+    :param search_terms: A dictionary of field names and their corresponding search values.
+    :return: A dictionary representing the Elasticsearch query.
+
+    Usage for strings:
+    search_terms = {
+        "field_name1": "search_term1",
+        "field_name2": "search_term2"
+    }
+
+    Usage for strings and booleans:
+    search_terms = {
+        "field_name1": "search_term1",
+        "field_name2": True
+    }
+    """
+
+    must_clauses = []
+    for field, value in search_terms.items():
+        if isinstance(value, bool):
+            # Use term query for boolean values
+            must_clauses.append({"term": {field: value}})
+        else:
+            # Use match query for text and other types
+            must_clauses.append({"match": {field: value}})
+
+    # must_clauses = [{"term": {field: value}} for field, value in search_terms.items()]
+
+    query = {
+        "query": {
+            "bool": {
+                "must": must_clauses
+            }
+        }
+    }
+
+    return query

atomicshop/wrappers/elasticsearchw/queries/query_single.py

@@ -0,0 +1,87 @@
+def match_all():
+    """
+    Create a match_all query for Elasticsearch.
+    This query will match all the documents in the index.
+
+    :return: dict, the match_all query.
+    """
+
+    return {
+        "query": {
+            "match_all": {}
+        }
+    }
+
+
+def match(field_name: str, search_term: str):
+    """
+    Create a match query for Elasticsearch.
+    This query will match the documents that have the field 'field_name' set to 'search_term'.
+
+    :param field_name: str, the name of the field to search in.
+    :param search_term: str, the search term.
+    :return: dict, the match query.
+    """
+
+    return {
+        "query": {
+            "match": {
+                field_name: search_term
+            }
+        }
+    }
+
+
+def boolean_filter(field_name: str, value: bool):
+    """
+    Create a boolean filter for Elasticsearch.
+    This filter will filter all the documents that have the field 'field_name' set to True.
+
+    :param field_name: str, the name of the field to filter by.
+    :param value: bool, the value of the field to filter by.
+    :return: dict, the boolean filter.
+    """
+
+    return {
+        "query": {
+            "bool": {
+                "filter": [
+                    {"term": {field_name: value}}
+                ]
+            }
+        }
+    }
+
+
+def wildcard(field_name: str, search_term: str, exact_term: bool = False):
+    """
+    Create a wildcard query for Elasticsearch.
+    This query uses the regular 'field_name' and not the '.keyword' version.
+    What this means:
+    By default, all the text fields will be processed by the standard analyzer.
+    https://www.elastic.co/guide/en/elasticsearch/reference/current/analyzer.html
+    https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-standard-analyzer.html
+    This means that the text will be lower-cased, and the special characters will be stripped.
+
+    Example: "TEst1-TeSt2" will be processed to ["test1", "test2"].
+
+    To skip using the standard analyzer, we can use the '.keyword' version of the field or set the 'exact_term' to True.
+
+    :param field_name: str, the name of the field to search in.
+    :param search_term: str, the search term with the wildcard '*'.
+    :param exact_term: bool, if True, the '.keyword' version of the field will be used.
+    :return: dict, the wildcard query.
+    """
+
+    if exact_term:
+        field_name = f"{field_name}.keyword"
+
+    return {
+        "query": {
+            "wildcard": {
+                field_name: {
+                    "value": search_term
+                }
+            }
+        }
+    }

atomicshop/wrappers/elasticsearchw/queries/size.py

@@ -0,0 +1,12 @@
+def maximum():
+    """
+    Add the maximum size to the query.
+    The maximum size is 10000 for regular queries.
+    If you need more than 10000 results, you need to use the 'scroll' API or Search After.
+
+    :return: dict, the query with the maximum size.
+    """
+
+    return {
+        "size": 10000
+    }

atomicshop/wrappers/elasticsearchw/queries/sort.py

@@ -0,0 +1,46 @@
+def ascending(field_name: str):
+    """
+    Create a sorting query for Elasticsearch.
+    This query will sort the results by the 'field_name' field in ascending order.
+
+    :param field_name: str, the name of the field to sort by.
+    :return: dict, the sorting query.
+    """
+
+    return {
+        "sort": [
+            {field_name: {"order": "asc"}}
+        ]
+    }
+
+
+def descending(field_name: str):
+    """
+    Create a sorting query for Elasticsearch.
+    This query will sort the results by the 'field_name' field in descending order.
+
+    :param field_name: str, the name of the field to sort by.
+    :return: dict, the sorting query.
+    """
+
+    return {
+        "sort": [
+            {field_name: {"order": "desc"}}
+        ]
+    }
+
+
+def latest_time(time_field_name: str = None):
+    """
+    Create a sorting query for Elasticsearch.
+    This query will sort the results by the 'time_field_name' field in descending order.
+
+    :param time_field_name: str, the name of the field to sort by.
+        If None, the 'timestamp' field name will be used.
+    :return: dict, the sorting query.
+    """
+
+    if time_field_name is None:
+        time_field_name = "timestamp"
+
+    return descending(field_name=time_field_name)

{atomicshop-2.7.4.dist-info → atomicshop-2.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.7.4
+Version: 2.7.6
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License

{atomicshop-2.7.4.dist-info → atomicshop-2.7.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=iiq9H1b0qmR9J0mPdAsokey5lpHpvDyfpuvjxt4aKhE,122
+atomicshop/__init__.py,sha256=DoGkKi75FQlqIpSnJTBu70jSyzfi3tC2S62u0x9o08M,122
 atomicshop/_basics_temp.py,sha256=6cu2dd6r2dLrd1BRNcVDKTHlsHs_26Gpw8QS6v32lQ0,3699
 atomicshop/_patch_import.py,sha256=ENp55sKVJ0e6-4lBvZnpz9PQCt3Otbur7F6aXDlyje4,6334
 atomicshop/appointment_management.py,sha256=N3wVGJgrqJfsj_lqiRfaL3FxMEe57by5Stzanh189mk,7263
@@ -13,7 +13,7 @@ atomicshop/dns.py,sha256=bNZOo5jVPzq7OT2qCPukXoK3zb1oOsyaelUwQEyK1SA,2500
 atomicshop/domains.py,sha256=Rxu6JhhMqFZRcoFs69IoEd1PtYca0lMCG6F1AomP7z4,3197
 atomicshop/emails.py,sha256=I0KyODQpIMEsNRi9YWSOL8EUPBiWyon3HRdIuSj3AEU,1410
 atomicshop/file_types.py,sha256=-0jzQMRlmU1AP9DARjk-HJm1tVE22E6ngP2mRblyEjY,763
-atomicshop/filesystem.py,sha256=ZIVmZ3Zfq4U3gJ7Bta6wPnHSNJMwpyC1CoJcgTDxKUg,32624
+atomicshop/filesystem.py,sha256=b9FJjw2IoZNd-U7feY5o9y9w58vBgGHAgsahxlkzhbA,33163
 atomicshop/functions.py,sha256=pK8hoCE9z61PtWCxQJsda7YAphrLH1wxU5x-1QJP-sY,499
 atomicshop/hashing.py,sha256=Le8qGFyt3_wX-zGTeQShz7L2HL_b6nVv9PnawjglyHo,3474
 atomicshop/http_parse.py,sha256=nrf2rZcprLqtW8HVrV7TCZ1iTBcWRRy-mXIlAOzcaJs,9703
@@ -40,6 +40,7 @@ atomicshop/system_resources.py,sha256=CMJfhDv6dI9K3IejpyKu-6qRlfeTphaOCd2RaLxXDy
 atomicshop/tempfiles.py,sha256=uq1ve2WlWehZ3NOTXJnpBBMt6HyCdBufqedF0HyzA6k,2517
 atomicshop/timer.py,sha256=KxBBgVM8po6pUJDW8TgY1UXj0iiDmRmL5XDCq0VHAfU,1670
 atomicshop/urls.py,sha256=CQl1j1kjEVDlAuYJqYD9XxPF1SUSgrmG8PjlcXNEKsQ,597
+atomicshop/uuids.py,sha256=JSQdm3ZTJiwPQ1gYe6kU0TKS_7suwVrHc8JZDGYlydM,2214
 atomicshop/virtualization.py,sha256=LPP4vjE0Vr10R6DA4lqhfX_WaNdDGRAZUW0Am6VeGco,494
 atomicshop/web.py,sha256=K3UndqJqHO9bTogZUWDz-IEZN776KNhpk28m3Ct_pbc,11069
 atomicshop/addons/PlayWrightCodegen.cmd,sha256=Z5cnllsyXD4F1W2h-WLEnyFkg5nZy0-hTGHRWXVOuW4,173
@@ -154,8 +155,15 @@ atomicshop/wrappers/dockerw/dockerw.py,sha256=w8zSJr5C7cbvbuG09ORCpAe0BOcibqqL_Z
 atomicshop/wrappers/dockerw/install_docker.py,sha256=dpSOmD690oLukoLCo0u6Pzh5fRyCWBuSQEtG8VwC3jk,2765
 atomicshop/wrappers/elasticsearchw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/elasticsearchw/config_basic.py,sha256=nMtWYBlkQwzUMTLBaL3US8-f87bNPS_wzVxpLR1D6Hc,121
-atomicshop/wrappers/elasticsearchw/elasticsearchw.py,sha256=WlN3BRkaTZQ5YVKsrzDg4yyQj1AgvdXqfORj89rF9V8,5497
-atomicshop/wrappers/elasticsearchw/queries.py,sha256=IpK3sk1ShAK47qVUHwyTb8fQzMrXZjJYlr85Th6Q7HU,4542
+atomicshop/wrappers/elasticsearchw/elasticsearchw.py,sha256=KCU1OgzqG4YALQkVZqF6tpsCG-gU_SkJa1HQK6zV07A,7301
+atomicshop/wrappers/elasticsearchw/queries/__init__.py,sha256=KBjT-bAt75CJsx1Apko9mpuFU4pfZV8DcGWQvpX65RU,78
+atomicshop/wrappers/elasticsearchw/queries/aggregation.py,sha256=N9a5yMMnb10sMa_x1qJBFQpgyJ49UWo8_vxuqmUtZ1A,1742
+atomicshop/wrappers/elasticsearchw/queries/info.py,sha256=e2O_vW8admhs5-kyoSGkZYHGK2O-hfdAOsWuMZzY0D4,2821
+atomicshop/wrappers/elasticsearchw/queries/pagination.py,sha256=ySPJuXZOMiNAo7SDycxVOg35uP-CK59GzrLbs-0CqcM,509
+atomicshop/wrappers/elasticsearchw/queries/query_multi.py,sha256=hiqLqX3_Go_QKZpcyEXr9Qvyxf6uKHP3IS6JSNzChL4,1167
+atomicshop/wrappers/elasticsearchw/queries/query_single.py,sha256=HdYBW17vIvmHTI3nviOBmMspefDCT4xWXXnK7cbE2gQ,2662
+atomicshop/wrappers/elasticsearchw/queries/size.py,sha256=ZThvspfxpXRBI6Mht9kkb5lO-9KtprXqll_jBxDggns,319
+atomicshop/wrappers/elasticsearchw/queries/sort.py,sha256=-CUhgcs_AVRvncRlLTl5IJZE8K3RgDNLYSIHnn0j7aE,1274
 atomicshop/wrappers/factw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/factw/config_fact.py,sha256=J-K9Zn50WcDC7ubb-boraSZExfBk7a6M52NhRJVlsjk,895
 atomicshop/wrappers/factw/config_install.py,sha256=QRygFnZ5r1ybJQl7ftFci3kNRmU-a-w3lMG1joElvcY,417
@@ -214,8 +222,8 @@ atomicshop/wrappers/socketw/socket_server_tester.py,sha256=AhpurHJmP2kgzHaUbq5ey
 atomicshop/wrappers/socketw/socket_wrapper.py,sha256=aXBwlEIJhFT0-c4i8iNlFx2It9VpCEpsv--5Oqcpxao,11624
 atomicshop/wrappers/socketw/ssl_base.py,sha256=k4V3gwkbq10MvOH4btU4onLX2GNOsSfUAdcHmL1rpVE,2274
 atomicshop/wrappers/socketw/statistics_csv.py,sha256=t3dtDEfN47CfYVi0CW6Kc2QHTEeZVyYhc57IYYh5nmA,826
-atomicshop-2.7.4.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.7.4.dist-info/METADATA,sha256=8qWJOKUcT77GMFGs_rvHwBOUQHdKqgvQB54yX5Y4ogw,10369
-atomicshop-2.7.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-atomicshop-2.7.4.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.7.4.dist-info/RECORD,,
+atomicshop-2.7.6.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.7.6.dist-info/METADATA,sha256=ouPceXaGo8HF2r-OEYqADM0a2mpeM_V7zvxoLrqJTwE,10369
+atomicshop-2.7.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+atomicshop-2.7.6.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.7.6.dist-info/RECORD,,

atomicshop/wrappers/elasticsearchw/queries.py

@@ -1,149 +0,0 @@
-def create_match_all():
-    """
-    Create a match_all query for Elasticsearch.
-    This query will match all the documents in the index.
-
-    :return: dict, the match_all query.
-    """
-
-    return {
-        "query": {
-            "match_all": {}
-        }
-    }
-
-
-def create_boolean_filter(field_name: str, value: bool):
-    """
-    Create a boolean filter for Elasticsearch.
-    This filter will filter all the documents that have the field 'field_name' set to True.
-
-    :param field_name: str, the name of the field to filter by.
-    :param value: bool, the value of the field to filter by.
-    :return: dict, the boolean filter.
-    """
-
-    return {
-        "query": {
-            "bool": {
-                "filter": [
-                    {"term": {field_name: value}}
-                ]
-            }
-        }
-    }
-
-
-def create_wildcard(field_name: str, search_term: str):
-    """
-    Create a wildcard query for Elasticsearch.
-    This query uses the regular 'field_name' and not the '.keyword' version.
-    What this means:
-    By default, all the text fields will be processed by the standard analyzer.
-    https://www.elastic.co/guide/en/elasticsearch/reference/current/analyzer.html
-    https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-standard-analyzer.html
-    This means that the text will be lower-cased, and the special characters will be stripped.
-
-    Example: "TEst1-TeSt2" will be processed to ["test1", "test2"].
-
-    To skip using the standard analyzer, we can use the '.keyword' version of the field.
-
-    :param field_name: str, the name of the field to search in.
-    :param search_term: str, the search term with the wildcard '*'.
-    :return: dict, the wildcard query.
-    """
-
-    return {
-        "query": {
-            "wildcard": {
-                field_name: {
-                    "value": search_term
-                }
-            }
-        }
-    }
-
-
-def create_wildcard_exact_term(field_name: str, search_term: str):
-    """
-    Create a wildcard query for Elasticsearch to unprocessed version by the standard analyzer.
-    This query uses the '.keyword' version of the field.
-
-    To read about the problem with the standard analyzer, read the docstring of the function 'create_wildcard'.
-
-    :param field_name: str, the name of the field to search in.
-    :param search_term: str, the search term with the wildcard '*'.
-    :return: dict, the wildcard query.
-    """
-
-    return {
-        "query": {
-            "wildcard": {
-                f"{field_name}.keyword": {
-                    "value": search_term
-                }
-            }
-        }
-    }
-
-
-def create_pagination(page: int, size: int) -> dict:
-    """
-    Create the pagination query for Elasticsearch.
-
-    :param page: int, the page number.
-    :param size: int, the number of results per page.
-    :return: dict, the pagination query.
-    """
-
-    # Calculate the "from" parameter for Elasticsearch
-    start_from = (page - 1) * size
-
-    # Elasticsearch query
-    return {
-        "from": start_from,
-        "size": size,
-        "query": {
-            "match_all": {}
-        }
-    }
-
-
-def create_pagination_latest_entries(page: int, size: int, sort_by_time_field_name: str = None):
-    """
-    Create the pagination query for Elasticsearch.
-    This query will sort the results by the 'sort_by_time_field_name' field in descending order.
-    This query will return the latest entries.
-
-    :param page: int, the page number.
-    :param size: int, the number of results per page.
-    :param sort_by_time_field_name: str, the name of the field to sort by.
-    :return: dict, the pagination query.
-    """
-
-    if sort_by_time_field_name is None:
-        sort_by_time_field_name = "timestamp"
-
-    # Get the pagination query.
-    query = create_pagination(page=page, size=size)
-
-    sorting: dict = {
-        "sort": [
-            {sort_by_time_field_name: {"order": "desc"}}  # Sort by the 'timestamp' field in descending order.
-        ]
-    }
-
-    return query.update(sorting)
-
-
-def add_maximum_size(query: dict):
-    """
-    Add the maximum size to the query.
-    The maximum size is 10000 for regular queries.
-    If you need more than 10000 results, you need to use the 'scroll' API or Search After.
-
-    :param query: dict, the query to add the maximum size to.
-    :return: dict, the query with the maximum size.
-    """
-
-    query['size'] = 10000