Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/google/cloud/bigquery/routine/routine.py: 48%

685 """string: Fully qualified name of the user-provided connection object which holds the authentication information to send requests to the remote service.

686

687 Format is "projects/{projectId}/locations/{locationId}/connections/{connectionId}"

688 """

689 return _helpers._str_or_none(self._properties.get("connection"))

690

691 @connection.setter

692 def connection(self, value):

693 self._properties["connection"] = _helpers._str_or_none(value)

694

695 @property

696 def endpoint(self):

697 """string: Endpoint of the user-provided remote service

698

699 Example: "https://us-east1-my_gcf_project.cloudfunctions.net/remote_add"

700 """

701 return _helpers._str_or_none(self._properties.get("endpoint"))

702

703 @endpoint.setter

704 def endpoint(self, value):

705 self._properties["endpoint"] = _helpers._str_or_none(value)

706

707 @property

708 def max_batching_rows(self):

709 """int64: Max number of rows in each batch sent to the remote service.

710

711 If absent or if 0, BigQuery dynamically decides the number of rows in a batch.

712 """

713 return _helpers._int_or_none(self._properties.get("maxBatchingRows"))

714

715 @max_batching_rows.setter

716 def max_batching_rows(self, value):

717 self._properties["maxBatchingRows"] = _helpers._str_or_none(value)

718

719 @property

720 def user_defined_context(self):

721 """Dict[str, str]: User-defined context as a set of key/value pairs,

722 which will be sent as function invocation context together with

723 batched arguments in the requests to the remote service. The total

724 number of bytes of keys and values must be less than 8KB.

725 """

726 return self._properties.get("userDefinedContext")

727

728 @user_defined_context.setter

729 def user_defined_context(self, value):

730 if not isinstance(value, dict):

731 raise ValueError("value must be dictionary")

732 self._properties["userDefinedContext"] = value

733

734 @classmethod

735 def from_api_repr(cls, resource: dict) -> "RemoteFunctionOptions":

736 """Factory: construct remote function options given its API representation.

737

738 Args:

739 resource (Dict[str, object]): Resource, as returned from the API.

740

741 Returns:

742 google.cloud.bigquery.routine.RemoteFunctionOptions:

743 Python object, as parsed from ``resource``.

744 """

745 ref = cls()

746 ref._properties = resource

747 return ref

748

749 def to_api_repr(self) -> dict:

750 """Construct the API resource representation of this RemoteFunctionOptions.

751

752 Returns:

753 Dict[str, object]: Remote function options represented as an API resource.

754 """

755 return self._properties

756

757 def __eq__(self, other):

758 if not isinstance(other, RemoteFunctionOptions):

759 return NotImplemented

760 return self._properties == other._properties

761

762 def __ne__(self, other):

763 return not self == other

764

765 def __repr__(self):

766 all_properties = [

767 "{}={}".format(property_name, repr(getattr(self, property_name)))

768 for property_name in sorted(self._PROPERTY_TO_API_FIELD)

769 ]

770 return "RemoteFunctionOptions({})".format(", ".join(all_properties))

771

772

773class ExternalRuntimeOptions(object):

774 """Options for the runtime of the external system.

775

776 Args:

777 container_memory (str):

778 Optional. Amount of memory provisioned for a Python UDF container

779 instance. Format: {number}{unit} where unit is one of "M", "G", "Mi"

780 and "Gi" (e.g. 1G, 512Mi). If not specified, the default value is

781 512Mi. For more information, see `Configure container limits for

782 Python UDFs <https://cloud.google.com/bigquery/docs/user-defined-functions-python#configure-container-limits>`_

783 container_cpu (int):

784 Optional. Amount of CPU provisioned for a Python UDF container

785 instance. For more information, see `Configure container limits

786 for Python UDFs <https://cloud.google.com/bigquery/docs/user-defined-functions-python#configure-container-limits>`_

787 runtime_connection (str):

788 Optional. Fully qualified name of the connection whose service account

789 will be used to execute the code in the container. Format:

790 "projects/{projectId}/locations/{locationId}/connections/{connectionId}"

791 max_batching_rows (int):

792 Optional. Maximum number of rows in each batch sent to the external

793 runtime. If absent or if 0, BigQuery dynamically decides the number of

794 rows in a batch.

795 runtime_version (str):

796 Optional. Language runtime version. Example: python-3.11.

797 """

798

