Skip to content

pixano.features.utils.creators

create_instance_of_pixano_type(pix_type, **data)

Create a pixano object.

Source code in pixano/features/utils/creators.py 
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
def create_instance_of_pixano_type(pix_type: type["BaseType"], **data) -> "BaseType":
    """Create a pixano object."""
    # Import here to avoid circular imports
    from pixano.features.types import (
        create_annotation_ref,
        create_embedding_ref,
        create_entity_ref,
        create_item_ref,
        create_ndarray_float,
        create_schema_ref,
        create_source_ref,
        create_view_ref,
        is_annotation_ref,
        is_base_type,
        is_embedding_ref,
        is_entity_ref,
        is_item_ref,
        is_ndarray_float,
        is_schema_ref,
        is_source_ref,
        is_view_ref,
    )

    if is_ndarray_float(pix_type, True):
        return create_ndarray_float(**data)

    elif is_schema_ref(pix_type, True):
        return create_schema_ref(**data)

    elif is_item_ref(pix_type, True):
        return create_item_ref(**data)

    elif is_view_ref(pix_type, True):
        return create_view_ref(**data)

    elif is_entity_ref(pix_type, True):
        return create_entity_ref(**data)

    elif is_annotation_ref(pix_type, True):
        return create_annotation_ref(**data)

    elif is_embedding_ref(pix_type, True):
        return create_embedding_ref(**data)

    elif is_source_ref(pix_type, True):
        return create_source_ref(**data)

    elif is_base_type(pix_type, False):
        return pix_type(**data)

    raise ValueError(f"Type {pix_type} not supported.")

create_instance_of_schema(schema, **data)

Create a row in a Schema.

Source code in pixano/features/utils/creators.py 
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
80
def create_instance_of_schema(schema: type["BaseSchema"], **data) -> "BaseSchema":
    """Create a row in a Schema."""
    # Import here to avoid circular imports
    from pixano.features.schemas import (
        create_bbox,
        create_bbox3d,
        create_cam_calibration,
        create_compressed_rle,
        create_image,
        create_keypoints,
        create_keypoints3d,
        create_sequence_frame,
        create_track,
        create_tracklet,
        create_video,
        is_base_schema,
        is_bbox,
        is_bbox3d,
        is_cam_calibration,
        is_compressed_rle,
        is_image,
        is_keypoints,
        is_keypoints3d,
        is_sequence_frame,
        is_track,
        is_tracklet,
        is_video,
    )

    if is_image(schema, strict=True):
        return create_image(**data)

    elif is_video(schema, strict=True):
        return create_video(**data)

    elif is_sequence_frame(schema, strict=True):
        return create_sequence_frame(**data)

    elif is_tracklet(schema, strict=True):
        return create_tracklet(**data)

    elif is_track(schema, True):
        return create_track(**data)

    elif is_bbox(schema, True):
        return create_bbox(**data)

    elif is_bbox3d(schema, True):
        return create_bbox3d(**data)

    elif is_cam_calibration(schema, True):
        return create_cam_calibration(**data)

    elif is_compressed_rle(schema, True):
        return create_compressed_rle(**data)

    elif is_keypoints(schema, True):
        return create_keypoints(**data)

    elif is_keypoints3d(schema, True):
        return create_keypoints3d(**data)

    elif is_base_schema(schema, False):
        return schema(**data)

    raise ValueError(f"Schema {schema} is not a base schema.")