nuql 0.0.1__tar.gz → 0.0.3__tar.gz

nuql-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025, Github:lukeshortland
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nuql-0.0.3/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: nuql
+Version: 0.0.3
+Summary: Nuql (pronounced 'nuckle') is a lightweight DynamoDB library for implementing the single table model pattern.
+License: MIT License
+        
+        Copyright (c) 2025, Github:lukeshortland
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.13
+Requires-Dist: boto3>=1.40.0
+Requires-Dist: pyparsing>=3.2.3
+Requires-Dist: python-ulid>=3.0.0
+Requires-Dist: uuid-utils>=0.11.0

{nuql-0.0.1 → nuql-0.0.3}/nuql/api/put_item.py

@@ -16,7 +16,7 @@ class PutItem(Boto3Adapter):
     def prepare_client_args(
             self,
             data: Dict[str, Any],
-            condition: Optional['types.QueryWhere'] = None,
+            condition: Optional[Dict[str, Any]] = None,
             exclude_condition: bool = False,
             **kwargs,
     ) -> Dict[str, Any]:
@@ -109,4 +109,4 @@ class PutItem(Boto3Adapter):
         except ClientError as exc:
             raise nuql.Boto3Error(exc, args)
 
-        return args['Item']
+        return self.table.serialiser.deserialise(args['Item'])

{nuql-0.0.1 → nuql-0.0.3}/nuql/api/query/key_condition.py

@@ -65,8 +65,13 @@ class KeyCondition:
         else:
             self.index = table.indexes.get_index(index_name)
 
-        if self.index['hash'] not in condition:
+        pk_field = table.fields[self.index['hash']]
+        sk_field = table.fields.get(self.index.get('sort'))
+
+        if pk_field.auto_include_key_condition:
             condition[self.index['hash']] = None
+        if sk_field and sk_field.auto_include_key_condition:
+            condition[self.index.get('sort')] = None
 
         parsed_conditions = {}
 
@@ -98,22 +103,27 @@ class KeyCondition:
 
             # Process projected field
             else:
-                key_name = self.index['hash'] if is_hash_key else self.index['sort']
+                projected_keys = []
+                if projects_to_hash:
+                    projected_keys.append(self.index['hash'])
+                if projects_to_sort:
+                    projected_keys.append(self.index['sort'])
 
-                if key_name not in parsed_conditions:
-                    parsed_conditions[key_name] = ['eq', {}]
+                for key_name in projected_keys:
+                    if key_name not in parsed_conditions:
+                        parsed_conditions[key_name] = ['eq', {}]
 
-                if parsed_conditions[key_name][0] != 'eq' and operand != 'eq':
-                    raise nuql.NuqlError(
-                        code='KeyConditionError',
-                        message=f'Multiple non-equals operators provided for the key \'{key_name}\' '
-                                'will result in an ambiguous key condition.'
-                    )
+                    if parsed_conditions[key_name][0] != 'eq' and operand != 'eq':
+                        raise nuql.NuqlError(
+                            code='KeyConditionError',
+                            message=f'Multiple non-equals operators provided for the key \'{key_name}\' '
+                                    'will result in an ambiguous key condition.'
+                        )
 
-                if operand != 'eq':
-                    parsed_conditions[key_name][0] = operand
+                    if operand != 'eq':
+                        parsed_conditions[key_name][0] = operand
 
-                parsed_conditions[key_name][1][key] = condition_value
+                    parsed_conditions[key_name][1][key] = condition_value
 
         self.condition = None
         validator = resources.Validator()
@@ -135,6 +145,17 @@ class KeyCondition:
                 serialised_value = field(value, 'query', validator)
                 key_condition = getattr(key_obj, operand)(serialised_value)
 
+            is_partial = key in validator.partial_keys
+
+            if key == self.index['hash'] and is_partial:
+                raise nuql.NuqlError(
+                    code='KeyConditionError',
+                    message=f'Partial key \'{key}\' cannot be used in a key condition on \'{index_name}\' index.'
+                )
+
+            if is_partial and operand != 'begins_with':
+                continue
+
             if self.condition is None:
                 self.condition = key_condition
             else:

