yandexcloud 0.318.0__tar.gz → 0.320.0__tar.gz

yandexcloud-0.320.0/PKG-INFO

@@ -0,0 +1,205 @@
+Metadata-Version: 2.1
+Name: yandexcloud
+Version: 0.320.0
+Summary: The Yandex.Cloud official SDK
+Home-page: https://github.com/yandex-cloud/python-sdk
+Author: Yandex LLC
+Author-email: cloud@support.yandex.ru
+License: MIT
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: cryptography<43,>=41.0.7
+Requires-Dist: grpcio<2,>=1.64.0
+Requires-Dist: protobuf<5,>=4.25.3
+Requires-Dist: googleapis-common-protos<2,>=1.63.0
+Requires-Dist: pyjwt<3,>=2.8.0
+Requires-Dist: requests<3,>=2.32.3
+Requires-Dist: six<2,>=1.16.0
+
+[![PyPI Version][pypi-image]][pypi-url]
+[![Build Status][build-image]][build-url]
+[![License][license-image]][license-url]
+
+<!-- Badges -->
+
+[pypi-image]: https://img.shields.io/pypi/v/yandexcloud
+[pypi-url]: https://pypi.org/project/yandexcloud/
+[build-image]: https://github.com/yandex-cloud/python-sdk/actions/workflows/run-tests.yml/badge.svg
+[build-url]: https://github.com/yandex-cloud/python-sdk/actions/workflows/run-tests.yml
+[license-image]: https://img.shields.io/github/license/yandex-cloud/python-sdk.svg
+[license-url]: https://github.com/yandex-cloud/python-sdk/blob/master/LICENSE
+
+# Yandex.Cloud SDK (Python) 
+
+Need to automate your infrastructure or use services provided by Yandex.Cloud? We've got you covered.
+
+Installation:
+
+    pip install yandexcloud
+
+## Getting started
+
+There are several options for authorization your requests - OAuth Token,
+Metadata Service (if you're executing your code inside VMs or Cloud Functions
+running in Yandex.Cloud), Service Account Keys, and externally created IAM tokens.
+
+### OAuth Token
+
+```python
+sdk = yandexcloud.SDK(token='AQAD-.....')
+```
+
+### Metadata Service
+
+Don't forget to assign Service Account for your Instance or Function and grant required roles.
+
+```python
+sdk = yandexcloud.SDK()
+```
+
+### Service Account Keys
+
+```python
+# you can store and read it from JSON file 
+sa_key = {
+    "id": "...",
+    "service_account_id": "...",
+    "private_key": "..."
+}
+
+sdk = yandexcloud.SDK(service_account_key=sa_key)
+```
+
+### IAM tokens
+
+```python
+sdk = yandexcloud.SDK(iam_token="t1.9eu...")
+```
+
+Check `examples` directory for more examples.
+
+### Override service endpoint
+
+#### Supported services
+
+| Service Name                                                           | Alias                    |
+|------------------------------------------------------------------------|--------------------------|
+| yandex.cloud.ai.foundation_models                                      | ai-foundation-models     |
+| yandex.cloud.ai.llm                                                    | ai-llm                   |
+| yandex.cloud.ai.ocr                                                    | ai-vision-ocr            |
+| yandex.cloud.ai.stt                                                    | ai-stt                   |
+| yandex.cloud.ai.translate                                              | ai-translate             |
+| yandex.cloud.ai.tts                                                    | ai-speechkit             |
+| yandex.cloud.ai.vision                                                 | ai-vision                |
+| yandex.cloud.apploadbalancer                                           | alb                      |
+| yandex.cloud.billing                                                   | billing                  |
+| yandex.cloud.cdn                                                       | cdn                      |
+| yandex.cloud.certificatemanager.v1.certificate_content_service         | certificate-manager-data |
+| yandex.cloud.certificatemanager                                        | certificate-manager      |
+| yandex.cloud.compute                                                   | compute                  |
+| yandex.cloud.containerregistry                                         | container-registry       |
+| yandex.cloud.dataproc.manager                                          | dataproc-manager         |
+| yandex.cloud.dataproc                                                  | dataproc                 |
+| yandex.cloud.datasphere                                                | datasphere               |
+| yandex.cloud.datatransfer                                              | datatransfer             |
+| yandex.cloud.dns                                                       | dns                      |
+| yandex.cloud.endpoint                                                  | endpoint                 |
+| yandex.cloud.iam                                                       | iam                      |
+| yandex.cloud.iot.devices                                               | iot-devices              |
+| yandex.cloud.k8s                                                       | managed-kubernetes       |
+| yandex.cloud.kms.v1.symmetric_crypto_service                           | kms-crypto               |
+| yandex.cloud.kms                                                       | kms                      |
+| yandex.cloud.loadbalancer                                              | load-balancer            |
+| yandex.cloud.loadtesting                                               | loadtesting              |
+| yandex.cloud.lockbox.v1.payload_service                                | lockbox-payload          |
+| yandex.cloud.lockbox                                                   | lockbox                  |
+| yandex.cloud.logging.v1.log_ingestion_service                          | log-ingestion            |
+| yandex.cloud.logging.v1.log_reading_service                            | log-reading              |
+| yandex.cloud.logging                                                   | logging                  |
+| yandex.cloud.marketplace                                               | marketplace              |
+| yandex.cloud.mdb.clickhouse                                            | managed-clickhouse       |
+| yandex.cloud.mdb.elasticsearch                                         | managed-elasticsearch    |
+| yandex.cloud.mdb.greenplum                                             | managed-greenplum        |
+| yandex.cloud.mdb.kafka                                                 | managed-kafka            |
+| yandex.cloud.mdb.mongodb                                               | managed-mongodb          |
+| yandex.cloud.mdb.mysql                                                 | managed-mysql            |
+| yandex.cloud.mdb.opensearch                                            | managed-opensearch       |
+| yandex.cloud.mdb.postgresql                                            | managed-postgresql       |
+| yandex.cloud.mdb.redis                                                 | managed-redis            |
+| yandex.cloud.mdb.sqlserver                                             | managed-sqlserver        |
+| yandex.cloud.operation                                                 | operation                |
+| yandex.cloud.organizationmanager                                       | organization-manager     |
+| yandex.cloud.resourcemanager                                           | resource-manager         |
+| yandex.cloud.serverless.apigateway.websocket                           | apigateway-connections   |
+| yandex.cloud.serverless.apigateway                                     | serverless-apigateway    |
+| yandex.cloud.serverless.containers                                     | serverless-containers    |
+| yandex.cloud.serverless.functions                                      | serverless-functions     |
+| yandex.cloud.serverless.triggers                                       | serverless-triggers      |
+| yandex.cloud.storage                                                   | storage-api              |
+| yandex.cloud.vpc                                                       | vpc                      |
+| yandex.cloud.ydb                                                       | ydb                      |
+
+
+#### Override in client
+```python
+from yandex.cloud.vpc.v1.network_service_pb2_grpc import NetworkServiceStub
+from yandexcloud import SDK
+
+sdk = SDK(iam_token="t1.9eu...")
+new_network_client_endpoint = "example.new.vpc.very.new.yandex:50051"
+insecure = False # by default is False, but if server does not support verification can be set to True
+network_client = sdk.client(NetworkServiceStub, endpoint=new_network_client_endpoint, insecure=False)
+```
+
+#### Override in sdk config
+To override endpoints provide dict in format {alias : new-endpoint}
+```python
+from yandex.cloud.vpc.v1.network_service_pb2_grpc import NetworkServiceStub
+from yandexcloud import SDK
+new_network_client_endpoint = "example.new.vpc.very.new.yandex:50051"
+sdk = SDK(iam_token="t1.9eu...", endpoints={"vpc": new_network_client_endpoint})
+insecure = False # by default is False, but if server does not support verification can be set to True
+network_client = sdk.client(NetworkServiceStub, insecure=False)
+```
+
+Notice: if both overrides are used for same endpoint, override by client has priority
+
+#### Switch SDK region
+```python
+from yandexcloud import SDK, set_up_yc_api_endpoint
+kz_region_endpoint = "api.yandexcloud.kz"
+# this will make SDK list endpoints from KZ yc installation 
+sdk = SDK(iam_token="t1.9eu...", endpoint="api.yandexcloud.kz")
+# or you can use global function
+set_up_yc_api_endpoint(kz_region_endpoint)
+```
+
+## Contributing
+### Dependencies
+Use `make deps` command to install library, its production and development dependencies.
+
+### Formatting
+Use `make format` to autoformat code with black tool. 
+
+### Tests
+- `make test` to run tests for current python version
+- `make lint` to run only linters for current python version
+- `make tox-current` to run all checks (tests + code style checks + linters + format check) for current python version
+- `make tox` to run all checks for all supported (installed in your system) python versions
+- `make test-all-versions` to run all checks for all supported python versions in docker container
+
+
+### Maintaining
+If pull request consists of several meaningful commits, that should be preserved, 
+then use "Rebase and merge" option. Otherwise use "Squash and merge". 
+
+New release (changelog, tag and pypi upload) will be automatically created 
+on each push to master via Github Actions workflow.

