diff --git a/README.md b/README.md index dd4ff1d..8fec546 100644 --- a/README.md +++ b/README.md @@ -39,6 +39,7 @@ Additionally: ## Cloud providers - Google Lens: Google Vision in disguise (no need for API keys!), install with `pip install owocr[lens]` ("l" key) - Google Lens (web): alternative version of Lens (Google webpage version). Results should be the same but it's much slower. Install with `pip install owocr[lensweb]` ("k" key) +- Bing: Azure in disguise (no need for API keys!) ("b" key) - Google Vision: install with `pip install owocr[gvision]`, you also need a service account .json file named google_vision.json in `user directory/.config/` ("g" key) - Azure Image Analysis: install with `pip install owocr[azure]`, you also need to specify an api key and an endpoint in the config file ("v" key) - OCRSpace: you need to specify an api key in the config file ("o" key) @@ -49,6 +50,7 @@ This uses code from/references these projects: - Viola for working on the Google Lens implementation (twice!) and helping with the pyobjc VisionKit code! - [google-lens-ocr](https://github.com/dimdenGD/chrome-lens-ocr) for additional Lens reverse engineering and the headers/URL parameters I currently use - @ronaldoussoren for helping with the pyobjc VisionKit code +- @bropines for the Bing code ([Github issue](https://github.com/AuroraWright/owocr/issues/10)) - [Manga OCR](https://github.com/kha-white/manga-ocr) - [ocrmac](https://github.com/straussmaximilian/ocrmac) for the Apple Vision framework API - [NadeOCR](https://github.com/Natsume-197/NadeOCR) for the Google Vision API diff --git a/owocr/lens_betterproto.py b/owocr/lens_betterproto.py new file mode 100644 index 0000000..5419c19 --- /dev/null +++ b/owocr/lens_betterproto.py @@ -0,0 +1,1238 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# sources: lens_overlay_client_context.proto, lens_overlay_client_logs.proto, lens_overlay_client_platform.proto, lens_overlay_cluster_info.proto, lens_overlay_deep_gleam_data.proto, lens_overlay_document.proto, lens_overlay_filters.proto, lens_overlay_geometry.proto, lens_overlay_image_crop.proto, lens_overlay_image_data.proto, lens_overlay_interaction_request_metadata.proto, lens_overlay_knowledge_intent_query.proto, lens_overlay_knowledge_query.proto, lens_overlay_math_solver_query.proto, lens_overlay_message_set.proto, lens_overlay_overlay_object.proto, lens_overlay_payload.proto, lens_overlay_phase_latencies_metadata.proto, lens_overlay_platform.proto, lens_overlay_polygon.proto, lens_overlay_request_id.proto, lens_overlay_routing_info.proto, lens_overlay_selection_type.proto, lens_overlay_server.proto, lens_overlay_service_deps.proto, lens_overlay_stickiness_signals.proto, lens_overlay_surface.proto, lens_overlay_text.proto, lens_overlay_text_query.proto, lens_overlay_translate_stickiness_signals.proto, lens_overlay_video_context_input_params.proto, lens_overlay_video_params.proto, lens_overlay_visual_search_interaction_data.proto, lens_overlay_visual_search_interaction_log_data.proto +# plugin: python-betterproto +# This file has been @generated + +from dataclasses import dataclass +from typing import ( + List, + Optional, +) + +import betterproto + + +class LensOverlayFilterType(betterproto.Enum): + """Supported filter types.""" + + UNKNOWN_FILTER_TYPE = 0 + TRANSLATE = 2 + AUTO_FILTER = 7 + + +class Platform(betterproto.Enum): + UNSPECIFIED = 0 + WEB = 3 + + +class Surface(betterproto.Enum): + UNSPECIFIED = 0 + CHROMIUM = 4 + + +class LensRenderingEnvironment(betterproto.Enum): + """The possible rendering environments.""" + + RENDERING_ENV_UNSPECIFIED = 0 + RENDERING_ENV_LENS_OVERLAY = 14 + + +class LensOverlayPhaseLatenciesMetadataImageType(betterproto.Enum): + UNKNOWN = 0 + JPEG = 1 + PNG = 2 + WEBP = 3 + + +class LensOverlayClientLogsLensOverlayEntryPoint(betterproto.Enum): + UNKNOWN_ENTRY_POINT = 0 + APP_MENU = 1 + PAGE_CONTEXT_MENU = 2 + IMAGE_CONTEXT_MENU = 3 + OMNIBOX_BUTTON = 4 + TOOLBAR_BUTTON = 5 + FIND_IN_PAGE = 6 + + +class ClientPlatform(betterproto.Enum): + UNSPECIFIED = 0 + LENS_OVERLAY = 2 + + +class CoordinateType(betterproto.Enum): + """Specifies the coordinate system used for geometry protos.""" + + UNSPECIFIED = 0 + """Unspecified default value, per proto best practice.""" + + NORMALIZED = 1 + """Normalized coordinates.""" + + IMAGE = 2 + """Image pixel coordinates.""" + + +class PolygonVertexOrdering(betterproto.Enum): + """Specifies the vertex ordering.""" + + VERTEX_ORDERING_UNSPECIFIED = 0 + CLOCKWISE = 1 + COUNTER_CLOCKWISE = 2 + + +class WritingDirection(betterproto.Enum): + """The text reading order.""" + + LEFT_TO_RIGHT = 0 + RIGHT_TO_LEFT = 1 + TOP_TO_BOTTOM = 2 + + +class Alignment(betterproto.Enum): + """The text alignment.""" + + DEFAULT_LEFT_ALIGNED = 0 + RIGHT_ALIGNED = 1 + CENTER_ALIGNED = 2 + + +class TextLayoutWordType(betterproto.Enum): + TEXT = 0 + """Printed text.""" + + FORMULA = 1 + """Formula type, including mathematical or chemical formulas.""" + + +class TranslationDataStatusCode(betterproto.Enum): + UNKNOWN = 0 + SUCCESS = 1 + SERVER_ERROR = 2 + UNSUPPORTED_LANGUAGE_PAIR = 3 + SAME_LANGUAGE = 4 + UNKNOWN_SOURCE_LANGUAGE = 5 + INVALID_REQUEST = 6 + DEADLINE_EXCEEDED = 7 + EMPTY_TRANSLATION = 8 + NO_OP_TRANSLATION = 9 + + +class TranslationDataBackgroundImageDataFileFormat(betterproto.Enum): + """File format of the bytes in background_image.""" + + UNKNOWN = 0 + RAW_BYTES_RGBA = 1 + PNG_RGBA = 2 + WEBP_RGBA = 3 + JPEG_RGB_PNG_MASK = 4 + + +class LensOverlayInteractionRequestMetadataType(betterproto.Enum): + UNKNOWN = 0 + TAP = 1 + """User's tap on the screen.""" + + REGION = 2 + """User's region selection on the screenshot.""" + + TEXT_SELECTION = 3 + """User's text selection on the screenshot.""" + + REGION_SEARCH = 4 + """User selected a bounding box to region search.""" + + OBJECT_FULFILLMENT = 5 + """Requests selection and fulfillment of a specific object.""" + + CONTEXTUAL_SEARCH_QUERY = 9 + """User sent a query in the contextual search box.""" + + PDF_QUERY = 10 + """User sent a query about a pdf.""" + + WEBPAGE_QUERY = 11 + """User sent a query about a website.""" + + +class OverlayObjectRenderingMetadataRenderType(betterproto.Enum): + DEFAULT = 0 + GLEAM = 1 + + +class LensOverlaySelectionType(betterproto.Enum): + """Possible selection types for Lens overlay.""" + + UNKNOWN_SELECTION_TYPE = 0 + TAP_ON_EMPTY = 1 + SELECT_TEXT_HIGHLIGHT = 3 + REGION_SEARCH = 7 + INJECTED_IMAGE = 10 + TAP_ON_REGION_GLEAM = 15 + MULTIMODAL_SEARCH = 18 + SELECT_TRANSLATED_TEXT = 21 + TAP_ON_OBJECT = 22 + MULTIMODAL_SUGGEST_TYPEAHEAD = 25 + MULTIMODAL_SUGGEST_ZERO_PREFIX = 26 + TRANSLATE_CHIP = 52 + SYMBOLIC_MATH_OBJECT = 53 + + +class PayloadRequestType(betterproto.Enum): + """The type of the request the payload is sent in.""" + + REQUEST_TYPE_DEFAULT = 0 + """Unset Request type.""" + + REQUEST_TYPE_PDF = 1 + """Request is for PDF.""" + + REQUEST_TYPE_EARLY_PARTIAL_PDF = 3 + """Request is for partial PDF upload.""" + + REQUEST_TYPE_WEBPAGE = 2 + """Request is for webpage.""" + + +class PayloadCompressionType(betterproto.Enum): + """Possible compression types for content_data.""" + + UNCOMPRESSED = 0 + """Default value. File is not compressed.""" + + ZSTD = 1 + """ZSTD compression.""" + + +class LensOverlayServerErrorErrorType(betterproto.Enum): + UNKNOWN_TYPE = 0 + MISSING_REQUEST = 1 + + +class StickinessSignalsNamespace(betterproto.Enum): + UNKNOWN = 0 + TRANSLATE_LITE = 56 + EDUCATION_INPUT = 79 + + +@dataclass(eq=False, repr=False) +class AppliedFilter(betterproto.Message): + """Supported filter types.""" + + filter_type: "LensOverlayFilterType" = betterproto.enum_field(1) + translate: "AppliedFilterTranslate" = betterproto.message_field( + 3, group="filter_payload" + ) + + +@dataclass(eq=False, repr=False) +class AppliedFilterTranslate(betterproto.Message): + target_language: str = betterproto.string_field(1) + source_language: str = betterproto.string_field(2) + + +@dataclass(eq=False, repr=False) +class AppliedFilters(betterproto.Message): + """Supported filter types.""" + + filter: List["AppliedFilter"] = betterproto.message_field(1) + + +@dataclass(eq=False, repr=False) +class LensOverlayClientContext(betterproto.Message): + """Context information of the client sending the request.""" + + platform: "Platform" = betterproto.enum_field(1) + """Required. Client platform.""" + + surface: "Surface" = betterproto.enum_field(2) + """Optional. Client surface.""" + + locale_context: "LocaleContext" = betterproto.message_field(4) + """Required. Locale specific context.""" + + app_id: str = betterproto.string_field(6) + """ + Required. Name of the package which sends the request to Lens Frontend. + """ + + client_filters: "AppliedFilters" = betterproto.message_field(17) + """Filters that are enabled on the client side.""" + + rendering_context: "RenderingContext" = betterproto.message_field(20) + """The rendering context info.""" + + client_logging_data: "ClientLoggingData" = betterproto.message_field(23) + """Logging data.""" + + +@dataclass(eq=False, repr=False) +class LocaleContext(betterproto.Message): + """Describes locale context.""" + + language: str = betterproto.string_field(1) + """The BCP 47 language tag used to identify the language of the client.""" + + region: str = betterproto.string_field(2) + """The CLDR region tag used to identify the region of the client.""" + + time_zone: str = betterproto.string_field(3) + """The CLDR time zone ID used to identify the timezone of the client.""" + + +@dataclass(eq=False, repr=False) +class RenderingContext(betterproto.Message): + rendering_environment: "LensRenderingEnvironment" = betterproto.enum_field(2) + """The rendering environment.""" + + +@dataclass(eq=False, repr=False) +class ClientLoggingData(betterproto.Message): + """Contains data that can be used for logging purposes.""" + + is_history_eligible: bool = betterproto.bool_field(1) + """Whether history is enabled.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayPhaseLatenciesMetadata(betterproto.Message): + """Phase latency metadata for the Lens Overlay.""" + + phase: List["LensOverlayPhaseLatenciesMetadataPhase"] = betterproto.message_field(1) + + +@dataclass(eq=False, repr=False) +class LensOverlayPhaseLatenciesMetadataPhase(betterproto.Message): + """ + Represents a single point in time during the image preprocessing flow. + """ + + image_downscale_data: "LensOverlayPhaseLatenciesMetadataPhaseImageDownscaleData" = ( + betterproto.message_field(3, group="phase_data") + ) + """Data specifically only relevant for IMAGE_DOWNSCALE_END PhaseType.""" + + image_encode_data: "LensOverlayPhaseLatenciesMetadataPhaseImageEncodeData" = ( + betterproto.message_field(4, group="phase_data") + ) + """Data specifically only relevant for IMAGE_ENCODE_END PhaseType.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayPhaseLatenciesMetadataPhaseImageDownscaleData(betterproto.Message): + original_image_size: int = betterproto.int64_field(1) + """The size of the original image, in pixels.""" + + downscaled_image_size: int = betterproto.int64_field(2) + """The size of the downscaled image, in pixels.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayPhaseLatenciesMetadataPhaseImageEncodeData(betterproto.Message): + original_image_type: "LensOverlayPhaseLatenciesMetadataImageType" = ( + betterproto.enum_field(1) + ) + """ + The type of the original Image. This only applies to IMAGE_ENCODE_END + PhaseTypes + """ + + encoded_image_size_bytes: int = betterproto.int64_field(2) + """The bytes size of the encoded image.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayClientLogs(betterproto.Message): + phase_latencies_metadata: "LensOverlayPhaseLatenciesMetadata" = ( + betterproto.message_field(1) + ) + """ + The phase latency metadata for any image preprocessing required for the + request. + """ + + lens_overlay_entry_point: "LensOverlayClientLogsLensOverlayEntryPoint" = ( + betterproto.enum_field(2) + ) + """The Lens Overlay entry point used to access lens.""" + + paella_id: int = betterproto.uint64_field(3) + """ + A unique identifier for associating events logged by lens asynchronously. + """ + + metrics_collection_disabled: bool = betterproto.bool_field(5) + """Whether the user has disabled metrics collection.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayRoutingInfo(betterproto.Message): + """Information about where to route the request.""" + + server_address: str = betterproto.string_field(1) + """Address to route the request to.""" + + cell_address: str = betterproto.string_field(3) + """Cell to route the request to.""" + + blade_target: str = betterproto.string_field(2) + """Blade target to route the request to.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayClusterInfo(betterproto.Message): + """The cluster info for a Lens Overlay session.""" + + server_session_id: str = betterproto.string_field(1) + """ID for subsequent server requests.""" + + search_session_id: str = betterproto.string_field(2) + """ID for subsequent search requests.""" + + routing_info: "LensOverlayRoutingInfo" = betterproto.message_field(6) + """Info used for routing subsequent requests.""" + + +@dataclass(eq=False, repr=False) +class Polygon(betterproto.Message): + """Information about a polygon.""" + + vertex: List["PolygonVertex"] = betterproto.message_field(1) + vertex_ordering: "PolygonVertexOrdering" = betterproto.enum_field(2) + coordinate_type: "CoordinateType" = betterproto.enum_field(3) + """Specifies the coordinate type of vertices.""" + + +@dataclass(eq=False, repr=False) +class PolygonVertex(betterproto.Message): + """Represents a single vertex in the polygon.""" + + x: float = betterproto.float_field(1) + y: float = betterproto.float_field(2) + + +@dataclass(eq=False, repr=False) +class CenterRotatedBox(betterproto.Message): + """Information about a center bounding box rotated around its center.""" + + center_x: float = betterproto.float_field(1) + center_y: float = betterproto.float_field(2) + width: float = betterproto.float_field(3) + height: float = betterproto.float_field(4) + rotation_z: float = betterproto.float_field(5) + """ + Clockwise rotation around the center in radians. The rotation angle is + computed before normalizing the coordinates. + """ + + coordinate_type: "CoordinateType" = betterproto.enum_field(6) + """ + Specifies the coordinate type of center and size. + @note default is COORDINATE_TYPE_UNSPECIFIED, please initialize this value + to NORMALIZED or IMAGE for Lens detection API usage. + """ + + +@dataclass(eq=False, repr=False) +class Geometry(betterproto.Message): + """Geometric shape(s) used for tracking and detection.""" + + bounding_box: "CenterRotatedBox" = betterproto.message_field(1) + """Specifies the bounding box for this geometry.""" + + segmentation_polygon: List["Polygon"] = betterproto.message_field(5) + """ + Specifies the segmentation polygon. The vertices of the outer-boundaries + are in clockwise, and the ones of inner-boundaries are in counter-clockwise + ordering. + """ + + +@dataclass(eq=False, repr=False) +class ZoomedCrop(betterproto.Message): + """ + A cropped and potentially re-scaled image region, rectangular subregion of a + canonical image. + """ + + crop: "CenterRotatedBox" = betterproto.message_field(1) + """The cropped region of the parent image in parent coordinates.""" + + parent_width: int = betterproto.int32_field(2) + """Width of the parent image.""" + + parent_height: int = betterproto.int32_field(3) + """Height of the parent image.""" + + zoom: float = betterproto.float_field(4) + """ + The ratio of the pixel dimensions of the child image to the pixel + dimensions of the 'crop' in parent coordinates. + """ + + +@dataclass(eq=False, repr=False) +class Text(betterproto.Message): + text_layout: "TextLayout" = betterproto.message_field(1) + """Optional. Information describing the text.""" + + content_language: str = betterproto.string_field(2) + """ + Optional. Dominant content language of the text. Language + code is CLDR/BCP-47. + """ + + +@dataclass(eq=False, repr=False) +class TextLayout(betterproto.Message): + """Nested text structure.""" + + paragraphs: List["TextLayoutParagraph"] = betterproto.message_field(1) + """Optional. List of paragraphs in natural reading order.""" + + +@dataclass(eq=False, repr=False) +class TextLayoutWord(betterproto.Message): + id: "TextEntityIdentifier" = betterproto.message_field(1) + """Required. Unique id within TextLayout.""" + + plain_text: str = betterproto.string_field(2) + """Optional. The text in a plain text.""" + + text_separator: Optional[str] = betterproto.string_field(3, optional=True) + """ + Optional. The text separator that should be appended after this word when + it is concatenated with the subsequent word in the same or next + line/paragraph into a single-line string. This is specified as optional + because there is a distinction between the absence of a separator and + the empty string as a separator. + """ + + geometry: "Geometry" = betterproto.message_field(4) + """Optional. The geometry of the word.""" + + type: "TextLayoutWordType" = betterproto.enum_field(5) + """Optional. The type of this word.""" + + formula_metadata: "TextLayoutWordFormulaMetadata" = betterproto.message_field(6) + """ + Optional. Metadata for formulas. This is populated for entities of + `type=FORMULA`. + """ + + +@dataclass(eq=False, repr=False) +class TextLayoutWordFormulaMetadata(betterproto.Message): + latex: str = betterproto.string_field(1) + """ + Optional. LaTeX representation of a formula. Can be the same as + `plain_text`. Example: "\frac{2}{x}=y". The plain text + representation of this is available in Word.plain_text. + """ + + +@dataclass(eq=False, repr=False) +class TextLayoutLine(betterproto.Message): + words: List["TextLayoutWord"] = betterproto.message_field(1) + """Optional. List of words in natural reading order.""" + + geometry: "Geometry" = betterproto.message_field(2) + """Optional. The geometry of the line.""" + + +@dataclass(eq=False, repr=False) +class TextLayoutParagraph(betterproto.Message): + id: "TextEntityIdentifier" = betterproto.message_field(1) + """Required. Unique id within TextLayout.""" + + lines: List["TextLayoutLine"] = betterproto.message_field(2) + """ + Optional. List of lines in natural reading order (see also + `writing_direction`). + """ + + geometry: "Geometry" = betterproto.message_field(3) + """Optional. Geometry of the paragraph.""" + + writing_direction: "WritingDirection" = betterproto.enum_field(4) + """Optional. The text writing direction (aka reading order).""" + + content_language: str = betterproto.string_field(5) + """ + Optional. BCP-47 language code of the dominant language in this + paragraph. + """ + + +@dataclass(eq=False, repr=False) +class TextEntityIdentifier(betterproto.Message): + id: int = betterproto.int64_field(1) + """ + Required. Unique entity id used to reference (and match) text entities and + ranges. + """ + + +@dataclass(eq=False, repr=False) +class DeepGleamData(betterproto.Message): + translation: "TranslationData" = betterproto.message_field( + 10, group="rendering_oneof" + ) + visual_object_id: List[str] = betterproto.string_field(11) + + +@dataclass(eq=False, repr=False) +class TranslationData(betterproto.Message): + status: "TranslationDataStatus" = betterproto.message_field(1) + target_language: str = betterproto.string_field(2) + source_language: str = betterproto.string_field(3) + translation: str = betterproto.string_field(4) + """The translated text.""" + + line: List["TranslationDataLine"] = betterproto.message_field(5) + writing_direction: "WritingDirection" = betterproto.enum_field(7) + """The original writing direction of the source text.""" + + alignment: "Alignment" = betterproto.enum_field(8) + justified: bool = betterproto.bool_field(9) + """Whether the text is justified.""" + + +@dataclass(eq=False, repr=False) +class TranslationDataStatus(betterproto.Message): + code: "TranslationDataStatusCode" = betterproto.enum_field(1) + + +@dataclass(eq=False, repr=False) +class TranslationDataTextStyle(betterproto.Message): + """ + Style as the aggregation of the styles of the words in the original text. + """ + + text_color: int = betterproto.uint32_field(1) + """The foreground color of text in aRGB format.""" + + background_primary_color: int = betterproto.uint32_field(2) + """The background color of text in aRGB format.""" + + +@dataclass(eq=False, repr=False) +class TranslationDataBackgroundImageData(betterproto.Message): + """Properties of the image used to inpaint the source text.""" + + background_image: bytes = betterproto.bytes_field(1) + """ + Image bytes to inpaint the source text. Contains image bytes in the + format specified in file_format. + """ + + image_width: int = betterproto.int32_field(2) + """Width of background_image in pixels.""" + + image_height: int = betterproto.int32_field(3) + """Height of background_image in pixels.""" + + vertical_padding: float = betterproto.float_field(4) + """ + Vertical padding to apply to the text box before drawing the background + image. Expressed as a fraction of the text box height, i.e. 1.0 means + that the height should be doubled. Half of the padding should be added on + the top and half on the bottom. + """ + + horizontal_padding: float = betterproto.float_field(5) + """ + Horizontal padding to apply to the text box before drawing the background + image. Expressed as a fraction of the text box height. Half of the + padding should be added on the left and half on the right. + """ + + file_format: "TranslationDataBackgroundImageDataFileFormat" = ( + betterproto.enum_field(6) + ) + text_mask: bytes = betterproto.bytes_field(7) + """Text mask for the generated background image.""" + + +@dataclass(eq=False, repr=False) +class TranslationDataLine(betterproto.Message): + start: int = betterproto.int32_field(1) + """ + A substring from the translation from start to end (exclusive), + that needs to be distributed on this line, measured in Unicode + characters. If not set, the Line doesn't have any translation. + """ + + end: int = betterproto.int32_field(2) + style: "TranslationDataTextStyle" = betterproto.message_field(3) + word: List["TranslationDataLineWord"] = betterproto.message_field(5) + background_image_data: "TranslationDataBackgroundImageData" = ( + betterproto.message_field(9) + ) + """Background image data is set only when inpainting is computed.""" + + +@dataclass(eq=False, repr=False) +class TranslationDataLineWord(betterproto.Message): + start: int = betterproto.int32_field(1) + """ + A substring from the translation from start to end (exclusive), + representing a word (without separator), measured in Unicode + characters. + """ + + end: int = betterproto.int32_field(2) + + +@dataclass(eq=False, repr=False) +class LensOverlayDocument(betterproto.Message): + """ + Top-level PDF representation extracted using Pdfium. + Next ID: 6 + """ + + pages: List["Page"] = betterproto.message_field(1) + """Ordered pdf pages.""" + + +@dataclass(eq=False, repr=False) +class Page(betterproto.Message): + """ + Represents a single page of the PDF. + Next ID: 10 + """ + + page_number: int = betterproto.int32_field(1) + """Page number in the pdf (indexed starting at 1).""" + + text_segments: List[str] = betterproto.string_field(4) + """List of text segments of the page.""" + + +@dataclass(eq=False, repr=False) +class ClientImage(betterproto.Message): + """Image data from the client.""" + + image_content: bytes = betterproto.bytes_field(1) + """Required. A byte array encoding an image.""" + + +@dataclass(eq=False, repr=False) +class ImageCrop(betterproto.Message): + """User-selected / auto-detected cropped image region.""" + + crop_id: str = betterproto.string_field(1) + """The ID of the cropped image region.""" + + image: "ClientImage" = betterproto.message_field(2) + """The image content of the cropped image region.""" + + zoomed_crop: "ZoomedCrop" = betterproto.message_field(3) + """The zoomed crop properties of the cropped image region.""" + + +@dataclass(eq=False, repr=False) +class ImageData(betterproto.Message): + """ + Data representing image. Contains image bytes or image retrieval identifier. + """ + + payload: "ImagePayload" = betterproto.message_field(1) + """Image payload to process. This contains image bytes.""" + + image_metadata: "ImageMetadata" = betterproto.message_field(3) + """Required. Context of the given image.""" + + significant_regions: List["Geometry"] = betterproto.message_field(4) + """The bounds of significant regions in the image.""" + + +@dataclass(eq=False, repr=False) +class ImagePayload(betterproto.Message): + image_bytes: bytes = betterproto.bytes_field(1) + """Required. Image byte array.""" + + +@dataclass(eq=False, repr=False) +class ImageMetadata(betterproto.Message): + width: int = betterproto.int32_field(1) + """ + Required. Image width in pixels. Should reflect the actual size of + image_bytes. + """ + + height: int = betterproto.int32_field(2) + """ + Required. Image height in pixels. Should reflect the actual size of + image_bytes. + """ + + +@dataclass(eq=False, repr=False) +class TextQuery(betterproto.Message): + """Contains an unstructured text query to add to an image query.""" + + query: str = betterproto.string_field(1) + """The unstructured text query, such as "blue" or "blouse".""" + + is_primary: bool = betterproto.bool_field(2) + + +@dataclass(eq=False, repr=False) +class LensOverlayInteractionRequestMetadata(betterproto.Message): + """Metadata associated with an interaction request.""" + + type: "LensOverlayInteractionRequestMetadataType" = betterproto.enum_field(1) + selection_metadata: "LensOverlayInteractionRequestMetadataSelectionMetadata" = ( + betterproto.message_field(2) + ) + query_metadata: "LensOverlayInteractionRequestMetadataQueryMetadata" = ( + betterproto.message_field(4) + ) + + +@dataclass(eq=False, repr=False) +class LensOverlayInteractionRequestMetadataSelectionMetadata(betterproto.Message): + """ + Metadata related to the selection associated with this interaction request. + """ + + point: "LensOverlayInteractionRequestMetadataSelectionMetadataPoint" = ( + betterproto.message_field(1, group="selection") + ) + region: "LensOverlayInteractionRequestMetadataSelectionMetadataRegion" = ( + betterproto.message_field(2, group="selection") + ) + object: "LensOverlayInteractionRequestMetadataSelectionMetadataObject" = ( + betterproto.message_field(3, group="selection") + ) + + +@dataclass(eq=False, repr=False) +class LensOverlayInteractionRequestMetadataSelectionMetadataPoint(betterproto.Message): + x: float = betterproto.float_field(1) + y: float = betterproto.float_field(2) + + +@dataclass(eq=False, repr=False) +class LensOverlayInteractionRequestMetadataSelectionMetadataRegion(betterproto.Message): + region: "CenterRotatedBox" = betterproto.message_field(1) + + +@dataclass(eq=False, repr=False) +class LensOverlayInteractionRequestMetadataSelectionMetadataObject(betterproto.Message): + object_id: str = betterproto.string_field(1) + geometry: "Geometry" = betterproto.message_field(2) + + +@dataclass(eq=False, repr=False) +class LensOverlayInteractionRequestMetadataQueryMetadata(betterproto.Message): + """Metadata related to query.""" + + text_query: "TextQuery" = betterproto.message_field(2) + """The text query information.""" + + +@dataclass(eq=False, repr=False) +class TranslateStickinessSignals(betterproto.Message): + """ + Signals specific to queries coming from translate stickiness extension. + """ + + translate_suppress_echo_for_sticky: bool = betterproto.bool_field(1) + + +@dataclass(eq=False, repr=False) +class FunctionCall(betterproto.Message): + """A message representing the function call of an answers intent query.""" + + name: str = betterproto.string_field(1) + """Name of this function call.""" + + argument: List["Argument"] = betterproto.message_field(2) + """A list of arguments of this function call.""" + + signals: "FunctionCallSignals" = betterproto.message_field(4) + """Signals at the function call level""" + + +@dataclass(eq=False, repr=False) +class FunctionCallSignals(betterproto.Message): + """Signals at the function call level""" + + translate_stickiness_signals: "TranslateStickinessSignals" = ( + betterproto.message_field(311378150) + ) + + +@dataclass(eq=False, repr=False) +class Argument(betterproto.Message): + """A message representing the function argument.""" + + name: str = betterproto.string_field(1) + """Name of this argument.""" + + value: "ArgumentValue" = betterproto.message_field(2) + """The value of this argument.""" + + +@dataclass(eq=False, repr=False) +class ArgumentValue(betterproto.Message): + """A message representing the value of an argument.""" + + simple_value: "SimpleValue" = betterproto.message_field(3, group="value") + + +@dataclass(eq=False, repr=False) +class SimpleValue(betterproto.Message): + """A message representing a simple literal value.""" + + string_value: str = betterproto.string_field(1, group="value") + + +@dataclass(eq=False, repr=False) +class Query(betterproto.Message): + """A Query is a representation of the meaning of the user query.""" + + intent_query: "FunctionCall" = betterproto.message_field(56249026) + + +@dataclass(eq=False, repr=False) +class MathSolverQuery(betterproto.Message): + math_input_equation: str = betterproto.string_field(3) + + +@dataclass(eq=False, repr=False) +class MessageSet(betterproto.Message): + """This is proto2's version of MessageSet.""" + + message_set_extension: "Query" = betterproto.message_field(41401449) + + +@dataclass(eq=False, repr=False) +class OverlayObject(betterproto.Message): + """Overlay Object.""" + + id: str = betterproto.string_field(1) + """The id.""" + + geometry: "Geometry" = betterproto.message_field(2) + """The object geometry.""" + + rendering_metadata: "OverlayObjectRenderingMetadata" = betterproto.message_field(8) + """The rendering metadata for the object.""" + + interaction_properties: "OverlayObjectInteractionProperties" = ( + betterproto.message_field(4) + ) + is_fulfilled: bool = betterproto.bool_field(9) + """ + Indicates to the client that this object is eligible to be an object + fulfillment request. + """ + + +@dataclass(eq=False, repr=False) +class OverlayObjectRenderingMetadata(betterproto.Message): + """Rendering metadata for the object.""" + + render_type: "OverlayObjectRenderingMetadataRenderType" = betterproto.enum_field(1) + + +@dataclass(eq=False, repr=False) +class OverlayObjectInteractionProperties(betterproto.Message): + select_on_tap: bool = betterproto.bool_field(1) + """Whether an object can be tapped""" + + +@dataclass(eq=False, repr=False) +class LensOverlayRequestId(betterproto.Message): + """ + Request Id definition to support request sequencing and state lookup. + """ + + uuid: int = betterproto.uint64_field(1) + """A unique identifier for a sequence of related Lens requests.""" + + sequence_id: int = betterproto.int32_field(2) + """ + An id to indicate the order of the current request within a sequence of + requests sharing the same uuid. Starts from 1, increments by 1 if there is + a new request with the same uuid. + """ + + image_sequence_id: int = betterproto.int32_field(3) + """ + An id to indicate the order of image payload sent within a sequence of + requests sharing the same uuid. Starts from 1, increments by 1 if there is + a new request with an image payload with the same uuid. + Note, region search request does not increment this id. + """ + + analytics_id: bytes = betterproto.bytes_field(4) + """ + Analytics ID for the Lens request. Will be updated on the initial request + and once per interaction request. + """ + + routing_info: "LensOverlayRoutingInfo" = betterproto.message_field(6) + """Information about where to route the request.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayRequestContext(betterproto.Message): + """Request context for a Lens Overlay request.""" + + request_id: "LensOverlayRequestId" = betterproto.message_field(3) + """Required. Identifiers for this request.""" + + client_context: "LensOverlayClientContext" = betterproto.message_field(4) + """The client context for the request.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayObjectsRequest(betterproto.Message): + request_context: "LensOverlayRequestContext" = betterproto.message_field(1) + """Required. Basic information and context for the request.""" + + image_data: "ImageData" = betterproto.message_field(3) + """Required. Image Data to process.""" + + payload: "Payload" = betterproto.message_field(4) + """ + Optional. Data payload of the request. + TODO(b/359638436): Mark required when clients have migrated to use Payload + field. + """ + + +@dataclass(eq=False, repr=False) +class LensOverlayObjectsResponse(betterproto.Message): + overlay_objects: List["OverlayObject"] = betterproto.message_field(2) + """Overlay objects.""" + + text: "Text" = betterproto.message_field(3) + """Text.""" + + deep_gleams: List["DeepGleamData"] = betterproto.message_field(4) + """Gleams.""" + + cluster_info: "LensOverlayClusterInfo" = betterproto.message_field(7) + """The cluster info.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayInteractionRequest(betterproto.Message): + request_context: "LensOverlayRequestContext" = betterproto.message_field(1) + """Basic information and context for the request.""" + + interaction_request_metadata: "LensOverlayInteractionRequestMetadata" = ( + betterproto.message_field(2) + ) + """Metadata associated with an interaction request.""" + + image_crop: "ImageCrop" = betterproto.message_field(3) + """The image crop data.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayInteractionResponse(betterproto.Message): + encoded_response: str = betterproto.string_field(3) + + +@dataclass(eq=False, repr=False) +class Payload(betterproto.Message): + """Next ID: 9""" + + request_type: "PayloadRequestType" = betterproto.enum_field(6) + """Optional. The type of the request.""" + + image_data: "ImageData" = betterproto.message_field(2) + """ + Currently unset, use image_data in ObjectsRequest. + TODO(b/359638436): Move ObjectsRequest clients onto Payload.ImageData. + """ + + content_data: bytes = betterproto.bytes_field(3) + """ + Data for non-image payloads. May be sent with or without an image in the + image_data field. If content_data is set, content_type must also be set. + """ + + content_type: str = betterproto.string_field(4) + """ + The media type/MIME type of the data represented i content_data, e.g. + "application/pdf". If content_type is set, content_data should also be set. + """ + + page_url: str = betterproto.string_field(5) + """The page url this request was made on.""" + + partial_pdf_document: "LensOverlayDocument" = betterproto.message_field(7) + """ + The partially parsed PDF document. Used to get early suggest signals. This + is only set for REQUEST_TYPE_EARLY_PARTIAL_PDF. + """ + + compression_type: "PayloadCompressionType" = betterproto.enum_field(8) + """ + Compression format of content_data. Currently only used for PDF data. + """ + + +@dataclass(eq=False, repr=False) +class LensOverlayServerClusterInfoRequest(betterproto.Message): + """The cluster info request for a Lens Overlay session.""" + + enable_search_session_id: bool = betterproto.bool_field(1) + """ + Whether to return a search session id alongside the server session id. + """ + + +@dataclass(eq=False, repr=False) +class LensOverlayServerClusterInfoResponse(betterproto.Message): + server_session_id: str = betterproto.string_field(1) + """ID for subsequent server requests.""" + + search_session_id: str = betterproto.string_field(2) + """ID for subsequent search requests.""" + + routing_info: "LensOverlayRoutingInfo" = betterproto.message_field(3) + """The routing info for the server session.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayServerError(betterproto.Message): + """ + An error encountered while handling a request. + Next ID: 2 + """ + + error_type: "LensOverlayServerErrorErrorType" = betterproto.enum_field(1) + """The error type.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayServerRequest(betterproto.Message): + """Next ID: 4""" + + objects_request: "LensOverlayObjectsRequest" = betterproto.message_field(1) + """Options for fetching objects.""" + + interaction_request: "LensOverlayInteractionRequest" = betterproto.message_field(2) + """Options for fetching interactions.""" + + client_logs: "LensOverlayClientLogs" = betterproto.message_field(3) + """Client logs for the request.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayServerResponse(betterproto.Message): + """ + Response details for an LensOverlay request. + Next ID: 4 + """ + + error: "LensOverlayServerError" = betterproto.message_field(1) + """The encountered error.""" + + objects_response: "LensOverlayObjectsResponse" = betterproto.message_field(2) + """The objects response.""" + + interaction_response: "LensOverlayInteractionResponse" = betterproto.message_field( + 3 + ) + """The interaction response.""" + + +@dataclass(eq=False, repr=False) +class StickinessSignals(betterproto.Message): + id_namespace: "StickinessSignalsNamespace" = betterproto.enum_field(1) + interpretation: "MessageSet" = betterproto.message_field(28) + education_input_extension: "EducationInputExtension" = betterproto.message_field( + 121 + ) + + +@dataclass(eq=False, repr=False) +class EducationInputExtension(betterproto.Message): + math_solver_query: "MathSolverQuery" = betterproto.message_field(1) + + +@dataclass(eq=False, repr=False) +class LensOverlayVideoContextInputParams(betterproto.Message): + url: str = betterproto.string_field(1) + """Url of the video.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayVideoParams(betterproto.Message): + video_context_input_params: "LensOverlayVideoContextInputParams" = ( + betterproto.message_field(1) + ) + """Video context params from input.""" + + +@dataclass(eq=False, repr=False) +class LensOverlayVisualSearchInteractionLogData(betterproto.Message): + """Log data for a Lens Overlay visual search interaction.""" + + filter_data: "FilterData" = betterproto.message_field(1) + """Filter related metadata.""" + + user_selection_data: "UserSelectionData" = betterproto.message_field(2) + """User Selection metadata.""" + + is_parent_query: bool = betterproto.bool_field(3) + """Whether the query is a parent query.""" + + client_platform: "ClientPlatform" = betterproto.enum_field(4) + """The client platform this query was originated from.""" + + +@dataclass(eq=False, repr=False) +class FilterData(betterproto.Message): + """ + Filter data. + Next ID: 2 + """ + + filter_type: "LensOverlayFilterType" = betterproto.enum_field(1) + """ + The filter type associated with this interaction (auto, translate, etc.). + """ + + +@dataclass(eq=False, repr=False) +class UserSelectionData(betterproto.Message): + """ + User selection data. + Next ID: 2 + """ + + selection_type: "LensOverlaySelectionType" = betterproto.enum_field(1) + """ + The selection type associated with this interaction (e.g. region search). + """ + + +@dataclass(eq=False, repr=False) +class LensOverlayVisualSearchInteractionData(betterproto.Message): + """Metadata associated with a Lens Visual Search request.""" + + interaction_type: "LensOverlayInteractionRequestMetadataType" = ( + betterproto.enum_field(1) + ) + """The type of interaction.""" + + zoomed_crop: "ZoomedCrop" = betterproto.message_field(7) + """The selected region for this interaction, instead of the object id.""" + + object_id: str = betterproto.string_field(3) + """ + The selected object id for this interaction, instead of the zoomed crop. + Currently unsupported and should not be populated. + """ + + log_data: "LensOverlayVisualSearchInteractionLogData" = betterproto.message_field(5) + """Logging-specific data.""" diff --git a/owocr/ocr.py b/owocr/ocr.py index f82ef82..7b2eaa4 100644 --- a/owocr/ocr.py +++ b/owocr/ocr.py @@ -6,6 +6,8 @@ import sys import platform import logging from math import sqrt +import base64 +from urllib.parse import urlparse, parse_qs import jaconv import numpy as np @@ -63,11 +65,8 @@ except ImportError: pass try: - from google.protobuf.json_format import MessageToDict - from .py_lens.lens_overlay_server_pb2 import LensOverlayServerRequest, LensOverlayServerResponse - from .py_lens.lens_overlay_platform_pb2 import PLATFORM_WEB - from .py_lens.lens_overlay_surface_pb2 import SURFACE_CHROMIUM - from .py_lens.lens_overlay_filters_pb2 import AUTO_FILTER + import betterproto + from .lens_betterproto import * import random except ImportError: pass @@ -189,10 +188,8 @@ class GoogleLens: available = False def __init__(self): - if 'google.protobuf' not in sys.modules: - logger.warning('protobuf not available, Google Lens will not work!') - elif 'requests' not in sys.modules: - logger.warning('requests not available, Google Lens will not work!') + if 'betterproto' not in sys.modules: + logger.warning('betterproto not available, Google Lens will not work!') else: self.available = True logger.info('Google Lens ready') @@ -211,10 +208,10 @@ class GoogleLens: request.objects_request.request_context.request_id.sequence_id = 0 request.objects_request.request_context.request_id.image_sequence_id = 0 request.objects_request.request_context.request_id.analytics_id = random.randbytes(16) - request.objects_request.request_context.request_id.routing_info.Clear() + request.objects_request.request_context.request_id.routing_info = LensOverlayRoutingInfo() - request.objects_request.request_context.client_context.platform = PLATFORM_WEB - request.objects_request.request_context.client_context.surface = SURFACE_CHROMIUM + request.objects_request.request_context.client_context.platform = Platform.WEB + request.objects_request.request_context.client_context.surface = Surface.CHROMIUM request.objects_request.request_context.client_context.locale_context.language = 'ja' request.objects_request.request_context.client_context.locale_context.region = 'Asia/Tokyo' @@ -222,8 +219,9 @@ class GoogleLens: request.objects_request.request_context.client_context.app_id = '' # not set by chromium - filter = request.objects_request.request_context.client_context.client_filters.filter.add() - filter.filter_type = AUTO_FILTER + filter = AppliedFilter() + filter.filter_type = LensOverlayFilterType.AUTO_FILTER + request.objects_request.request_context.client_context.client_filters.filter.append(filter) image_data = self._preprocess(img) request.objects_request.image_data.payload.image_bytes = image_data[0] @@ -255,9 +253,8 @@ class GoogleLens: if res.status_code != 200: return (False, 'Unknown error!') - response_proto = LensOverlayServerResponse() - response_proto.ParseFromString(res.content) - response_dict = MessageToDict(response_proto, preserving_proto_field_name=True) + response_proto = LensOverlayServerResponse().FromString(res.content) + response_dict = response_proto.to_dict(betterproto.Casing.SNAKE) res = '' text = response_dict['objects_response']['text']['text_layout']['paragraphs'] @@ -288,8 +285,6 @@ class GoogleLensWeb: def __init__(self): if 'pyjson5' not in sys.modules: logger.warning('pyjson5 not available, Google Lens (web) will not work!') - elif 'requests' not in sys.modules: - logger.warning('requests not available, Google Lens (web) will not work!') else: self.regex = re.compile(r'(\w+)=([^&]+)') self.requests_session = requests.Session() @@ -372,6 +367,119 @@ class GoogleLensWeb: return pil_image_to_bytes(img) +class Bing: + name = 'bing' + readable_name = 'Bing' + key = 'b' + available = False + + def __init__(self): + self.requests_session = requests.Session() + self.available = True + logger.info('Bing ready') + + def __call__(self, img_or_path): + if isinstance(img_or_path, str) or isinstance(img_or_path, Path): + img = Image.open(img_or_path) + elif isinstance(img_or_path, Image.Image): + img = img_or_path + else: + raise ValueError(f'img_or_path must be a path or PIL.Image, instead got: {img_or_path}') + + upload_url = 'https://www.bing.com/images/search?view=detailv2&iss=sbiupload' + upload_headers = { + 'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7', + 'accept-language': 'ja-JP;q=0.6,ja;q=0.5', + 'cache-control': 'max-age=0', + 'origin': 'https://www.bing.com', + 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:136.0) Gecko/20100101 Firefox/136.0', + } + files = { + 'imgurl': (None, ''), + 'cbir': (None, 'sbi'), + 'imageBin': (None, self._preprocess(img)) + } + + try: + res = self.requests_session.post(upload_url, headers=upload_headers, files=files, timeout=20, allow_redirects=False) + except requests.exceptions.Timeout: + return (False, 'Request timeout!') + except requests.exceptions.ConnectionError: + return (False, 'Connection error!') + + if res.status_code != 302: + return (False, 'Unknown error!') + + redirect_url = res.headers.get('Location') + if not redirect_url: + return (False, 'Error getting redirect URL!') + + parsed_url = urlparse(redirect_url) + query_params = parse_qs(parsed_url.query) + + image_insights_token = query_params.get('insightsToken') + if not image_insights_token: + return (False, 'Error getting token!') + image_insights_token = image_insights_token[0] + + api_url = 'https://www.bing.com/images/api/custom/knowledge' + api_headers = { + 'accept': '*/*', + 'accept-language': 'ja-JP;q=0.6,ja;q=0.5', + 'origin': 'https://www.bing.com', + 'referer': f'https://www.bing.com/images/search?view=detailV2&insightstoken={image_insights_token}', + 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:136.0) Gecko/20100101 Firefox/136.0', + } + api_data_json = { + 'imageInfo': {'imageInsightsToken': image_insights_token, 'source': 'Url'}, + 'knowledgeRequest': {'invokedSkills': ['OCR'], 'index': 1} + } + files = { + 'knowledgeRequest': (None, json.dumps(api_data_json), 'application/json') + } + + try: + res = self.requests_session.post(api_url, headers=api_headers, files=files, timeout=20) + except requests.exceptions.Timeout: + return (False, 'Request timeout!') + except requests.exceptions.ConnectionError: + return (False, 'Connection error!') + + if res.status_code != 200: + return (False, 'Unknown error!') + + data = res.json() + + text_tag = None + for tag in data['tags']: + if tag.get('displayName') == '##TextRecognition': + text_tag = tag + break + if not text_tag: + return (False, 'No ##TextRecognition tag in response!') + + text_action = None + for action in text_tag['actions']: + if action.get('_type') == 'ImageKnowledge/TextRecognitionAction': + text_action = action + break + if not text_action: + return (False, 'No TextRecognitionAction action in response!') + + regions = text_action['data'].get('regions', []) + + res = '' + for region in regions: + for line in region.get('lines', []): + res += line['text'] + '\n' + + x = (True, res) + return x + + def _preprocess(self, img): + img_bytes = pil_image_to_bytes(img) + return base64.b64encode(img_bytes).decode('utf-8') + class AppleVision: name = 'avision' readable_name = 'Apple Vision' @@ -521,15 +629,12 @@ class WinRTOCR: self.available = True logger.info('WinRT OCR ready') else: - if 'requests' not in sys.modules: - logger.warning('requests not available, WinRT OCR will not work!') - else: - try: - self.url = config['url'] - self.available = True - logger.info('WinRT OCR ready') - except: - logger.warning('Error reading URL from config, WinRT OCR will not work!') + try: + self.url = config['url'] + self.available = True + logger.info('WinRT OCR ready') + except: + logger.warning('Error reading URL from config, WinRT OCR will not work!') def __call__(self, img_or_path): if isinstance(img_or_path, str) or isinstance(img_or_path, Path): @@ -704,15 +809,12 @@ class OCRSpace: available = False def __init__(self, config={}): - if 'requests' not in sys.modules: - logger.warning('requests not available, OCRSpace will not work!') - else: - try: - self.api_key = config['api_key'] - self.available = True - logger.info('OCRSpace ready') - except: - logger.warning('Error reading API key from config, OCRSpace will not work!') + try: + self.api_key = config['api_key'] + self.available = True + logger.info('OCRSpace ready') + except: + logger.warning('Error reading API key from config, OCRSpace will not work!') def __call__(self, img_or_path): if isinstance(img_or_path, str) or isinstance(img_or_path, Path): diff --git a/owocr/py_lens/__init__.py b/owocr/py_lens/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/owocr/py_lens/lens_overlay_client_context_pb2.py b/owocr/py_lens/lens_overlay_client_context_pb2.py deleted file mode 100644 index 15bb723..0000000 --- a/owocr/py_lens/lens_overlay_client_context_pb2.py +++ /dev/null @@ -1,75 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_client_context.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import enum_type_wrapper -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_filters_pb2 as lens__overlay__filters__pb2 -import owocr.py_lens.lens_overlay_platform_pb2 as lens__overlay__platform__pb2 -import owocr.py_lens.lens_overlay_surface_pb2 as lens__overlay__surface__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!lens_overlay_client_context.proto\x12\x04lens\x1a\x1alens_overlay_filters.proto\x1a\x1blens_overlay_platform.proto\x1a\x1alens_overlay_surface.proto\"\x90\x03\n\x18LensOverlayClientContext\x12 \n\x08platform\x18\x01 \x01(\x0e\x32\x0e.lens.Platform\x12\x1e\n\x07surface\x18\x02 \x01(\x0e\x32\r.lens.Surface\x12+\n\x0elocale_context\x18\x04 \x01(\x0b\x32\x13.lens.LocaleContext\x12\x0e\n\x06\x61pp_id\x18\x06 \x01(\t\x12,\n\x0e\x63lient_filters\x18\x11 \x01(\x0b\x32\x14.lens.AppliedFilters\x12\x31\n\x11rendering_context\x18\x14 \x01(\x0b\x32\x16.lens.RenderingContext\x12\x34\n\x13\x63lient_logging_data\x18\x17 \x01(\x0b\x32\x17.lens.ClientLoggingDataJ\x04\x08\x03\x10\x04J\x04\x08\x05\x10\x06J\x04\x08\x07\x10\x08J\x04\x08\x08\x10\tJ\x04\x08\t\x10\nJ\x04\x08\n\x10\x0bJ\x04\x08\x0b\x10\x0cJ\x04\x08\x0c\x10\rJ\x04\x08\r\x10\x0eJ\x04\x08\x0e\x10\x0fJ\x04\x08\x0f\x10\x10J\x04\x08\x10\x10\x11J\x04\x08\x12\x10\x13J\x04\x08\x13\x10\x14J\x04\x08\x15\x10\x16J\x04\x08\x16\x10\x17\"D\n\rLocaleContext\x12\x10\n\x08language\x18\x01 \x01(\t\x12\x0e\n\x06region\x18\x02 \x01(\t\x12\x11\n\ttime_zone\x18\x03 \x01(\t\"W\n\x10RenderingContext\x12=\n\x15rendering_environment\x18\x02 \x01(\x0e\x32\x1e.lens.LensRenderingEnvironmentJ\x04\x08\x01\x10\x02\"0\n\x11\x43lientLoggingData\x12\x1b\n\x13is_history_eligible\x18\x01 \x01(\x08*Y\n\x18LensRenderingEnvironment\x12\x1d\n\x19RENDERING_ENV_UNSPECIFIED\x10\x00\x12\x1e\n\x1aRENDERING_ENV_LENS_OVERLAY\x10\x0e\x42\x02H\x03\x62\x06proto3') - -_LENSRENDERINGENVIRONMENT = DESCRIPTOR.enum_types_by_name['LensRenderingEnvironment'] -LensRenderingEnvironment = enum_type_wrapper.EnumTypeWrapper(_LENSRENDERINGENVIRONMENT) -RENDERING_ENV_UNSPECIFIED = 0 -RENDERING_ENV_LENS_OVERLAY = 14 - - -_LENSOVERLAYCLIENTCONTEXT = DESCRIPTOR.message_types_by_name['LensOverlayClientContext'] -_LOCALECONTEXT = DESCRIPTOR.message_types_by_name['LocaleContext'] -_RENDERINGCONTEXT = DESCRIPTOR.message_types_by_name['RenderingContext'] -_CLIENTLOGGINGDATA = DESCRIPTOR.message_types_by_name['ClientLoggingData'] -LensOverlayClientContext = _reflection.GeneratedProtocolMessageType('LensOverlayClientContext', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYCLIENTCONTEXT, - '__module__' : 'lens_overlay_client_context_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayClientContext) - }) -_sym_db.RegisterMessage(LensOverlayClientContext) - -LocaleContext = _reflection.GeneratedProtocolMessageType('LocaleContext', (_message.Message,), { - 'DESCRIPTOR' : _LOCALECONTEXT, - '__module__' : 'lens_overlay_client_context_pb2' - # @@protoc_insertion_point(class_scope:lens.LocaleContext) - }) -_sym_db.RegisterMessage(LocaleContext) - -RenderingContext = _reflection.GeneratedProtocolMessageType('RenderingContext', (_message.Message,), { - 'DESCRIPTOR' : _RENDERINGCONTEXT, - '__module__' : 'lens_overlay_client_context_pb2' - # @@protoc_insertion_point(class_scope:lens.RenderingContext) - }) -_sym_db.RegisterMessage(RenderingContext) - -ClientLoggingData = _reflection.GeneratedProtocolMessageType('ClientLoggingData', (_message.Message,), { - 'DESCRIPTOR' : _CLIENTLOGGINGDATA, - '__module__' : 'lens_overlay_client_context_pb2' - # @@protoc_insertion_point(class_scope:lens.ClientLoggingData) - }) -_sym_db.RegisterMessage(ClientLoggingData) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSRENDERINGENVIRONMENT._serialized_start=740 - _LENSRENDERINGENVIRONMENT._serialized_end=829 - _LENSOVERLAYCLIENTCONTEXT._serialized_start=129 - _LENSOVERLAYCLIENTCONTEXT._serialized_end=529 - _LOCALECONTEXT._serialized_start=531 - _LOCALECONTEXT._serialized_end=599 - _RENDERINGCONTEXT._serialized_start=601 - _RENDERINGCONTEXT._serialized_end=688 - _CLIENTLOGGINGDATA._serialized_start=690 - _CLIENTLOGGINGDATA._serialized_end=738 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_client_logs_pb2.py b/owocr/py_lens/lens_overlay_client_logs_pb2.py deleted file mode 100644 index d1b641d..0000000 --- a/owocr/py_lens/lens_overlay_client_logs_pb2.py +++ /dev/null @@ -1,39 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_client_logs.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_phase_latencies_metadata_pb2 as lens__overlay__phase__latencies__metadata__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1elens_overlay_client_logs.proto\x12\x04lens\x1a+lens_overlay_phase_latencies_metadata.proto\"\x9f\x03\n\x15LensOverlayClientLogs\x12I\n\x18phase_latencies_metadata\x18\x01 \x01(\x0b\x32\'.lens.LensOverlayPhaseLatenciesMetadata\x12S\n\x18lens_overlay_entry_point\x18\x02 \x01(\x0e\x32\x31.lens.LensOverlayClientLogs.LensOverlayEntryPoint\x12\x11\n\tpaella_id\x18\x03 \x01(\x04\x12#\n\x1bmetrics_collection_disabled\x18\x05 \x01(\x08\"\xa7\x01\n\x15LensOverlayEntryPoint\x12\x17\n\x13UNKNOWN_ENTRY_POINT\x10\x00\x12\x0c\n\x08\x41PP_MENU\x10\x01\x12\x15\n\x11PAGE_CONTEXT_MENU\x10\x02\x12\x16\n\x12IMAGE_CONTEXT_MENU\x10\x03\x12\x12\n\x0eOMNIBOX_BUTTON\x10\x04\x12\x12\n\x0eTOOLBAR_BUTTON\x10\x05\x12\x10\n\x0c\x46IND_IN_PAGE\x10\x06J\x04\x08\x04\x10\x05\x42\x02H\x03') - - - -_LENSOVERLAYCLIENTLOGS = DESCRIPTOR.message_types_by_name['LensOverlayClientLogs'] -_LENSOVERLAYCLIENTLOGS_LENSOVERLAYENTRYPOINT = _LENSOVERLAYCLIENTLOGS.enum_types_by_name['LensOverlayEntryPoint'] -LensOverlayClientLogs = _reflection.GeneratedProtocolMessageType('LensOverlayClientLogs', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYCLIENTLOGS, - '__module__' : 'lens_overlay_client_logs_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayClientLogs) - }) -_sym_db.RegisterMessage(LensOverlayClientLogs) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYCLIENTLOGS._serialized_start=86 - _LENSOVERLAYCLIENTLOGS._serialized_end=501 - _LENSOVERLAYCLIENTLOGS_LENSOVERLAYENTRYPOINT._serialized_start=328 - _LENSOVERLAYCLIENTLOGS_LENSOVERLAYENTRYPOINT._serialized_end=495 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_client_platform_pb2.py b/owocr/py_lens/lens_overlay_client_platform_pb2.py deleted file mode 100644 index 84751b6..0000000 --- a/owocr/py_lens/lens_overlay_client_platform_pb2.py +++ /dev/null @@ -1,32 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_client_platform.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import enum_type_wrapper -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"lens_overlay_client_platform.proto\x12\x04lens*S\n\x0e\x43lientPlatform\x12\x1f\n\x1b\x43LIENT_PLATFORM_UNSPECIFIED\x10\x00\x12 \n\x1c\x43LIENT_PLATFORM_LENS_OVERLAY\x10\x02\x42\x02H\x03\x62\x06proto3') - -_CLIENTPLATFORM = DESCRIPTOR.enum_types_by_name['ClientPlatform'] -ClientPlatform = enum_type_wrapper.EnumTypeWrapper(_CLIENTPLATFORM) -CLIENT_PLATFORM_UNSPECIFIED = 0 -CLIENT_PLATFORM_LENS_OVERLAY = 2 - - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _CLIENTPLATFORM._serialized_start=44 - _CLIENTPLATFORM._serialized_end=127 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_cluster_info_pb2.py b/owocr/py_lens/lens_overlay_cluster_info_pb2.py deleted file mode 100644 index 77bd672..0000000 --- a/owocr/py_lens/lens_overlay_cluster_info_pb2.py +++ /dev/null @@ -1,36 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_cluster_info.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_routing_info_pb2 as lens__overlay__routing__info__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1flens_overlay_cluster_info.proto\x12\x04lens\x1a\x1flens_overlay_routing_info.proto\"\x82\x01\n\x16LensOverlayClusterInfo\x12\x19\n\x11server_session_id\x18\x01 \x01(\t\x12\x19\n\x11search_session_id\x18\x02 \x01(\t\x12\x32\n\x0crouting_info\x18\x06 \x01(\x0b\x32\x1c.lens.LensOverlayRoutingInfoB\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYCLUSTERINFO = DESCRIPTOR.message_types_by_name['LensOverlayClusterInfo'] -LensOverlayClusterInfo = _reflection.GeneratedProtocolMessageType('LensOverlayClusterInfo', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYCLUSTERINFO, - '__module__' : 'lens_overlay_cluster_info_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayClusterInfo) - }) -_sym_db.RegisterMessage(LensOverlayClusterInfo) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYCLUSTERINFO._serialized_start=75 - _LENSOVERLAYCLUSTERINFO._serialized_end=205 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_deep_gleam_data_pb2.py b/owocr/py_lens/lens_overlay_deep_gleam_data_pb2.py deleted file mode 100644 index 922c18c..0000000 --- a/owocr/py_lens/lens_overlay_deep_gleam_data_pb2.py +++ /dev/null @@ -1,107 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_deep_gleam_data.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_text_pb2 as lens__overlay__text__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"lens_overlay_deep_gleam_data.proto\x12\x04lens\x1a\x17lens_overlay_text.proto\"\xa6\x01\n\rDeepGleamData\x12,\n\x0btranslation\x18\n \x01(\x0b\x32\x15.lens.TranslationDataH\x00\x12\x18\n\x10visual_object_id\x18\x0b \x03(\tB\x11\n\x0frendering_oneofJ\x04\x08\x01\x10\x02J\x04\x08\x02\x10\x03J\x04\x08\x03\x10\x04J\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07J\x04\x08\x07\x10\x08J\x04\x08\x08\x10\tJ\x04\x08\t\x10\nJ\x04\x08\x0c\x10\r\"\xe7\t\n\x0fTranslationData\x12,\n\x06status\x18\x01 \x01(\x0b\x32\x1c.lens.TranslationData.Status\x12\x17\n\x0ftarget_language\x18\x02 \x01(\t\x12\x17\n\x0fsource_language\x18\x03 \x01(\t\x12\x13\n\x0btranslation\x18\x04 \x01(\t\x12(\n\x04line\x18\x05 \x03(\x0b\x32\x1a.lens.TranslationData.Line\x12\x31\n\x11writing_direction\x18\x07 \x01(\x0e\x32\x16.lens.WritingDirection\x12\"\n\talignment\x18\x08 \x01(\x0e\x32\x0f.lens.Alignment\x12\x11\n\tjustified\x18\t \x01(\x08\x1a\x97\x02\n\x06Status\x12/\n\x04\x63ode\x18\x01 \x01(\x0e\x32!.lens.TranslationData.Status.Code\"\xdb\x01\n\x04\x43ode\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07SUCCESS\x10\x01\x12\x10\n\x0cSERVER_ERROR\x10\x02\x12\x1d\n\x19UNSUPPORTED_LANGUAGE_PAIR\x10\x03\x12\x11\n\rSAME_LANGUAGE\x10\x04\x12\x1b\n\x17UNKNOWN_SOURCE_LANGUAGE\x10\x05\x12\x13\n\x0fINVALID_REQUEST\x10\x06\x12\x15\n\x11\x44\x45\x41\x44LINE_EXCEEDED\x10\x07\x12\x15\n\x11\x45MPTY_TRANSLATION\x10\x08\x12\x15\n\x11NO_OP_TRANSLATION\x10\t\x1aM\n\tTextStyle\x12\x12\n\ntext_color\x18\x01 \x01(\r\x12 \n\x18\x62\x61\x63kground_primary_color\x18\x02 \x01(\rJ\x04\x08\x03\x10\x04J\x04\x08\x04\x10\x05\x1a\xd1\x02\n\x13\x42\x61\x63kgroundImageData\x12\x18\n\x10\x62\x61\x63kground_image\x18\x01 \x01(\x0c\x12\x13\n\x0bimage_width\x18\x02 \x01(\x05\x12\x14\n\x0cimage_height\x18\x03 \x01(\x05\x12\x18\n\x10vertical_padding\x18\x04 \x01(\x02\x12\x1a\n\x12horizontal_padding\x18\x05 \x01(\x02\x12I\n\x0b\x66ile_format\x18\x06 \x01(\x0e\x32\x34.lens.TranslationData.BackgroundImageData.FileFormat\x12\x11\n\ttext_mask\x18\x07 \x01(\x0c\"a\n\nFileFormat\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x12\n\x0eRAW_BYTES_RGBA\x10\x01\x12\x0c\n\x08PNG_RGBA\x10\x02\x12\r\n\tWEBP_RGBA\x10\x03\x12\x15\n\x11JPEG_RGB_PNG_MASK\x10\x04\x1a\x87\x02\n\x04Line\x12\r\n\x05start\x18\x01 \x01(\x05\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x05\x12.\n\x05style\x18\x03 \x01(\x0b\x32\x1f.lens.TranslationData.TextStyle\x12-\n\x04word\x18\x05 \x03(\x0b\x32\x1f.lens.TranslationData.Line.Word\x12H\n\x15\x62\x61\x63kground_image_data\x18\t \x01(\x0b\x32).lens.TranslationData.BackgroundImageData\x1a\"\n\x04Word\x12\r\n\x05start\x18\x01 \x01(\x05\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x05J\x04\x08\x04\x10\x05J\x04\x08\x06\x10\x07J\x04\x08\x07\x10\x08J\x04\x08\x08\x10\tJ\x04\x08\x06\x10\x07\x42\x02H\x03\x62\x06proto3') - - - -_DEEPGLEAMDATA = DESCRIPTOR.message_types_by_name['DeepGleamData'] -_TRANSLATIONDATA = DESCRIPTOR.message_types_by_name['TranslationData'] -_TRANSLATIONDATA_STATUS = _TRANSLATIONDATA.nested_types_by_name['Status'] -_TRANSLATIONDATA_TEXTSTYLE = _TRANSLATIONDATA.nested_types_by_name['TextStyle'] -_TRANSLATIONDATA_BACKGROUNDIMAGEDATA = _TRANSLATIONDATA.nested_types_by_name['BackgroundImageData'] -_TRANSLATIONDATA_LINE = _TRANSLATIONDATA.nested_types_by_name['Line'] -_TRANSLATIONDATA_LINE_WORD = _TRANSLATIONDATA_LINE.nested_types_by_name['Word'] -_TRANSLATIONDATA_STATUS_CODE = _TRANSLATIONDATA_STATUS.enum_types_by_name['Code'] -_TRANSLATIONDATA_BACKGROUNDIMAGEDATA_FILEFORMAT = _TRANSLATIONDATA_BACKGROUNDIMAGEDATA.enum_types_by_name['FileFormat'] -DeepGleamData = _reflection.GeneratedProtocolMessageType('DeepGleamData', (_message.Message,), { - 'DESCRIPTOR' : _DEEPGLEAMDATA, - '__module__' : 'lens_overlay_deep_gleam_data_pb2' - # @@protoc_insertion_point(class_scope:lens.DeepGleamData) - }) -_sym_db.RegisterMessage(DeepGleamData) - -TranslationData = _reflection.GeneratedProtocolMessageType('TranslationData', (_message.Message,), { - - 'Status' : _reflection.GeneratedProtocolMessageType('Status', (_message.Message,), { - 'DESCRIPTOR' : _TRANSLATIONDATA_STATUS, - '__module__' : 'lens_overlay_deep_gleam_data_pb2' - # @@protoc_insertion_point(class_scope:lens.TranslationData.Status) - }) - , - - 'TextStyle' : _reflection.GeneratedProtocolMessageType('TextStyle', (_message.Message,), { - 'DESCRIPTOR' : _TRANSLATIONDATA_TEXTSTYLE, - '__module__' : 'lens_overlay_deep_gleam_data_pb2' - # @@protoc_insertion_point(class_scope:lens.TranslationData.TextStyle) - }) - , - - 'BackgroundImageData' : _reflection.GeneratedProtocolMessageType('BackgroundImageData', (_message.Message,), { - 'DESCRIPTOR' : _TRANSLATIONDATA_BACKGROUNDIMAGEDATA, - '__module__' : 'lens_overlay_deep_gleam_data_pb2' - # @@protoc_insertion_point(class_scope:lens.TranslationData.BackgroundImageData) - }) - , - - 'Line' : _reflection.GeneratedProtocolMessageType('Line', (_message.Message,), { - - 'Word' : _reflection.GeneratedProtocolMessageType('Word', (_message.Message,), { - 'DESCRIPTOR' : _TRANSLATIONDATA_LINE_WORD, - '__module__' : 'lens_overlay_deep_gleam_data_pb2' - # @@protoc_insertion_point(class_scope:lens.TranslationData.Line.Word) - }) - , - 'DESCRIPTOR' : _TRANSLATIONDATA_LINE, - '__module__' : 'lens_overlay_deep_gleam_data_pb2' - # @@protoc_insertion_point(class_scope:lens.TranslationData.Line) - }) - , - 'DESCRIPTOR' : _TRANSLATIONDATA, - '__module__' : 'lens_overlay_deep_gleam_data_pb2' - # @@protoc_insertion_point(class_scope:lens.TranslationData) - }) -_sym_db.RegisterMessage(TranslationData) -_sym_db.RegisterMessage(TranslationData.Status) -_sym_db.RegisterMessage(TranslationData.TextStyle) -_sym_db.RegisterMessage(TranslationData.BackgroundImageData) -_sym_db.RegisterMessage(TranslationData.Line) -_sym_db.RegisterMessage(TranslationData.Line.Word) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _DEEPGLEAMDATA._serialized_start=70 - _DEEPGLEAMDATA._serialized_end=236 - _TRANSLATIONDATA._serialized_start=239 - _TRANSLATIONDATA._serialized_end=1494 - _TRANSLATIONDATA_STATUS._serialized_start=524 - _TRANSLATIONDATA_STATUS._serialized_end=803 - _TRANSLATIONDATA_STATUS_CODE._serialized_start=584 - _TRANSLATIONDATA_STATUS_CODE._serialized_end=803 - _TRANSLATIONDATA_TEXTSTYLE._serialized_start=805 - _TRANSLATIONDATA_TEXTSTYLE._serialized_end=882 - _TRANSLATIONDATA_BACKGROUNDIMAGEDATA._serialized_start=885 - _TRANSLATIONDATA_BACKGROUNDIMAGEDATA._serialized_end=1222 - _TRANSLATIONDATA_BACKGROUNDIMAGEDATA_FILEFORMAT._serialized_start=1125 - _TRANSLATIONDATA_BACKGROUNDIMAGEDATA_FILEFORMAT._serialized_end=1222 - _TRANSLATIONDATA_LINE._serialized_start=1225 - _TRANSLATIONDATA_LINE._serialized_end=1488 - _TRANSLATIONDATA_LINE_WORD._serialized_start=1430 - _TRANSLATIONDATA_LINE_WORD._serialized_end=1464 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_document_pb2.py b/owocr/py_lens/lens_overlay_document_pb2.py deleted file mode 100644 index f8687a6..0000000 --- a/owocr/py_lens/lens_overlay_document_pb2.py +++ /dev/null @@ -1,45 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_document.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1blens_overlay_document.proto\x12\x04lens\"0\n\x13LensOverlayDocument\x12\x19\n\x05pages\x18\x01 \x03(\x0b\x32\n.lens.Page\"2\n\x04Page\x12\x13\n\x0bpage_number\x18\x01 \x01(\x05\x12\x15\n\rtext_segments\x18\x04 \x03(\tB\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYDOCUMENT = DESCRIPTOR.message_types_by_name['LensOverlayDocument'] -_PAGE = DESCRIPTOR.message_types_by_name['Page'] -LensOverlayDocument = _reflection.GeneratedProtocolMessageType('LensOverlayDocument', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYDOCUMENT, - '__module__' : 'lens_overlay_document_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayDocument) - }) -_sym_db.RegisterMessage(LensOverlayDocument) - -Page = _reflection.GeneratedProtocolMessageType('Page', (_message.Message,), { - 'DESCRIPTOR' : _PAGE, - '__module__' : 'lens_overlay_document_pb2' - # @@protoc_insertion_point(class_scope:lens.Page) - }) -_sym_db.RegisterMessage(Page) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYDOCUMENT._serialized_start=37 - _LENSOVERLAYDOCUMENT._serialized_end=85 - _PAGE._serialized_start=87 - _PAGE._serialized_end=137 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_filters_pb2.py b/owocr/py_lens/lens_overlay_filters_pb2.py deleted file mode 100644 index 3dcc9ac..0000000 --- a/owocr/py_lens/lens_overlay_filters_pb2.py +++ /dev/null @@ -1,64 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_filters.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import enum_type_wrapper -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1alens_overlay_filters.proto\x12\x04lens\"\xc6\x01\n\rAppliedFilter\x12\x30\n\x0b\x66ilter_type\x18\x01 \x01(\x0e\x32\x1b.lens.LensOverlayFilterType\x12\x32\n\ttranslate\x18\x03 \x01(\x0b\x32\x1d.lens.AppliedFilter.TranslateH\x00\x1a=\n\tTranslate\x12\x17\n\x0ftarget_language\x18\x01 \x01(\t\x12\x17\n\x0fsource_language\x18\x02 \x01(\tB\x10\n\x0e\x66ilter_payload\"5\n\x0e\x41ppliedFilters\x12#\n\x06\x66ilter\x18\x01 \x03(\x0b\x32\x13.lens.AppliedFilter*P\n\x15LensOverlayFilterType\x12\x17\n\x13UNKNOWN_FILTER_TYPE\x10\x00\x12\r\n\tTRANSLATE\x10\x02\x12\x0f\n\x0b\x41UTO_FILTER\x10\x07\x42\x02H\x03\x62\x06proto3') - -_LENSOVERLAYFILTERTYPE = DESCRIPTOR.enum_types_by_name['LensOverlayFilterType'] -LensOverlayFilterType = enum_type_wrapper.EnumTypeWrapper(_LENSOVERLAYFILTERTYPE) -UNKNOWN_FILTER_TYPE = 0 -TRANSLATE = 2 -AUTO_FILTER = 7 - - -_APPLIEDFILTER = DESCRIPTOR.message_types_by_name['AppliedFilter'] -_APPLIEDFILTER_TRANSLATE = _APPLIEDFILTER.nested_types_by_name['Translate'] -_APPLIEDFILTERS = DESCRIPTOR.message_types_by_name['AppliedFilters'] -AppliedFilter = _reflection.GeneratedProtocolMessageType('AppliedFilter', (_message.Message,), { - - 'Translate' : _reflection.GeneratedProtocolMessageType('Translate', (_message.Message,), { - 'DESCRIPTOR' : _APPLIEDFILTER_TRANSLATE, - '__module__' : 'lens_overlay_filters_pb2' - # @@protoc_insertion_point(class_scope:lens.AppliedFilter.Translate) - }) - , - 'DESCRIPTOR' : _APPLIEDFILTER, - '__module__' : 'lens_overlay_filters_pb2' - # @@protoc_insertion_point(class_scope:lens.AppliedFilter) - }) -_sym_db.RegisterMessage(AppliedFilter) -_sym_db.RegisterMessage(AppliedFilter.Translate) - -AppliedFilters = _reflection.GeneratedProtocolMessageType('AppliedFilters', (_message.Message,), { - 'DESCRIPTOR' : _APPLIEDFILTERS, - '__module__' : 'lens_overlay_filters_pb2' - # @@protoc_insertion_point(class_scope:lens.AppliedFilters) - }) -_sym_db.RegisterMessage(AppliedFilters) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYFILTERTYPE._serialized_start=292 - _LENSOVERLAYFILTERTYPE._serialized_end=372 - _APPLIEDFILTER._serialized_start=37 - _APPLIEDFILTER._serialized_end=235 - _APPLIEDFILTER_TRANSLATE._serialized_start=156 - _APPLIEDFILTER_TRANSLATE._serialized_end=217 - _APPLIEDFILTERS._serialized_start=237 - _APPLIEDFILTERS._serialized_end=290 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_geometry_pb2.py b/owocr/py_lens/lens_overlay_geometry_pb2.py deleted file mode 100644 index fac52c5..0000000 --- a/owocr/py_lens/lens_overlay_geometry_pb2.py +++ /dev/null @@ -1,56 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_geometry.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_polygon_pb2 as lens__overlay__polygon__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1blens_overlay_geometry.proto\x12\x04lens\x1a\x1alens_overlay_polygon.proto\"\x98\x01\n\x10\x43\x65nterRotatedBox\x12\x10\n\x08\x63\x65nter_x\x18\x01 \x01(\x02\x12\x10\n\x08\x63\x65nter_y\x18\x02 \x01(\x02\x12\r\n\x05width\x18\x03 \x01(\x02\x12\x0e\n\x06height\x18\x04 \x01(\x02\x12\x12\n\nrotation_z\x18\x05 \x01(\x02\x12-\n\x0f\x63oordinate_type\x18\x06 \x01(\x0e\x32\x14.lens.CoordinateType\"}\n\x08Geometry\x12,\n\x0c\x62ounding_box\x18\x01 \x01(\x0b\x32\x16.lens.CenterRotatedBox\x12+\n\x14segmentation_polygon\x18\x05 \x03(\x0b\x32\r.lens.PolygonJ\x04\x08\x02\x10\x03J\x04\x08\x03\x10\x04J\x04\x08\x04\x10\x05J\x04\x08\x06\x10\x07\"m\n\nZoomedCrop\x12$\n\x04\x63rop\x18\x01 \x01(\x0b\x32\x16.lens.CenterRotatedBox\x12\x14\n\x0cparent_width\x18\x02 \x01(\x05\x12\x15\n\rparent_height\x18\x03 \x01(\x05\x12\x0c\n\x04zoom\x18\x04 \x01(\x02\x42\x02H\x03\x62\x06proto3') - - - -_CENTERROTATEDBOX = DESCRIPTOR.message_types_by_name['CenterRotatedBox'] -_GEOMETRY = DESCRIPTOR.message_types_by_name['Geometry'] -_ZOOMEDCROP = DESCRIPTOR.message_types_by_name['ZoomedCrop'] -CenterRotatedBox = _reflection.GeneratedProtocolMessageType('CenterRotatedBox', (_message.Message,), { - 'DESCRIPTOR' : _CENTERROTATEDBOX, - '__module__' : 'lens_overlay_geometry_pb2' - # @@protoc_insertion_point(class_scope:lens.CenterRotatedBox) - }) -_sym_db.RegisterMessage(CenterRotatedBox) - -Geometry = _reflection.GeneratedProtocolMessageType('Geometry', (_message.Message,), { - 'DESCRIPTOR' : _GEOMETRY, - '__module__' : 'lens_overlay_geometry_pb2' - # @@protoc_insertion_point(class_scope:lens.Geometry) - }) -_sym_db.RegisterMessage(Geometry) - -ZoomedCrop = _reflection.GeneratedProtocolMessageType('ZoomedCrop', (_message.Message,), { - 'DESCRIPTOR' : _ZOOMEDCROP, - '__module__' : 'lens_overlay_geometry_pb2' - # @@protoc_insertion_point(class_scope:lens.ZoomedCrop) - }) -_sym_db.RegisterMessage(ZoomedCrop) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _CENTERROTATEDBOX._serialized_start=66 - _CENTERROTATEDBOX._serialized_end=218 - _GEOMETRY._serialized_start=220 - _GEOMETRY._serialized_end=345 - _ZOOMEDCROP._serialized_start=347 - _ZOOMEDCROP._serialized_end=456 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_image_crop_pb2.py b/owocr/py_lens/lens_overlay_image_crop_pb2.py deleted file mode 100644 index a56ddae..0000000 --- a/owocr/py_lens/lens_overlay_image_crop_pb2.py +++ /dev/null @@ -1,37 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_image_crop.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_geometry_pb2 as lens__overlay__geometry__pb2 -import owocr.py_lens.lens_overlay_payload_pb2 as lens__overlay__payload__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1dlens_overlay_image_crop.proto\x12\x04lens\x1a\x1blens_overlay_geometry.proto\x1a\x1alens_overlay_payload.proto\"k\n\tImageCrop\x12\x0f\n\x07\x63rop_id\x18\x01 \x01(\t\x12 \n\x05image\x18\x02 \x01(\x0b\x32\x11.lens.ClientImage\x12%\n\x0bzoomed_crop\x18\x03 \x01(\x0b\x32\x10.lens.ZoomedCropJ\x04\x08\x04\x10\x05\x42\x02H\x03\x62\x06proto3') - - - -_IMAGECROP = DESCRIPTOR.message_types_by_name['ImageCrop'] -ImageCrop = _reflection.GeneratedProtocolMessageType('ImageCrop', (_message.Message,), { - 'DESCRIPTOR' : _IMAGECROP, - '__module__' : 'lens_overlay_image_crop_pb2' - # @@protoc_insertion_point(class_scope:lens.ImageCrop) - }) -_sym_db.RegisterMessage(ImageCrop) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _IMAGECROP._serialized_start=96 - _IMAGECROP._serialized_end=203 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_image_data_pb2.py b/owocr/py_lens/lens_overlay_image_data_pb2.py deleted file mode 100644 index 049a441..0000000 --- a/owocr/py_lens/lens_overlay_image_data_pb2.py +++ /dev/null @@ -1,56 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_image_data.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_geometry_pb2 as lens__overlay__geometry__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1dlens_overlay_image_data.proto\x12\x04lens\x1a\x1blens_overlay_geometry.proto\"\x90\x01\n\tImageData\x12#\n\x07payload\x18\x01 \x01(\x0b\x32\x12.lens.ImagePayload\x12+\n\x0eimage_metadata\x18\x03 \x01(\x0b\x32\x13.lens.ImageMetadata\x12+\n\x13significant_regions\x18\x04 \x03(\x0b\x32\x0e.lens.GeometryJ\x04\x08\x02\x10\x03\")\n\x0cImagePayload\x12\x13\n\x0bimage_bytes\x18\x01 \x01(\x0cJ\x04\x08\x02\x10\x03\"4\n\rImageMetadata\x12\r\n\x05width\x18\x01 \x01(\x05\x12\x0e\n\x06height\x18\x02 \x01(\x05J\x04\x08\x06\x10\x07\x42\x02H\x03\x62\x06proto3') - - - -_IMAGEDATA = DESCRIPTOR.message_types_by_name['ImageData'] -_IMAGEPAYLOAD = DESCRIPTOR.message_types_by_name['ImagePayload'] -_IMAGEMETADATA = DESCRIPTOR.message_types_by_name['ImageMetadata'] -ImageData = _reflection.GeneratedProtocolMessageType('ImageData', (_message.Message,), { - 'DESCRIPTOR' : _IMAGEDATA, - '__module__' : 'lens_overlay_image_data_pb2' - # @@protoc_insertion_point(class_scope:lens.ImageData) - }) -_sym_db.RegisterMessage(ImageData) - -ImagePayload = _reflection.GeneratedProtocolMessageType('ImagePayload', (_message.Message,), { - 'DESCRIPTOR' : _IMAGEPAYLOAD, - '__module__' : 'lens_overlay_image_data_pb2' - # @@protoc_insertion_point(class_scope:lens.ImagePayload) - }) -_sym_db.RegisterMessage(ImagePayload) - -ImageMetadata = _reflection.GeneratedProtocolMessageType('ImageMetadata', (_message.Message,), { - 'DESCRIPTOR' : _IMAGEMETADATA, - '__module__' : 'lens_overlay_image_data_pb2' - # @@protoc_insertion_point(class_scope:lens.ImageMetadata) - }) -_sym_db.RegisterMessage(ImageMetadata) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _IMAGEDATA._serialized_start=69 - _IMAGEDATA._serialized_end=213 - _IMAGEPAYLOAD._serialized_start=215 - _IMAGEPAYLOAD._serialized_end=256 - _IMAGEMETADATA._serialized_start=258 - _IMAGEMETADATA._serialized_end=310 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_interaction_request_metadata_pb2.py b/owocr/py_lens/lens_overlay_interaction_request_metadata_pb2.py deleted file mode 100644 index dbb71fe..0000000 --- a/owocr/py_lens/lens_overlay_interaction_request_metadata_pb2.py +++ /dev/null @@ -1,95 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_interaction_request_metadata.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_geometry_pb2 as lens__overlay__geometry__pb2 -import owocr.py_lens.lens_overlay_text_query_pb2 as lens__overlay__text__query__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n/lens_overlay_interaction_request_metadata.proto\x12\x04lens\x1a\x1blens_overlay_geometry.proto\x1a\x1dlens_overlay_text_query.proto\"\xb9\x07\n%LensOverlayInteractionRequestMetadata\x12>\n\x04type\x18\x01 \x01(\x0e\x32\x30.lens.LensOverlayInteractionRequestMetadata.Type\x12Y\n\x12selection_metadata\x18\x02 \x01(\x0b\x32=.lens.LensOverlayInteractionRequestMetadata.SelectionMetadata\x12Q\n\x0equery_metadata\x18\x04 \x01(\x0b\x32\x39.lens.LensOverlayInteractionRequestMetadata.QueryMetadata\x1a\xb6\x03\n\x11SelectionMetadata\x12T\n\x05point\x18\x01 \x01(\x0b\x32\x43.lens.LensOverlayInteractionRequestMetadata.SelectionMetadata.PointH\x00\x12V\n\x06region\x18\x02 \x01(\x0b\x32\x44.lens.LensOverlayInteractionRequestMetadata.SelectionMetadata.RegionH\x00\x12V\n\x06object\x18\x03 \x01(\x0b\x32\x44.lens.LensOverlayInteractionRequestMetadata.SelectionMetadata.ObjectH\x00\x1a\x1d\n\x05Point\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\x1a\x30\n\x06Region\x12&\n\x06region\x18\x01 \x01(\x0b\x32\x16.lens.CenterRotatedBox\x1a=\n\x06Object\x12\x11\n\tobject_id\x18\x01 \x01(\t\x12 \n\x08geometry\x18\x02 \x01(\x0b\x32\x0e.lens.GeometryB\x0b\n\tselection\x1a:\n\rQueryMetadata\x12#\n\ntext_query\x18\x02 \x01(\x0b\x32\x0f.lens.TextQueryJ\x04\x08\x01\x10\x02\"\xa6\x01\n\x04Type\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x07\n\x03TAP\x10\x01\x12\n\n\x06REGION\x10\x02\x12\x12\n\x0eTEXT_SELECTION\x10\x03\x12\x11\n\rREGION_SEARCH\x10\x04\x12\x16\n\x12OBJECT_FULFILLMENT\x10\x05\x12\x1b\n\x17\x43ONTEXTUAL_SEARCH_QUERY\x10\t\x12\r\n\tPDF_QUERY\x10\n\x12\x11\n\rWEBPAGE_QUERY\x10\x0bJ\x04\x08\x03\x10\x04\x42\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYINTERACTIONREQUESTMETADATA = DESCRIPTOR.message_types_by_name['LensOverlayInteractionRequestMetadata'] -_LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA = _LENSOVERLAYINTERACTIONREQUESTMETADATA.nested_types_by_name['SelectionMetadata'] -_LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_POINT = _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA.nested_types_by_name['Point'] -_LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_REGION = _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA.nested_types_by_name['Region'] -_LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_OBJECT = _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA.nested_types_by_name['Object'] -_LENSOVERLAYINTERACTIONREQUESTMETADATA_QUERYMETADATA = _LENSOVERLAYINTERACTIONREQUESTMETADATA.nested_types_by_name['QueryMetadata'] -_LENSOVERLAYINTERACTIONREQUESTMETADATA_TYPE = _LENSOVERLAYINTERACTIONREQUESTMETADATA.enum_types_by_name['Type'] -LensOverlayInteractionRequestMetadata = _reflection.GeneratedProtocolMessageType('LensOverlayInteractionRequestMetadata', (_message.Message,), { - - 'SelectionMetadata' : _reflection.GeneratedProtocolMessageType('SelectionMetadata', (_message.Message,), { - - 'Point' : _reflection.GeneratedProtocolMessageType('Point', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_POINT, - '__module__' : 'lens_overlay_interaction_request_metadata_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayInteractionRequestMetadata.SelectionMetadata.Point) - }) - , - - 'Region' : _reflection.GeneratedProtocolMessageType('Region', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_REGION, - '__module__' : 'lens_overlay_interaction_request_metadata_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayInteractionRequestMetadata.SelectionMetadata.Region) - }) - , - - 'Object' : _reflection.GeneratedProtocolMessageType('Object', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_OBJECT, - '__module__' : 'lens_overlay_interaction_request_metadata_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayInteractionRequestMetadata.SelectionMetadata.Object) - }) - , - 'DESCRIPTOR' : _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA, - '__module__' : 'lens_overlay_interaction_request_metadata_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayInteractionRequestMetadata.SelectionMetadata) - }) - , - - 'QueryMetadata' : _reflection.GeneratedProtocolMessageType('QueryMetadata', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYINTERACTIONREQUESTMETADATA_QUERYMETADATA, - '__module__' : 'lens_overlay_interaction_request_metadata_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayInteractionRequestMetadata.QueryMetadata) - }) - , - 'DESCRIPTOR' : _LENSOVERLAYINTERACTIONREQUESTMETADATA, - '__module__' : 'lens_overlay_interaction_request_metadata_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayInteractionRequestMetadata) - }) -_sym_db.RegisterMessage(LensOverlayInteractionRequestMetadata) -_sym_db.RegisterMessage(LensOverlayInteractionRequestMetadata.SelectionMetadata) -_sym_db.RegisterMessage(LensOverlayInteractionRequestMetadata.SelectionMetadata.Point) -_sym_db.RegisterMessage(LensOverlayInteractionRequestMetadata.SelectionMetadata.Region) -_sym_db.RegisterMessage(LensOverlayInteractionRequestMetadata.SelectionMetadata.Object) -_sym_db.RegisterMessage(LensOverlayInteractionRequestMetadata.QueryMetadata) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYINTERACTIONREQUESTMETADATA._serialized_start=118 - _LENSOVERLAYINTERACTIONREQUESTMETADATA._serialized_end=1071 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA._serialized_start=398 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA._serialized_end=836 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_POINT._serialized_start=681 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_POINT._serialized_end=710 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_REGION._serialized_start=712 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_REGION._serialized_end=760 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_OBJECT._serialized_start=762 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_SELECTIONMETADATA_OBJECT._serialized_end=823 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_QUERYMETADATA._serialized_start=838 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_QUERYMETADATA._serialized_end=896 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_TYPE._serialized_start=899 - _LENSOVERLAYINTERACTIONREQUESTMETADATA_TYPE._serialized_end=1065 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_knowledge_intent_query_pb2.py b/owocr/py_lens/lens_overlay_knowledge_intent_query_pb2.py deleted file mode 100644 index 0139040..0000000 --- a/owocr/py_lens/lens_overlay_knowledge_intent_query_pb2.py +++ /dev/null @@ -1,76 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_knowledge_intent_query.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_translate_stickiness_signals_pb2 as lens__overlay__translate__stickiness__signals__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n)lens_overlay_knowledge_intent_query.proto\x12\x04lens\x1a/lens_overlay_translate_stickiness_signals.proto\"j\n\x0c\x46unctionCall\x12\x0c\n\x04name\x18\x01 \x01(\t\x12 \n\x08\x61rgument\x18\x02 \x03(\x0b\x32\x0e.lens.Argument\x12*\n\x07signals\x18\x04 \x01(\x0b\x32\x19.lens.FunctionCallSignals\"a\n\x13\x46unctionCallSignals\x12J\n\x1ctranslate_stickiness_signals\x18\xe6\x81\xbd\x94\x01 \x01(\x0b\x32 .lens.TranslateStickinessSignals\"<\n\x08\x41rgument\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\"\n\x05value\x18\x02 \x01(\x0b\x32\x13.lens.ArgumentValue\"C\n\rArgumentValue\x12)\n\x0csimple_value\x18\x03 \x01(\x0b\x32\x11.lens.SimpleValueH\x00\x42\x07\n\x05value\".\n\x0bSimpleValue\x12\x16\n\x0cstring_value\x18\x01 \x01(\tH\x00\x42\x07\n\x05valueB\x02H\x03\x62\x06proto3') - - - -_FUNCTIONCALL = DESCRIPTOR.message_types_by_name['FunctionCall'] -_FUNCTIONCALLSIGNALS = DESCRIPTOR.message_types_by_name['FunctionCallSignals'] -_ARGUMENT = DESCRIPTOR.message_types_by_name['Argument'] -_ARGUMENTVALUE = DESCRIPTOR.message_types_by_name['ArgumentValue'] -_SIMPLEVALUE = DESCRIPTOR.message_types_by_name['SimpleValue'] -FunctionCall = _reflection.GeneratedProtocolMessageType('FunctionCall', (_message.Message,), { - 'DESCRIPTOR' : _FUNCTIONCALL, - '__module__' : 'lens_overlay_knowledge_intent_query_pb2' - # @@protoc_insertion_point(class_scope:lens.FunctionCall) - }) -_sym_db.RegisterMessage(FunctionCall) - -FunctionCallSignals = _reflection.GeneratedProtocolMessageType('FunctionCallSignals', (_message.Message,), { - 'DESCRIPTOR' : _FUNCTIONCALLSIGNALS, - '__module__' : 'lens_overlay_knowledge_intent_query_pb2' - # @@protoc_insertion_point(class_scope:lens.FunctionCallSignals) - }) -_sym_db.RegisterMessage(FunctionCallSignals) - -Argument = _reflection.GeneratedProtocolMessageType('Argument', (_message.Message,), { - 'DESCRIPTOR' : _ARGUMENT, - '__module__' : 'lens_overlay_knowledge_intent_query_pb2' - # @@protoc_insertion_point(class_scope:lens.Argument) - }) -_sym_db.RegisterMessage(Argument) - -ArgumentValue = _reflection.GeneratedProtocolMessageType('ArgumentValue', (_message.Message,), { - 'DESCRIPTOR' : _ARGUMENTVALUE, - '__module__' : 'lens_overlay_knowledge_intent_query_pb2' - # @@protoc_insertion_point(class_scope:lens.ArgumentValue) - }) -_sym_db.RegisterMessage(ArgumentValue) - -SimpleValue = _reflection.GeneratedProtocolMessageType('SimpleValue', (_message.Message,), { - 'DESCRIPTOR' : _SIMPLEVALUE, - '__module__' : 'lens_overlay_knowledge_intent_query_pb2' - # @@protoc_insertion_point(class_scope:lens.SimpleValue) - }) -_sym_db.RegisterMessage(SimpleValue) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _FUNCTIONCALL._serialized_start=100 - _FUNCTIONCALL._serialized_end=206 - _FUNCTIONCALLSIGNALS._serialized_start=208 - _FUNCTIONCALLSIGNALS._serialized_end=305 - _ARGUMENT._serialized_start=307 - _ARGUMENT._serialized_end=367 - _ARGUMENTVALUE._serialized_start=369 - _ARGUMENTVALUE._serialized_end=436 - _SIMPLEVALUE._serialized_start=438 - _SIMPLEVALUE._serialized_end=484 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_knowledge_query_pb2.py b/owocr/py_lens/lens_overlay_knowledge_query_pb2.py deleted file mode 100644 index 40d3d88..0000000 --- a/owocr/py_lens/lens_overlay_knowledge_query_pb2.py +++ /dev/null @@ -1,36 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_knowledge_query.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_knowledge_intent_query_pb2 as lens__overlay__knowledge__intent__query__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"lens_overlay_knowledge_query.proto\x12\x04lens\x1a)lens_overlay_knowledge_intent_query.proto\"4\n\x05Query\x12+\n\x0cintent_query\x18\xc2\x95\xe9\x1a \x01(\x0b\x32\x12.lens.FunctionCallB\x02H\x03\x62\x06proto3') - - - -_QUERY = DESCRIPTOR.message_types_by_name['Query'] -Query = _reflection.GeneratedProtocolMessageType('Query', (_message.Message,), { - 'DESCRIPTOR' : _QUERY, - '__module__' : 'lens_overlay_knowledge_query_pb2' - # @@protoc_insertion_point(class_scope:lens.Query) - }) -_sym_db.RegisterMessage(Query) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _QUERY._serialized_start=87 - _QUERY._serialized_end=139 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_math_solver_query_pb2.py b/owocr/py_lens/lens_overlay_math_solver_query_pb2.py deleted file mode 100644 index f1d7e02..0000000 --- a/owocr/py_lens/lens_overlay_math_solver_query_pb2.py +++ /dev/null @@ -1,35 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_math_solver_query.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$lens_overlay_math_solver_query.proto\x12\x04lens\".\n\x0fMathSolverQuery\x12\x1b\n\x13math_input_equation\x18\x03 \x01(\tB\x02H\x03\x62\x06proto3') - - - -_MATHSOLVERQUERY = DESCRIPTOR.message_types_by_name['MathSolverQuery'] -MathSolverQuery = _reflection.GeneratedProtocolMessageType('MathSolverQuery', (_message.Message,), { - 'DESCRIPTOR' : _MATHSOLVERQUERY, - '__module__' : 'lens_overlay_math_solver_query_pb2' - # @@protoc_insertion_point(class_scope:lens.MathSolverQuery) - }) -_sym_db.RegisterMessage(MathSolverQuery) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _MATHSOLVERQUERY._serialized_start=46 - _MATHSOLVERQUERY._serialized_end=92 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_message_set_pb2.py b/owocr/py_lens/lens_overlay_message_set_pb2.py deleted file mode 100644 index 6dd0b27..0000000 --- a/owocr/py_lens/lens_overlay_message_set_pb2.py +++ /dev/null @@ -1,36 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_message_set.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_knowledge_query_pb2 as lens__overlay__knowledge__query__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1elens_overlay_message_set.proto\x12\x04lens\x1a\"lens_overlay_knowledge_query.proto\";\n\nMessageSet\x12-\n\x15message_set_extension\x18\xe9\xf8\xde\x13 \x01(\x0b\x32\x0b.lens.QueryB\x02H\x03\x62\x06proto3') - - - -_MESSAGESET = DESCRIPTOR.message_types_by_name['MessageSet'] -MessageSet = _reflection.GeneratedProtocolMessageType('MessageSet', (_message.Message,), { - 'DESCRIPTOR' : _MESSAGESET, - '__module__' : 'lens_overlay_message_set_pb2' - # @@protoc_insertion_point(class_scope:lens.MessageSet) - }) -_sym_db.RegisterMessage(MessageSet) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _MESSAGESET._serialized_start=76 - _MESSAGESET._serialized_end=135 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_overlay_object_pb2.py b/owocr/py_lens/lens_overlay_overlay_object_pb2.py deleted file mode 100644 index 42fddf1..0000000 --- a/owocr/py_lens/lens_overlay_overlay_object_pb2.py +++ /dev/null @@ -1,61 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_overlay_object.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_geometry_pb2 as lens__overlay__geometry__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!lens_overlay_overlay_object.proto\x12\x04lens\x1a\x1blens_overlay_geometry.proto\"\xac\x03\n\rOverlayObject\x12\n\n\x02id\x18\x01 \x01(\t\x12 \n\x08geometry\x18\x02 \x01(\x0b\x32\x0e.lens.Geometry\x12\x41\n\x12rendering_metadata\x18\x08 \x01(\x0b\x32%.lens.OverlayObject.RenderingMetadata\x12I\n\x16interaction_properties\x18\x04 \x01(\x0b\x32).lens.OverlayObject.InteractionProperties\x12\x14\n\x0cis_fulfilled\x18\t \x01(\x08\x1a\x80\x01\n\x11RenderingMetadata\x12\x45\n\x0brender_type\x18\x01 \x01(\x0e\x32\x30.lens.OverlayObject.RenderingMetadata.RenderType\"$\n\nRenderType\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05GLEAM\x10\x01\x1a.\n\x15InteractionProperties\x12\x15\n\rselect_on_tap\x18\x01 \x01(\x08J\x04\x08\x03\x10\x04J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07J\x04\x08\x07\x10\x08\x42\x02H\x03\x62\x06proto3') - - - -_OVERLAYOBJECT = DESCRIPTOR.message_types_by_name['OverlayObject'] -_OVERLAYOBJECT_RENDERINGMETADATA = _OVERLAYOBJECT.nested_types_by_name['RenderingMetadata'] -_OVERLAYOBJECT_INTERACTIONPROPERTIES = _OVERLAYOBJECT.nested_types_by_name['InteractionProperties'] -_OVERLAYOBJECT_RENDERINGMETADATA_RENDERTYPE = _OVERLAYOBJECT_RENDERINGMETADATA.enum_types_by_name['RenderType'] -OverlayObject = _reflection.GeneratedProtocolMessageType('OverlayObject', (_message.Message,), { - - 'RenderingMetadata' : _reflection.GeneratedProtocolMessageType('RenderingMetadata', (_message.Message,), { - 'DESCRIPTOR' : _OVERLAYOBJECT_RENDERINGMETADATA, - '__module__' : 'lens_overlay_overlay_object_pb2' - # @@protoc_insertion_point(class_scope:lens.OverlayObject.RenderingMetadata) - }) - , - - 'InteractionProperties' : _reflection.GeneratedProtocolMessageType('InteractionProperties', (_message.Message,), { - 'DESCRIPTOR' : _OVERLAYOBJECT_INTERACTIONPROPERTIES, - '__module__' : 'lens_overlay_overlay_object_pb2' - # @@protoc_insertion_point(class_scope:lens.OverlayObject.InteractionProperties) - }) - , - 'DESCRIPTOR' : _OVERLAYOBJECT, - '__module__' : 'lens_overlay_overlay_object_pb2' - # @@protoc_insertion_point(class_scope:lens.OverlayObject) - }) -_sym_db.RegisterMessage(OverlayObject) -_sym_db.RegisterMessage(OverlayObject.RenderingMetadata) -_sym_db.RegisterMessage(OverlayObject.InteractionProperties) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _OVERLAYOBJECT._serialized_start=73 - _OVERLAYOBJECT._serialized_end=501 - _OVERLAYOBJECT_RENDERINGMETADATA._serialized_start=301 - _OVERLAYOBJECT_RENDERINGMETADATA._serialized_end=429 - _OVERLAYOBJECT_RENDERINGMETADATA_RENDERTYPE._serialized_start=393 - _OVERLAYOBJECT_RENDERINGMETADATA_RENDERTYPE._serialized_end=429 - _OVERLAYOBJECT_INTERACTIONPROPERTIES._serialized_start=431 - _OVERLAYOBJECT_INTERACTIONPROPERTIES._serialized_end=477 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_payload_pb2.py b/owocr/py_lens/lens_overlay_payload_pb2.py deleted file mode 100644 index cdca286..0000000 --- a/owocr/py_lens/lens_overlay_payload_pb2.py +++ /dev/null @@ -1,35 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_payload.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1alens_overlay_payload.proto\x12\x04lens\"0\n\x0b\x43lientImage\x12\x15\n\rimage_content\x18\x01 \x01(\x0cJ\x04\x08\x02\x10\x03J\x04\x08\x03\x10\x04\x42\x02H\x03\x62\x06proto3') - - - -_CLIENTIMAGE = DESCRIPTOR.message_types_by_name['ClientImage'] -ClientImage = _reflection.GeneratedProtocolMessageType('ClientImage', (_message.Message,), { - 'DESCRIPTOR' : _CLIENTIMAGE, - '__module__' : 'lens_overlay_payload_pb2' - # @@protoc_insertion_point(class_scope:lens.ClientImage) - }) -_sym_db.RegisterMessage(ClientImage) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _CLIENTIMAGE._serialized_start=36 - _CLIENTIMAGE._serialized_end=84 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_phase_latencies_metadata_pb2.py b/owocr/py_lens/lens_overlay_phase_latencies_metadata_pb2.py deleted file mode 100644 index c39d772..0000000 --- a/owocr/py_lens/lens_overlay_phase_latencies_metadata_pb2.py +++ /dev/null @@ -1,71 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_phase_latencies_metadata.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n+lens_overlay_phase_latencies_metadata.proto\x12\x04lens\"\xd2\x04\n!LensOverlayPhaseLatenciesMetadata\x12<\n\x05phase\x18\x01 \x03(\x0b\x32-.lens.LensOverlayPhaseLatenciesMetadata.Phase\x1a\xb7\x03\n\x05Phase\x12`\n\x14image_downscale_data\x18\x03 \x01(\x0b\x32@.lens.LensOverlayPhaseLatenciesMetadata.Phase.ImageDownscaleDataH\x00\x12Z\n\x11image_encode_data\x18\x04 \x01(\x0b\x32=.lens.LensOverlayPhaseLatenciesMetadata.Phase.ImageEncodeDataH\x00\x1aP\n\x12ImageDownscaleData\x12\x1b\n\x13original_image_size\x18\x01 \x01(\x03\x12\x1d\n\x15\x64ownscaled_image_size\x18\x02 \x01(\x03\x1a\x83\x01\n\x0fImageEncodeData\x12N\n\x13original_image_type\x18\x01 \x01(\x0e\x32\x31.lens.LensOverlayPhaseLatenciesMetadata.ImageType\x12 \n\x18\x65ncoded_image_size_bytes\x18\x02 \x01(\x03\x42\x0c\n\nphase_dataJ\x04\x08\x01\x10\x02J\x04\x08\x02\x10\x03\"5\n\tImageType\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x08\n\x04JPEG\x10\x01\x12\x07\n\x03PNG\x10\x02\x12\x08\n\x04WEBP\x10\x03\x42\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYPHASELATENCIESMETADATA = DESCRIPTOR.message_types_by_name['LensOverlayPhaseLatenciesMetadata'] -_LENSOVERLAYPHASELATENCIESMETADATA_PHASE = _LENSOVERLAYPHASELATENCIESMETADATA.nested_types_by_name['Phase'] -_LENSOVERLAYPHASELATENCIESMETADATA_PHASE_IMAGEDOWNSCALEDATA = _LENSOVERLAYPHASELATENCIESMETADATA_PHASE.nested_types_by_name['ImageDownscaleData'] -_LENSOVERLAYPHASELATENCIESMETADATA_PHASE_IMAGEENCODEDATA = _LENSOVERLAYPHASELATENCIESMETADATA_PHASE.nested_types_by_name['ImageEncodeData'] -_LENSOVERLAYPHASELATENCIESMETADATA_IMAGETYPE = _LENSOVERLAYPHASELATENCIESMETADATA.enum_types_by_name['ImageType'] -LensOverlayPhaseLatenciesMetadata = _reflection.GeneratedProtocolMessageType('LensOverlayPhaseLatenciesMetadata', (_message.Message,), { - - 'Phase' : _reflection.GeneratedProtocolMessageType('Phase', (_message.Message,), { - - 'ImageDownscaleData' : _reflection.GeneratedProtocolMessageType('ImageDownscaleData', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYPHASELATENCIESMETADATA_PHASE_IMAGEDOWNSCALEDATA, - '__module__' : 'lens_overlay_phase_latencies_metadata_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayPhaseLatenciesMetadata.Phase.ImageDownscaleData) - }) - , - - 'ImageEncodeData' : _reflection.GeneratedProtocolMessageType('ImageEncodeData', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYPHASELATENCIESMETADATA_PHASE_IMAGEENCODEDATA, - '__module__' : 'lens_overlay_phase_latencies_metadata_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayPhaseLatenciesMetadata.Phase.ImageEncodeData) - }) - , - 'DESCRIPTOR' : _LENSOVERLAYPHASELATENCIESMETADATA_PHASE, - '__module__' : 'lens_overlay_phase_latencies_metadata_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayPhaseLatenciesMetadata.Phase) - }) - , - 'DESCRIPTOR' : _LENSOVERLAYPHASELATENCIESMETADATA, - '__module__' : 'lens_overlay_phase_latencies_metadata_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayPhaseLatenciesMetadata) - }) -_sym_db.RegisterMessage(LensOverlayPhaseLatenciesMetadata) -_sym_db.RegisterMessage(LensOverlayPhaseLatenciesMetadata.Phase) -_sym_db.RegisterMessage(LensOverlayPhaseLatenciesMetadata.Phase.ImageDownscaleData) -_sym_db.RegisterMessage(LensOverlayPhaseLatenciesMetadata.Phase.ImageEncodeData) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYPHASELATENCIESMETADATA._serialized_start=54 - _LENSOVERLAYPHASELATENCIESMETADATA._serialized_end=648 - _LENSOVERLAYPHASELATENCIESMETADATA_PHASE._serialized_start=154 - _LENSOVERLAYPHASELATENCIESMETADATA_PHASE._serialized_end=593 - _LENSOVERLAYPHASELATENCIESMETADATA_PHASE_IMAGEDOWNSCALEDATA._serialized_start=353 - _LENSOVERLAYPHASELATENCIESMETADATA_PHASE_IMAGEDOWNSCALEDATA._serialized_end=433 - _LENSOVERLAYPHASELATENCIESMETADATA_PHASE_IMAGEENCODEDATA._serialized_start=436 - _LENSOVERLAYPHASELATENCIESMETADATA_PHASE_IMAGEENCODEDATA._serialized_end=567 - _LENSOVERLAYPHASELATENCIESMETADATA_IMAGETYPE._serialized_start=595 - _LENSOVERLAYPHASELATENCIESMETADATA_IMAGETYPE._serialized_end=648 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_platform_pb2.py b/owocr/py_lens/lens_overlay_platform_pb2.py deleted file mode 100644 index 0f58b47..0000000 --- a/owocr/py_lens/lens_overlay_platform_pb2.py +++ /dev/null @@ -1,33 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_platform.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import enum_type_wrapper -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1blens_overlay_platform.proto\x12\x04lens*Q\n\x08Platform\x12\x18\n\x14PLATFORM_UNSPECIFIED\x10\x00\x12\x10\n\x0cPLATFORM_WEB\x10\x03\x12\x19\n\x15PLATFORM_LENS_OVERLAY\x10\x06\x42\x02H\x03\x62\x06proto3') - -_PLATFORM = DESCRIPTOR.enum_types_by_name['Platform'] -Platform = enum_type_wrapper.EnumTypeWrapper(_PLATFORM) -PLATFORM_UNSPECIFIED = 0 -PLATFORM_WEB = 3 -PLATFORM_LENS_OVERLAY = 6 - - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _PLATFORM._serialized_start=37 - _PLATFORM._serialized_end=118 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_polygon_pb2.py b/owocr/py_lens/lens_overlay_polygon_pb2.py deleted file mode 100644 index fb9555a..0000000 --- a/owocr/py_lens/lens_overlay_polygon_pb2.py +++ /dev/null @@ -1,57 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_polygon.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import enum_type_wrapper -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1alens_overlay_polygon.proto\x12\x04lens\"\x8e\x02\n\x07Polygon\x12$\n\x06vertex\x18\x01 \x03(\x0b\x32\x14.lens.Polygon.Vertex\x12\x35\n\x0fvertex_ordering\x18\x02 \x01(\x0e\x32\x1c.lens.Polygon.VertexOrdering\x12-\n\x0f\x63oordinate_type\x18\x03 \x01(\x0e\x32\x14.lens.CoordinateType\x1a\x1e\n\x06Vertex\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\"W\n\x0eVertexOrdering\x12\x1f\n\x1bVERTEX_ORDERING_UNSPECIFIED\x10\x00\x12\r\n\tCLOCKWISE\x10\x01\x12\x15\n\x11\x43OUNTER_CLOCKWISE\x10\x02*L\n\x0e\x43oordinateType\x12\x1f\n\x1b\x43OORDINATE_TYPE_UNSPECIFIED\x10\x00\x12\x0e\n\nNORMALIZED\x10\x01\x12\t\n\x05IMAGE\x10\x02\x42\x02H\x03\x62\x06proto3') - -_COORDINATETYPE = DESCRIPTOR.enum_types_by_name['CoordinateType'] -CoordinateType = enum_type_wrapper.EnumTypeWrapper(_COORDINATETYPE) -COORDINATE_TYPE_UNSPECIFIED = 0 -NORMALIZED = 1 -IMAGE = 2 - - -_POLYGON = DESCRIPTOR.message_types_by_name['Polygon'] -_POLYGON_VERTEX = _POLYGON.nested_types_by_name['Vertex'] -_POLYGON_VERTEXORDERING = _POLYGON.enum_types_by_name['VertexOrdering'] -Polygon = _reflection.GeneratedProtocolMessageType('Polygon', (_message.Message,), { - - 'Vertex' : _reflection.GeneratedProtocolMessageType('Vertex', (_message.Message,), { - 'DESCRIPTOR' : _POLYGON_VERTEX, - '__module__' : 'lens_overlay_polygon_pb2' - # @@protoc_insertion_point(class_scope:lens.Polygon.Vertex) - }) - , - 'DESCRIPTOR' : _POLYGON, - '__module__' : 'lens_overlay_polygon_pb2' - # @@protoc_insertion_point(class_scope:lens.Polygon) - }) -_sym_db.RegisterMessage(Polygon) -_sym_db.RegisterMessage(Polygon.Vertex) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _COORDINATETYPE._serialized_start=309 - _COORDINATETYPE._serialized_end=385 - _POLYGON._serialized_start=37 - _POLYGON._serialized_end=307 - _POLYGON_VERTEX._serialized_start=188 - _POLYGON_VERTEX._serialized_end=218 - _POLYGON_VERTEXORDERING._serialized_start=220 - _POLYGON_VERTEXORDERING._serialized_end=307 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_request_id_pb2.py b/owocr/py_lens/lens_overlay_request_id_pb2.py deleted file mode 100644 index 6f49309..0000000 --- a/owocr/py_lens/lens_overlay_request_id_pb2.py +++ /dev/null @@ -1,36 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_request_id.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_routing_info_pb2 as lens__overlay__routing__info__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1dlens_overlay_request_id.proto\x12\x04lens\x1a\x1flens_overlay_routing_info.proto\"\xb7\x01\n\x14LensOverlayRequestId\x12\x0c\n\x04uuid\x18\x01 \x01(\x04\x12\x13\n\x0bsequence_id\x18\x02 \x01(\x05\x12\x19\n\x11image_sequence_id\x18\x03 \x01(\x05\x12\x14\n\x0c\x61nalytics_id\x18\x04 \x01(\x0c\x12\x17\n\x0flong_context_id\x18\t \x01(\x05\x12\x32\n\x0crouting_info\x18\x06 \x01(\x0b\x32\x1c.lens.LensOverlayRoutingInfoB\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYREQUESTID = DESCRIPTOR.message_types_by_name['LensOverlayRequestId'] -LensOverlayRequestId = _reflection.GeneratedProtocolMessageType('LensOverlayRequestId', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYREQUESTID, - '__module__' : 'lens_overlay_request_id_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayRequestId) - }) -_sym_db.RegisterMessage(LensOverlayRequestId) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYREQUESTID._serialized_start=73 - _LENSOVERLAYREQUESTID._serialized_end=256 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_request_type_pb2.py b/owocr/py_lens/lens_overlay_request_type_pb2.py deleted file mode 100644 index b724a4f..0000000 --- a/owocr/py_lens/lens_overlay_request_type_pb2.py +++ /dev/null @@ -1,34 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_request_type.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import enum_type_wrapper -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1flens_overlay_request_type.proto\x12\x04lens*{\n\x0bRequestType\x12\x18\n\x14REQUEST_TYPE_DEFAULT\x10\x00\x12\x14\n\x10REQUEST_TYPE_PDF\x10\x01\x12\"\n\x1eREQUEST_TYPE_EARLY_PARTIAL_PDF\x10\x03\x12\x18\n\x14REQUEST_TYPE_WEBPAGE\x10\x02\x42\x02H\x03\x62\x06proto3') - -_REQUESTTYPE = DESCRIPTOR.enum_types_by_name['RequestType'] -RequestType = enum_type_wrapper.EnumTypeWrapper(_REQUESTTYPE) -REQUEST_TYPE_DEFAULT = 0 -REQUEST_TYPE_PDF = 1 -REQUEST_TYPE_EARLY_PARTIAL_PDF = 3 -REQUEST_TYPE_WEBPAGE = 2 - - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _REQUESTTYPE._serialized_start=41 - _REQUESTTYPE._serialized_end=164 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_routing_info_pb2.py b/owocr/py_lens/lens_overlay_routing_info_pb2.py deleted file mode 100644 index 29aeac2..0000000 --- a/owocr/py_lens/lens_overlay_routing_info_pb2.py +++ /dev/null @@ -1,35 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_routing_info.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1flens_overlay_routing_info.proto\x12\x04lens\"\\\n\x16LensOverlayRoutingInfo\x12\x16\n\x0eserver_address\x18\x01 \x01(\t\x12\x14\n\x0c\x63\x65ll_address\x18\x03 \x01(\t\x12\x14\n\x0c\x62lade_target\x18\x02 \x01(\tB\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYROUTINGINFO = DESCRIPTOR.message_types_by_name['LensOverlayRoutingInfo'] -LensOverlayRoutingInfo = _reflection.GeneratedProtocolMessageType('LensOverlayRoutingInfo', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYROUTINGINFO, - '__module__' : 'lens_overlay_routing_info_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayRoutingInfo) - }) -_sym_db.RegisterMessage(LensOverlayRoutingInfo) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYROUTINGINFO._serialized_start=41 - _LENSOVERLAYROUTINGINFO._serialized_end=133 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_selection_type_pb2.py b/owocr/py_lens/lens_overlay_selection_type_pb2.py deleted file mode 100644 index 1e193fe..0000000 --- a/owocr/py_lens/lens_overlay_selection_type_pb2.py +++ /dev/null @@ -1,43 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_selection_type.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import enum_type_wrapper -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!lens_overlay_selection_type.proto\x12\x04lens*\xdd\x02\n\x18LensOverlaySelectionType\x12\x1a\n\x16UNKNOWN_SELECTION_TYPE\x10\x00\x12\x10\n\x0cTAP_ON_EMPTY\x10\x01\x12\x19\n\x15SELECT_TEXT_HIGHLIGHT\x10\x03\x12\x11\n\rREGION_SEARCH\x10\x07\x12\x12\n\x0eINJECTED_IMAGE\x10\n\x12\x17\n\x13TAP_ON_REGION_GLEAM\x10\x0f\x12\x15\n\x11MULTIMODAL_SEARCH\x10\x12\x12\x1a\n\x16SELECT_TRANSLATED_TEXT\x10\x15\x12\x11\n\rTAP_ON_OBJECT\x10\x16\x12 \n\x1cMULTIMODAL_SUGGEST_TYPEAHEAD\x10\x19\x12\"\n\x1eMULTIMODAL_SUGGEST_ZERO_PREFIX\x10\x1a\x12\x12\n\x0eTRANSLATE_CHIP\x10\x34\x12\x18\n\x14SYMBOLIC_MATH_OBJECT\x10\x35\x42\x02H\x03\x62\x06proto3') - -_LENSOVERLAYSELECTIONTYPE = DESCRIPTOR.enum_types_by_name['LensOverlaySelectionType'] -LensOverlaySelectionType = enum_type_wrapper.EnumTypeWrapper(_LENSOVERLAYSELECTIONTYPE) -UNKNOWN_SELECTION_TYPE = 0 -TAP_ON_EMPTY = 1 -SELECT_TEXT_HIGHLIGHT = 3 -REGION_SEARCH = 7 -INJECTED_IMAGE = 10 -TAP_ON_REGION_GLEAM = 15 -MULTIMODAL_SEARCH = 18 -SELECT_TRANSLATED_TEXT = 21 -TAP_ON_OBJECT = 22 -MULTIMODAL_SUGGEST_TYPEAHEAD = 25 -MULTIMODAL_SUGGEST_ZERO_PREFIX = 26 -TRANSLATE_CHIP = 52 -SYMBOLIC_MATH_OBJECT = 53 - - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYSELECTIONTYPE._serialized_start=44 - _LENSOVERLAYSELECTIONTYPE._serialized_end=393 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_server_pb2.py b/owocr/py_lens/lens_overlay_server_pb2.py deleted file mode 100644 index dea4d38..0000000 --- a/owocr/py_lens/lens_overlay_server_pb2.py +++ /dev/null @@ -1,81 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_server.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_client_logs_pb2 as lens__overlay__client__logs__pb2 -import owocr.py_lens.lens_overlay_routing_info_pb2 as lens__overlay__routing__info__pb2 -import owocr.py_lens.lens_overlay_service_deps_pb2 as lens__overlay__service__deps__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x19lens_overlay_server.proto\x12\x04lens\x1a\x1elens_overlay_client_logs.proto\x1a\x1flens_overlay_routing_info.proto\x1a\x1flens_overlay_service_deps.proto\"G\n#LensOverlayServerClusterInfoRequest\x12 \n\x18\x65nable_search_session_id\x18\x01 \x01(\x08\"\x90\x01\n$LensOverlayServerClusterInfoResponse\x12\x19\n\x11server_session_id\x18\x01 \x01(\t\x12\x19\n\x11search_session_id\x18\x02 \x01(\t\x12\x32\n\x0crouting_info\x18\x03 \x01(\x0b\x32\x1c.lens.LensOverlayRoutingInfo\"\x88\x01\n\x16LensOverlayServerError\x12:\n\nerror_type\x18\x01 \x01(\x0e\x32&.lens.LensOverlayServerError.ErrorType\"2\n\tErrorType\x12\x10\n\x0cUNKNOWN_TYPE\x10\x00\x12\x13\n\x0fMISSING_REQUEST\x10\x01\"\xc8\x01\n\x18LensOverlayServerRequest\x12\x38\n\x0fobjects_request\x18\x01 \x01(\x0b\x32\x1f.lens.LensOverlayObjectsRequest\x12@\n\x13interaction_request\x18\x02 \x01(\x0b\x32#.lens.LensOverlayInteractionRequest\x12\x30\n\x0b\x63lient_logs\x18\x03 \x01(\x0b\x32\x1b.lens.LensOverlayClientLogs\"\xc8\x01\n\x19LensOverlayServerResponse\x12+\n\x05\x65rror\x18\x01 \x01(\x0b\x32\x1c.lens.LensOverlayServerError\x12:\n\x10objects_response\x18\x02 \x01(\x0b\x32 .lens.LensOverlayObjectsResponse\x12\x42\n\x14interaction_response\x18\x03 \x01(\x0b\x32$.lens.LensOverlayInteractionResponseB\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYSERVERCLUSTERINFOREQUEST = DESCRIPTOR.message_types_by_name['LensOverlayServerClusterInfoRequest'] -_LENSOVERLAYSERVERCLUSTERINFORESPONSE = DESCRIPTOR.message_types_by_name['LensOverlayServerClusterInfoResponse'] -_LENSOVERLAYSERVERERROR = DESCRIPTOR.message_types_by_name['LensOverlayServerError'] -_LENSOVERLAYSERVERREQUEST = DESCRIPTOR.message_types_by_name['LensOverlayServerRequest'] -_LENSOVERLAYSERVERRESPONSE = DESCRIPTOR.message_types_by_name['LensOverlayServerResponse'] -_LENSOVERLAYSERVERERROR_ERRORTYPE = _LENSOVERLAYSERVERERROR.enum_types_by_name['ErrorType'] -LensOverlayServerClusterInfoRequest = _reflection.GeneratedProtocolMessageType('LensOverlayServerClusterInfoRequest', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYSERVERCLUSTERINFOREQUEST, - '__module__' : 'lens_overlay_server_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayServerClusterInfoRequest) - }) -_sym_db.RegisterMessage(LensOverlayServerClusterInfoRequest) - -LensOverlayServerClusterInfoResponse = _reflection.GeneratedProtocolMessageType('LensOverlayServerClusterInfoResponse', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYSERVERCLUSTERINFORESPONSE, - '__module__' : 'lens_overlay_server_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayServerClusterInfoResponse) - }) -_sym_db.RegisterMessage(LensOverlayServerClusterInfoResponse) - -LensOverlayServerError = _reflection.GeneratedProtocolMessageType('LensOverlayServerError', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYSERVERERROR, - '__module__' : 'lens_overlay_server_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayServerError) - }) -_sym_db.RegisterMessage(LensOverlayServerError) - -LensOverlayServerRequest = _reflection.GeneratedProtocolMessageType('LensOverlayServerRequest', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYSERVERREQUEST, - '__module__' : 'lens_overlay_server_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayServerRequest) - }) -_sym_db.RegisterMessage(LensOverlayServerRequest) - -LensOverlayServerResponse = _reflection.GeneratedProtocolMessageType('LensOverlayServerResponse', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYSERVERRESPONSE, - '__module__' : 'lens_overlay_server_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayServerResponse) - }) -_sym_db.RegisterMessage(LensOverlayServerResponse) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYSERVERCLUSTERINFOREQUEST._serialized_start=133 - _LENSOVERLAYSERVERCLUSTERINFOREQUEST._serialized_end=204 - _LENSOVERLAYSERVERCLUSTERINFORESPONSE._serialized_start=207 - _LENSOVERLAYSERVERCLUSTERINFORESPONSE._serialized_end=351 - _LENSOVERLAYSERVERERROR._serialized_start=354 - _LENSOVERLAYSERVERERROR._serialized_end=490 - _LENSOVERLAYSERVERERROR_ERRORTYPE._serialized_start=440 - _LENSOVERLAYSERVERERROR_ERRORTYPE._serialized_end=490 - _LENSOVERLAYSERVERREQUEST._serialized_start=493 - _LENSOVERLAYSERVERREQUEST._serialized_end=693 - _LENSOVERLAYSERVERRESPONSE._serialized_start=696 - _LENSOVERLAYSERVERRESPONSE._serialized_end=896 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_service_deps_pb2.py b/owocr/py_lens/lens_overlay_service_deps_pb2.py deleted file mode 100644 index afb502a..0000000 --- a/owocr/py_lens/lens_overlay_service_deps_pb2.py +++ /dev/null @@ -1,176 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_service_deps.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import enum_type_wrapper -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_client_context_pb2 as lens__overlay__client__context__pb2 -import owocr.py_lens.lens_overlay_cluster_info_pb2 as lens__overlay__cluster__info__pb2 -import owocr.py_lens.lens_overlay_deep_gleam_data_pb2 as lens__overlay__deep__gleam__data__pb2 -import owocr.py_lens.lens_overlay_document_pb2 as lens__overlay__document__pb2 -import owocr.py_lens.lens_overlay_image_crop_pb2 as lens__overlay__image__crop__pb2 -import owocr.py_lens.lens_overlay_image_data_pb2 as lens__overlay__image__data__pb2 -import owocr.py_lens.lens_overlay_interaction_request_metadata_pb2 as lens__overlay__interaction__request__metadata__pb2 -import owocr.py_lens.lens_overlay_overlay_object_pb2 as lens__overlay__overlay__object__pb2 -import owocr.py_lens.lens_overlay_request_id_pb2 as lens__overlay__request__id__pb2 -import owocr.py_lens.lens_overlay_request_type_pb2 as lens__overlay__request__type__pb2 -import owocr.py_lens.lens_overlay_text_pb2 as lens__overlay__text__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1flens_overlay_service_deps.proto\x12\x04lens\x1a!lens_overlay_client_context.proto\x1a\x1flens_overlay_cluster_info.proto\x1a\"lens_overlay_deep_gleam_data.proto\x1a\x1blens_overlay_document.proto\x1a\x1dlens_overlay_image_crop.proto\x1a\x1dlens_overlay_image_data.proto\x1a/lens_overlay_interaction_request_metadata.proto\x1a!lens_overlay_overlay_object.proto\x1a\x1dlens_overlay_request_id.proto\x1a\x1flens_overlay_request_type.proto\x1a\x17lens_overlay_text.proto\"\x8f\x01\n\x19LensOverlayRequestContext\x12.\n\nrequest_id\x18\x03 \x01(\x0b\x32\x1a.lens.LensOverlayRequestId\x12\x36\n\x0e\x63lient_context\x18\x04 \x01(\x0b\x32\x1e.lens.LensOverlayClientContextJ\x04\x08\x01\x10\x02J\x04\x08\x02\x10\x03\"\xa0\x01\n\x19LensOverlayObjectsRequest\x12\x38\n\x0frequest_context\x18\x01 \x01(\x0b\x32\x1f.lens.LensOverlayRequestContext\x12#\n\nimage_data\x18\x03 \x01(\x0b\x32\x0f.lens.ImageData\x12\x1e\n\x07payload\x18\x04 \x01(\x0b\x32\r.lens.PayloadJ\x04\x08\x02\x10\x03\"\xb0\x01\n\x1dLensOverlayUploadChunkRequest\x12\x38\n\x0frequest_context\x18\x01 \x01(\x0b\x32\x1f.lens.LensOverlayRequestContext\x12.\n\rdebug_options\x18\x06 \x01(\x0b\x32\x17.lens.ChunkDebugOptions\x12\x10\n\x08\x63hunk_id\x18\x03 \x01(\x03\x12\x13\n\x0b\x63hunk_bytes\x18\x04 \x01(\x0c\"R\n\x1eLensOverlayUploadChunkResponse\x12\x30\n\x0e\x64\x65\x62ug_metadata\x18\x02 \x01(\x0b\x32\x18.lens.ChunkDebugMetadata\"?\n\x11\x43hunkDebugOptions\x12\x14\n\x0ctotal_chunks\x18\x01 \x01(\x03\x12\x14\n\x0cquery_chunks\x18\x02 \x01(\x08\".\n\x12\x43hunkDebugMetadata\x12\x18\n\x10remaining_chunks\x18\x01 \x03(\x03\"\xd4\x01\n\x1aLensOverlayObjectsResponse\x12,\n\x0foverlay_objects\x18\x02 \x03(\x0b\x32\x13.lens.OverlayObject\x12\x18\n\x04text\x18\x03 \x01(\x0b\x32\n.lens.Text\x12(\n\x0b\x64\x65\x65p_gleams\x18\x04 \x03(\x0b\x32\x13.lens.DeepGleamData\x12\x32\n\x0c\x63luster_info\x18\x07 \x01(\x0b\x32\x1c.lens.LensOverlayClusterInfoJ\x04\x08\x01\x10\x02J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07\"\xd1\x01\n\x1dLensOverlayInteractionRequest\x12\x38\n\x0frequest_context\x18\x01 \x01(\x0b\x32\x1f.lens.LensOverlayRequestContext\x12Q\n\x1cinteraction_request_metadata\x18\x02 \x01(\x0b\x32+.lens.LensOverlayInteractionRequestMetadata\x12#\n\nimage_crop\x18\x03 \x01(\x0b\x32\x0f.lens.ImageCrop\"f\n\x1eLensOverlayInteractionResponse\x12\x18\n\x10\x65ncoded_response\x18\x03 \x01(\t\x12\x18\n\x04text\x18\x05 \x01(\x0b\x32\n.lens.TextJ\x04\x08\x01\x10\x02J\x04\x08\x02\x10\x03J\x04\x08\x04\x10\x05\"\xdd\x02\n\x07Payload\x12\'\n\x0crequest_type\x18\x06 \x01(\x0e\x32\x11.lens.RequestType\x12#\n\nimage_data\x18\x02 \x01(\x0b\x32\x0f.lens.ImageData\x12\x14\n\x0c\x63ontent_data\x18\x03 \x01(\x0c\x12\x14\n\x0c\x63ontent_type\x18\x04 \x01(\t\x12\x10\n\x08page_url\x18\x05 \x01(\t\x12\x37\n\x14partial_pdf_document\x18\x07 \x01(\x0b\x32\x19.lens.LensOverlayDocument\x12/\n\x10\x63ompression_type\x18\x08 \x01(\x0e\x32\x15.lens.CompressionType\x12\x36\n\x14stored_chunk_options\x18\t \x01(\x0b\x32\x18.lens.StoredChunkOptions\x12\x1e\n\x07\x63ontent\x18\n \x01(\x0b\x32\r.lens.ContentJ\x04\x08\x01\x10\x02\"M\n\x12StoredChunkOptions\x12\x1a\n\x12read_stored_chunks\x18\x01 \x01(\x08\x12\x1b\n\x13total_stored_chunks\x18\x02 \x01(\x03\"p\n\x07\x43ontent\x12\x13\n\x0bwebpage_url\x18\x01 \x01(\t\x12\'\n\x0c\x63ontent_data\x18\x02 \x03(\x0b\x32\x11.lens.ContentData\x12\'\n\x0crequest_type\x18\x03 \x01(\x0e\x32\x11.lens.RequestType\"\x84\x03\n\x0b\x43ontentData\x12\x33\n\x0c\x63ontent_type\x18\x01 \x01(\x0e\x32\x1d.lens.ContentData.ContentType\x12\x0c\n\x04\x64\x61ta\x18\x02 \x01(\x0c\x12/\n\x10\x63ompression_type\x18\x03 \x01(\x0e\x32\x15.lens.CompressionType\x12\x36\n\x14stored_chunk_options\x18\x04 \x01(\x0b\x32\x18.lens.StoredChunkOptions\"\xc8\x01\n\x0b\x43ontentType\x12\x1c\n\x18\x43ONTENT_TYPE_UNSPECIFIED\x10\x00\x12\x14\n\x10\x43ONTENT_TYPE_PDF\x10\x01\x12\x1b\n\x17\x43ONTENT_TYPE_INNER_TEXT\x10\x02\x12\x1b\n\x17\x43ONTENT_TYPE_INNER_HTML\x10\x03\x12\'\n#CONTENT_TYPE_ANNOTATED_PAGE_CONTENT\x10\x04\x12\"\n\x1e\x43ONTENT_TYPE_EARLY_PARTIAL_PDF\x10\x05*-\n\x0f\x43ompressionType\x12\x10\n\x0cUNCOMPRESSED\x10\x00\x12\x08\n\x04ZSTD\x10\x01\x42\x02H\x03\x62\x06proto3') - -_COMPRESSIONTYPE = DESCRIPTOR.enum_types_by_name['CompressionType'] -CompressionType = enum_type_wrapper.EnumTypeWrapper(_COMPRESSIONTYPE) -UNCOMPRESSED = 0 -ZSTD = 1 - - -_LENSOVERLAYREQUESTCONTEXT = DESCRIPTOR.message_types_by_name['LensOverlayRequestContext'] -_LENSOVERLAYOBJECTSREQUEST = DESCRIPTOR.message_types_by_name['LensOverlayObjectsRequest'] -_LENSOVERLAYUPLOADCHUNKREQUEST = DESCRIPTOR.message_types_by_name['LensOverlayUploadChunkRequest'] -_LENSOVERLAYUPLOADCHUNKRESPONSE = DESCRIPTOR.message_types_by_name['LensOverlayUploadChunkResponse'] -_CHUNKDEBUGOPTIONS = DESCRIPTOR.message_types_by_name['ChunkDebugOptions'] -_CHUNKDEBUGMETADATA = DESCRIPTOR.message_types_by_name['ChunkDebugMetadata'] -_LENSOVERLAYOBJECTSRESPONSE = DESCRIPTOR.message_types_by_name['LensOverlayObjectsResponse'] -_LENSOVERLAYINTERACTIONREQUEST = DESCRIPTOR.message_types_by_name['LensOverlayInteractionRequest'] -_LENSOVERLAYINTERACTIONRESPONSE = DESCRIPTOR.message_types_by_name['LensOverlayInteractionResponse'] -_PAYLOAD = DESCRIPTOR.message_types_by_name['Payload'] -_STOREDCHUNKOPTIONS = DESCRIPTOR.message_types_by_name['StoredChunkOptions'] -_CONTENT = DESCRIPTOR.message_types_by_name['Content'] -_CONTENTDATA = DESCRIPTOR.message_types_by_name['ContentData'] -_CONTENTDATA_CONTENTTYPE = _CONTENTDATA.enum_types_by_name['ContentType'] -LensOverlayRequestContext = _reflection.GeneratedProtocolMessageType('LensOverlayRequestContext', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYREQUESTCONTEXT, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayRequestContext) - }) -_sym_db.RegisterMessage(LensOverlayRequestContext) - -LensOverlayObjectsRequest = _reflection.GeneratedProtocolMessageType('LensOverlayObjectsRequest', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYOBJECTSREQUEST, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayObjectsRequest) - }) -_sym_db.RegisterMessage(LensOverlayObjectsRequest) - -LensOverlayUploadChunkRequest = _reflection.GeneratedProtocolMessageType('LensOverlayUploadChunkRequest', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYUPLOADCHUNKREQUEST, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayUploadChunkRequest) - }) -_sym_db.RegisterMessage(LensOverlayUploadChunkRequest) - -LensOverlayUploadChunkResponse = _reflection.GeneratedProtocolMessageType('LensOverlayUploadChunkResponse', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYUPLOADCHUNKRESPONSE, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayUploadChunkResponse) - }) -_sym_db.RegisterMessage(LensOverlayUploadChunkResponse) - -ChunkDebugOptions = _reflection.GeneratedProtocolMessageType('ChunkDebugOptions', (_message.Message,), { - 'DESCRIPTOR' : _CHUNKDEBUGOPTIONS, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.ChunkDebugOptions) - }) -_sym_db.RegisterMessage(ChunkDebugOptions) - -ChunkDebugMetadata = _reflection.GeneratedProtocolMessageType('ChunkDebugMetadata', (_message.Message,), { - 'DESCRIPTOR' : _CHUNKDEBUGMETADATA, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.ChunkDebugMetadata) - }) -_sym_db.RegisterMessage(ChunkDebugMetadata) - -LensOverlayObjectsResponse = _reflection.GeneratedProtocolMessageType('LensOverlayObjectsResponse', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYOBJECTSRESPONSE, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayObjectsResponse) - }) -_sym_db.RegisterMessage(LensOverlayObjectsResponse) - -LensOverlayInteractionRequest = _reflection.GeneratedProtocolMessageType('LensOverlayInteractionRequest', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYINTERACTIONREQUEST, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayInteractionRequest) - }) -_sym_db.RegisterMessage(LensOverlayInteractionRequest) - -LensOverlayInteractionResponse = _reflection.GeneratedProtocolMessageType('LensOverlayInteractionResponse', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYINTERACTIONRESPONSE, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayInteractionResponse) - }) -_sym_db.RegisterMessage(LensOverlayInteractionResponse) - -Payload = _reflection.GeneratedProtocolMessageType('Payload', (_message.Message,), { - 'DESCRIPTOR' : _PAYLOAD, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.Payload) - }) -_sym_db.RegisterMessage(Payload) - -StoredChunkOptions = _reflection.GeneratedProtocolMessageType('StoredChunkOptions', (_message.Message,), { - 'DESCRIPTOR' : _STOREDCHUNKOPTIONS, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.StoredChunkOptions) - }) -_sym_db.RegisterMessage(StoredChunkOptions) - -Content = _reflection.GeneratedProtocolMessageType('Content', (_message.Message,), { - 'DESCRIPTOR' : _CONTENT, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.Content) - }) -_sym_db.RegisterMessage(Content) - -ContentData = _reflection.GeneratedProtocolMessageType('ContentData', (_message.Message,), { - 'DESCRIPTOR' : _CONTENTDATA, - '__module__' : 'lens_overlay_service_deps_pb2' - # @@protoc_insertion_point(class_scope:lens.ContentData) - }) -_sym_db.RegisterMessage(ContentData) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _COMPRESSIONTYPE._serialized_start=2561 - _COMPRESSIONTYPE._serialized_end=2606 - _LENSOVERLAYREQUESTCONTEXT._serialized_start=410 - _LENSOVERLAYREQUESTCONTEXT._serialized_end=553 - _LENSOVERLAYOBJECTSREQUEST._serialized_start=556 - _LENSOVERLAYOBJECTSREQUEST._serialized_end=716 - _LENSOVERLAYUPLOADCHUNKREQUEST._serialized_start=719 - _LENSOVERLAYUPLOADCHUNKREQUEST._serialized_end=895 - _LENSOVERLAYUPLOADCHUNKRESPONSE._serialized_start=897 - _LENSOVERLAYUPLOADCHUNKRESPONSE._serialized_end=979 - _CHUNKDEBUGOPTIONS._serialized_start=981 - _CHUNKDEBUGOPTIONS._serialized_end=1044 - _CHUNKDEBUGMETADATA._serialized_start=1046 - _CHUNKDEBUGMETADATA._serialized_end=1092 - _LENSOVERLAYOBJECTSRESPONSE._serialized_start=1095 - _LENSOVERLAYOBJECTSRESPONSE._serialized_end=1307 - _LENSOVERLAYINTERACTIONREQUEST._serialized_start=1310 - _LENSOVERLAYINTERACTIONREQUEST._serialized_end=1519 - _LENSOVERLAYINTERACTIONRESPONSE._serialized_start=1521 - _LENSOVERLAYINTERACTIONRESPONSE._serialized_end=1623 - _PAYLOAD._serialized_start=1626 - _PAYLOAD._serialized_end=1975 - _STOREDCHUNKOPTIONS._serialized_start=1977 - _STOREDCHUNKOPTIONS._serialized_end=2054 - _CONTENT._serialized_start=2056 - _CONTENT._serialized_end=2168 - _CONTENTDATA._serialized_start=2171 - _CONTENTDATA._serialized_end=2559 - _CONTENTDATA_CONTENTTYPE._serialized_start=2359 - _CONTENTDATA_CONTENTTYPE._serialized_end=2559 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_stickiness_signals_pb2.py b/owocr/py_lens/lens_overlay_stickiness_signals_pb2.py deleted file mode 100644 index b3f8da0..0000000 --- a/owocr/py_lens/lens_overlay_stickiness_signals_pb2.py +++ /dev/null @@ -1,50 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_stickiness_signals.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_math_solver_query_pb2 as lens__overlay__math__solver__query__pb2 -import owocr.py_lens.lens_overlay_message_set_pb2 as lens__overlay__message__set__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n%lens_overlay_stickiness_signals.proto\x12\x04lens\x1a$lens_overlay_math_solver_query.proto\x1a\x1elens_overlay_message_set.proto\"\xfb\x01\n\x11StickinessSignals\x12\x37\n\x0cid_namespace\x18\x01 \x01(\x0e\x32!.lens.StickinessSignals.Namespace\x12(\n\x0einterpretation\x18\x1c \x01(\x0b\x32\x10.lens.MessageSet\x12@\n\x19\x65\x64ucation_input_extension\x18y \x01(\x0b\x32\x1d.lens.EducationInputExtension\"A\n\tNamespace\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x12\n\x0eTRANSLATE_LITE\x10\x38\x12\x13\n\x0f\x45\x44UCATION_INPUT\x10O\"K\n\x17\x45\x64ucationInputExtension\x12\x30\n\x11math_solver_query\x18\x01 \x01(\x0b\x32\x15.lens.MathSolverQueryB\x02H\x03') - - - -_STICKINESSSIGNALS = DESCRIPTOR.message_types_by_name['StickinessSignals'] -_EDUCATIONINPUTEXTENSION = DESCRIPTOR.message_types_by_name['EducationInputExtension'] -_STICKINESSSIGNALS_NAMESPACE = _STICKINESSSIGNALS.enum_types_by_name['Namespace'] -StickinessSignals = _reflection.GeneratedProtocolMessageType('StickinessSignals', (_message.Message,), { - 'DESCRIPTOR' : _STICKINESSSIGNALS, - '__module__' : 'lens_overlay_stickiness_signals_pb2' - # @@protoc_insertion_point(class_scope:lens.StickinessSignals) - }) -_sym_db.RegisterMessage(StickinessSignals) - -EducationInputExtension = _reflection.GeneratedProtocolMessageType('EducationInputExtension', (_message.Message,), { - 'DESCRIPTOR' : _EDUCATIONINPUTEXTENSION, - '__module__' : 'lens_overlay_stickiness_signals_pb2' - # @@protoc_insertion_point(class_scope:lens.EducationInputExtension) - }) -_sym_db.RegisterMessage(EducationInputExtension) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _STICKINESSSIGNALS._serialized_start=118 - _STICKINESSSIGNALS._serialized_end=369 - _STICKINESSSIGNALS_NAMESPACE._serialized_start=304 - _STICKINESSSIGNALS_NAMESPACE._serialized_end=369 - _EDUCATIONINPUTEXTENSION._serialized_start=371 - _EDUCATIONINPUTEXTENSION._serialized_end=446 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_surface_pb2.py b/owocr/py_lens/lens_overlay_surface_pb2.py deleted file mode 100644 index 12885b0..0000000 --- a/owocr/py_lens/lens_overlay_surface_pb2.py +++ /dev/null @@ -1,33 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_surface.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import enum_type_wrapper -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1alens_overlay_surface.proto\x12\x04lens*R\n\x07Surface\x12\x17\n\x13SURFACE_UNSPECIFIED\x10\x00\x12\x14\n\x10SURFACE_CHROMIUM\x10\x04\x12\x18\n\x14SURFACE_LENS_OVERLAY\x10*B\x02H\x03\x62\x06proto3') - -_SURFACE = DESCRIPTOR.enum_types_by_name['Surface'] -Surface = enum_type_wrapper.EnumTypeWrapper(_SURFACE) -SURFACE_UNSPECIFIED = 0 -SURFACE_CHROMIUM = 4 -SURFACE_LENS_OVERLAY = 42 - - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _SURFACE._serialized_start=36 - _SURFACE._serialized_end=118 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_text_pb2.py b/owocr/py_lens/lens_overlay_text_pb2.py deleted file mode 100644 index 576c71a..0000000 --- a/owocr/py_lens/lens_overlay_text_pb2.py +++ /dev/null @@ -1,118 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_text.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import enum_type_wrapper -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_geometry_pb2 as lens__overlay__geometry__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x17lens_overlay_text.proto\x12\x04lens\x1a\x1blens_overlay_geometry.proto\"M\n\x04Text\x12%\n\x0btext_layout\x18\x01 \x01(\x0b\x32\x10.lens.TextLayout\x12\x18\n\x10\x63ontent_language\x18\x02 \x01(\tJ\x04\x08\x03\x10\x04\"\x9a\x05\n\nTextLayout\x12.\n\nparagraphs\x18\x01 \x03(\x0b\x32\x1a.lens.TextLayout.Paragraph\x1a\xc0\x02\n\x04Word\x12&\n\x02id\x18\x01 \x01(\x0b\x32\x1a.lens.TextEntityIdentifier\x12\x12\n\nplain_text\x18\x02 \x01(\t\x12\x1b\n\x0etext_separator\x18\x03 \x01(\tH\x00\x88\x01\x01\x12 \n\x08geometry\x18\x04 \x01(\x0b\x32\x0e.lens.Geometry\x12(\n\x04type\x18\x05 \x01(\x0e\x32\x1a.lens.TextLayout.Word.Type\x12?\n\x10\x66ormula_metadata\x18\x06 \x01(\x0b\x32%.lens.TextLayout.Word.FormulaMetadata\x1a \n\x0f\x46ormulaMetadata\x12\r\n\x05latex\x18\x01 \x01(\t\"\x1d\n\x04Type\x12\x08\n\x04TEXT\x10\x00\x12\x0b\n\x07\x46ORMULA\x10\x01\x42\x11\n\x0f_text_separator\x1aN\n\x04Line\x12$\n\x05words\x18\x01 \x03(\x0b\x32\x15.lens.TextLayout.Word\x12 \n\x08geometry\x18\x02 \x01(\x0b\x32\x0e.lens.Geometry\x1a\xc8\x01\n\tParagraph\x12&\n\x02id\x18\x01 \x01(\x0b\x32\x1a.lens.TextEntityIdentifier\x12$\n\x05lines\x18\x02 \x03(\x0b\x32\x15.lens.TextLayout.Line\x12 \n\x08geometry\x18\x03 \x01(\x0b\x32\x0e.lens.Geometry\x12\x31\n\x11writing_direction\x18\x04 \x01(\x0e\x32\x16.lens.WritingDirection\x12\x18\n\x10\x63ontent_language\x18\x05 \x01(\t\"\"\n\x14TextEntityIdentifier\x12\n\n\x02id\x18\x01 \x01(\x03*\x89\x01\n\x10WritingDirection\x12+\n\'DEFAULT_WRITING_DIRECTION_LEFT_TO_RIGHT\x10\x00\x12#\n\x1fWRITING_DIRECTION_RIGHT_TO_LEFT\x10\x01\x12#\n\x1fWRITING_DIRECTION_TOP_TO_BOTTOM\x10\x02*L\n\tAlignment\x12\x18\n\x14\x44\x45\x46\x41ULT_LEFT_ALIGNED\x10\x00\x12\x11\n\rRIGHT_ALIGNED\x10\x01\x12\x12\n\x0e\x43\x45NTER_ALIGNED\x10\x02\x42\x02H\x03\x62\x06proto3') - -_WRITINGDIRECTION = DESCRIPTOR.enum_types_by_name['WritingDirection'] -WritingDirection = enum_type_wrapper.EnumTypeWrapper(_WRITINGDIRECTION) -_ALIGNMENT = DESCRIPTOR.enum_types_by_name['Alignment'] -Alignment = enum_type_wrapper.EnumTypeWrapper(_ALIGNMENT) -DEFAULT_WRITING_DIRECTION_LEFT_TO_RIGHT = 0 -WRITING_DIRECTION_RIGHT_TO_LEFT = 1 -WRITING_DIRECTION_TOP_TO_BOTTOM = 2 -DEFAULT_LEFT_ALIGNED = 0 -RIGHT_ALIGNED = 1 -CENTER_ALIGNED = 2 - - -_TEXT = DESCRIPTOR.message_types_by_name['Text'] -_TEXTLAYOUT = DESCRIPTOR.message_types_by_name['TextLayout'] -_TEXTLAYOUT_WORD = _TEXTLAYOUT.nested_types_by_name['Word'] -_TEXTLAYOUT_WORD_FORMULAMETADATA = _TEXTLAYOUT_WORD.nested_types_by_name['FormulaMetadata'] -_TEXTLAYOUT_LINE = _TEXTLAYOUT.nested_types_by_name['Line'] -_TEXTLAYOUT_PARAGRAPH = _TEXTLAYOUT.nested_types_by_name['Paragraph'] -_TEXTENTITYIDENTIFIER = DESCRIPTOR.message_types_by_name['TextEntityIdentifier'] -_TEXTLAYOUT_WORD_TYPE = _TEXTLAYOUT_WORD.enum_types_by_name['Type'] -Text = _reflection.GeneratedProtocolMessageType('Text', (_message.Message,), { - 'DESCRIPTOR' : _TEXT, - '__module__' : 'lens_overlay_text_pb2' - # @@protoc_insertion_point(class_scope:lens.Text) - }) -_sym_db.RegisterMessage(Text) - -TextLayout = _reflection.GeneratedProtocolMessageType('TextLayout', (_message.Message,), { - - 'Word' : _reflection.GeneratedProtocolMessageType('Word', (_message.Message,), { - - 'FormulaMetadata' : _reflection.GeneratedProtocolMessageType('FormulaMetadata', (_message.Message,), { - 'DESCRIPTOR' : _TEXTLAYOUT_WORD_FORMULAMETADATA, - '__module__' : 'lens_overlay_text_pb2' - # @@protoc_insertion_point(class_scope:lens.TextLayout.Word.FormulaMetadata) - }) - , - 'DESCRIPTOR' : _TEXTLAYOUT_WORD, - '__module__' : 'lens_overlay_text_pb2' - # @@protoc_insertion_point(class_scope:lens.TextLayout.Word) - }) - , - - 'Line' : _reflection.GeneratedProtocolMessageType('Line', (_message.Message,), { - 'DESCRIPTOR' : _TEXTLAYOUT_LINE, - '__module__' : 'lens_overlay_text_pb2' - # @@protoc_insertion_point(class_scope:lens.TextLayout.Line) - }) - , - - 'Paragraph' : _reflection.GeneratedProtocolMessageType('Paragraph', (_message.Message,), { - 'DESCRIPTOR' : _TEXTLAYOUT_PARAGRAPH, - '__module__' : 'lens_overlay_text_pb2' - # @@protoc_insertion_point(class_scope:lens.TextLayout.Paragraph) - }) - , - 'DESCRIPTOR' : _TEXTLAYOUT, - '__module__' : 'lens_overlay_text_pb2' - # @@protoc_insertion_point(class_scope:lens.TextLayout) - }) -_sym_db.RegisterMessage(TextLayout) -_sym_db.RegisterMessage(TextLayout.Word) -_sym_db.RegisterMessage(TextLayout.Word.FormulaMetadata) -_sym_db.RegisterMessage(TextLayout.Line) -_sym_db.RegisterMessage(TextLayout.Paragraph) - -TextEntityIdentifier = _reflection.GeneratedProtocolMessageType('TextEntityIdentifier', (_message.Message,), { - 'DESCRIPTOR' : _TEXTENTITYIDENTIFIER, - '__module__' : 'lens_overlay_text_pb2' - # @@protoc_insertion_point(class_scope:lens.TextEntityIdentifier) - }) -_sym_db.RegisterMessage(TextEntityIdentifier) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _WRITINGDIRECTION._serialized_start=847 - _WRITINGDIRECTION._serialized_end=984 - _ALIGNMENT._serialized_start=986 - _ALIGNMENT._serialized_end=1062 - _TEXT._serialized_start=62 - _TEXT._serialized_end=139 - _TEXTLAYOUT._serialized_start=142 - _TEXTLAYOUT._serialized_end=808 - _TEXTLAYOUT_WORD._serialized_start=205 - _TEXTLAYOUT_WORD._serialized_end=525 - _TEXTLAYOUT_WORD_FORMULAMETADATA._serialized_start=443 - _TEXTLAYOUT_WORD_FORMULAMETADATA._serialized_end=475 - _TEXTLAYOUT_WORD_TYPE._serialized_start=477 - _TEXTLAYOUT_WORD_TYPE._serialized_end=506 - _TEXTLAYOUT_LINE._serialized_start=527 - _TEXTLAYOUT_LINE._serialized_end=605 - _TEXTLAYOUT_PARAGRAPH._serialized_start=608 - _TEXTLAYOUT_PARAGRAPH._serialized_end=808 - _TEXTENTITYIDENTIFIER._serialized_start=810 - _TEXTENTITYIDENTIFIER._serialized_end=844 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_text_query_pb2.py b/owocr/py_lens/lens_overlay_text_query_pb2.py deleted file mode 100644 index 39267c5..0000000 --- a/owocr/py_lens/lens_overlay_text_query_pb2.py +++ /dev/null @@ -1,35 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_text_query.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1dlens_overlay_text_query.proto\x12\x04lens\".\n\tTextQuery\x12\r\n\x05query\x18\x01 \x01(\t\x12\x12\n\nis_primary\x18\x02 \x01(\x08\x42\x02H\x03\x62\x06proto3') - - - -_TEXTQUERY = DESCRIPTOR.message_types_by_name['TextQuery'] -TextQuery = _reflection.GeneratedProtocolMessageType('TextQuery', (_message.Message,), { - 'DESCRIPTOR' : _TEXTQUERY, - '__module__' : 'lens_overlay_text_query_pb2' - # @@protoc_insertion_point(class_scope:lens.TextQuery) - }) -_sym_db.RegisterMessage(TextQuery) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _TEXTQUERY._serialized_start=39 - _TEXTQUERY._serialized_end=85 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_translate_stickiness_signals_pb2.py b/owocr/py_lens/lens_overlay_translate_stickiness_signals_pb2.py deleted file mode 100644 index e695c32..0000000 --- a/owocr/py_lens/lens_overlay_translate_stickiness_signals_pb2.py +++ /dev/null @@ -1,35 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_translate_stickiness_signals.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n/lens_overlay_translate_stickiness_signals.proto\x12\x04lens\"H\n\x1aTranslateStickinessSignals\x12*\n\"translate_suppress_echo_for_sticky\x18\x01 \x01(\x08\x42\x02H\x03\x62\x06proto3') - - - -_TRANSLATESTICKINESSSIGNALS = DESCRIPTOR.message_types_by_name['TranslateStickinessSignals'] -TranslateStickinessSignals = _reflection.GeneratedProtocolMessageType('TranslateStickinessSignals', (_message.Message,), { - 'DESCRIPTOR' : _TRANSLATESTICKINESSSIGNALS, - '__module__' : 'lens_overlay_translate_stickiness_signals_pb2' - # @@protoc_insertion_point(class_scope:lens.TranslateStickinessSignals) - }) -_sym_db.RegisterMessage(TranslateStickinessSignals) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _TRANSLATESTICKINESSSIGNALS._serialized_start=57 - _TRANSLATESTICKINESSSIGNALS._serialized_end=129 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_video_context_input_params_pb2.py b/owocr/py_lens/lens_overlay_video_context_input_params_pb2.py deleted file mode 100644 index 1ad5acb..0000000 --- a/owocr/py_lens/lens_overlay_video_context_input_params_pb2.py +++ /dev/null @@ -1,35 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_video_context_input_params.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n-lens_overlay_video_context_input_params.proto\x12\x04lens\"1\n\"LensOverlayVideoContextInputParams\x12\x0b\n\x03url\x18\x01 \x01(\tB\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYVIDEOCONTEXTINPUTPARAMS = DESCRIPTOR.message_types_by_name['LensOverlayVideoContextInputParams'] -LensOverlayVideoContextInputParams = _reflection.GeneratedProtocolMessageType('LensOverlayVideoContextInputParams', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYVIDEOCONTEXTINPUTPARAMS, - '__module__' : 'lens_overlay_video_context_input_params_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayVideoContextInputParams) - }) -_sym_db.RegisterMessage(LensOverlayVideoContextInputParams) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYVIDEOCONTEXTINPUTPARAMS._serialized_start=55 - _LENSOVERLAYVIDEOCONTEXTINPUTPARAMS._serialized_end=104 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_video_params_pb2.py b/owocr/py_lens/lens_overlay_video_params_pb2.py deleted file mode 100644 index e2cb5ff..0000000 --- a/owocr/py_lens/lens_overlay_video_params_pb2.py +++ /dev/null @@ -1,36 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_video_params.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_video_context_input_params_pb2 as lens__overlay__video__context__input__params__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1flens_overlay_video_params.proto\x12\x04lens\x1a-lens_overlay_video_context_input_params.proto\"f\n\x16LensOverlayVideoParams\x12L\n\x1avideo_context_input_params\x18\x01 \x01(\x0b\x32(.lens.LensOverlayVideoContextInputParamsB\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYVIDEOPARAMS = DESCRIPTOR.message_types_by_name['LensOverlayVideoParams'] -LensOverlayVideoParams = _reflection.GeneratedProtocolMessageType('LensOverlayVideoParams', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYVIDEOPARAMS, - '__module__' : 'lens_overlay_video_params_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayVideoParams) - }) -_sym_db.RegisterMessage(LensOverlayVideoParams) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYVIDEOPARAMS._serialized_start=88 - _LENSOVERLAYVIDEOPARAMS._serialized_end=190 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_visual_search_interaction_data_pb2.py b/owocr/py_lens/lens_overlay_visual_search_interaction_data_pb2.py deleted file mode 100644 index b123830..0000000 --- a/owocr/py_lens/lens_overlay_visual_search_interaction_data_pb2.py +++ /dev/null @@ -1,38 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_visual_search_interaction_data.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_geometry_pb2 as lens__overlay__geometry__pb2 -import owocr.py_lens.lens_overlay_interaction_request_metadata_pb2 as lens__overlay__interaction__request__metadata__pb2 -import owocr.py_lens.lens_overlay_visual_search_interaction_log_data_pb2 as lens__overlay__visual__search__interaction__log__data__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n1lens_overlay_visual_search_interaction_data.proto\x12\x04lens\x1a\x1blens_overlay_geometry.proto\x1a/lens_overlay_interaction_request_metadata.proto\x1a\x35lens_overlay_visual_search_interaction_log_data.proto\"\x83\x02\n&LensOverlayVisualSearchInteractionData\x12J\n\x10interaction_type\x18\x01 \x01(\x0e\x32\x30.lens.LensOverlayInteractionRequestMetadata.Type\x12%\n\x0bzoomed_crop\x18\x07 \x01(\x0b\x32\x10.lens.ZoomedCrop\x12\x11\n\tobject_id\x18\x03 \x01(\t\x12\x41\n\x08log_data\x18\x05 \x01(\x0b\x32/.lens.LensOverlayVisualSearchInteractionLogDataJ\x04\x08\x02\x10\x03J\x04\x08\x04\x10\x05J\x04\x08\x06\x10\x07\x42\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYVISUALSEARCHINTERACTIONDATA = DESCRIPTOR.message_types_by_name['LensOverlayVisualSearchInteractionData'] -LensOverlayVisualSearchInteractionData = _reflection.GeneratedProtocolMessageType('LensOverlayVisualSearchInteractionData', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYVISUALSEARCHINTERACTIONDATA, - '__module__' : 'lens_overlay_visual_search_interaction_data_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayVisualSearchInteractionData) - }) -_sym_db.RegisterMessage(LensOverlayVisualSearchInteractionData) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYVISUALSEARCHINTERACTIONDATA._serialized_start=193 - _LENSOVERLAYVISUALSEARCHINTERACTIONDATA._serialized_end=452 -# @@protoc_insertion_point(module_scope) diff --git a/owocr/py_lens/lens_overlay_visual_search_interaction_log_data_pb2.py b/owocr/py_lens/lens_overlay_visual_search_interaction_log_data_pb2.py deleted file mode 100644 index afa006e..0000000 --- a/owocr/py_lens/lens_overlay_visual_search_interaction_log_data_pb2.py +++ /dev/null @@ -1,58 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: lens_overlay_visual_search_interaction_log_data.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import owocr.py_lens.lens_overlay_client_platform_pb2 as lens__overlay__client__platform__pb2 -import owocr.py_lens.lens_overlay_filters_pb2 as lens__overlay__filters__pb2 -import owocr.py_lens.lens_overlay_selection_type_pb2 as lens__overlay__selection__type__pb2 - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n5lens_overlay_visual_search_interaction_log_data.proto\x12\x04lens\x1a\"lens_overlay_client_platform.proto\x1a\x1alens_overlay_filters.proto\x1a!lens_overlay_selection_type.proto\"\xd0\x01\n)LensOverlayVisualSearchInteractionLogData\x12%\n\x0b\x66ilter_data\x18\x01 \x01(\x0b\x32\x10.lens.FilterData\x12\x34\n\x13user_selection_data\x18\x02 \x01(\x0b\x32\x17.lens.UserSelectionData\x12\x17\n\x0fis_parent_query\x18\x03 \x01(\x08\x12-\n\x0f\x63lient_platform\x18\x04 \x01(\x0e\x32\x14.lens.ClientPlatform\">\n\nFilterData\x12\x30\n\x0b\x66ilter_type\x18\x01 \x01(\x0e\x32\x1b.lens.LensOverlayFilterType\"K\n\x11UserSelectionData\x12\x36\n\x0eselection_type\x18\x01 \x01(\x0e\x32\x1e.lens.LensOverlaySelectionTypeB\x02H\x03\x62\x06proto3') - - - -_LENSOVERLAYVISUALSEARCHINTERACTIONLOGDATA = DESCRIPTOR.message_types_by_name['LensOverlayVisualSearchInteractionLogData'] -_FILTERDATA = DESCRIPTOR.message_types_by_name['FilterData'] -_USERSELECTIONDATA = DESCRIPTOR.message_types_by_name['UserSelectionData'] -LensOverlayVisualSearchInteractionLogData = _reflection.GeneratedProtocolMessageType('LensOverlayVisualSearchInteractionLogData', (_message.Message,), { - 'DESCRIPTOR' : _LENSOVERLAYVISUALSEARCHINTERACTIONLOGDATA, - '__module__' : 'lens_overlay_visual_search_interaction_log_data_pb2' - # @@protoc_insertion_point(class_scope:lens.LensOverlayVisualSearchInteractionLogData) - }) -_sym_db.RegisterMessage(LensOverlayVisualSearchInteractionLogData) - -FilterData = _reflection.GeneratedProtocolMessageType('FilterData', (_message.Message,), { - 'DESCRIPTOR' : _FILTERDATA, - '__module__' : 'lens_overlay_visual_search_interaction_log_data_pb2' - # @@protoc_insertion_point(class_scope:lens.FilterData) - }) -_sym_db.RegisterMessage(FilterData) - -UserSelectionData = _reflection.GeneratedProtocolMessageType('UserSelectionData', (_message.Message,), { - 'DESCRIPTOR' : _USERSELECTIONDATA, - '__module__' : 'lens_overlay_visual_search_interaction_log_data_pb2' - # @@protoc_insertion_point(class_scope:lens.UserSelectionData) - }) -_sym_db.RegisterMessage(UserSelectionData) - -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - DESCRIPTOR._serialized_options = b'H\003' - _LENSOVERLAYVISUALSEARCHINTERACTIONLOGDATA._serialized_start=163 - _LENSOVERLAYVISUALSEARCHINTERACTIONLOGDATA._serialized_end=371 - _FILTERDATA._serialized_start=373 - _FILTERDATA._serialized_end=435 - _USERSELECTIONDATA._serialized_start=437 - _USERSELECTIONDATA._serialized_end=512 -# @@protoc_insertion_point(module_scope) diff --git a/pyproject.toml b/pyproject.toml index eee5475..fb9affb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "owocr" -version = "1.11" +version = "1.12" description = "Japanese OCR" readme = "README.md" requires-python = ">=3.11" @@ -63,7 +63,7 @@ winrt = [ ] lens = [ - "protobuf", + "betterproto==2.0.0b7", ] lensweb = [