{nuql-0.0.1 → nuql-0.0.3}/nuql/client.py

@@ -37,8 +37,8 @@ class Nuql:
 
         # Insert global fields on to all tables
         if isinstance(global_fields, dict):
-            for table in schema.values():
-                table.update(global_fields)
+            for table_name in list(schema.keys()):
+                schema[table_name].update(global_fields)
 
         self.connection = Connection(name, session)
         self.fields = custom_fields

{nuql-0.0.1 → nuql-0.0.3}/nuql/fields/key.py

@@ -5,58 +5,12 @@ from typing import Dict, Any
 
 import nuql
 from nuql import resources, types
+from nuql.resources import EmptyValue
 
 
 class Key(resources.FieldBase):
     type = 'key'
 
-    def __call__(self, value: Any, action: 'types.SerialisationType', validator: 'resources.Validator') -> Any:
-        """
-        Encapsulates the internal serialisation logic to prepare for
-        sending the record to DynamoDB.
-
-        :arg value: Deserialised value.
-        :arg action: SerialisationType (`create`, `update`, `write` or `query`).
-        :arg validator: Validator instance.
-        :return: Serialised value.
-        """
-        has_value = not isinstance(value, resources.EmptyValue)
-
-        # Apply generators if applicable to the field to overwrite the value
-        if action in ['create', 'update', 'write']:
-            if action == 'create' and self.on_create:
-                value = self.on_create()
-
-            if action == 'update' and self.on_update:
-                value = self.on_update()
-
-            if self.on_write:
-                value = self.on_write()
-
-        # Set default value if applicable
-        if not has_value and not value:
-            value = self.default
-
-        # Serialise the value
-        value = self.serialise_template(value, action, validator)
-
-        # Validate required field
-        if self.required and action == 'create' and value is None:
-            validator.add(name=self.name, message='Field is required')
-
-        # Validate against enum
-        if self.enum and has_value and action in ['create', 'update', 'write'] and value not in self.enum:
-            validator.add(name=self.name, message=f'Value must be one of: {", ".join(self.enum)}')
-
-        # Run internal validation
-        self.internal_validation(value, action, validator)
-
-        # Run custom validation logic
-        if self.validator and action in ['create', 'update', 'write']:
-            self.validator(value, validator)
-
-        return value
-
     def on_init(self) -> None:
         """Initialises the key field."""
         # Validate the field has a value
@@ -69,6 +23,8 @@ class Key(resources.FieldBase):
         # Callback fn handles configuring projected fields on the schema
         def callback(field_map: dict) -> None:
             """Callback fn to configure projected fields on the schema."""
+            auto_include_map = {}
+
             for key, value in self.value.items():
                 projected_name = self.parse_projected_name(value)
 
@@ -88,15 +44,38 @@ class Key(resources.FieldBase):
                 field_map[projected_name].projected_from.append(self.name)
                 self.projects_fields.append(projected_name)
 
+                auto_include_map[projected_name] = field_map[projected_name].default is not None
+
+            self.auto_include_key_condition = all(auto_include_map.values())
+
         if self.init_callback is not None:
             self.init_callback(callback)
 