799 _PROPERTY_TO_API_FIELD = {

800 "container_memory": "containerMemory",

801 "container_cpu": "containerCpu",

802 "runtime_connection": "runtimeConnection",

803 "max_batching_rows": "maxBatchingRows",

804 "runtime_version": "runtimeVersion",

805 }

806

807 def __init__(

808 self,

809 container_memory: Optional[str] = None,

810 container_cpu: Optional[int] = None,

811 runtime_connection: Optional[str] = None,

812 max_batching_rows: Optional[int] = None,

813 runtime_version: Optional[str] = None,

814 _properties: Optional[Dict] = None,

815 ) -> None:

816 if _properties is None:

817 _properties = {}

818 self._properties = _properties

819

820 if container_memory is not None:

821 self.container_memory = container_memory

822 if container_cpu is not None:

823 self.container_cpu = container_cpu

824 if runtime_connection is not None:

825 self.runtime_connection = runtime_connection

826 if max_batching_rows is not None:

827 self.max_batching_rows = max_batching_rows

828 if runtime_version is not None:

829 self.runtime_version = runtime_version

830

831 @property

832 def container_memory(self) -> Optional[str]:

833 """Optional. Amount of memory provisioned for a Python UDF container instance."""

834 return _helpers._str_or_none(self._properties.get("containerMemory"))

835

836 @container_memory.setter

837 def container_memory(self, value: Optional[str]):

838 if value is not None and not isinstance(value, str):

839 raise ValueError("container_memory must be a string or None.")

840 self._properties["containerMemory"] = value

841

842 @property

843 def container_cpu(self) -> Optional[int]:

844 """Optional. Amount of CPU provisioned for a Python UDF container instance."""

845 return _helpers._int_or_none(self._properties.get("containerCpu"))

846

847 @container_cpu.setter

848 def container_cpu(self, value: Optional[int]):

849 if value is not None and not isinstance(value, int):

850 raise ValueError("container_cpu must be an integer or None.")

851 self._properties["containerCpu"] = value

852

853 @property

854 def runtime_connection(self) -> Optional[str]:

855 """Optional. Fully qualified name of the connection."""

856 return _helpers._str_or_none(self._properties.get("runtimeConnection"))

857

858 @runtime_connection.setter

859 def runtime_connection(self, value: Optional[str]):

860 if value is not None and not isinstance(value, str):

861 raise ValueError("runtime_connection must be a string or None.")

862 self._properties["runtimeConnection"] = value

863

864 @property

865 def max_batching_rows(self) -> Optional[int]:

866 """Optional. Maximum number of rows in each batch sent to the external runtime."""

867 return typing.cast(

868 int, _helpers._int_or_none(self._properties.get("maxBatchingRows"))

869 )

870

871 @max_batching_rows.setter

872 def max_batching_rows(self, value: Optional[int]):

873 if value is not None and not isinstance(value, int):

874 raise ValueError("max_batching_rows must be an integer or None.")

875 self._properties["maxBatchingRows"] = _helpers._str_or_none(value)

876

877 @property

878 def runtime_version(self) -> Optional[str]:

879 """Optional. Language runtime version."""

880 return _helpers._str_or_none(self._properties.get("runtimeVersion"))

881

882 @runtime_version.setter

883 def runtime_version(self, value: Optional[str]):

884 if value is not None and not isinstance(value, str):

885 raise ValueError("runtime_version must be a string or None.")

886 self._properties["runtimeVersion"] = value

887

888 @classmethod

889 def from_api_repr(cls, resource: dict) -> "ExternalRuntimeOptions":

890 """Factory: construct external runtime options given its API representation.

891 Args:

892 resource (Dict[str, object]): Resource, as returned from the API.

893 Returns:

894 google.cloud.bigquery.routine.ExternalRuntimeOptions:

895 Python object, as parsed from ``resource``.

896 """

897 ref = cls()

898 ref._properties = resource

899 return ref

900

901 def to_api_repr(self) -> dict:

902 """Construct the API resource representation of this ExternalRuntimeOptions.

903 Returns:

904 Dict[str, object]: External runtime options represented as an API resource.

905 """

906 return self._properties

907

908 def __eq__(self, other):

909 if not isinstance(other, ExternalRuntimeOptions):

910 return NotImplemented

911 return self._properties == other._properties

912

913 def __ne__(self, other):

914 return not self == other

915

916 def __repr__(self):

917 all_properties = [

918 "{}={}".format(property_name, repr(getattr(self, property_name)))

919 for property_name in sorted(self._PROPERTY_TO_API_FIELD)

920 ]

921 return "ExternalRuntimeOptions({})".format(", ".join(all_properties))