Skip to content

Filtering

cognite.pygen.config.Filtering dataclass

The type of filters to use for each property type.

When pygen generates, for example, a list or timeseries method, it uses the type of the property to determine which filters to implement. For example, if you have two properties, year of type Int32 and name of type Text, and you generate a list method with the default options, you will get the following filters:

class MyAPIClass:
    ...
    def list(self,
        min_year: int | None = None,
        max_year: int | None = None,
        name: str | list[str] | None = None,
        name_prefix: str | None = None,
        external_id_prefix: str | None = None,
    ):
        ...

Not supported properties

Currently primitive type properties and one-to-one edges are supported. If you have a list of primitive types, e.g., list of strings, it will not be used to generate filters. One-to-many edges will also not be used to create filters.

Parameters:

Name Type Description Default
integer tuple[type[Filter], ...]

Filters to use for integer properties.

 (Range)
boolean tuple[type[Filter], ...]

Filters to use for boolean properties.

 (Equals)
float tuple[type[Filter], ...]

Filters to use for float properties.

 (Range)
date tuple[type[Filter], ...]

Filters to use for date properties.

 (Range)
datetime tuple[type[Filter], ...]

Filters to use for datetime properties.

 (Range)
string tuple[type[Filter], ...]

Filters to use for string properties.

 (Equals, In, Prefix)
edge_one_to_one tuple[type[Filter], ...]

Filters to use for one-to-one edges, i.e., direct references to other resources.

 (Equals, In)
by_name dict[str, tuple[type[Filter], ...]]

Filters to use for properties with a specific name. This overwrites the default filters for the property with the given name.

 lambda: {'externalId': (Prefix), 'space': (Equals, In)}()
Source code in cognite/pygen/config/filtering_methods.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
@dataclass
class Filtering:
    """The type of filters to use for each property type.

    When pygen generates, for example, a list or timeseries method, it uses the type of the property to determine which
    filters to implement. For example, if you have two properties, `year` of type Int32 and `name` of type Text,
    and you generate a list method with the default options, you will get the following filters:

    ```python
    class MyAPIClass:
        ...
        def list(self,
            min_year: int | None = None,
            max_year: int | None = None,
            name: str | list[str] | None = None,
            name_prefix: str | None = None,
            external_id_prefix: str | None = None,
        ):
            ...

    ```

    !!! warning "Not supported properties"
        Currently primitive type properties and one-to-one edges are supported. If you have a list of
        primitive types, e.g., list of strings, it will not be used to generate filters. One-to-many edges will also
        not be used to create filters.

    Args:
        integer: Filters to use for integer properties.
        boolean: Filters to use for boolean properties.
        float: Filters to use for float properties.
        date: Filters to use for date properties.
        datetime: Filters to use for datetime properties.
        string: Filters to use for string properties.
        edge_one_to_one: Filters to use for one-to-one edges, i.e., direct references to other resources.
        by_name: Filters to use for properties with a specific name. This
            overwrites the default filters for the property with the given name.
    """

    integer: tuple[type[dm.Filter], ...] = (dm.filters.Range,)
    boolean: tuple[type[dm.Filter], ...] = (dm.filters.Equals,)
    float: tuple[type[dm.Filter], ...] = (dm.filters.Range,)
    date: tuple[type[dm.Filter], ...] = (dm.filters.Range,)
    datetime: tuple[type[dm.Filter], ...] = (dm.filters.Range,)
    string: tuple[type[dm.Filter], ...] = (dm.filters.Equals, dm.filters.In, dm.filters.Prefix)
    edge_one_to_one: tuple[type[dm.Filter], ...] = (dm.filters.Equals, dm.filters.In)
    by_name: dict[str, tuple[type[dm.Filter], ...]] = dataclass_field(
        default_factory=lambda: {"externalId": (dm.filters.Prefix,), "space": (dm.filters.Equals, dm.filters.In)}
    )

    def get(self, type_: dm.PropertyType, prop_name: str | None = None) -> tuple[type[dm.Filter], ...]:
        if prop_name is not None and prop_name in self.by_name:
            return self.by_name[prop_name]

        if isinstance(type_, (dm.Int32, dm.Int64)):
            return self.integer
        elif isinstance(type_, dm.Boolean):
            return self.boolean
        elif isinstance(type_, (dm.Float32, dm.Float64)):
            return self.float
        elif isinstance(type_, dm.Date):
            return self.date
        elif isinstance(type_, dm.Timestamp):
            return self.datetime
        elif isinstance(type_, dm.Text):
            return self.string
        elif isinstance(type_, dm.DirectRelation):
            return self.edge_one_to_one
        else:
            # Skip unsupported types
            return tuple([])