+    def serialise_internal(
+            self,
+            value: Any,
+            action: 'types.SerialisationType',
+            validator: 'resources.Validator'
+    ) -> Any:
+        """
+        Internal serialisation override.
+
+        :arg value: Value to serialise.
+        :arg action: Serialisation action.
+        :arg validator: Validator instance.
+        :return: Serialised value.
+        """
+        serialised = self.serialise_template(value, action, validator)
+        if serialised['is_partial']:
+            validator.partial_keys.append(self.name)
+        return serialised['value']
+
     def serialise_template(
             self,
             key_dict: Dict[str, Any],
             action: 'types.SerialisationType',
             validator: 'resources.Validator'
-    ) -> str:
+    ) -> Dict[str, Any]:
         """
         Serialises the key dict to a string.
 
@@ -108,6 +87,11 @@ class Key(resources.FieldBase):
         output = ''
         s = self.sanitise
 
+        if key_dict is None:
+            key_dict = {}
+
+        is_partial = False
+
         for key, value in self.value.items():
             projected_name = self.parse_projected_name(value)
 
@@ -121,7 +105,9 @@ class Key(resources.FieldBase):
                                 f'\'{self.name}\') is not defined in the schema'
                     )
 
-                projected_value = key_dict.get(projected_name)
+                is_partial = is_partial or (key not in key_dict and not projected_field.default)
+
+                projected_value = key_dict.get(projected_name) or EmptyValue()
                 serialised_value = projected_field(projected_value, action, validator)
                 used_value = s(serialised_value) if serialised_value else None
             else:
@@ -133,7 +119,7 @@ class Key(resources.FieldBase):
 
             output += f'{s(key)}:{used_value if used_value else ""}|'
 
-        return output[:-1]
+        return {'value': output[:-1], 'is_partial': is_partial}
 
     def deserialise(self, value: str) -> Dict[str, Any]:
         """

nuql-0.0.3/nuql/fields/list.py

@@ -0,0 +1,52 @@
+__all__ = ['List']
+
+from typing import List as _List, Any
+
+import nuql
+from nuql import resources, types
+from nuql.resources import FieldBase
+
+
+class List(FieldBase):
+    type = 'list'
+    of: FieldBase
+
+    def on_init(self) -> None:
+        """Defines the contents of the list."""
+        if 'of' not in self.config:
+            raise nuql.NuqlError(
+                code='SchemaError',
+                message='Config key \'of\' must be defined for the list field type'
+            )
+
+        # Initialise the configured 'of' field type
+        field_map = resources.create_field_map(
+            fields={'of': self.config['of']},
+            parent=self.parent,
+            field_types=self.parent.provider.fields
+        )
+        self.of = field_map['of']
+
+    def serialise_internal(
+            self,
+            value: Any,
+            action: 'types.SerialisationType',
+            validator: 'resources.Validator'
+    ) -> Any:
+        """Internal serialisation"""
+        if not isinstance(value, list):
+            return None
+        else:
+            return [self.of(item, action, validator) for item in value]
+
+    def deserialise(self, value: _List[Any] | None) -> _List[Any] | None:
+        """
+        Deserialises a list of values.
+
+        :arg value: List or None.
+        :return: List or None.
+        """
+        if not isinstance(value, list):
+            return None
+
+        return [self.of.deserialise(item) for item in value]

nuql-0.0.3/nuql/fields/map.py

@@ -0,0 +1,37 @@
+__all__ = ['Map']
+
+from typing import Dict as _Dict, Any
+
+import nuql
+from nuql import resources, types
+
+
+class Map(resources.FieldBase):
+    type = 'map'
+    fields: _Dict[str, Any] = {}
+    serialiser: 'resources.Serialiser' = None
+
+    def on_init(self) -> None:
+        """Initialises the dict schema."""
+        if 'fields' not in self.config:
+            raise nuql.NuqlError(
+                code='SchemaError',
+                message='Config key \'fields\' must be defined for the dict field type'
+            )
+
+        self.fields = resources.create_field_map(self.config['fields'], self.parent, self.parent.provider.fields)
+        self.serialiser = resources.Serialiser(self)
+
+    def serialise_internal(
+            self,
+            value: Any,
+            action: 'types.SerialisationType',
+            validator: 'resources.Validator'
+    ) -> Any:
+        """Serialises the Map value"""
+        if value:
+            return self.serialiser.serialise(action, value, validator)
+
+    def deserialise(self, value: Any) -> Any:
+        """Deserialises the Map value"""
+        return self.serialiser.deserialise(value)

{nuql-0.0.1 → nuql-0.0.3}/nuql/fields/string.py

@@ -6,7 +6,7 @@ from typing import List, Dict, Any
 
 import nuql
 from nuql import resources, types
-
+from nuql.resources import EmptyValue
 
 TEMPLATE_PATTERN = r'\$\{(\w+)}'
 
@@ -15,61 +15,14 @@ class String(resources.FieldBase):
     type = 'string'
     is_template = False
 
