def on_post(self, req: falcon.Request, resp: falcon.Response): source_value = req.get_param("source_value", required=True) source_type = req.get_param("source_type", required=True) target_value = req.get_param("target_value", required=True) target_type = req.get_param("target_type", required=True) auth = parse_auth(req) username = None if auth is None else auth.get_username() completed_at = datetime.datetime.utcnow() target_value_tag = get_tag(target_value) source_value_tag = get_tag(source_value) taxonomy_value = match_unprefixed_value(target_value_tag, target_type) query = LogoAnnotation.update( { LogoAnnotation.annotation_type: target_type, LogoAnnotation.annotation_value: target_value, LogoAnnotation.annotation_value_tag: target_value_tag, LogoAnnotation.taxonomy_value: taxonomy_value, LogoAnnotation.username: username, LogoAnnotation.completed_at: completed_at, } ).where( LogoAnnotation.annotation_type == source_type, LogoAnnotation.annotation_value_tag == source_value_tag, ) updated = query.execute() resp.media = {"updated": updated}
def search(self, req: falcon.Request, resp: falcon.Response): count: int = req.get_param_as_int( "count", min_value=1, max_value=2000, default=25 ) type_: Optional[str] = req.get_param("type") barcode: Optional[str] = req.get_param("barcode") value: Optional[str] = req.get_param("value") min_confidence: Optional[float] = req.get_param_as_float("min_confidence") random: bool = req.get_param_as_bool("random", default=False) server_domain: Optional[str] = req.get_param("server_domain") annotated: bool = req.get_param_as_bool("annotated", default=False) where_clauses = [LogoAnnotation.annotation_value.is_null(not annotated)] join_image_prediction = False join_image_model = False if server_domain: where_clauses.append(ImageModel.server_domain == server_domain) join_image_model = True if min_confidence is not None: where_clauses.append(ImagePrediction.max_confidence >= min_confidence) join_image_prediction = True if barcode is not None: where_clauses.append(ImageModel.barcode == barcode) join_image_model = True if type_ is not None: where_clauses.append(LogoAnnotation.annotation_type == type_) if value is not None: value_tag = get_tag(value) where_clauses.append(LogoAnnotation.annotation_value_tag == value_tag) query = LogoAnnotation.select() join_image_prediction = join_image_prediction or join_image_model if join_image_prediction: query = query.join(ImagePrediction) if join_image_model: query = query.join(ImageModel) if where_clauses: query = query.where(*where_clauses) query_count = query.count() if random: query = query.order_by(peewee.fn.Random()) query = query.limit(count) items = [item.to_dict() for item in query.iterator()] for item in items: image_prediction = item.pop("image_prediction") item["image"] = image_prediction["image"] resp.media = {"logos": items, "count": query_count}
def on_post(self, req: falcon.Request, resp: falcon.Response): server_domain = req.media.get("server_domain", settings.OFF_SERVER_DOMAIN) annotations = req.media["annotations"] auth = parse_auth(req) username = None if auth is None else auth.get_username() completed_at = datetime.datetime.utcnow() annotated_logos = [] for annotation in annotations: logo_id = annotation["logo_id"] type_ = annotation["type"] value = annotation["value"] or None logo = LogoAnnotation.get_by_id(logo_id) if value is not None: logo.annotation_value = value value_tag = get_tag(value) logo.annotation_value_tag = value_tag logo.taxonomy_value = match_unprefixed_value(value_tag, type_) logo.annotation_type = type_ logo.username = username logo.completed_at = completed_at logo.save() annotated_logos.append(logo) created = generate_insights_from_annotated_logos(annotated_logos, server_domain) resp.media = {"created insights": created}
def spellcheck( pattern: str, correction: str, country: str = "fr", dry: bool = False, ) -> None: from robotoff.cli.spellcheck import correct_ingredient from robotoff.off import OFFAuthentication from robotoff.utils import get_logger from robotoff.utils.text import get_tag username = typer.prompt("Username ?") password = typer.prompt("Password ?", hide_input=True) get_logger() ingredient = get_tag(pattern) comment = "Fixing '{}' typo".format(pattern) auth = OFFAuthentication(username=username, password=password) correct_ingredient(country, ingredient, pattern, correction, comment, dry_run=dry, auth=auth)
def find_packaging(content: Union[OCRResult, str]) -> List[RawInsight]: insights = [] text = get_text(content) if not text: return [] processor = KEYWORD_PROCESSOR_STORE.get() for (packaging_str, _), span_start, span_end in processor.extract_keywords( text, span_info=True ): packagings = packaging_str.split(";") for packaging in packagings: match_str = text[span_start:span_end] insights.append( RawInsight( type=InsightType.packaging, value_tag=get_tag(packaging), value=packaging, data={"text": match_str, "notify": False}, automatic_processing=True, ) ) return insights
def extract_brands_google_cloud_vision(ocr_result: OCRResult) -> List[RawInsight]: insights = [] for logo_annotation in ocr_result.logo_annotations: if logo_annotation.description in LOGO_ANNOTATION_BRANDS: brand = LOGO_ANNOTATION_BRANDS[logo_annotation.description] insights.append( RawInsight( type=InsightType.brand, value=brand, value_tag=get_tag(brand), automatic_processing=False, predictor="google-cloud-vision", data={"confidence": logo_annotation.score, "notify": False}, ) ) return insights
def spellcheck( pattern: str, correction: str, country: str, username: str, password: str, dry: bool, ): from robotoff.cli.spellcheck import correct_ingredient from robotoff.utils.text import get_tag from robotoff.utils import get_logger from robotoff.off import OFFAuthentication get_logger() ingredient = get_tag(pattern) comment = "Fixing '{}' typo".format(pattern) auth = OFFAuthentication(username=username, password=password) correct_ingredient(country, ingredient, pattern, correction, comment, dry_run=dry, auth=auth)
def on_put(self, req: falcon.Request, resp: falcon.Response, logo_id: int): logo = LogoAnnotation.get_or_none(id=logo_id) if logo is None: resp.status = falcon.HTTP_404 return type_ = req.media["type"] value = req.media["value"] or None updated = False if type_ != logo.annotation_type: logo.annotation_type = type_ updated = True if value != logo.annotation_value: logo.annotation_value = value if value is not None: value_tag = get_tag(value) logo.annotation_value_tag = value_tag logo.taxonomy_value = match_unprefixed_value(value_tag, type_) else: logo.annotation_value_tag = None logo.taxonomy_value = None updated = True if updated: auth = parse_auth(req) username = None if auth is None else auth.get_username() logo.username = username logo.completed_at = datetime.datetime.utcnow() logo.save() resp.status = falcon.HTTP_204
def test_get_tag(value: str, output: str): assert get_tag(value) == output