increase filter options for both query and scan operations

Author: kauelima21

Diff for: README.md

@@ -117,7 +117,7 @@ Para os casos de consultas com filtro em determinada propriedade que não seja u
 
 ```python
 users = User()
-online_users = users.find_by('status', 'online').fetch(True)
+online_users = users.find_by('status', '=', 'online').fetch(True)
 print(f'{users.get_count} online no momento!')
 ```
 
@@ -126,7 +126,7 @@ Para os casos de consultas com filtro em determinada chave de partição, pode-s
 
 ```python
 users = User()
-online_users = users.query_by('status', 'online').fetch(True)
+online_users = users.query_by('status', '=', 'online').fetch(True)
 print(f'{users.get_count} online no momento!')
 ```
 
@@ -135,7 +135,7 @@ Serve para ordenar de acordo com determinado atributo, podendo também trazer a
 
 ```python
 users = User()
-online_users = users.find_by('status', 'online').order('first_name').fetch(True)
+online_users = users.find_by('status', '=', 'online').order('first_name').fetch(True)
 print(f'{users.get_count} online no momento!')
 ```
 
@@ -144,15 +144,15 @@ Caso queira contar o total de itens na tabela ou operação que você fizer sem
 
 ```python
 users = User()
-online_users = users.find_by('status', 'online').order('first_name').count()
+online_users = users.find_by('status', '=', 'online').order('first_name').count()
 print(f'{online_users} online no momento!')
 ```
 
 ### Fetch
 Por default retorna os dados como um dict, mas ao passar o argumento object como True ele retorna os registros como um objeto DynoLayer.
 
 ```python
-users = User().find_by('status', 'online').order('first_name').fetch(object=True)
+users = User().find_by('status', '=', 'online').order('first_name').fetch(object=True)
 print(users[0].name)
 ```
 

Diff for: dynolayer/dynolayer.py

@@ -3,6 +3,8 @@
 import uuid
 import os
 import pytz
+import random
+import string
 from datetime import datetime
 from dotenv import load_dotenv
 from decimal import Decimal
@@ -29,6 +31,7 @@ def __init__(
         self._secondary_index = ''
         self._attributes_to_get = ''
         self._filter_expression = ''
+        self._query_filter_expression = ''
         self._filter_params = {}
         self._filter_params_name = {}
         self._last_evaluated_key = {}
@@ -88,14 +91,35 @@ def _load_dynamo(self):
     def query_by(
             self,
             key: str,
-            comparator: Literal["=", "<>", "<", "<=", ">", ">="],
+            comparator: Literal["=", "<", "<=", ">", ">=", "BETWEEN", "begins_with"],
             key_value,
-            secondary_index = None
-        ):
+            secondary_index=None
+    ):
         self._is_query_operation = True
         self._secondary_index = secondary_index
         return self.find_by(key, comparator, key_value)
 