-    def __call__(self, value: Any, action: 'types.SerialisationType', validator: 'resources.Validator') -> Any:
-        """
-        Encapsulates the internal serialisation logic to prepare for
-        sending the record to DynamoDB.
-
-        :arg value: Deserialised value.
-        :arg action: SerialisationType (`create`, `update`, `write` or `query`).
-        :arg validator: Validator instance.
-        :return: Serialised value.
-        """
-        has_value = not isinstance(value, resources.EmptyValue)
-
-        # Apply generators if applicable to the field to overwrite the value
-        if action in ['create', 'update', 'write']:
-            if action == 'create' and self.on_create:
-                value = self.on_create()
-
-            if action == 'update' and self.on_update:
-                value = self.on_update()
-
-            if self.on_write:
-                value = self.on_write()
-
-        # Set default value if applicable
-        if not has_value and not value and not self.value and not self.is_template:
-            value = self.default
-
-        if self.value and not self.is_template:
-            value = self.value
-
-        # Serialise the value
-        if self.is_template:
-            value = self.serialise_template(value, action, validator)
-        else:
-            value = self.serialise(value)
-
-        # Validate required field
-        if self.required and action == 'create' and value is None:
-            validator.add(name=self.name, message='Field is required')
-
-        # Run internal validation
-        self.internal_validation(value, action, validator)
-
-        # Run custom validation logic
-        if self.validator and action in ['create', 'update', 'write']:
-            self.validator(value, validator)
-
-        return value
-
     def on_init(self) -> None:
         """Initialises the string field when a template is defined."""
         self.is_template = self.value is not None and bool(re.search(TEMPLATE_PATTERN, self.value))
 
         def callback(field_map: dict) -> None:
             """Callback fn to configure projected fields on the schema."""
+            auto_include_map = {}
+
             for key in self.find_projections(self.value):
                 if key not in field_map:
                     raise nuql.NuqlError(
@@ -82,9 +35,35 @@ class String(resources.FieldBase):
                 field_map[key].projected_from.append(self.name)
                 self.projects_fields.append(key)
 
+                auto_include_map[key] = field_map[key].default is not None
+
+            self.auto_include_key_condition = all(auto_include_map.values())
+
         if self.init_callback is not None and self.is_template:
             self.init_callback(callback)
 
+    def serialise_internal(
+            self,
+            value: Any,
+            action: 'types.SerialisationType',
+            validator: 'resources.Validator'
+    ) -> Any:
+        """
+        Internal serialisation override.
+
+        :arg value: Value to serialise.
+        :arg action: Serialisation action.
+        :arg validator: Validator instance.
+        :return: Serialised value.
+        """
+        if self.is_template:
+            serialised = self.serialise_template(value, action, validator)
+            if serialised['is_partial']:
+                validator.partial_keys.append(self.name)
+            return serialised['value']
+        else:
+            return self.serialise(value)
+
     def serialise(self, value: str | None) -> str | None:
         """
         Serialises a string value.
@@ -108,7 +87,7 @@ class String(resources.FieldBase):
             value: Dict[str, Any],
             action: 'types.SerialisationType',
             validator: 'resources.Validator'
-    ) -> str | None:
+    ) -> Dict[str, Any]:
         """
         Serialises a template string.
 
@@ -120,9 +99,12 @@ class String(resources.FieldBase):
         if not isinstance(value, dict):
             value = {}
 
+        is_partial = False
+
         # Add not provided keys as empty strings
         for key in self.find_projections(self.value):
             if key not in value:
+                is_partial = True
                 value[key] = None
 
         serialised = {}
@@ -138,11 +120,11 @@ class String(resources.FieldBase):
                             f'\'{self.name}\') is not defined in the schema'
                 )
 
-            serialised_value = field(deserialised_value, action, validator)
+            serialised_value = field(deserialised_value or EmptyValue(), action, validator)
             serialised[key] = serialised_value if serialised_value else ''
 
         template = Template(self.value)
