def test_label_entity_serialization(self): """ This test serializes LabelEntity and checks serialized representation. Then it compares deserialized LabelEntity with original one. """ cur_date = now() red = randint(0, 255) # nosec green = randint(0, 255) # nosec blue = randint(0, 255) # nosec alpha = randint(0, 255) # nosec label = LabelEntity( name="my_label", domain=Domain.DETECTION, color=Color(red, green, blue, alpha), hotkey="ctrl+1", creation_date=cur_date, is_empty=False, id=ID("0000213"), ) serialized = LabelMapper.forward(label) assert serialized == { "_id": "0000213", "name": "my_label", "color": {"red": red, "green": green, "blue": blue, "alpha": alpha}, "hotkey": "ctrl+1", "domain": "DETECTION", "creation_date": DatetimeMapper.forward(cur_date), "is_empty": False, } deserialized = LabelMapper.backward(serialized) assert label == deserialized
def convert_to_annotation( self, predictions: np.ndarray, metadata: Optional[Dict] = None) -> AnnotationSceneEntity: """ Converts a set of predictions into an AnnotationScene object :param predictions: Prediction with shape [num_predictions, 6] or [num_predictions, 7] Supported detection formats are * [label, confidence, x1, y1, x2, y2] * [_, label, confidence, x1, y1, x2, y2] .. note:: `label` can be any integer that can be mapped to `self.labels` `confidence` should be a value between 0 and 1 `x1`, `x2`, `y1` and `y2` are expected to be normalized. :returns AnnotationScene: AnnotationScene Object containing the boxes obtained from the prediction """ annotations = self.__convert_to_annotations(predictions) # media_identifier = ImageIdentifier(image_id=ID()) annotation_scene = AnnotationSceneEntity( id=ID(), kind=AnnotationSceneKind.PREDICTION, editor="ote", creation_date=now(), annotations=annotations, ) return annotation_scene
def __init__( self, points: List[Point], labels: Optional[List[ScoredLabel]] = None, modification_date: Optional[datetime.datetime] = None, ): labels = [] if labels is None else labels modification_date = now( ) if modification_date is None else modification_date super().__init__( type=ShapeType.POLYGON, labels=labels, modification_date=modification_date, ) if len(points) == 0: raise ValueError("Cannot create polygon with no points") self.points = points self.min_x = min(points, key=attrgetter("x")).x self.max_x = max(points, key=attrgetter("x")).x self.min_y = min(points, key=attrgetter("y")).y self.max_y = max(points, key=attrgetter("y")).y is_valid = True for (x, y) in [(self.min_x, self.min_y), (self.max_x, self.max_y)]: is_valid = is_valid and self._validate_coordinates(x, y) if not is_valid: points_str = "; ".join(str(p) for p in self.points) warnings.warn( f"{type(self).__name__} coordinates are invalid : {points_str}", UserWarning, )
def __init__( self, x1: float, y1: float, x2: float, y2: float, labels: Optional[List[ScoredLabel]] = None, modification_date: Optional[datetime.datetime] = None, ): labels = [] if labels is None else labels modification_date = now( ) if modification_date is None else modification_date super().__init__( type=ShapeType.ELLIPSE, labels=labels, modification_date=modification_date, ) for (x, y) in [(x1, y1), (x2, y2)]: self._validate_coordinates(x, y) self.x1 = x1 self.y1 = y1 self.x2 = x2 self.y2 = y2 if self.width <= 0 or self.height <= 0: raise ValueError( f"Invalid Ellipse with coordinates: x1={self.x1}, y1={self.y1}, x2={self.x2}," f" y2={self.y2}")
def __init__( self, x1: float, y1: float, x2: float, y2: float, labels: Optional[List[ScoredLabel]] = None, modification_date: Optional[datetime.datetime] = None, ): labels = [] if labels is None else labels modification_date = now( ) if modification_date is None else modification_date super().__init__( type=ShapeType.RECTANGLE, labels=labels, modification_date=modification_date, ) is_valid = True for (x, y) in [(x1, y1), (x2, y2)]: is_valid = is_valid and self._validate_coordinates(x, y) if not is_valid: warnings.warn( f"{type(self).__name__} coordinates are invalid : x1={x1}, y1={y1}, x2={x2}, y2={y2}", UserWarning, ) self.x1 = x1 self.y1 = y1 self.x2 = x2 self.y2 = y2 if self.width <= 0 or self.height <= 0: raise ValueError( f"Invalid rectangle with coordinates: x1={self.x1}, y1={self.y1}, " f"x2={self.x2}, y2={self.y2}")
def backward(instance: Union[None, str]) -> datetime.datetime: """Deserializes datetime from str or create new one if it is None""" if isinstance(instance, str): modification_date = datetime.datetime.strptime( instance, "%Y-%m-%dT%H:%M:%S.%f" ) return modification_date.replace(tzinfo=datetime.timezone.utc) return now()
def test_serialization_deserialization(self): """ This test serializes datetime, deserializes serialized datetime and compares with original one. """ original_time = now() serialized_time = DatetimeMapper.forward(original_time) assert serialized_time == original_time.strftime( "%Y-%m-%dT%H:%M:%S.%f") deserialized_time = DatetimeMapper.backward(serialized_time) assert original_time == deserialized_time
def __init__( self, annotations: List[Annotation], kind: AnnotationSceneKind, editor: str = "", creation_date: Optional[datetime.datetime] = None, id: Optional[ID] = None, ): self.__annotations = annotations self.__kind = kind self.__editor = editor self.__creation_date = now( ) if creation_date is None else creation_date self.__id = ID() if id is None else id
def __init__( self, model: ModelEntity, ground_truth_dataset: DatasetEntity, prediction_dataset: DatasetEntity, purpose: ResultsetPurpose = ResultsetPurpose.EVALUATION, performance: Optional[Performance] = None, creation_date: Optional[datetime.datetime] = None, id: Optional[ID] = None, ): id = ID() if id is None else id performance = NullPerformance() if performance is None else performance creation_date = now() if creation_date is None else creation_date self.__id = id self.__model = model self.__prediction_dataset = prediction_dataset self.__ground_truth_dataset = ground_truth_dataset self.__performance = performance self.__purpose = purpose self.__creation_date = creation_date
def __init__( self, name: str, domain: Domain, color: Optional[Color] = None, hotkey: str = "", creation_date: Optional[datetime.datetime] = None, is_empty: bool = False, id: Optional[ID] = None, ): id = ID() if id is None else id color = Color.random() if color is None else color creation_date = now() if creation_date is None else creation_date if not hotkey and is_empty: hotkey = "ctrl+0" self._name = name self._color = color self._hotkey = hotkey self._domain = domain self._is_empty = is_empty self._creation_date = creation_date self._id = id
class TestLabelEntity: creation_date = now() label_car_params = { "name": "car", "domain": Domain.DETECTION, "color": Color(255, 0, 0), "hotkey": "ctrl+1", "creation_date": creation_date, "is_empty": False, "id": ID(123456789), } label_person_params = { "name": "person", "domain": Domain.DETECTION, "color": Color(255, 17, 17), "hotkey": "ctrl+2", "creation_date": creation_date, "is_empty": False, "id": ID(987654321), } car = LabelEntity(**label_car_params) # type: ignore empty = LabelEntity(name="empty", domain=Domain.SEGMENTATION, is_empty=True) person = LabelEntity(**label_person_params) # type: ignore @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_label_entity(self): """ <b>Description:</b> Check the LabelEntity can correctly return the value <b>Input data:</b> Dummy data <b>Expected results:</b> Test passes if incoming data is processed correctly <b>Steps</b> 1. Use already created dummy data 2. Check the processing of default values 3. Check the processing of changed values """ assert self.car == LabelEntity(**self.label_car_params) assert self.car != Domain assert self.car != self.person for attr in [ "name", "domain", "color", "hotkey", "creation_date", "is_empty", "id", ]: assert getattr(self.car, attr) == self.label_car_params[attr] label_car_new_name = "electric car" label_car_new_domain = Domain.CLASSIFICATION label_car_new_color = Color(0, 255, 0) label_car_new_hotkey = "ctrl+2" label_car_new_id = ID(987654321) setattr(self.car, "name", label_car_new_name) setattr(self.car, "domain", label_car_new_domain) setattr(self.car, "color", label_car_new_color) setattr(self.car, "hotkey", label_car_new_hotkey) setattr(self.car, "id", label_car_new_id) assert self.car.name == label_car_new_name assert self.car.domain == label_car_new_domain assert self.car.color == label_car_new_color assert self.car.hotkey == label_car_new_hotkey assert self.car.id == label_car_new_id test_label_entity_repr = [ f"{self.car.id}", f"name={self.car.name}", f"hotkey={self.car.hotkey}", f"domain={self.car.domain}", f"color={self.car.color}", ] for i in test_label_entity_repr: assert i in self.car.__repr__() assert hash(self.car) == hash(str(self.car)) assert self.car.__lt__(Domain) is False assert self.car.__gt__(Domain) is False @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_empty_label_entity(self): """ <b>Description:</b> Check the LabelEntity can correctly return the value for empty label <b>Input data:</b> Dummy data <b>Expected results:</b> Test passes if incoming data is processed correctly <b>Steps</b> 1. Use already created dummy data 2. Check the processing of default values """ assert self.empty.hotkey == "ctrl+0" assert self.empty.id == ID() assert type(self.empty.color) == Color @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_label_comparison(self): """ <b>Description:</b> Check the LabelEntity __lt__, __gt__ methods with changed id <b>Input data:</b> Dummy data <b>Expected results:</b> Test passes if incoming data is processed correctly <b>Steps</b> 1. Use already created dummy data 2. Check the processing of changed id """ self.empty.id = ID(999999999) assert self.empty > self.car assert self.car < self.empty
class TestModelEntity: creation_date = now() def generate_random_image(self): with generate_random_single_image() as path: image = Image(file_path=path) return DatasetItemEntity( media=image, annotation_scene=NullAnnotationSceneEntity()) def dataset(self): return DatasetEntity(items=[self.generate_random_image()]) def configuration(self): parameters = ConfigurableParameters(header="Test header") label_schema = LabelSchemaEntity() return ModelConfiguration(configurable_parameters=parameters, label_schema=label_schema) def other_configuration(self): parameters = ConfigurableParameters(header="Other test header") label_schema = LabelSchemaEntity() return ModelConfiguration(configurable_parameters=parameters, label_schema=label_schema) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_model_entity_default_values(self): """ <b>Description:</b> Check that ModelEntity correctly returns the default values <b>Expected results:</b> Test passes if ModelEntity correctly returns the default values <b>Steps</b> 1. Check default values in the ModelEntity """ model_entity = ModelEntity(train_dataset=self.dataset(), configuration=self.configuration()) assert model_entity.id == ID() assert type(model_entity.configuration) == ModelConfiguration assert type(model_entity.creation_date) == datetime assert type(model_entity.train_dataset) == DatasetEntity assert model_entity.version == 1 assert model_entity.model_status == ModelStatus.SUCCESS assert model_entity.model_format == ModelFormat.OPENVINO assert model_entity.precision == [ModelPrecision.FP32] assert model_entity.target_device == TargetDevice.CPU assert model_entity.optimization_type == ModelOptimizationType.NONE assert model_entity.performance == NullPerformance() for default_val_none in [ "previous_trained_revision", "previous_revision", "target_device_type", ]: assert getattr(model_entity, default_val_none) is None for default_val_0_0 in ["training_duration", "model_size_reduction"]: assert getattr(model_entity, default_val_0_0) == 0.0 for default_val_empty_list in ["tags", "optimization_methods"]: assert getattr(model_entity, default_val_empty_list) == [] for default_val_empty_dict in [ "model_adapters", "optimization_objectives", "performance_improvement", ]: assert getattr(model_entity, default_val_empty_dict) == {} for default_val_zero in ["latency", "fps_throughput"]: assert getattr(model_entity, default_val_zero) == 0 assert model_entity.is_optimized() is False @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_model_entity_sets_values(self): """ <b>Description:</b> Check that ModelEntity correctly returns the set values <b>Expected results:</b> Test passes if ModelEntity correctly returns the set values <b>Steps</b> 1. Check set values in the ModelEntity """ def __get_path_to_file(filename: str): """ Return the path to the file named 'filename', which lives in the tests/entities directory """ return str(Path(__file__).parent / Path(filename)) car = LabelEntity(name="car", domain=Domain.DETECTION) labels_list = [car] dummy_template = __get_path_to_file("./dummy_template.yaml") model_template = parse_model_template(dummy_template) hyper_parameters = model_template.hyper_parameters.data params = ote_config_helper.create(hyper_parameters) labels_schema = LabelSchemaEntity.from_labels(labels_list) environment = TaskEnvironment( model=None, hyper_parameters=params, label_schema=labels_schema, model_template=model_template, ) item = self.generate_random_image() dataset = DatasetEntity(items=[item]) score_metric = ScoreMetric(name="Model accuracy", value=0.5) model_entity = ModelEntity(train_dataset=self.dataset(), configuration=self.configuration()) set_params = { "configuration": environment.get_model_configuration(), "train_dataset": dataset, "id": ID(1234567890), "creation_date": self.creation_date, "previous_trained_revision": 5, "previous_revision": 2, "version": 2, "tags": ["tree", "person"], "model_status": ModelStatus.TRAINED_NO_STATS, "model_format": ModelFormat.BASE_FRAMEWORK, "performance": Performance(score_metric), "training_duration": 5.8, "precision": [ModelPrecision.INT8], "latency": 328, "fps_throughput": 20, "target_device": TargetDevice.GPU, "target_device_type": "notebook", "optimization_methods": [OptimizationMethod.QUANTIZATION], "optimization_type": ModelOptimizationType.MO, "optimization_objectives": { "param": "Test param" }, "performance_improvement": {"speed", 0.5}, "model_size_reduction": 1.0, } for key, value in set_params.items(): setattr(model_entity, key, value) assert getattr(model_entity, key) == value assert model_entity.is_optimized() is True @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_model_entity_model_adapters(self): """ <b>Description:</b> Check that ModelEntity correctly returns the adapters <b>Expected results:</b> Test passes if ModelEntity correctly returns the adapters <b>Steps</b> 1. Create a ModelEntity with adapters 2. Change data source for an adapter 3. Remove an adapter """ data_source_0 = b"{0: binaryrepo://localhost/repo/data_source/0}" data_source_1 = b"binaryrepo://localhost/repo/data_source/1" data_source_2 = b"binaryrepo://localhost/repo/data_source/2" data_source_3 = b"binaryrepo://localhost/repo/data_source/3" temp_dir = tempfile.TemporaryDirectory() temp_file = os.path.join(temp_dir.name, "data_source_0") with open(temp_file, "wb") as tmp: tmp.write(data_source_0) model_adapters = { "0": ModelAdapter(data_source=data_source_0), "1": ModelAdapter(data_source=data_source_1), "2": ModelAdapter(data_source=data_source_2), } model_entity = ModelEntity( train_dataset=self.dataset(), configuration=self.configuration(), model_adapters=model_adapters, ) assert model_entity.weight_paths == {} # Adapter with key 0 not from file assert model_entity.model_adapters["0"].from_file_storage is False model_entity.set_data("0", temp_file) for adapter in model_entity.model_adapters: if adapter == "0": # Adapter with key 0 from file assert model_entity.model_adapters[ adapter].from_file_storage is True else: assert model_entity.model_adapters[ adapter].from_file_storage is False assert model_entity.get_data("1") == data_source_1 model_entity.set_data("2", data_source_1) assert model_entity.get_data("2") == data_source_1 assert len(model_entity.model_adapters) == 3 model_entity.set_data("3", data_source_3) assert model_entity.get_data("3") == data_source_3 assert len(model_entity.model_adapters) == 4 model_entity.delete_data("3") assert len(model_entity.model_adapters) == 3 # Attempt to retrieve a missing and deleted key with pytest.raises(KeyError): model_entity.get_data("5") with pytest.raises(KeyError): model_entity.get_data("3") # The presence of outdated code in ModelEntity "model_adapter.data_source.binary_url" with pytest.raises(AttributeError): assert model_entity.weight_paths == {"0": temp_file} @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_model_entity__eq__(self): """ <b>Description:</b> Check that ModelEntity __eq__ method <b>Expected results:</b> Test passes if ModelEntity equal ModelEntity and not equal another type """ dataset = self.dataset() other_model_entity = ModelEntity(train_dataset=dataset, configuration=self.configuration()) model_entity = ModelEntity(train_dataset=dataset, configuration=self.configuration()) third_model_entity = ModelEntity( train_dataset=self.dataset(), configuration=self.other_configuration()) assert model_entity.__eq__("") is False assert model_entity == other_model_entity assert model_entity != third_model_entity
def test_flat_label_schema_serialization(self): """ This test serializes flat LabelSchema and checks serialized representation. Then it compares deserialized LabelSchema with original one. """ cur_date = now() names = ["cat", "dog", "mouse"] colors = [ Color( randint(0, 255), # nosec randint(0, 255), # nosec randint(0, 255), # nosec randint(0, 255), # nosec ) # nosec # noqa for _ in range(3) ] labels = [ LabelEntity( name=name, domain=Domain.CLASSIFICATION, creation_date=cur_date, id=ID(i), color=colors[i], ) for i, name in enumerate(names) ] label_shema = LabelSchemaEntity.from_labels(labels) serialized = LabelSchemaMapper.forward(label_shema) assert serialized == { "label_tree": {"type": "tree", "directed": True, "nodes": [], "edges": []}, "exclusivity_graph": { "type": "graph", "directed": False, "nodes": [], "edges": [], }, "label_groups": [ { "_id": label_shema.get_groups()[0].id, "name": "from_label_list", "label_ids": ["0", "1", "2"], "relation_type": "EXCLUSIVE", } ], "all_labels": { "0": { "_id": "0", "name": "cat", "color": ColorMapper.forward(colors[0]), "hotkey": "", "domain": "CLASSIFICATION", "creation_date": DatetimeMapper.forward(cur_date), "is_empty": False, }, "1": { "_id": "1", "name": "dog", "color": ColorMapper.forward(colors[1]), "hotkey": "", "domain": "CLASSIFICATION", "creation_date": DatetimeMapper.forward(cur_date), "is_empty": False, }, "2": { "_id": "2", "name": "mouse", "color": ColorMapper.forward(colors[2]), "hotkey": "", "domain": "CLASSIFICATION", "creation_date": DatetimeMapper.forward(cur_date), "is_empty": False, }, }, } deserialized = LabelSchemaMapper.backward(serialized) assert label_shema == deserialized
class TestAnnotationSceneEntity: creation_date = now() labels: List[ScoredLabel] = [] rectangle = Rectangle(x1=0.5, x2=1.0, y1=0.0, y2=0.5) annotation = Annotation(shape=rectangle, labels=labels) point1 = Point(0.3, 0.1) point2 = Point(0.8, 0.3) point3 = Point(0.6, 0.2) points = [point1, point2, point3] polygon = Polygon(points=points) annotation2 = Annotation(shape=polygon, labels=labels) annotations = [annotation, annotation2] annotation_scene_entity = AnnotationSceneEntity( annotations=annotations, kind=AnnotationSceneKind.ANNOTATION) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_annotation_scene_entity_default_value(self): """ <b>Description:</b> Check that AnnotationSceneEntity default values <b>Input data:</b> AnnotationSceneEntity class <b>Expected results:</b> Test passes if the AnnotationSceneEntity return correct values <b>Steps</b> 1. Create AnnotationSceneEntity instances 2. Check default values """ annotation_scene_entity = self.annotation_scene_entity assert annotation_scene_entity.id == ID() assert annotation_scene_entity.kind == AnnotationSceneKind.ANNOTATION assert annotation_scene_entity.editor_name == "" assert type(annotation_scene_entity.creation_date) == datetime.datetime assert "Annotation(shape=Rectangle" in str( annotation_scene_entity.annotations) assert "Annotation(shape=Polygon" in str( annotation_scene_entity.annotations) assert annotation_scene_entity.shapes == [self.rectangle, self.polygon] @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_annotation_scene_entity_setters(self): """ <b>Description:</b> Check that AnnotationSceneEntity can correctly return modified property value <b>Input data:</b> Annotation class <b>Expected results:</b> Test passes if the AnnotationSceneEntity return correct values <b>Steps</b> 1. Create AnnotationSceneEntity instances 2. Set another values 3. Check changed values """ annotation_scene_entity = self.annotation_scene_entity creation_date = self.creation_date annotation_scene_entity.id = ID(123456789) annotation_scene_entity.kind = AnnotationSceneKind.PREDICTION annotation_scene_entity.editor_name = "editor" annotation_scene_entity.creation_date = creation_date annotation_scene_entity.annotations = self.annotation assert annotation_scene_entity.id == ID(123456789) assert annotation_scene_entity.kind == AnnotationSceneKind.PREDICTION assert annotation_scene_entity.editor_name == "editor" assert annotation_scene_entity.creation_date == creation_date assert annotation_scene_entity.annotations == self.annotation @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_annotation_scene_entity_magic_methods(self): """ <b>Description:</b> Check Annotation __repr__ method <b>Input data:</b> Initialized instance of AnnotationSceneEntity <b>Expected results:</b> Test passes if AnnotationSceneEntity magic method returns correct values <b>Steps</b> 1. Create AnnotationSceneEntity instances 2. Check returning value of magic method """ annotation_scene_entity = self.annotation_scene_entity annotation_scene_entity_repr = [ f"{annotation_scene_entity.__class__.__name__}(" f"annotations={annotation_scene_entity.annotations}, " f"kind={annotation_scene_entity.kind}, " f"editor={annotation_scene_entity.editor_name}, " f"creation_date={annotation_scene_entity.creation_date}, " f"id={annotation_scene_entity.id})" ] for i in annotation_scene_entity_repr: assert i in repr(annotation_scene_entity) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_annotation_scene_entity_contains_any(self): """ <b>Description:</b> Check Annotation contains_any method <b>Input data:</b> Initialized instance of AnnotationSceneEntity <b>Expected results:</b> Test passes if AnnotationSceneEntity contains_any method returns correct values <b>Steps</b> 1. Create AnnotationSceneEntity instances 2. Check returning value of contains_any method """ annotation_scene_entity = self.annotation_scene_entity annotation_scene_entity.annotations = self.annotations car = LabelEntity(name="car", domain=Domain.DETECTION, is_empty=True) person = LabelEntity(name="person", domain=Domain.DETECTION) tree = LabelEntity(name="tree", domain=Domain.DETECTION) car_label = ScoredLabel(car) person_label = ScoredLabel(person) tree_label = ScoredLabel(tree) labels = [car_label] labels2 = [car_label, person_label] annotation = Annotation(shape=self.rectangle, labels=labels2) annotations = [annotation] annotation_scene_entity2 = AnnotationSceneEntity( annotations=annotations, kind=AnnotationSceneKind.ANNOTATION) assert annotation_scene_entity.contains_any(labels=labels) is False assert annotation_scene_entity2.contains_any(labels=labels2) is True assert annotation_scene_entity2.contains_any( labels=[tree_label]) is False @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_annotation_scene_entity_append_annotation(self): """ <b>Description:</b> Check Annotation append_annotation method <b>Input data:</b> Initialized instance of AnnotationSceneEntity <b>Expected results:</b> Test passes if AnnotationSceneEntity append_annotation method returns correct values <b>Steps</b> 1. Create AnnotationSceneEntity instances 2. Check returning value of append_annotation method """ annotation_scene_entity = self.annotation_scene_entity tree = LabelEntity(name="tree", domain=Domain.DETECTION) tree_label = ScoredLabel(tree) labels = [tree_label] annotation = Annotation(shape=self.rectangle, labels=labels) assert len(annotation_scene_entity.annotations) == 2 annotation_scene_entity.append_annotation(annotation) assert len(annotation_scene_entity.annotations) == 3 @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_annotation_scene_entity_append_annotations(self): """ <b>Description:</b> Check Annotation append_annotations method <b>Input data:</b> Initialized instance of AnnotationSceneEntity <b>Expected results:</b> Test passes if AnnotationSceneEntity append_annotations method returns correct values <b>Steps</b> 1. Create AnnotationSceneEntity instances 2. Check returning value of append_annotations method """ annotation_scene_entity = self.annotation_scene_entity annotation_scene_entity.append_annotations(self.annotations) assert len(annotation_scene_entity.annotations) == 6 @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_annotation_scene_entity_get_labels(self): """ <b>Description:</b> Check Annotation get_labels method <b>Input data:</b> Initialized instance of AnnotationSceneEntity <b>Expected results:</b> Test passes if AnnotationSceneEntity get_labels method returns correct values <b>Steps</b> 1. Create AnnotationSceneEntity instances 2. Check returning value of get_labels method """ annotation_scene_entity = self.annotation_scene_entity assert len(annotation_scene_entity.get_labels()) == 1 assert "name=tree" in str(annotation_scene_entity.get_labels()) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_annotation_scene_entity_get_label_ids(self): """ <b>Description:</b> Check Annotation get_label_ids method <b>Input data:</b> Initialized instance of AnnotationSceneEntity <b>Expected results:</b> Test passes if AnnotationSceneEntity get_label_ids method returns correct values <b>Steps</b> 1. Create AnnotationSceneEntity instances 2. Check returning value of get_label_ids method """ annotation_scene_entity = self.annotation_scene_entity assert annotation_scene_entity.get_label_ids() == {ID()} bus = LabelEntity(id=ID(123456789), name="bus", domain=Domain.DETECTION) bus_label = ScoredLabel(bus) labels = [bus_label] annotation = Annotation(shape=self.rectangle, labels=labels) annotation_scene_entity.append_annotation(annotation) assert annotation_scene_entity.get_label_ids() == {ID(), ID(123456789)}
def __init__( self, train_dataset: "DatasetEntity", configuration: ModelConfiguration, *, creation_date: Optional[datetime.datetime] = None, performance: Optional[Performance] = None, previous_trained_revision: Optional["ModelEntity"] = None, previous_revision: Optional["ModelEntity"] = None, version: int = 1, tags: Optional[List[str]] = None, model_status: ModelStatus = ModelStatus.SUCCESS, model_format: ModelFormat = ModelFormat.OPENVINO, training_duration: float = 0.0, model_adapters: Optional[Dict[str, ModelAdapter]] = None, exportable_code_adapter: Optional[ExportableCodeAdapter] = None, precision: Optional[List[ModelPrecision]] = None, latency: int = 0, fps_throughput: int = 0, target_device: TargetDevice = TargetDevice.CPU, target_device_type: Optional[str] = None, optimization_type: ModelOptimizationType = ModelOptimizationType.NONE, optimization_methods: List[OptimizationMethod] = None, optimization_objectives: Dict[str, str] = None, performance_improvement: Dict[str, float] = None, model_size_reduction: float = 0.0, _id: Optional[ID] = None, ): _id = ID() if _id is None else _id performance = NullPerformance() if performance is None else performance creation_date = now() if creation_date is None else creation_date optimization_methods = ( [] if optimization_methods is None else optimization_methods ) optimization_objectives = ( {} if optimization_objectives is None else optimization_objectives ) performance_improvement = ( {} if performance_improvement is None else performance_improvement ) tags = [] if tags is None else tags precision = [ModelPrecision.FP32] if precision is None else precision if model_adapters is None: model_adapters = {} self.__id = _id self.__creation_date = creation_date self.__train_dataset = train_dataset self.__previous_trained_revision = previous_trained_revision self.__previous_revision = previous_revision self.__version = version self.__tags = tags self.__model_status = model_status self.__model_format = model_format self.__performance = performance self.__training_duration = training_duration self.__configuration = configuration self.__model_adapters = model_adapters self.__exportable_code_adapter = exportable_code_adapter self.model_adapters_to_delete: List[ModelAdapter] = [] self.__precision = precision self.__latency = latency self.__fps_throughput = fps_throughput self.__target_device = target_device self.__target_device_type = target_device_type self.__optimization_type = optimization_type self.__optimization_methods = optimization_methods self.__optimization_objectives = optimization_objectives self.__performance_improvement = performance_improvement self.__model_size_reduction = model_size_reduction
class TestRectangle: modification_date = now() @staticmethod def rectangle_labels() -> list: rectangle_label = LabelEntity( name="Rectangle label", domain=Domain.DETECTION, color=Color(red=100, green=50, blue=200), id=ID("rectangle_label_1"), ) other_rectangle_label = LabelEntity( name="Other rectangle label", domain=Domain.SEGMENTATION, color=Color(red=200, green=80, blue=100), id=ID("rectangle_label_2"), ) return [ ScoredLabel(label=rectangle_label), ScoredLabel(label=other_rectangle_label), ] @staticmethod def horizontal_rectangle_params() -> dict: return {"x1": 0.1, "y1": 0.0, "x2": 0.4, "y2": 0.2} def horizontal_rectangle(self) -> Rectangle: return Rectangle(**self.horizontal_rectangle_params()) def vertical_rectangle_params(self) -> dict: return { "x1": 0.1, "y1": 0.1, "x2": 0.3, "y2": 0.4, "labels": self.rectangle_labels(), "modification_date": datetime( year=2020, month=1, day=1, hour=9, minute=30, second=15, microsecond=2 ), } def vertical_rectangle(self) -> Rectangle: return Rectangle(**self.vertical_rectangle_params()) @staticmethod def square_params() -> dict: return {"x1": 0.1, "y1": 0.1, "x2": 0.3, "y2": 0.3} def square(self) -> Rectangle: return Rectangle(**self.square_params()) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_required_parameters(self): """ <b>Description:</b> Check Rectangle class instance required parameters <b>Input data:</b> Rectangle class initiation parameters <b>Expected results:</b> Test passes if Rectangle instance has expected attributes specified during required parameters initiation <b>Steps</b> 1. Compare x1, y1, x2, y2 and type Rectangle instance parameters with expected values """ rectangle = self.horizontal_rectangle() assert rectangle.x1 == 0.1 assert rectangle.y1 == 0.0 assert rectangle.x2 == 0.4 assert rectangle.y2 == 0.2 assert rectangle.type == ShapeType.RECTANGLE @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_optional_parameters(self): """ <b>Description:</b> Check Rectangle optional parameters <b>Input data:</b> Instance of Rectangle class <b>Expected results:</b> Test passes if Rectangle instance has expected labels and modification attributes specified during Rectangle class object initiation with optional parameters <b>Steps</b> 1. Compare default label Rectangle instance attribute with expected value 2. Check type of default modification_date Rectangle instance attribute 3. Compare specified label Rectangle instance attribute with expected value 4. Compare specified modification_date Rectangle instance attribute with expected value """ # Checking default values of optional parameters default_params_rectangle = self.horizontal_rectangle() assert default_params_rectangle._labels == [] assert isinstance(default_params_rectangle.modification_date, datetime) # check for specified values of optional parameters specified_params_rectangle = self.vertical_rectangle() assert specified_params_rectangle._labels == self.rectangle_labels() assert specified_params_rectangle.modification_date == datetime( year=2020, month=1, day=1, hour=9, minute=30, second=15, microsecond=2 ) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_coordinates_validation(self): """ <b>Description:</b> Check Rectangle coordinates <b>Input data:</b> Rectangle class initiation parameters <b>Expected results:</b> Test passes if Rectangle correctly checks coordinates during initiation of Rectangle object <b>Steps</b> 1. Check Rectangle coordinates with correct width and height 2. Check Rectangle coordinates with incorrect width: (x2 - x1) <= 0 3. Check Rectangle coordinates with incorrect height: (y2 - y1) <= 0 4. Check Rectangle coordinates with all coordinates equal 0 """ # checks for correct width and height self.horizontal_rectangle() self.vertical_rectangle() self.square() with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Rectangle coordinates") Rectangle(x1=0.2, y1=0.1, x2=1.4, y2=1.5) Rectangle(x1=0.2, y1=0.1, x2=0.4, y2=0.5) # checks for incorrect coordinates width_less_than_zero_params = {"x1": 0.4, "y1": 0.0, "x2": 0.1, "y2": 0.2} width_equal_zero_params = {"x1": 0.1, "y1": 0.0, "x2": 0.1, "y2": 0.2} height_less_than_zero_params = {"x1": 0.1, "y1": 0.4, "x2": 0.3, "y2": 0.1} height_params_equal_zero_params = {"x1": 0.1, "y1": 0.4, "x2": 0.3, "y2": 0.4} zero_rectangle_params = {"x1": 0.0, "x2": 0.0, "y1": 0.0, "y2": 0.0} for incorrect_coordinates in [ width_less_than_zero_params, width_equal_zero_params, height_less_than_zero_params, height_params_equal_zero_params, zero_rectangle_params, ]: with pytest.raises(ValueError): Rectangle(**incorrect_coordinates) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_repr(self): """ <b>Description:</b> Check Rectangle __repr__ method <b>Input data:</b> Instance of Rectangle class <b>Expected results:</b> Test passes if __repr__ method prints expected message for Rectangle class instance <b>Steps</b> 1. Check message printed by __repr__ method """ rectangle = self.horizontal_rectangle() assert ( repr(rectangle) == "Rectangle(x=0.1, y=0.0, width=0.30000000000000004, height=0.2)" ) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_eq(self): """ <b>Description:</b> Check Rectangle __eq__ method <b>Input data:</b> Instances of Rectangle class <b>Expected results:</b> Test passes if __eq__ method returns expected bool value <b>Steps</b> 1. Check __eq__ method for instances of Rectangle class with equal parameters 2. Check __eq__ method for different instances of Rectangle class 3. Check __eq__ method for instances of different classes 4. Check __eq__ method for instances of Rectangle class with unequal labels attribute 5. Check __eq__ method for instances of Rectangle class with unequal x1, y1, x2, y2 and modification_date attributes """ rectangle = self.vertical_rectangle() # Check for instances with equal parameters equal_rectangle = self.vertical_rectangle() assert rectangle == equal_rectangle # Check for different instances of Rectangle class assert rectangle != self.horizontal_rectangle() # Check for different types branch assert rectangle != str # Check for unequal labels parameters. Expected that different labels are not affecting equality unequal_label = LabelEntity( name="Unequal label", domain=Domain.SEGMENTATION, id=ID("unequal_label_1") ) unequal_scored_label = ScoredLabel(label=unequal_label) equal_rectangle._labels.append(unequal_scored_label) assert rectangle == equal_rectangle # Check for instances with unequal parameters combinations # Generating all possible scenarios of parameter values submission keys_list = ["x1", "y1", "x2", "y2", "modification_date"] parameter_combinations = [] for i in range(1, len(keys_list) + 1): parameter_combinations.append(list(itertools.combinations(keys_list, i))) # In each of scenario creating a copy of equal Rectangle parameters and replacing to values from prepared # dictionary unequal_values_dict = { "x1": 0.09, "y1": 0.09, "x2": 0.29, "y2": 0.39, "modification_date": datetime( year=2019, month=2, day=3, hour=7, minute=15, second=10, microsecond=1 ), } for scenario in parameter_combinations: for rectangle_parameters in scenario: unequal_rectangle_params_dict = dict(self.vertical_rectangle_params()) for key in rectangle_parameters: unequal_rectangle_params_dict[key] = unequal_values_dict.get(key) unequal_rectangle = Rectangle(**unequal_rectangle_params_dict) assert rectangle != unequal_rectangle, ( "Failed to check that Rectangle instances with different " f"{rectangle_parameters} are unequal" ) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_hash(self): """ <b>Description:</b> Check Rectangle __hash__ method <b>Input data:</b> Instance of Rectangle class <b>Expected results:</b> Test passes if __hash__ method returns expected value <b>Steps</b> 1. Check value returned by __hash__ method """ rectangle = self.horizontal_rectangle() assert hash(rectangle) == hash(str(rectangle)) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_clip_to_visible_region(self): """ <b>Description:</b> Check Rectangle clip_to_visible_region method <b>Input data:</b> Rectangle class initiation parameters <b>Expected results:</b> Test passes if clip_to_visible_region method return correct value <b>Steps</b> 1. Check values returned by clip_to_visible_region method for 0<x1<x2, 0<y1<y2, x1<x2<1, y1<y2<1 2. Check values returned by clip_to_visible_region method for x1<0, y1<0, x2>1, y2>1 3. Check values returned by clip_to_visible_region method for x1=0, y1=0, x2=1, y2=1 4. Check ValueError exception raised if x1<0 and x1<x2<0: clipped Rectangle width will be equal 0 5. Check ValueError exception raised if 1<x1<x2 and x2>1: clipped Rectangle width will be equal 0 6. Check ValueError exception raised if y1<0 and y1<y2<0: clipped Rectangle height will be equal 0 7. Check ValueError exception raised if 1<y1<y2 and y2>1: clipped Rectangle height will be equal 0 """ positive_scenarios = [ { "input_params": { "x1": 0.3, "y1": 0.2, "x2": 0.6, "y2": 0.4, "labels": self.rectangle_labels(), }, "params_expected": {"x1": 0.3, "y1": 0.2, "x2": 0.6, "y2": 0.4}, }, { "input_params": { "x1": -0.2, "y1": -0.3, "x2": 1.6, "y2": 1.4, "labels": self.rectangle_labels(), }, "params_expected": {"x1": 0.0, "y1": 0.0, "x2": 1.0, "y2": 1.0}, }, { "input_params": { "x1": 0.0, "y1": 0.0, "x2": 1.0, "y2": 1.0, "labels": self.rectangle_labels(), }, "params_expected": {"x1": 0.0, "y1": 0.0, "x2": 1.0, "y2": 1.0}, }, ] for scenario in positive_scenarios: with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Rectangle coordinates") rectangle_actual = Rectangle(**scenario.get("input_params")) rectangle_expected = Rectangle(**scenario.get("params_expected")) rectangle_actual.modification_date = self.modification_date rectangle_expected.modification_date = self.modification_date assert rectangle_actual.clip_to_visible_region() == rectangle_expected negative_scenarios = [ {"x1": -0.4, "y1": 0.2, "x2": -0.2, "y2": 0.4}, {"x1": 1.2, "y1": 0.2, "x2": 1.6, "y2": 0.4}, {"x1": 0.4, "y1": -0.4, "x2": 0.6, "y2": -0.2}, {"x1": 1.2, "y1": 1.2, "x2": 1.6, "y2": 1.4}, ] for scenario in negative_scenarios: with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Rectangle coordinates") rectangle_actual = Rectangle(**scenario) with pytest.raises(ValueError): rectangle_actual.clip_to_visible_region() @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_normalize_wrt_roi_shape(self): """ <b>Description:</b> Check Rectangle normalize_wrt_roi_shape method <b>Input data:</b> Instance of Rectangle class <b>Expected results:</b> Test passes if normalize_wrt_roi_shape method returns expected instance of Rectangle class <b>Steps</b> 1. Check values returned by normalized Rectangle instance 2. Check raise ValueError exception when roi parameter has unexpected type """ # Positive scenario rectangle = self.horizontal_rectangle() with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Rectangle coordinates") roi_shape = Rectangle(x1=0.0, y1=0.0, x2=2.1, y2=2.2) normalized = rectangle.normalize_wrt_roi_shape(roi_shape) assert normalized.x1 == 0.1 assert normalized.y1 == 0.0 assert normalized.x2 == 0.4 assert normalized.y2 == 0.2 assert normalized.modification_date == rectangle.modification_date # Negative scenario with pytest.raises(ValueError): rectangle.normalize_wrt_roi_shape(str) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_denormalize_wrt_roi_shape(self): """ <b>Description:</b> Check Rectangle denormalize_wrt_roi_shape method <b>Input data:</b> Instance of Rectangle class <b>Expected results:</b> Test passes if denormalize_wrt_roi_shape method return expected instance of Rectangle class <b>Steps</b> 1. Check values returned by denormalized Rectangle instance 2. Check raise ValueError exception when roi parameter has unexpected type """ # Positive scenario rectangle = self.horizontal_rectangle() roi_shape = Rectangle(x1=0.2, y1=0.2, x2=0.4, y2=0.4) with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Rectangle coordinates") denormalized = rectangle.denormalize_wrt_roi_shape(roi_shape) assert denormalized.x1 == -0.5 assert denormalized.y1 == -1.0 assert denormalized.x2 == 1.0 assert denormalized.y2 == 0.0 assert denormalized.modification_date == rectangle.modification_date # Negative scenario with pytest.raises(ValueError): rectangle.denormalize_wrt_roi_shape(str) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_as_shapely_polygon(self): """ <b>Description:</b> Check Rectangle _as_shapely_polygon method <b>Input data:</b> Instance of Rectangle class <b>Expected results:</b> Test passes if _as_shapely_polygon method returns expected instance of Polygon class <b>Steps</b> 1. Check Polygon instance returned by _as_shapely_polygon method """ rectangle = self.horizontal_rectangle() shapely_polygon = rectangle._as_shapely_polygon() assert shapely_polygon.__class__ == Polygon assert shapely_polygon.bounds == (0.1, 0.0, 0.4, 0.2) assert shapely_polygon.area == 0.06000000000000001 @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_generate_full_box(self): """ <b>Description:</b> Check Rectangle generate_full_box method <b>Input data:</b> Labels specified for full_box instance of Rectangle class <b>Expected results:</b> Test passes if generate_full_box method returns instance of Rectangle class with coordinates (x1=0.0, y1=0.0, x2=1.0, y2=1.0) <b>Steps</b> 1. Check generate_full_box method for Rectangle instance with no labels specified 2. Check generate_full_box method for Rectangle instance with labels specified """ detection_label = ScoredLabel( LabelEntity(name="detection", domain=Domain.DETECTION) ) for label_actual, label_expected in [ (None, []), ([detection_label], [detection_label]), ]: full_box = Rectangle.generate_full_box(label_actual) assert full_box.type == ShapeType.RECTANGLE assert full_box.x1 == full_box.y1 == 0.0 assert full_box.x2 == full_box.y2 == 1.0 assert full_box._labels == label_expected @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_is_full_box(self): """ <b>Description:</b> Check Rectangle is_full_box method <b>Input data:</b> Rectangle class initiation parameters <b>Expected results:</b> Test passes if is_full_box method return expected bool value <b>Steps</b> 1. Check positive scenario for is_full_box method: x1=y1=0, x2=y2=1 2. Check negative scenarios for is_full_box method """ full_box_rectangle_params = {"x1": 0.0, "y1": 0.0, "x2": 1.0, "y2": 1.0} # Positive scenario for Rectangle instance full_box_rectangle = Rectangle(**full_box_rectangle_params) assert Rectangle.is_full_box(full_box_rectangle) # Negative scenarios for Rectangle instance # Generating all scenarios when Rectangle object not a full_box keys_list = ["x1", "y1", "x2", "y2"] parameter_combinations = [] for i in range(1, len(keys_list) + 1): parameter_combinations.append(list(itertools.combinations(keys_list, i))) # In each of scenario creating a copy of full_Box rectangle parameters and replacing to values from prepared # dictionary not_full_box_values_dict = {"x1": 0.01, "y1": 0.01, "x2": 0.9, "y2": 0.9} for combination in parameter_combinations: for scenario in combination: not_full_box_params = dict(full_box_rectangle_params) for key in scenario: not_full_box_params[key] = not_full_box_values_dict.get(key) not_full_box_rectangle = Rectangle(**not_full_box_params) assert not Rectangle.is_full_box(not_full_box_rectangle), ( f"Expected False returned by is_full_box method for rectangle with parameters " f"{not_full_box_params}" ) # Negative scenario for not Rectangle class instance assert not Rectangle.is_full_box(str) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_crop_numpy_array(self): """ <b>Description:</b> Check Rectangle crop_numpy_array method <b>Input data:</b> Rectangle class initiation parameters <b>Expected results:</b> Test passes if crop_numpy_array method return expected cropped array <b>Steps</b> 1. Check crop_numpy_array method for Rectangle with parameters less than 0 2. Check crop_numpy_array method for Rectangle with parameters range from 0 to 1 3. Check crop_numpy_array method for Rectangle with parameters more than 1 """ image_height = image_width = 128 numpy_image_array = np.random.uniform( low=0.0, high=255.0, size=(image_height, image_width, 3) ) scenarios = [ { "input_params": {"x1": -0.2, "x2": -0.1, "y1": -0.3, "y2": -0.2}, "cropped_expected": {"x1": 0, "y1": 0, "x2": 0, "y2": 0}, }, { "input_params": {"x1": 0.2, "x2": 0.3, "y1": 0.4, "y2": 0.8}, "cropped_expected": {"x1": 26, "y1": 51, "x2": 38, "y2": 102}, }, { "input_params": {"x1": 1.1, "x2": 1.3, "y1": 1.1, "y2": 1.5}, "cropped_expected": {"x1": 141, "y1": 141, "x2": 166, "y2": 192}, }, ] for rectangle_parameters in scenarios: with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Rectangle coordinates") rectangle = Rectangle(**rectangle_parameters.get("input_params")) expected_output = rectangle_parameters.get("cropped_expected") actual_cropped_image_array = rectangle.crop_numpy_array(numpy_image_array) expected_image_array = numpy_image_array[ expected_output.get("y1") : expected_output.get("y2"), expected_output.get("x1") : expected_output.get("x2"), ::, ] assert actual_cropped_image_array.shape[2] == 3 try: assert (expected_image_array == actual_cropped_image_array).all() except AttributeError: raise AssertionError("Unequal expected and cropped image arrays") @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_width(self): """ <b>Description:</b> Check Rectangle width method <b>Input data:</b> Instances of Rectangle class <b>Expected results:</b> Test passes if width method returns expected value of Rectangle width <b>Steps</b> 1. Check width method for Rectangle instances """ with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Rectangle coordinates") negative_x1_rectangle = Rectangle(x1=-0.3, y1=0.2, x2=0.7, y2=0.5) for rectangle, expected_width in [ (self.horizontal_rectangle(), 0.30000000000000004), (self.vertical_rectangle(), 0.19999999999999998), (self.square(), 0.19999999999999998), (negative_x1_rectangle, 1.0), ]: assert rectangle.width == expected_width @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_height(self): """ <b>Description:</b> Check Rectangle height method <b>Input data:</b> Instances of Rectangle class <b>Expected results:</b> Test passes if height method returns expected value of Rectangle height <b>Steps</b> 1. Check height method for Rectangle instances """ with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Rectangle coordinates") negative_y1_rectangle = Rectangle(x1=0.3, y1=-0.4, x2=0.7, y2=0.5) for rectangle, expected_height in [ (self.horizontal_rectangle(), 0.2), (self.vertical_rectangle(), 0.30000000000000004), (self.square(), 0.19999999999999998), (negative_y1_rectangle, 0.9), ]: assert rectangle.height == expected_height @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_diagonal(self): """ <b>Description:</b> Check Rectangle diagonal method <b>Input data:</b> Instances of Rectangle class <b>Expected results:</b> Test passes if diagonal method returns expected value of Rectangle diagonal <b>Steps</b> 1. Check diagonal method for Rectangle instance """ for rectangle, expected_diagonal in [ (self.horizontal_rectangle(), 0.360555127546399), (self.vertical_rectangle(), 0.3605551275463989), (self.square(), 0.282842712474619), ]: assert rectangle.diagonal == expected_diagonal @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_rectangle_get_area(self): """ <b>Description:</b> Check Rectangle get_area method <b>Input data:</b> Instances of Rectangle class <b>Expected results:</b> Test passes if get_area method returns expected value of Rectangle diagonal <b>Steps</b> 1. Check get_area method for Rectangle instance """ for rectangle, expected_area in [ (self.horizontal_rectangle(), 0.06000000000000001), (self.vertical_rectangle(), 0.060000000000000005), (self.square(), 0.039999999999999994), ]: assert rectangle.get_area() == expected_area
class TestResultset: creation_date = now() @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_resultset_purpose(self): """ <b>Description:</b> Check the ResultsetPurpose can correctly return the value <b>Input data:</b> Denotes, stages <b>Expected results:</b> Test passes if the results match """ denotes = ["EVALUATION", "TEST", "PREEVALUATION"] stages = ["Validation", "Test", "Pre-validation"] resultset_purpose = ResultsetPurpose assert len(resultset_purpose) == 3 for i in ResultsetPurpose: resultset_purpose = ResultsetPurpose(i) assert repr(resultset_purpose) == denotes[i.value] assert str(resultset_purpose) == stages[i.value] @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_resultset_entity(self): """ <b>Description:</b> Check the ResultSetEntity can correctly return the value <b>Input data:</b> Mock data <b>Expected results:</b> Test passes if incoming data is processed correctly <b>Steps</b> 1. Create dummy data 2. Check the processing of default values 3. Check the processing of changed values """ test_data = { "model": None, "ground_truth_dataset": None, "prediction_dataset": None, "purpose": None, "performance": None, "creation_date": None, "id": None, } result_set = ResultSetEntity(**test_data) for name, value in test_data.items(): set_attr_name = f"test_{name}" if name in [ "model", "ground_truth_dataset", "prediction_dataset", "purpose", ]: assert getattr(result_set, name) == value setattr(result_set, name, set_attr_name) assert getattr(result_set, name) == set_attr_name assert result_set.performance == NullPerformance() assert type(result_set.creation_date) == datetime.datetime assert result_set.id == ID() assert result_set.has_score_metric() is False result_set.performance = "test_performance" assert result_set.performance != NullPerformance() assert result_set.has_score_metric() is True creation_date = self.creation_date result_set.creation_date = creation_date assert result_set.creation_date == creation_date set_attr_id = ID(123456789) result_set.id = set_attr_id assert result_set.id == set_attr_id test_result_set_repr = [ f"model={result_set.model}", f"ground_truth_dataset={result_set.ground_truth_dataset}", f"prediction_dataset={result_set.prediction_dataset}", f"purpose={result_set.purpose}", f"performance={result_set.performance}", f"creation_date={result_set.creation_date}", f"id={result_set.id}", ] for i in test_result_set_repr: assert i in repr(result_set)
def __init__(self, name: str, date: Optional[datetime.datetime] = None): self.name = name if date is None: date = now() self.date = date
class TestEllipse: modification_date = now() def ellipse_params(self): ellipse_params = { "x1": 0.5, "x2": 1.0, "y1": 0.0, "y2": 0.5, "modification_date": self.modification_date, } return ellipse_params def ellipse(self): return Ellipse(**self.ellipse_params()) def width_gt_height_ellipse_params(self): width_gt_height_ellipse_params = { "x1": 0.5, "x2": 0.8, "y1": 0.1, "y2": 0.3, } return width_gt_height_ellipse_params @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_ellipse(self): """ <b>Description:</b> Check ellipse parameters <b>Input data:</b> Coordinates <b>Expected results:</b> Test passes if Ellipse correctly calculates parameters and returns default values <b>Steps</b> 1. Check ellipse params 2. Check ellipse default values 3. Check ellipse with incorrect coordinates """ ellipse = self.ellipse() modification_date = self.modification_date assert ellipse.width == 0.5 assert ellipse.height == 0.5 assert ellipse.x_center == 0.75 assert ellipse.y_center == 0.25 assert ellipse.minor_axis == 0.25 assert ellipse.major_axis == 0.25 assert ellipse._labels == [] assert ellipse.modification_date == modification_date incorrect_ellipse_params = { "x1": 0, "x2": 0, "y1": 0, "y2": 0, } with pytest.raises(ValueError): Ellipse(**incorrect_ellipse_params) width_lt_height_ellipse_params = { "x1": 0.4, "x2": 0.5, "y1": 0.3, "y2": 0.4, } width_lt_height_ellipse = Ellipse(**width_lt_height_ellipse_params) assert width_lt_height_ellipse.height > width_lt_height_ellipse.width assert width_lt_height_ellipse.major_axis == width_lt_height_ellipse.height / 2 assert width_lt_height_ellipse.width == 0.09999999999999998 assert width_lt_height_ellipse.height == 0.10000000000000003 assert width_lt_height_ellipse.x_center == 0.45 assert width_lt_height_ellipse.y_center == 0.35 assert width_lt_height_ellipse.minor_axis == 0.04999999999999999 assert width_lt_height_ellipse.major_axis == 0.05000000000000002 width_gt_height_ellipse = Ellipse( **self.width_gt_height_ellipse_params()) assert width_gt_height_ellipse.height < width_gt_height_ellipse.width assert width_gt_height_ellipse.minor_axis == width_gt_height_ellipse.height / 2 assert width_gt_height_ellipse.width == 0.30000000000000004 assert width_gt_height_ellipse.height == 0.19999999999999998 assert width_gt_height_ellipse.x_center == 0.65 assert width_gt_height_ellipse.y_center == 0.2 assert width_gt_height_ellipse.minor_axis == 0.09999999999999999 assert width_gt_height_ellipse.major_axis == 0.15000000000000002 @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_ellipse_magic_methods(self): """ <b>Description:</b> Check Ellipse __repr__, __eq__, __hash__ methods <b>Input data:</b> Initialized instance of Ellipse <b>Expected results:</b> Test passes if Ellipse magic methods returns correct values <b>Steps</b> 1. Initialize Ellipse instance 2. Check returning value of magic methods """ x1 = self.ellipse_params()["x1"] x2 = self.ellipse_params()["x2"] y1 = self.ellipse_params()["y1"] y2 = self.ellipse_params()["y2"] ellipse = self.ellipse() assert repr(ellipse) == f"Ellipse(x1={x1}, y1={y1}, x2={x2}, y2={y2})" other_ellipse_params = { "x1": 0.5, "x2": 1.0, "y1": 0.0, "y2": 0.5, "modification_date": self.modification_date, } third_ellipse_params = { "x1": 0.3, "y1": 0.5, "x2": 0.4, "y2": 0.6, "modification_date": self.modification_date, } other_ellipse = Ellipse(**other_ellipse_params) third_ellipse = Ellipse(**third_ellipse_params) assert ellipse == other_ellipse assert ellipse != third_ellipse assert ellipse != str assert hash(ellipse) == hash(str(ellipse)) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_ellipse_normalize_wrt_roi_shape(self): """ <b>Description:</b> Check Ellipse normalize_wrt_roi_shape methods <b>Input data:</b> Initialized instance of Ellipse Initialized instance of Rectangle <b>Expected results:</b> Test passes if Ellipse normalize_wrt_roi_shape returns correct values <b>Steps</b> 1. Initialize Ellipse instance 2. Check returning value """ ellipse = self.ellipse() roi = Rectangle(x1=0.0, x2=0.5, y1=0.0, y2=0.5) normalized = ellipse.normalize_wrt_roi_shape(roi) assert normalized.x1 == 0.25 assert normalized.y1 == 0.0 assert normalized.x2 == 0.5 assert normalized.y2 == 0.25 with pytest.raises(ValueError): ellipse.normalize_wrt_roi_shape("123") @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_ellipse_denormalize_wrt_roi_shape(self): """ <b>Description:</b> Check Ellipse denormalize_wrt_roi_shape methods <b>Input data:</b> Initialized instance of Ellipse Initialized instance of Rectangle <b>Expected results:</b> Test passes if Ellipse denormalize_wrt_roi_shape returns correct values <b>Steps</b> 1. Initialize Ellipse instance 2. Check returning value """ ellipse = self.ellipse() roi = Rectangle(x1=0.5, x2=1.0, y1=0.0, y2=1.0) denormalized = ellipse.denormalize_wrt_roi_shape(roi) assert denormalized.x1 == 0.0 assert denormalized.y1 == 0.0 assert denormalized.x2 == 1.0 assert denormalized.y2 == 0.5 with pytest.raises(ValueError): ellipse.denormalize_wrt_roi_shape("123") @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_ellipse_get_evenly_distributed_ellipse_coordinates(self): """ <b>Description:</b> Check Ellipse get_evenly_distributed_ellipse_coordinates methods <b>Input data:</b> Initialized instance of Ellipse <b>Expected results:</b> Test passes if Ellipse get_evenly_distributed_ellipse_coordinates returns correct values <b>Steps</b> 1. Initialize Ellipse instance 2. Check returning value """ ellipse = self.ellipse() number_of_coordinates = 3 coordinates_ellipse_line = ellipse.get_evenly_distributed_ellipse_coordinates( number_of_coordinates) assert len(coordinates_ellipse_line) == 3 assert coordinates_ellipse_line[0] == (1.0, 0.25) assert coordinates_ellipse_line[1] == (0.625, 0.4665063509461097) assert coordinates_ellipse_line[2] == (0.6249999999999999, 0.033493649053890406) width_gt_height_ellipse = Ellipse( **self.width_gt_height_ellipse_params()) coordinates_ellipse_line = ( width_gt_height_ellipse.get_evenly_distributed_ellipse_coordinates( number_of_coordinates)) assert width_gt_height_ellipse.height < width_gt_height_ellipse.width assert len(coordinates_ellipse_line) == 3 assert coordinates_ellipse_line[0] == (0.65, 0.3) assert coordinates_ellipse_line[1] == (0.7666223198362645, 0.1371094972158116) assert coordinates_ellipse_line[2] == (0.5333776801637811, 0.13710949721577403) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_ellipse__as_shapely_polygon(self): """ <b>Description:</b> Check Ellipse _as_shapely_polygon methods <b>Input data:</b> Initialized instance of Ellipse <b>Expected results:</b> Test passes if Ellipse _as_shapely_polygon returns correct values <b>Steps</b> 1. Initialize Ellipse instance 2. Check returning value """ ellipse = self.ellipse() shapely_polygon = ellipse._as_shapely_polygon() assert shapely_polygon.__class__ == Polygon assert shapely_polygon.area == 0.1958331774442254 @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_ellipse_get_area(self): """ <b>Description:</b> Check Ellipse get_area methods <b>Input data:</b> Initialized instance of Ellipse <b>Expected results:</b> Test passes if Ellipse get_area returns correct values <b>Steps</b> 1. Initialize Ellipse instance 2. Check returning value """ ellipse = self.ellipse() area = ellipse.get_area() assert area == 0.19634954084936207
class TestPolygon: modification_date = now() def points(self): point1 = Point(0.5, 0.0) point2 = Point(0.75, 0.2) point3 = Point(0.6, 0.1) return [point1, point2, point3] def other_points(self): point1 = Point(0.3, 0.1) point2 = Point(0.8, 0.3) point3 = Point(0.6, 0.2) return [point1, point2, point3] def polygon(self): return Polygon(self.points(), modification_date=self.modification_date) def other_polygon(self): return Polygon(self.other_points(), modification_date=self.modification_date) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_polygon(self): """ <b>Description:</b> Check Polygon parameters <b>Input data:</b> Points <b>Expected results:</b> Test passes if Polygon correctly calculates parameters and returns default values <b>Steps</b> 1. Check Polygon params 2. Check Polygon default values 3. Check Polygon with empty points """ polygon = self.polygon() modification_date = self.modification_date assert len(polygon.points) == 3 assert polygon.modification_date == modification_date assert polygon.points == self.points() empty_points_list = [] with pytest.raises(ValueError): Polygon(empty_points_list) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_polygon_magic_methods(self): """ <b>Description:</b> Check Polygon __repr__, __eq__, __hash__ methods <b>Input data:</b> Initialized instance of Polygon <b>Expected results:</b> Test passes if Polygon magic methods returns correct values <b>Steps</b> 1. Initialize Polygon instance 2. Check returning value of magic methods """ polygon = self.polygon() points_len = len(self.points()) min_x = min(self.points(), key=attrgetter("x")).x max_x = max(self.points(), key=attrgetter("x")).x min_y = min(self.points(), key=attrgetter("y")).y max_y = max(self.points(), key=attrgetter("y")).y assert f"Polygon(len(points)={points_len}, min_x={min_x}" in repr( polygon) assert f", max_x={max_x}, min_y={min_y}, max_y={max_y})" in repr( polygon) other_polygon = self.polygon() thirs_polygon = self.other_polygon() assert polygon == other_polygon assert polygon != thirs_polygon assert polygon != str assert hash(polygon) == hash(str(polygon)) @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_polygon_normalize_wrt_roi_shape(self): """ <b>Description:</b> Check Polygon normalize_wrt_roi_shape methods <b>Input data:</b> Initialized instance of Polygon Initialized instance of Rectangle <b>Expected results:</b> Test passes if Polygon normalize_wrt_roi_shape returns correct values <b>Steps</b> 1. Initialize Polygon instance 2. Check returning value """ polygon = self.polygon() roi = Rectangle(x1=0.0, x2=0.5, y1=0.0, y2=0.5) normalized = polygon.normalize_wrt_roi_shape(roi) assert len(normalized.points) == 3 assert normalized.min_x == 0.25 assert normalized.max_x == 0.375 assert normalized.min_y == 0.0 assert normalized.max_y == 0.1 with pytest.raises(ValueError): polygon.normalize_wrt_roi_shape("123") @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_polygon_denormalize_wrt_roi_shape(self): """ <b>Description:</b> Check Polygon denormalize_wrt_roi_shape methods <b>Input data:</b> Initialized instance of Polygon Initialized instance of Rectangle <b>Expected results:</b> Test passes if Polygon denormalize_wrt_roi_shape returns correct values <b>Steps</b> 1. Initialize Polygon instance 2. Check returning value """ polygon = self.polygon() roi = Rectangle(x1=0.5, x2=1.0, y1=0.0, y2=1.0) denormalized = polygon.denormalize_wrt_roi_shape(roi) assert len(denormalized.points) == 3 assert denormalized.min_x == 0.0 assert denormalized.max_x == 0.5 assert denormalized.min_y == 0.0 assert denormalized.max_y == 0.2 with pytest.raises(ValueError): polygon.denormalize_wrt_roi_shape("123") @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_polygon__as_shapely_polygon(self): """ <b>Description:</b> Check Polygon _as_shapely_polygon methods <b>Input data:</b> Initialized instance of Polygon <b>Expected results:</b> Test passes if Polygon _as_shapely_polygon returns correct values <b>Steps</b> 1. Initialize Polygon instance 2. Check returning value """ polygon = self.polygon() polygon2 = self.other_polygon() shapely_polygon = polygon._as_shapely_polygon() shapely_polygon2 = polygon2._as_shapely_polygon() assert shapely_polygon.area == 0.0025000000000000022 assert str( shapely_polygon) == "POLYGON ((0.5 0, 0.75 0.2, 0.6 0.1, 0.5 0))" assert shapely_polygon != shapely_polygon2 @pytest.mark.priority_medium @pytest.mark.component @pytest.mark.reqids(Requirements.REQ_1) def test_polygon_get_area(self): """ <b>Description:</b> Check Polygon get_area method <b>Input data:</b> Initialized instance of Polygon <b>Expected results:</b> Test passes if Polygon get_area returns correct values <b>Steps</b> 1. Initialize Polygon instance 2. Check returning value """ polygon = self.polygon() polygon2 = self.other_polygon() area = polygon.get_area() area2 = polygon2.get_area() assert area == 0.0025000000000000022 assert area != area2