yandexcloud-0.320.0/setup.py

@@ -0,0 +1,42 @@
+from setuptools import find_packages, setup
+
+packages = find_packages(".", include=["yandexcloud*", "yandex*"])
+
+__version__ = "0.320.0"
+
+with open("README.md") as file:
+    README = file.read()
+
+setup(
+    name="yandexcloud",
+    version=__version__,
+    description="The Yandex.Cloud official SDK",
+    url="https://github.com/yandex-cloud/python-sdk",
+    author="Yandex LLC",
+    author_email="cloud@support.yandex.ru",
+    long_description=README,
+    long_description_content_type="text/markdown",
+    include_package_data=True,
+    license="MIT",
+    install_requires=[
+        "cryptography>=41.0.7,<43",
+        "grpcio>=1.64.0,<2",
+        "protobuf>=4.25.3,<5",
+        "googleapis-common-protos>=1.63.0,<2",
+        "pyjwt>=2.8.0,<3",
+        "requests>=2.32.3,<3",
+        "six>=1.16.0,<2",
+    ],
+    classifiers=[
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+    tests_require=["pytest"],
+    packages=packages,
+    zip_safe=False,
+)

yandexcloud-0.320.0/yandex/cloud/ai/ocr/v1/ocr_pb2.pyi

@@ -0,0 +1,364 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+
+import builtins
+import collections.abc
+import google.protobuf.descriptor
+import google.protobuf.internal.containers
+import google.protobuf.internal.enum_type_wrapper
+import google.protobuf.message
+import sys
+import typing
+
+if sys.version_info >= (3, 10):
+    import typing as typing_extensions
+else:
+    import typing_extensions
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+class _Angle:
+    ValueType = typing.NewType("ValueType", builtins.int)
+    V: typing_extensions.TypeAlias = ValueType
+
+class _AngleEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Angle.ValueType], builtins.type):
+    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+    ANGLE_UNSPECIFIED: _Angle.ValueType  # 0
+    ANGLE_0: _Angle.ValueType  # 1
+    ANGLE_90: _Angle.ValueType  # 2
+    ANGLE_180: _Angle.ValueType  # 3
+    ANGLE_270: _Angle.ValueType  # 4
+
+class Angle(_Angle, metaclass=_AngleEnumTypeWrapper): ...
+
+ANGLE_UNSPECIFIED: Angle.ValueType  # 0
+ANGLE_0: Angle.ValueType  # 1
+ANGLE_90: Angle.ValueType  # 2
+ANGLE_180: Angle.ValueType  # 3
+ANGLE_270: Angle.ValueType  # 4
+global___Angle = Angle
+
+@typing.final
+class Polygon(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    VERTICES_FIELD_NUMBER: builtins.int
+    @property
+    def vertices(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Vertex]:
+        """The bounding polygon vertices."""
+
+    def __init__(
+        self,
+        *,
+        vertices: collections.abc.Iterable[global___Vertex] | None = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["vertices", b"vertices"]) -> None: ...
+
+global___Polygon = Polygon
+
+@typing.final
+class Vertex(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    X_FIELD_NUMBER: builtins.int
+    Y_FIELD_NUMBER: builtins.int
+    x: builtins.int
+    """X coordinate in pixels."""
+    y: builtins.int
+    """Y coordinate in pixels."""
+    def __init__(
+        self,
+        *,
+        x: builtins.int = ...,
+        y: builtins.int = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["x", b"x", "y", b"y"]) -> None: ...
+
+global___Vertex = Vertex
+
+@typing.final
+class TextAnnotation(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    WIDTH_FIELD_NUMBER: builtins.int
+    HEIGHT_FIELD_NUMBER: builtins.int
+    BLOCKS_FIELD_NUMBER: builtins.int
+    ENTITIES_FIELD_NUMBER: builtins.int
+    TABLES_FIELD_NUMBER: builtins.int
+    FULL_TEXT_FIELD_NUMBER: builtins.int
+    ROTATE_FIELD_NUMBER: builtins.int
+    width: builtins.int
+    """Page width in pixels."""
+    height: builtins.int
+    """Page height in pixels."""
+    full_text: builtins.str
+    """Full text recognized from image."""
+    rotate: global___Angle.ValueType
+    """Angle of image rotation."""
+    @property
+    def blocks(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Block]:
+        """Recognized text blocks in this page."""
+
+    @property
+    def entities(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Entity]:
+        """Recognized entities."""
+
+    @property
+    def tables(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Table]: ...
+    def __init__(
+        self,
+        *,
+        width: builtins.int = ...,
+        height: builtins.int = ...,
+        blocks: collections.abc.Iterable[global___Block] | None = ...,
+        entities: collections.abc.Iterable[global___Entity] | None = ...,
+        tables: collections.abc.Iterable[global___Table] | None = ...,
+        full_text: builtins.str = ...,
+        rotate: global___Angle.ValueType = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["blocks", b"blocks", "entities", b"entities", "full_text", b"full_text", "height", b"height", "rotate", b"rotate", "tables", b"tables", "width", b"width"]) -> None: ...
+
+global___TextAnnotation = TextAnnotation
+
+@typing.final
+class Entity(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    NAME_FIELD_NUMBER: builtins.int
+    TEXT_FIELD_NUMBER: builtins.int
+    name: builtins.str
+    """Entity name."""
+    text: builtins.str
+    """Recognized entity text."""
+    def __init__(
+        self,
+        *,
+        name: builtins.str = ...,
+        text: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["name", b"name", "text", b"text"]) -> None: ...
+
+global___Entity = Entity
+
+@typing.final
+class Block(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    @typing.final
+    class DetectedLanguage(google.protobuf.message.Message):
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        LANGUAGE_CODE_FIELD_NUMBER: builtins.int
+        language_code: builtins.str
+        """Detected language code."""
+        def __init__(
+            self,
+            *,
+            language_code: builtins.str = ...,
+        ) -> None: ...
+        def ClearField(self, field_name: typing.Literal["language_code", b"language_code"]) -> None: ...
+
+    BOUNDING_BOX_FIELD_NUMBER: builtins.int
+    LINES_FIELD_NUMBER: builtins.int
+    LANGUAGES_FIELD_NUMBER: builtins.int
+    TEXT_SEGMENTS_FIELD_NUMBER: builtins.int
+    @property
+    def bounding_box(self) -> global___Polygon:
+        """Area on the page where the text block is located."""
+
+    @property
+    def lines(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Line]:
+        """Recognized lines in this block."""
+
+    @property
+    def languages(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Block.DetectedLanguage]:
+        """A list of detected languages"""
+
+    @property
+    def text_segments(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TextSegments]:
+        """Block position from full_text string."""
+
+    def __init__(
+        self,
+        *,
+        bounding_box: global___Polygon | None = ...,
+        lines: collections.abc.Iterable[global___Line] | None = ...,
+        languages: collections.abc.Iterable[global___Block.DetectedLanguage] | None = ...,
+        text_segments: collections.abc.Iterable[global___TextSegments] | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["bounding_box", b"bounding_box"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["bounding_box", b"bounding_box", "languages", b"languages", "lines", b"lines", "text_segments", b"text_segments"]) -> None: ...
+
+global___Block = Block
+
+@typing.final
+class Line(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    BOUNDING_BOX_FIELD_NUMBER: builtins.int
+    TEXT_FIELD_NUMBER: builtins.int
+    WORDS_FIELD_NUMBER: builtins.int
+    TEXT_SEGMENTS_FIELD_NUMBER: builtins.int
+    ORIENTATION_FIELD_NUMBER: builtins.int
+    text: builtins.str
+    """Recognized text."""
+    orientation: global___Angle.ValueType
+    """Angle of line rotation."""
+    @property
+    def bounding_box(self) -> global___Polygon:
+        """Area on the page where the line is located."""
+
+    @property
+    def words(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Word]:
+        """Recognized words."""
+
+    @property
+    def text_segments(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TextSegments]:
+        """Line position from full_text string."""
+
+    def __init__(
+        self,
+        *,
+        bounding_box: global___Polygon | None = ...,
+        text: builtins.str = ...,
+        words: collections.abc.Iterable[global___Word] | None = ...,
+        text_segments: collections.abc.Iterable[global___TextSegments] | None = ...,
+        orientation: global___Angle.ValueType = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["bounding_box", b"bounding_box"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["bounding_box", b"bounding_box", "orientation", b"orientation", "text", b"text", "text_segments", b"text_segments", "words", b"words"]) -> None: ...
+
+global___Line = Line
+
+@typing.final
+class Word(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    BOUNDING_BOX_FIELD_NUMBER: builtins.int
+    TEXT_FIELD_NUMBER: builtins.int
+    ENTITY_INDEX_FIELD_NUMBER: builtins.int
+    TEXT_SEGMENTS_FIELD_NUMBER: builtins.int
+    text: builtins.str
+    """Recognized word value."""
+    entity_index: builtins.int
+    """ID of the recognized word in entities array."""
+    @property
+    def bounding_box(self) -> global___Polygon:
+        """Area on the page where the word is located."""
+
+    @property
+    def text_segments(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TextSegments]:
+        """Word position from full_text string."""
+
+    def __init__(
+        self,
+        *,
+        bounding_box: global___Polygon | None = ...,
+        text: builtins.str = ...,
+        entity_index: builtins.int = ...,
+        text_segments: collections.abc.Iterable[global___TextSegments] | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["bounding_box", b"bounding_box"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["bounding_box", b"bounding_box", "entity_index", b"entity_index", "text", b"text", "text_segments", b"text_segments"]) -> None: ...
+
+global___Word = Word
+
+@typing.final
+class TextSegments(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    START_INDEX_FIELD_NUMBER: builtins.int
+    LENGTH_FIELD_NUMBER: builtins.int
+    start_index: builtins.int
+    """Start character position from full_text string."""
+    length: builtins.int
+    """Text segment length."""
+    def __init__(
+        self,
+        *,
+        start_index: builtins.int = ...,
+        length: builtins.int = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["length", b"length", "start_index", b"start_index"]) -> None: ...
+
+global___TextSegments = TextSegments
+
+@typing.final
+class Table(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    BOUNDING_BOX_FIELD_NUMBER: builtins.int
+    ROW_COUNT_FIELD_NUMBER: builtins.int
+    COLUMN_COUNT_FIELD_NUMBER: builtins.int
+    CELLS_FIELD_NUMBER: builtins.int
+    row_count: builtins.int
+    """Number of rows in table."""
+    column_count: builtins.int
+    """Number of columns in table."""
+    @property
+    def bounding_box(self) -> global___Polygon:
+        """Area on the page where the table is located."""
+
+    @property
+    def cells(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TableCell]:
+        """Table cells."""
+
+    def __init__(
+        self,
+        *,
+        bounding_box: global___Polygon | None = ...,
+        row_count: builtins.int = ...,
+        column_count: builtins.int = ...,
+        cells: collections.abc.Iterable[global___TableCell] | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["bounding_box", b"bounding_box"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["bounding_box", b"bounding_box", "cells", b"cells", "column_count", b"column_count", "row_count", b"row_count"]) -> None: ...
+
+global___Table = Table
+
+@typing.final
+class TableCell(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    BOUNDING_BOX_FIELD_NUMBER: builtins.int
+    ROW_INDEX_FIELD_NUMBER: builtins.int
+    COLUMN_INDEX_FIELD_NUMBER: builtins.int
+    COLUMN_SPAN_FIELD_NUMBER: builtins.int
+    ROW_SPAN_FIELD_NUMBER: builtins.int
+    TEXT_FIELD_NUMBER: builtins.int
+    TEXT_SEGMENTS_FIELD_NUMBER: builtins.int
+    row_index: builtins.int
+    """Row index."""
+    column_index: builtins.int
+    """Column index."""
+    column_span: builtins.int
+    """Column span."""
+    row_span: builtins.int
+    """Row span."""
+    text: builtins.str
+    """Text in cell."""
+    @property
+    def bounding_box(self) -> global___Polygon:
+        """Area on the page where the table cell is located."""
+
+    @property
+    def text_segments(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TextSegments]:
+        """Table cell position from full_text string."""
+
+    def __init__(
+        self,
+        *,
+        bounding_box: global___Polygon | None = ...,
+        row_index: builtins.int = ...,
+        column_index: builtins.int = ...,
+        column_span: builtins.int = ...,
+        row_span: builtins.int = ...,
+        text: builtins.str = ...,
+        text_segments: collections.abc.Iterable[global___TextSegments] | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["bounding_box", b"bounding_box"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["bounding_box", b"bounding_box", "column_index", b"column_index", "column_span", b"column_span", "row_index", b"row_index", "row_span", b"row_span", "text", b"text", "text_segments", b"text_segments"]) -> None: ...
+
+global___TableCell = TableCell