Add MISSING sentinel to exclude keys from DictFactory

This adds a MISSING sentinel value that can be used with DictFactory
to exclude specific keys from the generated dictionary.

Example usage:
    class MyFactory(factory.DictFactory):
        name = factory.Faker('name')
        email = factory.MISSING  # This key will be excluded

The MISSING sentinel:
- Is a singleton with a falsy boolean value
- Can be used with Transformer declarations
- Can be conditionally returned from LazyFunction
- Can be overridden at call time to include the key

Author: rodrigo.nogueira

factory/__init__.py

@@ -33,6 +33,7 @@
 from .enums import BUILD_STRATEGY, CREATE_STRATEGY, STUB_STRATEGY
 from .errors import FactoryError
 from .faker import Faker
+from .utils import MISSING
 from .helpers import (
     build,
     build_batch,

factory/base.py

@@ -697,6 +697,12 @@ def _build(cls, model_class, *args, **kwargs):
     def _create(cls, model_class, *args, **kwargs):
         return cls._build(model_class, *args, **kwargs)
 
+    @classmethod
+    def _adjust_kwargs(cls, **kwargs):
+        from .utils import MISSING
+        return {k: v for k, v in kwargs.items() if v is not MISSING}
+
+
 
 class DictFactory(BaseDictFactory):
     class Meta:

factory/declarations.py

@@ -157,11 +157,14 @@ def evaluate_pre(self, instance, step, overrides):
             step=step,
             overrides=overrides,
         )
-        if bypass_transform:
+
+        from .utils import MISSING
+        if bypass_transform or value is MISSING:
             return value
         return self.transform(value)
 
 
+
 class _UNSPECIFIED:
     pass
 

factory/utils.py

@@ -5,6 +5,30 @@
 import importlib
 
 
+class _MissingSentinel:
+    """Sentinel value to mark dictionary items that should be excluded.
+
+    When used as a value in DictFactory, the corresponding key will be
+    completely omitted from the generated dictionary.
+    """
+
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __repr__(self) -> str:
+        return "<MISSING>"
+
+    def __bool__(self) -> bool:
+        return False
+
+
+MISSING = _MissingSentinel()
+
+
 def import_object(module_name, attribute_name):
     """Import an object from its absolute path.
 

tests/test_missing.py

@@ -0,0 +1,93 @@
+# Copyright: See the LICENSE file.
+
+import unittest
+
+import factory
+from factory import MISSING
+
+
+class MissingSentinelTestCase(unittest.TestCase):
+    """Tests for the MISSING sentinel object."""
+
+    def test_missing_basic(self):
+        """Test basic MISSING exclusion from DictFactory."""
+
+        class MyDictFactory(factory.DictFactory):
+            name = "John"
+            email = MISSING
+            phone = "123-456"
+
+        result = MyDictFactory()
+        self.assertEqual(result, {"name": "John", "phone": "123-456"})
+        self.assertNotIn("email", result)
+
+    def test_missing_override(self):
+        """Test MISSING can be overridden per-instance."""
+
+        class MyDictFactory(factory.DictFactory):
+            name = "John"
+            email = "default@example.com"
+
+        result = MyDictFactory(email=MISSING)
+        self.assertEqual(result, {"name": "John"})
+        self.assertNotIn("email", result)
+
+    def test_missing_all(self):
+        """Test all fields can be MISSING."""
+
+        class MyDictFactory(factory.DictFactory):
+            field1 = MISSING
+            field2 = MISSING
+
+        result = MyDictFactory()
+        self.assertEqual(result, {})
+
+    def test_missing_with_lazy_function(self):
+        """Test MISSING works with declarations."""
+
+        class MyDictFactory(factory.DictFactory):
+            name = factory.LazyFunction(lambda: "Generated")
+            skipped = MISSING
+            value = 42
+
+        result = MyDictFactory()
+        self.assertEqual(result["name"], "Generated")
+        self.assertEqual(result["value"], 42)
+        self.assertNotIn("skipped", result)
+
+    def test_missing_singleton(self):
+        """Test MISSING is a singleton."""
+        another_missing = factory.MISSING
+        self.assertIs(MISSING, another_missing)
+
+    def test_missing_bool(self):
+        """Test MISSING is falsy."""
+        self.assertFalse(MISSING)
+        self.assertFalse(bool(MISSING))
+
+    def test_missing_repr(self):
+        """Test MISSING has readable repr."""
+        self.assertEqual(repr(MISSING), "<MISSING>")
+
+    def test_missing_with_transformer(self):
+        """Test MISSING works with Transformer declarations."""
+
+        class MyDictFactory(factory.DictFactory):
+            timeout = factory.Transformer(30.0, transform=int)
+
+        result = MyDictFactory()
+        self.assertEqual(result, {"timeout": 30})
+
+        result = MyDictFactory(timeout=MISSING)
+        self.assertEqual(result, {})
+        self.assertNotIn("timeout", result)
+
+    def test_missing_transformer_default(self):
+        """Test MISSING as Transformer default excludes without error."""
+
+        class MyDictFactory(factory.DictFactory):
+            timeout = factory.Transformer(MISSING, transform=int)
+
+        result = MyDictFactory()
+        self.assertEqual(result, {})
+        self.assertNotIn("timeout", result)