+    """
+        Args:
+        key (str): The table key to filter on.
+        key_value: The value to use on the filter.
+
+        Returns:
+        self: The DynoLayer.
+        or_query_by('likes', '<', 20)
+        """
+
+    def or_query_by(
+            self,
+            key: str,
+            comparator: Literal["=", "<", "<=", ">", ">=", "BETWEEN", "begins_with"],
+            key_value,
+            secondary_index=None
+    ):
+        self._is_query_operation = True
+        self._secondary_index = secondary_index
+        return self.or_find_by(key, comparator, key_value)
+
     """
     Args:
     filter_expression (str): The filter expression string.
@@ -108,9 +132,13 @@ def query_by(
     def find(
             self,
             filter_expression: str = '',
-            filter_params: dict = {},
-            filter_params_name: dict = {}
+            filter_params=None,
+            filter_params_name=None
     ):
+        if filter_params_name is None:
+            filter_params_name = {}
+        if filter_params is None:
+            filter_params = {}
         self._filter_expression = filter_expression
         self._filter_params = filter_params
         self._filter_params_name = filter_params_name
@@ -142,20 +170,141 @@ def query(
     def find_by(
             self,
             attribute: str,
-            comparator: Literal["=", "<>", "<", "<=", ">", ">="],
+            comparator: Literal["=", "<>", "<", "<=", ">", ">=", "BETWEEN", "begins_with"],
             attribute_value
-        ):
-        self._is_find_by = True
+    ):
+        use_and_operator = ''
+        old_att = ''
+        if self._is_find_by:
+            use_and_operator = ' AND '
+            if str(self._filter_params.get(f':{attribute}', '')):
+                letters = string.ascii_lowercase
+                random_str = ''
+                for i in range(4):
+                    random_str += random.choice(letters)
+                old_att = attribute
+                attribute = random_str + attribute
+
+        if not self._is_find_by:
+            self._is_find_by = True
+
+        if isinstance(attribute_value, dict) or (isinstance(attribute_value, list) and comparator != 'BETWEEN'):
+            attribute_value = json.dumps(attribute_value)
+
+        filter_param = {
+            f':{attribute}': attribute_value
+        }
+        if comparator == 'BETWEEN':
+            self._filter_expression += f'{use_and_operator}(#{attribute} {comparator} :{attribute[0]} AND :{attribute[1]})'
+            filter_param = {
+                f':{attribute[0]}': attribute_value[0],
+                f':{attribute[1]}': attribute_value[1]
+            }
+        elif comparator == 'begins_with':
+            self._filter_expression += f'{use_and_operator}({comparator}(#{attribute},:{attribute}))'
+        else:
+            self._filter_expression += f'{use_and_operator}(#{attribute} {comparator} :{attribute})'
+        self._filter_params.update(filter_param)
+        self._filter_params_name.update({
+            f'#{attribute}': old_att if old_att else attribute
+        })
+
+        return self
+
+    """
+        Args:
+        attribute (str): The table attribute to filter on.
+        attribute_value: The value to use on the filter.
+
+        Returns:
+        self: The DynoLayer.
+        """
+
+    def or_find_by(
+            self,
+            attribute: str,
+            comparator: Literal["=", "<", "<=", ">", ">=", "BETWEEN", "begins_with"],
+            attribute_value
+    ):
+        use_or_operator = ' OR '
+        old_att = ''
+        if self._is_find_by:
+            if str(self._filter_params.get(f':{attribute}', '')):
+                letters = string.ascii_lowercase
+                random_str = ''
+                for i in range(4):
+                    random_str += random.choice(letters)
+                old_att = attribute
+                attribute = random_str + attribute
+
+        if not self._is_find_by:
+            self._is_find_by = True
+
+        if isinstance(attribute_value, dict) or (isinstance(attribute_value, list) and comparator != 'BETWEEN'):
+            attribute_value = json.dumps(attribute_value)
+
+        filter_param = {
+            f':{attribute}': attribute_value
+        }
+        if comparator == 'BETWEEN':
+            self._filter_expression += f'{use_or_operator}(#{attribute} {comparator} :{attribute[0]} AND :{attribute[1]})'
+            filter_param = {
+                f':{attribute[0]}': attribute_value[0],
+                f':{attribute[1]}': attribute_value[1]
+            }
+        elif comparator == 'begins_with':
+            self._filter_expression += f'{use_or_operator}({comparator}(#{attribute},:{attribute}))'
+        else:
+            self._filter_expression += f'{use_or_operator}(#{attribute} {comparator} :{attribute})'
+        self._filter_params.update(filter_param)
+        self._filter_params_name.update({
+            f'#{attribute}': old_att if old_att else attribute
+        })
+
+        return self
+
+    """
+    This function create a FilterExpression for a query operation
+    Args:
+    attributes (str): The specific attributes to return from table.
+
+    Returns:
+    self: The DynoLayer.
+    """
+
+    def filter(
+            self,
+            attribute: str,
+            comparator: Literal["=", "<>", "<", "<=", ">", ">=", "BETWEEN", "begins_with"],
+            attribute_value,
+            logical_operator: Literal['AND', 'OR', 'NOT'] = ''
+    ):
+        old_att = ''
+        if self._is_find_by:
+            if str(self._filter_params.get(f':{attribute}', '')):
+                letters = string.ascii_lowercase
+                random_str = ''
+                for i in range(4):
+                    random_str += random.choice(letters)
+                old_att = attribute
+                attribute = random_str + attribute
 
         if isinstance(attribute_value, dict) or isinstance(attribute_value, list):
             attribute_value = json.dumps(attribute_value)
 
-        self._filter_expression += f'#{attribute} {comparator} :{attribute}'
+        if logical_operator:
+            logical_operator = f' {logical_operator} '
+        if comparator == 'BETWEEN':
+            self._query_filter_expression += f'{logical_operator}(#{attribute} {comparator} :{attribute[0]} AND :{attribute[1]})'
+        elif comparator == 'begins_with':
+            self._query_filter_expression += f'{logical_operator}({comparator}(#{attribute},:{attribute}))'
+        else:
+            self._query_filter_expression += f'{logical_operator}(#{attribute} {comparator} :{attribute})'
         self._filter_params.update({
             f':{attribute}': attribute_value
         })
         self._filter_params_name.update({
-            f'#{attribute}': attribute
+            f'#{attribute}': old_att if old_att else attribute
         })
 
         return self
@@ -257,6 +406,10 @@ def _fetch(self, paginate_through_results: bool = False, just_count=False, objec
             if self._filter_expression:
                 filter_key = 'KeyConditionExpression' if self._is_query_operation else 'FilterExpression'
                 scan_params.update({filter_key: self._filter_expression})
+                if self._query_filter_expression:
+                    if not scan_params.get('FilterExpression', None):
+                        scan_params['FilterExpression'] = ''
+                    scan_params['FilterExpression'] += self._query_filter_expression
                 scan_params.update({'ExpressionAttributeValues': self._filter_params})
                 scan_params.update({'ExpressionAttributeNames': self._filter_params_name})
 
@@ -267,6 +420,9 @@ def _fetch(self, paginate_through_results: bool = False, just_count=False, objec
                 scan_params.update({'IndexName': self._secondary_index})
 
             self._is_find_by = False  # return to default value
+            self._filter_expression = ''  # return to default value
+            self._filter_params = {}  # return to default value
+            self._filter_params_name = {}  # return to default value
             if self._is_query_operation:
                 return self._order_response(self._fetch_query(scan_params, paginate_through_results), object=object)
 
@@ -352,7 +508,7 @@ def save(self) -> bool:
             self._table.put_item(
                 Item=data
             )
-            self.id = data[self._partition_key]
+            self._data['id'] = data[self._partition_key]
             return True
         except Exception as e:
             self._error = str(e)
@@ -494,7 +650,7 @@ def data(self):
     """
 
     def _order_response(self, response, object=False):
-        if len(response) == 0:
+        if not response or len(response) == 0:
             return response
 
         if self._order_by:
@@ -516,4 +672,3 @@ def _order_response(self, response, object=False):
             return transformed_response
 
         return response
-

Diff for: setup.py

@@ -7,7 +7,7 @@
 
 setup(
     name='dynolayer',
-    version='0.3.4',
+    version='0.4.0',
     license='MIT License',
     packages=['dynolayer'],
     install_requires=['boto3', 'pytz', 'python-dotenv'],

Diff for: tests/unit/test_destroy.py

@@ -1,7 +1,7 @@
 import boto3
 import pytest
 from dynolayer.dynolayer import DynoLayer
-from moto import mock_aws
+from moto import mock_dynamodb
 
 
 def create_table():
@@ -63,7 +63,7 @@ def __init__(self) -> None:
         super().__init__('users', [])
 
 
-@mock_aws
+@mock_dynamodb
 def test_it_should_destroy_a_record():
     create_table()
     save_record()