Skip to content

ForeignKey class

edgy.fields.ForeignKey

Bases: ForeignKeyFieldFactory

methods_overwritable_by_factory class-attribute instance-attribute 

methods_overwritable_by_factory = frozenset(default_methods_overwritable_by_factory)

field_bases class-attribute instance-attribute 

field_bases = (BaseForeignKeyField,)

build_field classmethod 

build_field(**kwargs)
Source code in edgy/core/db/fields/factories.py 
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
@classmethod
def build_field(cls, **kwargs: Any) -> BaseFieldType:
    column_type = cls.get_column_type(kwargs)
    pydantic_type = cls.get_pydantic_type(kwargs)
    constraints = cls.get_constraints(kwargs)

    new_field = cls._get_field_cls(cls)

    new_field_obj: BaseFieldType = new_field(  # type: ignore
        field_type=pydantic_type,
        annotation=pydantic_type,
        column_type=column_type,
        constraints=constraints,
        factory=cls,
        **kwargs,
    )
    cls.overwrite_methods(new_field_obj)
    return new_field_obj

overwrite_methods classmethod 

overwrite_methods(field_obj)

Called in metaclasses

Source code in edgy/core/db/fields/factories.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
@classmethod
def overwrite_methods(cls, field_obj: BaseFieldType) -> None:
    """Called in metaclasses"""
    for key in dir(cls):
        if key in cls.methods_overwritable_by_factory and hasattr(cls, key):
            fn = getattr(cls, key)
            original_fn = getattr(field_obj, key, None)
            # use original func, not the wrapper
            if hasattr(fn, "__func__"):
                fn = fn.__func__

            # fix classmethod, prevent injection of self or class
            setattr(
                field_obj,
                key,
                # .__func__ is a workaround for python < 3.10, python >=3.10 works without
                staticmethod(partial(fn, cls, field_obj, original_fn=original_fn)).__func__,
            )

repack classmethod 

repack(field_obj)
Source code in edgy/core/db/fields/factories.py 
109
110
111
112
113
114
115
116
117
118
119
120
121
122
@classmethod
def repack(cls, field_obj: BaseFieldType) -> None:
    for key in dir(cls):
        if key in cls.methods_overwritable_by_factory and hasattr(cls, key):
            packed_fn = getattr(field_obj, key, None)
            if packed_fn is not None and hasattr(packed_fn, "func"):
                setattr(
                    field_obj,
                    key,
                    # .__func__ is a workaround for python < 3.10, python >=3.10 works without
                    staticmethod(
                        partial(packed_fn.func, cls, field_obj, **packed_fn.keywords)
                    ).__func__,
                )

get_constraints classmethod 

get_constraints(kwargs)

Return the constraints for a column.

It is passed down as field argument/attribute: constraints.

Source code in edgy/core/db/fields/factories.py 
132
133
134
135
136
137
138
139
@classmethod
def get_constraints(cls, kwargs: dict[str, Any]) -> Sequence[Any]:
    """
    Return the constraints for a column.

    It is passed down as field argument/attribute: `constraints`.
    """
    return []

get_column_type classmethod 

get_column_type(kwargs)

Returns column type for the field, None for Metafields..

It is passed down as field argument/attribute: constraints.

Source code in edgy/core/db/fields/factories.py 
141
142
143
144
145
146
147
148
@classmethod
def get_column_type(cls, kwargs: dict[str, Any]) -> Any:
    """
    Returns column type for the field, None for Metafields..

    It is passed down as field argument/attribute: `constraints`.
    """
    return None

get_pydantic_type classmethod 

get_pydantic_type(kwargs)

Returns the type for pydantic

Source code in edgy/core/db/fields/factories.py 
150
151
152
153
@classmethod
def get_pydantic_type(cls, kwargs: dict[str, Any]) -> Any:
    """Returns the type for pydantic"""
    return cls.field_type

_get_field_cls cached staticmethod 

_get_field_cls()
Source code in edgy/core/db/fields/factories.py 
155
156
157
158
@staticmethod
@lru_cache(None)
def _get_field_cls(cls: "FieldFactory") -> BaseFieldType:
    return cast(BaseFieldType, type(cls.__name__, cast(Any, cls.field_bases), {}))

__new__ 

__new__(to, **kwargs)
Source code in edgy/core/db/fields/foreign_keys.py 
369
370
371
372
373
374
def __new__(  # type: ignore
    cls,
    to: Union[type["BaseModelType"], str],
    **kwargs: Any,
) -> BaseFieldType:
    return super().__new__(cls, to=to, **kwargs)

validate classmethod 

validate(kwargs)
Source code in edgy/core/db/fields/foreign_keys.py 
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
@classmethod
def validate(cls, kwargs: dict[str, Any]) -> None:
    super().validate(kwargs)
    if kwargs.get("auto_compute_server_default"):
        raise FieldDefinitionError(
            '"auto_compute_server_default" is not supported for ForeignKey.'
        ) from None
    kwargs["auto_compute_server_default"] = False
    if kwargs.get("server_default"):
        raise FieldDefinitionError(
            '"server_default" is not supported for ForeignKey.'
        ) from None
    if kwargs.get("server_onupdate"):
        raise FieldDefinitionError(
            '"server_onupdate" is not supported for ForeignKey.'
        ) from None
    embed_parent = kwargs.get("embed_parent")
    if embed_parent and "__" in embed_parent[1]:
        raise FieldDefinitionError(
            '"embed_parent" second argument (for embedding parent) cannot contain "__".'
        )