nuql 0.0.6__py3-none-any.whl → 0.0.7__py3-none-any.whl

nuql/api/batch_write.py

@@ -1,6 +1,6 @@
 __all__ = ['BatchWrite']
 
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Literal
 
 from botocore.exceptions import ClientError
 
@@ -51,35 +51,39 @@ class BatchWrite:
                 message='Batch write context manager has not been started'
             )
 
-    def create(self,
+    def put(
+            self,
             table: 'resources.Table',
             data: Dict[str, Any],
+            serialisation_type: Literal['create', 'update', 'write'] = 'write'
     ) -> None:
         """
         Create a new item on the table as part of a batch write.
 
         :arg table: Table instance.
         :arg data: Data to create.
+        :param serialisation_type: Data serialisation type.
         """
         self._validate_started()
-        create = api.Create(self.client, table)
-        args = create.prepare_args(data=data, exclude_condition=True)
-        self._actions['put_item'].append(args)
 
-    def update(
-            self,
-            table: 'resources.Table',
-            data: Dict[str, Any],
-    ) -> None:
-        """
-        Update an existing item on the table as part of a batch write.
+        if serialisation_type == 'create':
+            create = api.Create(self.client, table)
+            args = create.prepare_args(data=data, exclude_condition=True)
+
+        elif serialisation_type == 'update':
+            put_update = api.PutUpdate(self.client, table)
+            args = put_update.prepare_args(data=data, exclude_condition=True)
+
+        elif serialisation_type == 'write':
+            put = api.PutItem(self.client, table)
+            args = put.prepare_args(data=data, exclude_condition=True)
+
+        else:
+            raise nuql.NuqlError(
+                code='BatchWriteError',
+                message=f'Invalid serialisation type: {serialisation_type}'
+            )
 
-        :arg table: Table instance.
-        :arg data: Data to update.
-        """
-        self._validate_started()
-        put_update = api.PutUpdate(self.client, table)
-        args = put_update.prepare_args(data=data, exclude_condition=True)
         self._actions['put_item'].append(args)
 
     def delete(

nuql/api/condition_check.py

@@ -9,7 +9,7 @@ from nuql.api import Boto3Adapter
 
 
 class ConditionCheck(Boto3Adapter):
-    def prepare_client_args(self, key: Dict[str, Any], condition: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+    def prepare_client_args(self, key: Dict[str, Any], condition: str | Dict[str, Any], **kwargs) -> Dict[str, Any]:
         """
         Prepare the request args for a condition check operation against the table (client API).
 

nuql/api/delete.py

@@ -14,7 +14,7 @@ class Delete(Boto3Adapter):
     def prepare_client_args(
             self,
             key: Dict[str, Any],
-            condition: Dict[str, Any] | None = None,
+            condition: str | Dict[str, Any] | None = None,
             exclude_condition: bool = False,
             **kwargs,
     ) -> Dict[str, Any]:

nuql/api/put_item.py

@@ -16,7 +16,7 @@ class PutItem(Boto3Adapter):
     def prepare_client_args(
             self,
             data: Dict[str, Any],
-            condition: Optional[Dict[str, Any]] = None,
+            condition: Optional[str | Dict[str, Any]] = None,
             exclude_condition: bool = False,
             **kwargs,
     ) -> Dict[str, Any]:
@@ -59,7 +59,7 @@ class PutItem(Boto3Adapter):
     def prepare_args(
             self,
             data: Dict[str, Any],
-            condition: Dict[str, Any] | None = None,
+            condition: str | Dict[str, Any] | None = None,
             exclude_condition: bool = False,
             **kwargs,
     ) -> Dict[str, Any]:
@@ -94,7 +94,7 @@ class PutItem(Boto3Adapter):
         """
         pass
 
-    def invoke_sync(self, data: Dict[str, Any], condition: Dict[str, Any] | None = None) -> Dict[str, Any]:
+    def invoke_sync(self, data: Dict[str, Any], condition: str | Dict[str, Any] | None = None) -> Dict[str, Any]:
         """
         Perform a put operation against the table.
 

nuql/api/query/condition.py

@@ -13,7 +13,7 @@ class Condition:
     def __init__(
             self,
             table: 'resources.Table',
-            condition: Dict[str, Any] | None = None,
+            condition: str | Dict[str, Any] | None = None,
             condition_type: Literal['FilterExpression', 'ConditionExpression'] = 'FilterExpression',
     ) -> None:
         """
@@ -23,6 +23,9 @@ class Condition:
         :param condition: Condition dict.
         :param condition_type: Condition type (FilterExpression or ConditionExpression).
         """
+        # Initialise the condition even when it is a string
+        if isinstance(condition, str):
+            condition = {'where': condition, 'variables': {}}
 
         self.table = table
         self.variables = condition['variables'] if condition and condition.get('variables') else {}
@@ -88,16 +91,6 @@ class Condition:
             field_name = part['field']
             field = self.table.fields.get(field_name)
 
-            is_key = field_name in self.table.indexes.index_keys
-            is_projected_to_key = any([x in self.table.indexes.index_keys for x in field.projected_from])
-
-            # Validate that keys cannot be present in the query
-            if (is_key or is_projected_to_key) and self.type == 'FilterExpression':
-                raise nuql.NuqlError(
-                    code='ConditionError',
-                    message=f'Field \'{field_name}\' cannot be used in a condition query'
-                )
-
             # Functions are called differently
             if part['type'] == 'function':
                 expression = getattr(attr, part['function'])()

nuql/api/query/key_condition.py

@@ -1,11 +1,11 @@
 __all__ = ['KeyCondition']
 
-from typing import Dict, Any
+from typing import Dict, Any, Tuple, Union
 
-from boto3.dynamodb.conditions import Key, ConditionExpressionBuilder
+from boto3.dynamodb.conditions import Key, ConditionExpressionBuilder, ComparisonCondition
 
 import nuql
-from nuql import resources
+from nuql import resources, types
 
 
 KEY_OPERANDS = {
@@ -59,20 +59,88 @@ class KeyCondition:
             condition = {}
 
         self.index_name = index_name
-
-        if index_name == 'primary':
-            self.index = table.indexes.primary
-        else:
-            self.index = table.indexes.get_index(index_name)
+        self.index = self._resolve_index(table, index_name)
 
         pk_field = table.fields[self.index['hash']]
         sk_field = table.fields.get(self.index.get('sort'))
 
+        # Key fields that only contain fixed values should always be included
         if pk_field.auto_include_key_condition:
             condition[self.index['hash']] = None
-        if sk_field and sk_field.auto_include_key_condition:
+        if sk_field.auto_include_key_condition:
             condition[self.index.get('sort')] = None
 
+        parsed_conditions = self.parse_conditions(table, condition, index_name)
+        self.condition = self.build_condition_expression(table, parsed_conditions, index_name)
+
+    @property
+    def resource_args(self) -> Dict[str, Any]:
+        """Query request args."""
+        if self.condition is None:
+            raise nuql.NuqlError(code='KeyConditionError', message='Key condition is empty.')
+
+        args: Dict[str, Any] = {'KeyConditionExpression': self.condition}
+        if self.index_name != 'primary':
+            args['IndexName'] = self.index_name
+
+        return args
+
+    @property
+    def client_args(self) -> Dict[str, Any]:
+        """Boto3 client args for the condition."""
+        if self.condition is None:
+            raise nuql.NuqlError(code='KeyConditionError', message='Key condition is empty.')
+
+        args = {}
+
+        if self.index_name != 'primary':
+            args['IndexName'] = self.index_name
+
+        builder = ConditionExpressionBuilder()
+        expression = builder.build_expression(self.condition, is_key_condition=True)
+
+        args['KeyConditionExpression'] = getattr(expression, 'condition_expression')
+        args['ExpressionAttributeNames'] = getattr(expression, 'attribute_name_placeholders')
+        args['ExpressionAttributeValues'] = getattr(expression, 'attribute_value_placeholders')
+
+        return args
+
+    @staticmethod
+    def extract_condition(key: str, value: Any) -> Tuple[str, Any]:
+        """
+        Parses and extracts the operand and value from the condition.
+
+        :arg key: Condition key.
+        :arg value: Condition value or dict.
+        :return: Tuple containing the operand and value.
+        """
+        value_keys = list(value.keys()) if isinstance(value, dict) else []
+        if isinstance(value, dict) and all([x.lower() in KEY_OPERANDS for x in value.keys()]):
+            if len(value_keys) > 1:
+                raise nuql.NuqlError(
+                    code='KeyConditionError',
+                    message=f'Multiple operators provided for the key \'{key}\' (' + ', '.join(value_keys) + ').'
+                )
+
+            condition_dict = next(iter(value.items()))
+
+            operand = KEY_OPERANDS[condition_dict[0].lower()]
+            condition_value = condition_dict[1]
+        else:
+            operand = 'eq'
+            condition_value = value
+
+        return operand, condition_value
+
+    def parse_conditions(self, table: 'resources.Table', condition: Dict[str, Any], index_name: str) -> Dict[str, Any]:
+        """
+        Parse the condition dict handling projected fields.
+
+        :arg table: Table instance.
+        :arg condition: Condition dict.
+        :arg index_name: Index name.
+        :return: Parsed condition dict.
+        """
         parsed_conditions = {}
 
         for key, value in condition.items():
@@ -87,8 +155,15 @@ class KeyCondition:
             projects_to_hash = self.index['hash'] in field.projected_from
             projects_to_sort = self.index.get('sort') in field.projected_from
 
+            # Resolve projected fields to their respective key(s)
+            projected_keys = []
+            if projects_to_hash:
+                projected_keys.append(self.index['hash'])
+            if projects_to_sort:
+                projected_keys.append(self.index['sort'])
+
             # Validate that the key is available on the index
-            if not any([is_hash_key, is_sort_key, projects_to_hash, projects_to_sort]):
+            if not is_hash_key and not is_sort_key and not projects_to_hash and not projects_to_sort:
                 raise nuql.NuqlError(
                     code='KeyConditionError',
                     message=f'Field \'{key}\' cannot be used in a key condition on \'{index_name}\' index '
@@ -103,16 +178,14 @@ class KeyCondition:
 
             # Process projected field
             else:
-                projected_keys = []
-                if projects_to_hash:
-                    projected_keys.append(self.index['hash'])
-                if projects_to_sort:
-                    projected_keys.append(self.index['sort'])
-
                 for key_name in projected_keys:
                     if key_name not in parsed_conditions:
                         parsed_conditions[key_name] = ['eq', {}]
 
+                    parsed_conditions[key_name][1][key] = condition_value
+
+                    # Allow a key with projections to have a greater_than or begins_with operator
+                    # without disrupting the integrity of the condition
                     if parsed_conditions[key_name][0] != 'eq' and operand != 'eq':
                         raise nuql.NuqlError(
                             code='KeyConditionError',
@@ -120,102 +193,94 @@ class KeyCondition:
                                     'will result in an ambiguous key condition.'
                         )
 
+                    # The first non-equals operand becomes the winner
                     if operand != 'eq':
                         parsed_conditions[key_name][0] = operand
 
-                    parsed_conditions[key_name][1][key] = condition_value
+        if self.index['hash'] not in parsed_conditions:
+            raise nuql.NuqlError(
+                code='KeyConditionError',
+                message=f'Hash key \'{self.index["hash"]}\' is required in the key condition '
+                        f'but was not provided nor could be inferred from the schema.'
+            )
+
+        return parsed_conditions
+
+    def build_condition_expression(
+            self,
+            table: 'resources.Table',
+            parsed_conditions: Dict[str, Any],
+            index_name: str
+    ) -> ComparisonCondition:
+        """
+        Builds the final condition expression to be used in the query.
 
-        self.condition = None
+        :arg table: Table instance.
+        :arg parsed_conditions: Parsed conditions dict.
+        :arg index_name: Index name.
+        :return: ComparisonCondition instance.
+        """
+        condition = None
         validator = resources.Validator()
 
         # Generate key condition
         for key, (operand, value) in parsed_conditions.items():
+
             field = table.fields[key]
+
             key_obj = Key(key)
+            key_condition_args = set()
 
+            # Special case for the between operator
             if operand == 'between':
                 if len(value) != 2:
                     raise nuql.NuqlError(
                         code='KeyConditionError',
                         message=f'Between operator requires exactly two values for the key \'{key}\'.'
                     )
-                serialised_value = (field(value[0], 'query', validator), field(value[1], 'query', validator))
-                key_condition = getattr(key_obj, operand)(*serialised_value)
+                key_condition_args.add(field(value[0], 'query', validator))
+                key_condition_args.add(field(value[1], 'query', validator))
+
+            # All other operators use a single value
             else:
-                serialised_value = field(value, 'query', validator)
-                key_condition = getattr(key_obj, operand)(serialised_value)
+                key_condition_args.add(field(value, 'query', validator))
 
             is_partial = key in validator.partial_keys
 
+            # Disallow partial keys on hash 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.'
+                    message=f'Partial key \'{key}\' cannot be used in a key condition on \'{index_name}\' '
+                            f'index as it is the hash key for the index.'
                 )
 
-            if is_partial and operand != 'begins_with':
-                continue
-
-            if self.condition is None:
-                self.condition = key_condition
-            else:
-                self.condition &= key_condition
-
-    @property
-    def resource_args(self) -> Dict[str, Any]:
-        """Query request args."""
-        if self.condition is None:
-            raise nuql.NuqlError(code='KeyConditionError', message='Key condition is empty.')
-
-        args: Dict[str, Any] = {'KeyConditionExpression': self.condition}
-        if self.index_name != 'primary':
-            args['IndexName'] = self.index_name
-
-        return args
-
-    @property
-    def client_args(self) -> Dict[str, Any]:
-        """Boto3 client args for the condition."""
-        if self.condition is None:
-            raise nuql.NuqlError(code='KeyConditionError', message='Key condition is empty.')
-
-        args = {}
-
-        if self.index_name != 'primary':
-            args['IndexName'] = self.index_name
-
-        builder = ConditionExpressionBuilder()
-        expression = builder.build_expression(self.condition, is_key_condition=True)
-
-        args['KeyConditionExpression'] = getattr(expression, 'condition_expression')
-        args['ExpressionAttributeNames'] = getattr(expression, 'attribute_name_placeholders')
-        args['ExpressionAttributeValues'] = getattr(expression, 'attribute_value_placeholders')
-
-        return args
-
-    @staticmethod
-    def extract_condition(key: str, value: Any) -> (str, Any):
-        """
-        Parses and extracts the operand and value from the condition.
-
-        :arg key: Condition key.
-        :arg value: Condition value or dict.
-        :return: Tuple containing the operand and value.
-        """
-        value_keys = list(value.keys()) if isinstance(value, dict) else []
-        if isinstance(value, dict) and all([x.lower() in KEY_OPERANDS for x in value.keys()]):
-            if len(value_keys) > 1:
+            # Partial sort key is allowed, but we must switch the operand to begins_with
+            if is_partial and operand == 'eq':
+                operand = 'begins_with'
+            elif is_partial and operand != 'begins_with':
                 raise nuql.NuqlError(
                     code='KeyConditionError',
-                    message=f'Multiple operators provided for the key \'{key}\' (' + ', '.join(value_keys) + ').'
+                    message=f'Operator \'{operand}\' is not supported for the key \'{key}\' '
+                            f'as it results in a partial key. Only \'begins_with\' is supported.'
                 )
 
-            condition_dict = next(iter(value.items()))
+            key_condition = getattr(key_obj, operand)(*key_condition_args)
 
-            operand = KEY_OPERANDS[condition_dict[0].lower()]
-            condition_value = condition_dict[1]
-        else:
-            operand = 'eq'
-            condition_value = value
+            if condition is None:
+                condition = key_condition
+            else:
+                condition &= key_condition
 
-        return operand, condition_value
+        return condition
+
+    @staticmethod
+    def _resolve_index(
+            table: 'resources.Table',
+            index_name: str
+    ) -> Union['types.PrimaryIndex', 'types.SecondaryIndex',]:
+        """Resolves the index to query against"""
+        if index_name == 'primary':
+            return table.indexes.primary
+        else:
+            return table.indexes.get_index(index_name)

nuql/api/query/query.py

@@ -12,7 +12,7 @@ class Query(api.Boto3Adapter):
     def prepare_client_args(
             self,
             key_condition: Dict[str, Any] | None = None,
-            condition: Dict[str, Any] | None = None,
+            condition: str | Dict[str, Any] | None = None,
             index_name: str = 'primary',
             limit: int | None = None,
             scan_index_forward: bool = True,
@@ -52,7 +52,7 @@ class Query(api.Boto3Adapter):
     def prepare_args(
             self,
             key_condition: Dict[str, Any] | None = None,
-            condition: Dict[str, Any] | None = None,
+            condition: str | Dict[str, Any] | None = None,
             index_name: str = 'primary',
             limit: int | None = None,
             scan_index_forward: bool = True,
@@ -92,7 +92,7 @@ class Query(api.Boto3Adapter):
     def invoke_sync(
             self,
             key_condition: Dict[str, Any] | None = None,
-            condition: Dict[str, Any] | None = None,
+            condition: str | Dict[str, Any] | None = None,
             index_name: str = 'primary',
             limit: int | None = None,
             scan_index_forward: bool = True,

nuql/api/transaction.py

@@ -66,7 +66,7 @@ class Transaction:
             self,
             table: 'resources.Table',
             data: Dict[str, Any],
-            condition: Dict[str, Any] | None = None,
+            condition: str | Dict[str, Any] | None = None,
     ) -> None:
         """
         Create a new item on a table as part of a transaction.
@@ -86,7 +86,7 @@ class Transaction:
             self,
             table: 'resources.Table',
             data: Dict[str, Any],
-            condition: Dict[str, Any] | None = None,
+            condition: str | Dict[str, Any] | None = None,
             shallow: bool = False,
     ) -> None:
         """
@@ -108,7 +108,7 @@ class Transaction:
             self,
             table: 'resources.Table',
             key: Dict[str, Any],
-            condition: Dict[str, Any] | None = None,
+            condition: str | Dict[str, Any] | None = None,
     ) -> None:
         """
         Delete an item on a table as part of a transaction.
@@ -128,7 +128,7 @@ class Transaction:
             self,
             table: 'resources.Table',
             key: Dict[str, Any],
-            condition: Dict[str, Any],
+            condition: str | Dict[str, Any],
     ) -> None:
         """
         Perform a condition check on an item as part of a transaction.

nuql/fields/key.py

@@ -30,6 +30,7 @@ class Key(resources.FieldBase):
 
                 # Skip fixed value fields
                 if not projected_name:
+                    auto_include_map[key] = True
                     continue
 
                 # Validate projected key exists on the table
@@ -105,11 +106,17 @@ class Key(resources.FieldBase):
                                 f'\'{self.name}\') is not defined in the schema'
                     )
 
-                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
+
+                is_partial = (is_partial or
+                              (key not in key_dict and not projected_field.default) or
+                              isinstance(projected_value, EmptyValue))
+
+                if isinstance(projected_value, EmptyValue):
+                    break
+
+                used_value = s(serialised_value) if not isinstance(serialised_value, (type(None), EmptyValue)) else None
             else:
                 used_value = s(value)
 

nuql/fields/string.py

@@ -91,28 +91,30 @@ class String(resources.FieldBase):
         """
         Serialises a template string.
 
+        If a required projected value is missing (no user value and no default),
+        the output is truncated right before that placeholder and the result is marked partial.
+
         :arg value: Dict of projections.
         :arg action: Serialisation type.
         :arg validator: Validator instance.
-        :return: String value.
+        :return: Dict with 'value' and 'is_partial'.
         """
         if not isinstance(value, dict):
             value = {}
 
         is_partial = False
+        template_str = self.value or ""
+        output_parts: list[str] = []
 
-        # 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
+        last_idx = 0
 
-        serialised = {}
+        # Walk through template pieces and placeholders in order
+        for match in re.finditer(TEMPLATE_PATTERN, template_str):
+            key = match.group(1)
+            # Append literal chunk before this placeholder
+            literal_chunk = template_str[last_idx:match.start()]
 
-        # Serialise values before substituting
-        for key, deserialised_value in value.items():
             field = self.parent.fields.get(key)
-
             if not field:
                 raise nuql.NuqlError(
                     code='TemplateStringError',
@@ -120,11 +122,32 @@ class String(resources.FieldBase):
                             f'\'{self.name}\') is not defined in the schema'
                 )
 
-            serialised_value = field(deserialised_value or EmptyValue(), action, validator)
-            serialised[key] = serialised_value if serialised_value else ''
+            provided = key in value
+            provided_value = value.get(key)
+
+            # If not provided and no default, we mark partial and stop right before this placeholder
+            if (not provided) and (field.default is None):
+                is_partial = True
+                # Keep only what we have so far and the literal up to this point
+                output_parts.append(literal_chunk)
+                break
+
+            # Serialise the projected value (use EmptyValue to allow defaults)
+            serialised_value = field(provided_value or EmptyValue(), action, validator)
+            serialised_text = serialised_value if serialised_value else ''
+
+            # Append literal + substituted value
+            output_parts.append(literal_chunk)
+            output_parts.append(str(serialised_text))
+
+            # Advance past this placeholder
+            last_idx = match.end()
+
+        # If not partial, append the remaining tail literal
+        if not is_partial:
+            output_parts.append(template_str[last_idx:])
 
-        template = Template(self.value)
-        return {'value': template.substitute(serialised), 'is_partial': is_partial}
+        return {'value': ''.join(output_parts), 'is_partial': is_partial}
 
     def deserialise_template(self, value: str | None) -> Dict[str, Any]:
         """

nuql/fields/ulid.py

@@ -1,25 +1,34 @@
 __all__ = ['Ulid']
 
-from ulid import ULID
+from typing import Any
 
+import nuql
 from nuql import resources
 
 
 class Ulid(resources.FieldBase):
     type = 'ulid'
 
-    def serialise(self, value: ULID | str | None) -> str | None:
+    def serialise(self, value: Any) -> str | None:
         """
         Serialises a ULID value.
 
         :arg value: ULID, str or None.
         :return: str or None.
         """
-        if isinstance(value, ULID):
+        try:
+            import ulid
+        except ImportError:
+            raise nuql.NuqlError(
+                code='DependencyError',
+                message='The "python-ulid" package is required to use the ULID field.'
+            ) from None
+
+        if isinstance(value, ulid.ULID):
             return str(value)
         if isinstance(value, str):
             try:
-                return str(ULID.from_str(value))
+                return str(ulid.ULID.from_str(value))
             except ValueError:
                 return None
         return None
@@ -31,9 +40,17 @@ class Ulid(resources.FieldBase):
         :arg value: str or None.
         :return: str or None.
         """
+        try:
+            import ulid
+        except ImportError:
+            raise nuql.NuqlError(
+                code='DependencyError',
+                message='The "python-ulid" package is required to use the ULID field.'
+            ) from None
+
         if isinstance(value, str):
-            # try:
-                return str(ULID.from_str(value))
-            # except ValueError:
-            #     return None
+            try:
+                return str(ulid.ULID.from_str(value))
+            except ValueError:
+                return None
         return None

nuql/fields/uuid.py

@@ -1,7 +1,6 @@
 __all__ = ['Uuid']
 
-from uuid import UUID as NATIVE_UUID
-from uuid_utils import UUID
+from uuid import UUID
 
 from nuql import resources
 
@@ -9,23 +8,17 @@ from nuql import resources
 class Uuid(resources.FieldBase):
     type = 'uuid'
 
-    def serialise(self, value: NATIVE_UUID | UUID | str | None) -> str | None:
+    def serialise(self, value: UUID | str | None) -> str | None:
         """
         Serialises a UUID value.
 
         :arg value: UUID, str or None.
         :return: str or None.
         """
-        if isinstance(value, (NATIVE_UUID, UUID)):
-            return str(value)
-
-        if isinstance(value, str):
-            try:
-                return str(UUID(value))
-            except ValueError:
-                return None
-
-        return None
+        try:
+            return str(UUID(value))
+        except (AttributeError, ValueError, TypeError):
+            return None
 
     def deserialise(self, value: str | None) -> str | None:
         """
@@ -37,6 +30,6 @@ class Uuid(resources.FieldBase):
         if isinstance(value, str):
             try:
                 return str(UUID(value))
-            except ValueError:
+            except (AttributeError, ValueError, TypeError):
                 return None
         return None

nuql/generators/ulid.py

@@ -1,10 +1,19 @@
-from ulid import ULID
+from nuql import NuqlError
 
 
 class Ulid:
     @classmethod
     def now(cls):
         """Generates current ULID"""
+        try:
+            import ulid
+        except ImportError:
+            raise NuqlError(
+                code='DependencyError',
+                message='The "python-ulid" package is required to use the ULID field.'
+            )
+
         def generator():
-            return ULID()
+            return ulid.ULID()
+
         return generator

nuql/generators/uuid.py

@@ -1,12 +1,12 @@
 __all__ = ['Uuid']
 
-from uuid_utils import uuid4, uuid7
-
 
 class Uuid:
     @classmethod
     def v4(cls):
         """Generates a random UUID v4"""
+        from uuid import uuid4
+
         def generator():
             return uuid4()
         return generator
@@ -14,6 +14,12 @@ class Uuid:
     @classmethod
     def v7(cls):
         """Generates a random UUID v7"""
+        try:
+            from uuid_utils import uuid7
+        except ImportError:
+            raise ImportError('Dependency "uuid_utils" must be installed to use UUID v7 generation.')
+
         def generator():
             return uuid7()
+
         return generator

nuql/resources/fields/field.py

@@ -96,10 +96,7 @@ class FieldBase:
             value = self.default
 
         # Serialise the value
-        if not isinstance(value, (type(None), resources.EmptyValue)):
-            value = self.serialise_internal(value, action, validator)
-        else:
-            value = None
+        value = self.serialise_internal(value, action, validator)
 
         # Validate required field
         if self.required and action == 'create' and value is None:

nuql/resources/records/serialiser.py

@@ -45,6 +45,9 @@ class Serialiser:
         projections = resources.Projections(self.parent, self)
         output = {}
 
+        if not isinstance(data, dict):
+            data = {}
+
         # Serialise provided fields
         for key, deserialised_value in data.items():
             field = self.get_field(key)
@@ -123,6 +126,9 @@ class Serialiser:
         """
         record = {}
 
+        if not isinstance(data, dict):
+            data = {}
+
         for name, field in self.parent.fields.items():
             # Special Case: string templates
             if hasattr(field, 'deserialise_template') and getattr(field, 'is_template', True):

{nuql-0.0.6.dist-info → nuql-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nuql
-Version: 0.0.6
+Version: 0.0.7
 Summary: Nuql (pronounced 'nuckle') is a lightweight DynamoDB library for implementing the single table model pattern.
 License: MIT License
         
@@ -30,5 +30,3 @@ 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.6.dist-info → nuql-0.0.7.dist-info}/RECORD

@@ -4,23 +4,23 @@ nuql/connection.py,sha256=6PusMgUwPoOT8X0CqWLKdgsdvdAEwmb_dfelz0WpJE8,1471
 nuql/exceptions.py,sha256=1dhtHoLJZyP-njCPC2hNTK48tSllbGV7amlwq3tJQps,2044
 nuql/api/__init__.py,sha256=DKxuIAjckS1vjMIPykbI3h81HszlBB9LdwQuFf53-wo,324
 nuql/api/adapter.py,sha256=VIrItHyAW87xGgjavXRiN2-99shRjDn0kik_iLHeEl0,1355
-nuql/api/batch_write.py,sha256=IZi349BdEiahmWqtQlch4lN6yXNi921czxNTBQIzbzY,2998
-nuql/api/condition_check.py,sha256=uSB01Gp3ZwSWPFLJk6pZDv8zXF_QCZFLVu9yDNq2Vcs,1588
+nuql/api/batch_write.py,sha256=QqtFtLVpZvcy8eyizW3jSjVO_B7D_ev3TJxnd8ppU-c,3233
+nuql/api/condition_check.py,sha256=-okjA4NQPNMjA2If48X_Rxe3RKFN0AWMH9L5QT9Ln1Y,1594
 nuql/api/create.py,sha256=SUfsZtRrp1WWILsdwvSGXKdSGIiiRFsKlttX8uS8AMw,793
-nuql/api/delete.py,sha256=8d7LP2SLje9YHNXrCQNbt3IS67xGMtPLY5ZOx7NtJrg,3038
+nuql/api/delete.py,sha256=YWHCwYbnx27PE1ZUjn_19w3gTHsmoZRWcDila9eux7c,3044
 nuql/api/get.py,sha256=8K29b-wRW4szYInPvdgyTe7lq3SsvQf1VaiABxsaw_0,934
-nuql/api/put_item.py,sha256=JPGJABDZSDtzWOLLB93Cf6g2l_pFTtWbwQ-2kJ6sUxI,4140
+nuql/api/put_item.py,sha256=fBW0rsQ6qIHyKUrkbc5rINtBUQtQ9x79w_DksausT_A,4158
 nuql/api/put_update.py,sha256=ZkNUjX3GkBrymVenoI4RHmjn5Xzh4u1YcRxTte9X22Q,795
-nuql/api/transaction.py,sha256=tL7S_AvKXpcH0OwYh3Fn8N_TWDsGy3mihyjyM6gT5bg,4687
+nuql/api/transaction.py,sha256=C9gF4i2HmPDoIHIBQUbVP2bfW0NaYoHTIMnc_1IAavg,4711
 nuql/api/upsert.py,sha256=X7Qwg_1x8-RUUlQZUq6qLKzlzapOLyKMlFBiDMN8QOg,1133
 nuql/api/batch_get/__init__.py,sha256=N1NQ_WFov4bANyCdS1HBPaPYnlDhZ4QEJSMiEN0sL0k,48
 nuql/api/batch_get/batch_get.py,sha256=DgGCYLQqiCUzwZdrf1XyWHEecY4nzQ-mweWhLPe68RQ,1069
 nuql/api/batch_get/queue.py,sha256=6S70p0i4xXlh8pU8X0-F8-U8P3uzoxJDzbUNaMEhrzU,4032
 nuql/api/query/__init__.py,sha256=_YhXEUvd82bBhOlkBHtPYC8a8VgCHskeg4l95X8w2O0,112
-nuql/api/query/condition.py,sha256=SNCEJZah7v2ioSfxHUmco73HzuKCKVvrzDx6kSLMBQY,5965
+nuql/api/query/condition.py,sha256=9FxV8rtAyuD_v1tPN20UZztY21PqJkgv3loJc-_6Aqc,5615
 nuql/api/query/condition_builder.py,sha256=kHlpSYcrEX-vQvkqjOG6GVC2_a63zJSjJgIs2_zhGIo,6201
-nuql/api/query/key_condition.py,sha256=TgOIOC8lBgw2LJlK0nqWh3mxXqQUhiUhoi1leyLvKM4,8046
-nuql/api/query/query.py,sha256=Wb3TPmzUdnN96KV_kyXzrVmOsqrVbxFUv3sE48AZxuk,6365
+nuql/api/query/key_condition.py,sha256=UlxYjvgH9iVors7oEToHkl4vK_IDqbnQKro1bk6LBp0,10845
+nuql/api/query/query.py,sha256=90ieaZGwWXhpamJBX67y3SDA0oRaNf5YMyxjLWhz8W4,6383
 nuql/api/update/__init__.py,sha256=15mjrAPhrOM74c3Q6NQXTGVjFFgwPCiTAlBLHIDmPQ8,85
 nuql/api/update/expression_builder.py,sha256=jFkp0EASDx7uK2b0TanRALGusXqtXwvOVy02WW2OfGM,1147
 nuql/api/update/update_item.py,sha256=KCfrAZiDPmQc0k20UAA9H3dw_8WFYJ8fDOqHb_xSYNo,5295
@@ -31,24 +31,24 @@ nuql/fields/datetime.py,sha256=4K28yydnzUc1HsMH-lgSSNOx2NbEL4qXC3kTpuRBVis,1386
 nuql/fields/datetime_timestamp.py,sha256=drJLpmGhL8ANrfGsArKeVLb4v7maiignhzC4qpQzMHY,1275
 nuql/fields/float.py,sha256=x48Spo_GNku0djO0Ogs8usZTfwOY-27Mh5OPOQBO3OY,1316
 nuql/fields/integer.py,sha256=pHs3CJM4xKN60IYg5aTe4QjSQQBR4jp08HyANtidHgs,1312
-nuql/fields/key.py,sha256=r2Q4qVlAS51dOUI7Zk_OTr08VKkMBXNyUJb3ieY-nnY,6621
+nuql/fields/key.py,sha256=vG_yj4Lkiz3bsD2f31HEVgU5lEde_gTYk4awQ78gko8,6912
 nuql/fields/list.py,sha256=m7wTIb4-VRRKO5C8XZJFeGOPHIqrvc3xNbWw-vHppQM,1508
 nuql/fields/map.py,sha256=jFbJ9YhvVMrkLlzktMEQOrZw7uqOLgdfmwxuw9Zue-Y,1169
-nuql/fields/string.py,sha256=-7yk6T3HrKn52KdAyqoXqgtPdzpZKCCcbYR-TTtTjfk,5519
-nuql/fields/ulid.py,sha256=mcwTztzIqE_3q1cRa2pf6pN8s0322NQlfQcky9xAWkI,971
-nuql/fields/uuid.py,sha256=fhwAcMUHuih2NgPh7QOs4hcCwrl8Cu2CqSpvLMBAV-c,1041
+nuql/fields/string.py,sha256=ITzRSuDGomBfRhcbHAVkfRQ7j2kDwBBFPdkzQzVNI1w,6629
+nuql/fields/ulid.py,sha256=GSaEbi31_gUnZzx-MD-pCR8H_fNCEaLwwnWLxRg4JbI,1498
+nuql/fields/uuid.py,sha256=iv-_P8W3MRBrt41R8gMsZTEoFF1eS3deoueCgmznUz4,881
 nuql/generators/__init__.py,sha256=YgTwNlvZYM4EYo2u3gSN4bIuXz7f8SQF7Y7jnpXN_Ls,67
 nuql/generators/datetime.py,sha256=eX10E9mbCaFVJb3xsVaNxTCpBpl1lsd6HTGYS6hsqNs,981
-nuql/generators/ulid.py,sha256=MuxmKQBPEBSqhlD4NPCnUrDgwgn82a0sTQISQ0iIYmM,194
-nuql/generators/uuid.py,sha256=MoEQVxgEsqGlhpf4W-OuRiLKqNwRtE2NtS3eFTOc5lo,394
+nuql/generators/ulid.py,sha256=la23skED6VbkqcrxZ16j0RPw8vgy8EM1n33jC2ztf4o,450
+nuql/generators/uuid.py,sha256=ZxATeYevYhrJu6MceEK-CtNjRj0eBzoacv95icHh-2s,581
 nuql/resources/__init__.py,sha256=8HRJ_H5yTdQtfeVZ29ikdbLQSPKiZRyNkoocQd5QtZ8,92
 nuql/resources/fields/__init__.py,sha256=bajUBAvrK8kIMyb2vD_0NCwibRHOLo4Yoq1sac0Dobc,70
-nuql/resources/fields/field.py,sha256=5AjJbKxk1GwgP7nhMuZOPKQYFhlDTA9VrHeBF4mQcAA,5589
+nuql/resources/fields/field.py,sha256=NSynnwHwrKk7SaCvzpb2Zsjeu1LFNCfk0QR6cIKVvHo,5473
 nuql/resources/fields/field_map.py,sha256=bOzoBFbB2XOyLfnqaVEL_BDwt3S9_oUGIl1N0awgZ7g,2519
 nuql/resources/fields/value.py,sha256=CG3PnGeSMHDQciIMR6jkMhogCJZhpEfipLdyk9gnjJw,59
 nuql/resources/records/__init__.py,sha256=gD8-xt4uIOpx_ZTnw1QTzOiwUpjKhR3nhkZw4AmEvaI,81
 nuql/resources/records/projections.py,sha256=PTwoc8-XXieXsYw0H-3Fv7G8SzSN__j35QsqempXBj8,1618
-nuql/resources/records/serialiser.py,sha256=yhMUZ-E0NMMxDszOSfl9ZWNdc2mSJDZfSIjUxAGKnLM,5039
+nuql/resources/records/serialiser.py,sha256=5vqLjNzY07Rrl-u_-SufImjAGCxpF8txwzlhDW0OHiE,5169
 nuql/resources/records/validator.py,sha256=d8GQN_rwnuKnV6tkEDCqswE_ARso7ZNH0vB1L2eVrj0,1558
 nuql/resources/tables/__init__.py,sha256=Bk8ewpPb_myliQPmyIarzma_Vezd4XR-Z1lABsTUMPQ,46
 nuql/resources/tables/indexes.py,sha256=5e5bQ_yRgyLmnoXuKAqEw0mJJhY_NE4Sk0vavvMG2m4,5076
@@ -60,7 +60,7 @@ nuql/types/__init__.py,sha256=Ea4KR4mUs1RNUEskKF9sXfGpoQw2V9cnIYeE20wkChs,76
 nuql/types/config.py,sha256=lFfPPe62l4DkfLXR8ecw5AiSRAFzsTYy_3a0d_1M7hY,659
 nuql/types/fields.py,sha256=LjGgXM84WO54gRDkgvnwF3pjFvFxErdGYOvs0BskF_o,883
 nuql/types/serialisation.py,sha256=XAy_gARcwYmfEuxWAJox2ClWK9ow0F5WXKVbMUVBq9w,242
-nuql-0.0.6.dist-info/METADATA,sha256=R8gSusfsK1exy_2UL6_uwhyN9g6SjfgR_J4n5WGbg8c,1735
-nuql-0.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nuql-0.0.6.dist-info/licenses/LICENSE,sha256=AS8DF6oGYsvk781m40Nec9eCkj_S_oUVAWaFakB2LMs,1097
-nuql-0.0.6.dist-info/RECORD,,
+nuql-0.0.7.dist-info/METADATA,sha256=gLqBg1Yagk-W7bcv9Ccir4ljUXLhGT7XylyA0MTkPl8,1667
+nuql-0.0.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nuql-0.0.7.dist-info/licenses/LICENSE,sha256=AS8DF6oGYsvk781m40Nec9eCkj_S_oUVAWaFakB2LMs,1097
+nuql-0.0.7.dist-info/RECORD,,