-        return template.substitute(serialised)
+        return {'value': template.substitute(serialised), 'is_partial': is_partial}
 
     def deserialise_template(self, value: str | None) -> Dict[str, Any]:
         """

{nuql-0.0.1 → nuql-0.0.3}/nuql/resources/fields/field.py

@@ -28,6 +28,7 @@ class FieldBase:
         self.config = config
         self.parent = parent
         self.init_callback = init_callback
+        self.auto_include_key_condition = False
 
         # Handle 'KEY' field type
         self.projected_from = []
@@ -91,11 +92,11 @@ class FieldBase:
                 value = self.on_write()
 
         # Set default value if applicable
-        if not has_value and not value:
+        if not has_value and self.default:
             value = self.default
 
         # Serialise the value
-        value = self.serialise(value)
+        value = self.serialise_internal(value, action, validator)
 
         # Validate required field
         if self.required and action == 'create' and value is None:
@@ -126,6 +127,22 @@ class FieldBase:
             message='Serialisation has not been implemented for this field type.'
         )
 
+    def serialise_internal(
+            self,
+            value: Any,
+            _action: 'types.SerialisationType',
+            _validator: 'resources.Validator'
+    ) -> Any:
+        """
+        Internal serialisation wrapper to allow overridable serialisation behaviour.
+
+        :arg value: Value to serialise.
+        :arg _action: Serialisation type.
+        :arg _validator: Validator instance.
+        :return: Serialised value.
+        """
+        return self.serialise(value)
+
     def deserialise(self, value: Any) -> Any:
         """
         Deserialise/unmarshal the field value from DynamoDB format.

{nuql-0.0.1 → nuql-0.0.3}/nuql/resources/fields/field_map.py

@@ -62,10 +62,10 @@ def get_field_types(field_types: List[Type['types.FieldType']] | None = None) ->
 
     def is_valid(_obj: Any) -> bool:
         """Check the provided object is a valid field type."""
-        if not inspect.isclass(obj):
+        if not inspect.isclass(_obj):
             return False
 
-        if not issubclass(obj, resources.FieldBase):
+        if not issubclass(_obj, resources.FieldBase):
             return False
 
         return True

{nuql-0.0.1 → nuql-0.0.3}/nuql/resources/records/validator.py

@@ -15,6 +15,7 @@ class Validator:
         self.path = path
         self.children = []
         self._errors = []
+        self.partial_keys = []
 
     @property
     def errors(self):

