def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: # type: ignore[override] """Loads a LabeledPolyline2D from a dict containing the information of the label. Arguments: contents: A dict containing the information of the 2D polyline label. Returns: The loaded :class:`LabeledPolyline2D` object. Examples: >>> contents = { ... "polyline2d": [{'x': 1, 'y': 2}, {'x': 2, 'y': 4}, {'x': 2, 'y': 1}], ... "category": "example", ... "attributes": {"key": "value"}, ... "instance": "12345", ... "beizer_point_types": "LLL", ... } >>> LabeledPolyline2D.loads(contents) LabeledPolyline2D [ Vector2D(1, 2), Vector2D(2, 4), Vector2D(2, 1) ]( (beizer_point_types): 'LLL', (category): 'example', (attributes): {...}, (instance): '12345' ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Mapping[str, float]) -> _T: """Loads CameraMatrix from a dict containing the information of the camera matrix. Arguments: contents: A dict containing the information of the camera matrix. Returns: A :class:`CameraMatrix` instance contains the information from the contents dict. Examples: >>> contents = { ... "fx": 2, ... "fy": 6, ... "cx": 4, ... "cy": 7, ... "skew": 3 ... } >>> camera_matrix = CameraMatrix.loads(contents) >>> camera_matrix CameraMatrix( (fx): 2, (fy): 6, (cx): 4, (cy): 7, (skew): 3 ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a LabeledBox3D from a dict containing the information of the label. Arguments: contents: A dict containing the information of the 3D bounding box label. Returns: The loaded :class:`LabeledBox3D` object. Examples: >>> contents = { ... "box3d": { ... "size": {"x": 1, "y": 2, "z": 3}, ... "translation": {"x": 1, "y": 2, "z": 3}, ... "rotation": {"w": 1, "x": 0, "y": 0, "z": 0}, ... }, ... "category": "test", ... "attributes": {"key": "value"}, ... "instance": "12345", ... } >>> LabeledBox3D.loads(contents) LabeledBox3D( (size): Vector3D(1, 2, 3), (translation): Vector3D(1, 2, 3), (rotation): quaternion(1, 0, 0, 0), (category): 'test', (attributes): {...}, (instance): '12345' ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: # type: ignore[override] """Loads a LabeledMultiPolyline2D from a dict containing the information of the label. Arguments: contents: A dict containing the information of the 2D polyline label. Returns: The loaded :class:`LabeledMultiPolyline2D` object. Examples: >>> contents = { ... "multiPolyline2d": [[{'x': 1, 'y': 1}, {'x': 1, 'y': 2}, {'x': 2, 'y': 2}], [{'x': 2, 'y': 3}, {'x': 3, 'y': 5}]], ... "category": "example", ... "attributes": {"key": "value"}, ... "instance": "12345", ... } >>> LabeledMultiPolyline2D.loads(contents) LabeledMultiPolyline2D [ Polyline2D [...] Polyline2D [...] ]( (category): 'example', (attributes): {...}, (instance): '12345' ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Mapping[str, float]) -> _T: """Loads DistortionCoefficients from a dict containing the information. Arguments: contents: A dict containig distortion coefficients of a camera. Returns: A :class:`DistortionCoefficients` instance containing information from the contents dict. Examples: >>> contents = { ... "p1": 1, ... "p2": 2, ... "k1": 3, ... "k2": 4 ... } >>> distortion_coefficients = DistortionCoefficients.loads(contents) >>> distortion_coefficients DistortionCoefficients( (p1): 1, (p2): 2, (k1): 3, (k2): 4 ) """ return common_loads(cls, contents)
def loads(contents: Dict[str, Any]) -> "_Type": """Loads a Sensor from a dict containing the sensor information. Arguments: contents: A dict containing name, description and sensor extrinsics. Returns: A :class:`Sensor` instance containing the information from the contents dict. Examples: >>> contents = { ... "name": "Lidar1", ... "type": "LIDAR", ... "extrinsics": { ... "translation": {"x": 1.1, "y": 2.2, "z": 3.3}, ... "rotation": {"w": 1.1, "x": 2.2, "y": 3.3, "z": 4.4}, ... }, ... } >>> sensor = Sensor.loads(contents) >>> sensor Lidar("Lidar1")( (extrinsics): Transform3D( (translation): Vector3D(1.1, 2.2, 3.3), (rotation): quaternion(1.1, 2.2, 3.3, 4.4) ) ) """ sensor: "Sensor._Type" = common_loads(SensorType(contents["type"]).type, contents) return sensor
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a LabeledBox2D from a dict containing the information of the label. Arguments: contents: A dict containing the information of the 2D bounding box label. Returns: The loaded :class:`LabeledBox2D` object. Examples: >>> contents = { ... "box2d": {"xmin": 1, "ymin": 2, "xmax": 5, "ymax": 8}, ... "category": "example", ... "attributes": {"key": "value"}, ... "instance": "12345", ... } >>> LabeledBox2D.loads(contents) LabeledBox2D(1, 2, 5, 8)( (category): 'example', (attributes): {...}, (instance): '12345' ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Load an Items from a dict containing the items information. Arguments: contents: A dict containing the information of the items. Returns: The loaded :class:`Items` object. Examples: >>> contents = { ... "type": "array", ... "enum": [1, 2, 3, 4, 5], ... "minimum": 1, ... "maximum": 5, ... "items": { ... "enum": [None], ... "type": "null", ... }, ... } >>> Items.loads(contents) Items( (type): 'array', (enum): [...], (minimum): 1, (maximum): 5, (items): Items(...) ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Load an AttributeInfo from a dict containing the attribute information. Arguments: contents: A dict containing the information of the attribute. Returns: The loaded :class:`AttributeInfo` object. Examples: >>> contents = { ... "name": "example", ... "type": "array", ... "items": {"type": "boolean"}, ... "description": "This is an example", ... "parentCategories": ["parent_category_of_example"], ... } >>> AttributeInfo.loads(contents) AttributeInfo("example")( (type): 'array', (items): Items( (type): 'boolean', ), (parent_categories): [ 'parent_category_of_example' ] ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: # type: ignore[override] """Loads a LabeledMultiPolygon from a list of dict containing the information of the label. Arguments: contents: A dict containing the information of the multipolygon label. Returns: The loaded :class:`LabeledMultiPolygon` object. Examples: >>> contents = { ... "multiPolygon": [ ... [ ... {"x": 1.0, "y": 2.0}, ... {"x": 2.0, "y": 3.0}, ... {"x": 1.0, "y": 3.0}, ... ], ... [{"x": 1.0, "y": 4.0}, {"x": 2.0, "y": 3.0}, {"x": 1.0, "y": 8.0}], ... ], ... "category": "example", ... "attributes": {"key": "value"}, ... "instance": "12345", ... } >>> LabeledMultiPolygon.loads(contents) LabeledMultiPolygon [ Polygon [...], Polygon [...] ]( (category): 'example', (attributes): {...}, (instance): '12345' ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: # type: ignore[override] """Loads a LabeledRLE from a dict containing the information of the label. Arguments: contents: A dict containing the information of the rle label. Returns: The loaded :class:`LabeledRLE` object. Examples: >>> contents = { ... "rle": [272, 2, 4, 4, 2, 9], ... "category": "example", ... "attributes": {"key": "value"}, ... "instance": "12345", ... } >>> LabeledRLE.loads(contents) LabeledRLE [ 272, 2, ... ]( (category): 'example', (attributes): {...}, (instance): '12345' ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: # type: ignore[override] """Loads a LabeledPolygon from a dict containing the information of the label. Arguments: contents: A dict containing the information of the polygon label. Returns: The loaded :class:`LabeledPolygon` object. Examples: >>> contents = { ... "polygon": [ ... {"x": 1, "y": 2}, ... {"x": 2, "y": 3}, ... {"x": 1, "y": 3}, ... ], ... "category": "example", ... "attributes": {"key": "value"}, ... "instance": "12345", ... } >>> LabeledPolygon.loads(contents) LabeledPolygon [ Vector2D(1, 2), Vector2D(2, 3), Vector2D(1, 3) ]( (category): 'example', (attributes): {...}, (instance): '12345' ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a KeypointsInfo from a dict containing the information of the keypoints. Arguments: contents: A dict containing all the information of the set of keypoints. Returns: The loaded :class:`KeypointsInfo` object. Examples: >>> contents = { ... "number": 2, ... "names": ["L", "R"], ... "skeleton": [(0,1)], ... "visible": "TERNARY", ... "parentCategories": ["example"], ... "description": "example", ... } >>> KeypointsInfo.loads(contents) KeypointsInfo( (number): 2, (names): [...], (skeleton): [...], (visible): 'TERNARY', (parent_categories): [...] ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a :class:`Draft` instance from the given contents. Arguments: contents: A dict containing all the information of the draft:: { "number": <int> "title": <str> "branchName": <str> "status": "OPEN", "CLOSED" or "COMMITTED" "parentCommitId": <str> "author": { "name": <str> "date": <int> } "updatedAt": <int> "description": <str> } Returns: A :class:`Draft` instance containing all the information in the given contents. """ return common_loads(cls, contents)
def loads(cls: Type[_B3], contents: Mapping[str, Mapping[str, float]]) -> _B3: """Load a :class:`Box3D` from a dict containing the coordinates of the 3D box. Arguments: contents: A dict containing the coordinates of a 3D box. Returns: The loaded :class:`Box3D` object. Examples: >>> contents = { ... "size": {"x": 1.0, "y": 2.0, "z": 3.0}, ... "translation": {"x": 1.0, "y": 2.0, "z": 3.0}, ... "rotation": {"w": 0.0, "x": 1.0, "y": 0.0, "z": 0.0}, ... } >>> Box3D.loads(contents) Box3D( (size): Vector3D(1.0, 2.0, 3.0) (translation): Vector3D(1.0, 2.0, 3.0), (rotation): quaternion(0, 1, 0, 0), ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads data from a dict containing the labels information. Arguments: contents: A dict containing the labels information. Returns: A :class:`Label` instance containing labels information from the given dict. Examples: >>> contents = { ... "CLASSIFICATION": { ... "category": "example_category", ... "attributes": {"example_attribute1": "a"} ... } ... } >>> Label.loads(contents) Label( (classification): Classification( (category): 'example_category', (attributes): {...} ) ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a subcatalog from a dict containing the information of the subcatalog. Arguments: contents: A dict containing the information of the subcatalog. Returns: The loaded :class:`SubcatalogBase` object. """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: List[Dict[str, Any]]) -> _T: """Loads a :class:`Sensors` instance from the given contents. Arguments: contents: A list of dict containing the sensors information in a fusion segment, whose format should be like:: [ { "name": <str> "type": <str> "extrinsics": { "translation": { "x": <float> "y": <float> "z": <float> }, "rotation": { "w": <float> "x": <float> "y": <float> "z": <float> }, }, "intrinsics": { --- only for cameras "cameraMatrix": { "fx": <float> "fy": <float> "cx": <float> "cy": <float> "skew": <float> } "distortionCoefficients": { "k1": <float> "k2": <float> "p1": <float> "p2": <float> ... } }, "desctiption": <str> }, ... ] Returns: The loaded :class:`Sensors` instance. """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a :class:`DiffBase` instance from the given contents. Arguments: contents: A dict containing all the information of the diff:: { "action": <str> } Returns: A :class:`DiffBase` instance containing all the information in the given contents. """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, str]) -> _T: """Loads a CategoryInfo from a dict containing the category. Arguments: contents: A dict containing the information of the category. Returns: The loaded :class:`CategoryInfo` object. Examples: >>> contents = {"name": "example", "description": "This is an exmaple"} >>> CategoryInfo.loads(contents) CategoryInfo("example") """ return common_loads(cls, contents)
def loads(cls: Type[_B2], contents: Mapping[str, float]) -> _B2: """Load a :class:`Box2D` from a dict containing coordinates of the 2D box. Arguments: contents: A dict containing coordinates of a 2D box. Returns: The loaded :class:`Box2D` object. Examples: >>> contents = {"xmin": 1.0, "ymin": 2.0, "xmax": 3.0, "ymax": 4.0} >>> Box2D.loads(contents) Box2D(1.0, 2.0, 3.0, 4.0) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a :class:`User` instance from the given contents. Arguments: contents: A dict containing all the information of the commit:: { "name": <str> "date": <int> } Returns: A :class:`User` instance containing all the information in the given contents. """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a Camera from a dict containing the camera information. Arguments: contents: A dict containing name, description, extrinsics and intrinsics. Returns: A :class:`Camera` instance containing information from contents dict. Examples: >>> contents = { ... "name": "Camera1", ... "type": "CAMERA", ... "extrinsics": { ... "translation": {"x": 1, "y": 2, "z": 3}, ... "rotation": {"w": 1.0, "x": 2.0, "y": 3.0, "z": 4.0}, ... }, ... "intrinsics": { ... "cameraMatrix": {"fx": 1, "fy": 1, "cx": 1, "cy": 1, "skew": 0}, ... "distortionCoefficients": {"p1": 1, "p2": 1, "k1": 1, "k2": 1}, ... }, ... } >>> Camera.loads(contents) Camera("Camera1")( (extrinsics): Transform3D( (translation): Vector3D(1, 2, 3), (rotation): quaternion(1, 2, 3, 4) ), (intrinsics): CameraIntrinsics( (camera_matrix): CameraMatrix( (fx): 1, (fy): 1, (cx): 1, (cy): 1, (skew): 0 ), (distortion_coefficients): DistortionCoefficients( (p1): 1, (p2): 1, (k1): 1, (k2): 1 ) ) ) """ return common_loads(cls, contents)
def loads(cls: Type[_P], contents: Sequence[Mapping[str, float]]) -> _P: """Load a :class:`Polyline2D` from a list of dict. Arguments: contents: A list of dict containing the coordinates of the vertexes of the polyline. Returns: The loaded :class:`Polyline2D` object. Examples: >>> polyline = Polyline2D([[1, 1], [1, 2], [2, 2]]) >>> polyline.dumps() [{'x': 1, 'y': 1}, {'x': 1, 'y': 2}, {'x': 2, 'y': 2}] """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a LabeledSentence from a dict containing the information of the label. Arguments: contents: A dict containing the information of the sentence label. Returns: The loaded :class:`LabeledSentence` object. Examples: >>> contents = { ... "sentence": [{"text": "qi1shi2", "begin": 1, "end": 2}], ... "spell": [{"text": "qi1", "begin": 1, "end": 2}], ... "phone": [{"text": "q", "begin": 1, "end": 2}], ... "attributes": {"key": "value"}, ... } >>> LabeledSentence.loads(contents) LabeledSentence( (sentence): [ Word( (text): 'qi1shi2', (begin): 1, (end): 2 ) ], (spell): [ Word( (text): 'qi1', (begin): 1, (end): 2 ) ], (phone): [ Word( (text): 'q', (begin): 1, (end): 2 ) ], (attributes): { 'key': 'value' } ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Mapping[str, Mapping[str, float]]) -> _T: """Loads CameraIntrinsics from a dict containing the information. Arguments: contents: A dict containig camera matrix and distortion coefficients. Returns: A :class:`CameraIntrinsics` instance containing information from the contents dict. Examples: >>> contents = { ... "cameraMatrix": { ... "fx": 1, ... "fy": 2, ... "cx": 3, ... "cy": 4, ... }, ... "distortionCoefficients": { ... "p1": 1, ... "p2": 2, ... "k1": 3, ... "k2": 4 ... }, ... } >>> camera_intrinsics = CameraIntrinsics.loads(contents) >>> camera_intrinsics CameraIntrinsics( (camera_matrix): CameraMatrix( (fx): 1, (fy): 2, (cx): 3, (cy): 4, (skew): 0 ), (distortion_coefficients): DistortionCoefficients( (p1): 1, (p2): 2, (k1): 3, (k2): 4 ) ) """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a :class:`StorageConfig` instance from the given contents. Arguments: contents: The given dict containing the storage config:: { "name": <str>, "filePath": <str>, "type": <str>, "isGravitiStorage": <boolean> } Returns: The loaded :class:`StorageConfig` instance. """ return common_loads(cls, contents)
def loads(cls: Type[_P], contents: List[Dict[str, float]]) -> _P: """Load a :class:`Keypoints2D` from a list of dict. Arguments: contents: A list of dictionaries containing 2D keypoint. Returns: The loaded :class:`Keypoints2D` object. Examples: >>> contents = [{"x": 1.0, "y": 1.0, "v": 1}, {"x": 2.0, "y": 2.0, "v": 2}] >>> Keypoints2D.loads(contents) Keypoints2D [ Keypoint2D(1.0, 1.0, 1), Keypoint2D(2.0, 2.0, 2) ] """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a :class:`Notes` instance from the given contents. Arguments: contents: The given dict containing the dataset notes:: { "isContinuous": <boolean> "binPointCloudFields": [ <array> or null <field_name>, <str> ... ] } Returns: The loaded :class:`Notes` instance. """ return common_loads(cls, contents)
def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T: """Loads a Classification label from a dict containing the label information. Arguments: contents: A dict containing the information of the classification label. Returns: The loaded :class:`Classification` object. Examples: >>> contents = {"category": "example", "attributes": {"key": "value"}} >>> Classification.loads(contents) Classification( (category): 'example', (attributes): {...} ) """ return common_loads(cls, contents)