{nuql-0.0.1 → nuql-0.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nuql"
-version = "0.0.1"
+version = "0.0.3"
 description = "Nuql (pronounced 'nuckle') is a lightweight DynamoDB library for implementing the single table model pattern."
 requires-python = ">=3.13"
 dependencies = [
@@ -9,6 +9,7 @@ dependencies = [
     "python-ulid>=3.0.0",
     "uuid-utils>=0.11.0",
 ]
+license = { file = "LICENSE" }
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",

nuql-0.0.1/PKG-INFO

@@ -1,12 +0,0 @@
-Metadata-Version: 2.4
-Name: nuql
-Version: 0.0.1
-Summary: Nuql (pronounced 'nuckle') is a lightweight DynamoDB library for implementing the single table model pattern.
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.13
-Requires-Dist: boto3>=1.40.0
-Requires-Dist: pyparsing>=3.2.3
-Requires-Dist: python-ulid>=3.0.0
-Requires-Dist: uuid-utils>=0.11.0

nuql-0.0.1/nuql/fields/list.py

@@ -1,90 +0,0 @@
-__all__ = ['List']
-
-from typing import List as _List, Any
-
-import nuql
-from nuql import resources, types
-from nuql.resources import FieldBase
-
-
-class List(FieldBase):
-    type = 'list'
-    of: FieldBase
-
-    def on_init(self) -> None:
-        """Defines the contents of the list."""
-        if 'of' not in self.config:
-            raise nuql.NuqlError(
-                code='SchemaError',
-                message='Config key \'of\' must be defined for the list field type'
-            )
-
-        # Initialise the configured 'of' field type
-        field_map = resources.create_field_map(
-            fields={'of': self.config['of']},
-            parent=self.parent,
-            field_types=self.parent.provider.fields
-        )
-        self.of = field_map['of']
-
-    def __call__(self, value: Any, action: 'types.SerialisationType', validator: 'resources.Validator') -> Any:
-        """
-        Encapsulates the internal serialisation logic to prepare for
-        sending the record to DynamoDB.
-
-        :arg value: Deserialised value.
-        :arg action: SerialisationType (`create`, `update`, `write` or `query`).
-        :arg validator: Validator instance.
-        :return: Serialised value.
-        """
-        has_value = not isinstance(value, resources.EmptyValue)
-
-        # Apply generators if applicable to the field to overwrite the value
-        if action in ['create', 'update', 'write']:
-            if action == 'create' and self.on_create:
-                value = self.on_create()
-
-            if action == 'update' and self.on_update:
-                value = self.on_update()
-
-            if self.on_write:
-                value = self.on_write()
-
-        # Set default value if applicable
-        if not has_value and not value:
-            value = self.default
-
-        # Serialise the value
-        if not isinstance(value, list):
-            value = None
-        else:
-            value = [self.of(item, action, validator) for item in value]
-
-        # Validate required field
-        if self.required and action == 'create' and value is None:
-            validator.add(name=self.name, message='Field is required')
-
-        # Validate against enum
-        if self.enum and has_value and action in ['create', 'update', 'write'] and value not in self.enum:
-            validator.add(name=self.name, message=f'Value must be one of: {", ".join(self.enum)}')
-
-        # Run internal validation
-        self.internal_validation(value, action, validator)
-
-        # Run custom validation logic
-        if self.validator and action in ['create', 'update', 'write']:
-            self.validator(value, validator)
-
-        return value
-
-    def deserialise(self, value: _List[Any] | None) -> _List[Any] | None:
-        """
-        Deserialises a list of values.
-
-        :arg value: List or None.
-        :return: List or None.
-        """
-        if not isinstance(value, list):
-            return None
-
-        return [self.of.deserialise(item) for item in value]

nuql-0.0.1/nuql/fields/map.py

@@ -1,67 +0,0 @@
-__all__ = ['Map']
-
-from typing import Dict as _Dict, Any
-
-import nuql
-from nuql import resources, types
-
-
-class Map(resources.FieldBase):
-    type = 'map'
-    fields: _Dict[str, Any] = {}
-    serialiser: 'resources.Serialiser' = None
-
-    def on_init(self) -> None:
-        """Initialises the dict schema."""
-        if 'fields' not in self.config:
-            raise nuql.NuqlError(
-                code='SchemaError',
-                message='Config key \'fields\' must be defined for the dict field type'
-            )
-
-        self.fields = resources.create_field_map(self.config['fields'], self.parent, self.parent.provider.fields)
-        self.serialiser = resources.Serialiser(self)
-
-    def __call__(self, value: Any, action: 'types.SerialisationType', validator: 'resources.Validator') -> Any:
-        """
-        Encapsulates the internal serialisation logic to prepare for
-        sending the record to DynamoDB.
-
-        :arg value: Deserialised value.
-        :arg action: SerialisationType (`create`, `update`, `write` or `query`).
-        :arg validator: Validator instance.
-        :return: Serialised value.
-        """
-        has_value = not isinstance(value, resources.EmptyValue)
-
-        # Apply generators if applicable to the field to overwrite the value
-        if action in ['create', 'update', 'write']:
-            if action == 'create' and self.on_create:
-                value = self.on_create()
-
-            if action == 'update' and self.on_update:
-                value = self.on_update()
-
-            if self.on_write:
-                value = self.on_write()
-
-        # Set default value if applicable
-        if not has_value and not value:
-            value = self.default
-
-        # Serialise the value
-        if value:
-            value = self.serialiser.serialise(action, value, validator)
-
-        # Validate required field
-        if self.required and action == 'create' and value is None:
-            validator.add(name=self.name, message='Field is required')
-
-        # Run internal validation
-        self.internal_validation(value, action, validator)
-
-        # Run custom validation logic
-        if self.validator and action in ['create', 'update', 'write']:
-            self.validator(value, validator)
-
-        return value