interloper-google-cloud 0.76.0__tar.gz → 0.78.0__tar.gz

{interloper_google_cloud-0.76.0 → interloper_google_cloud-0.78.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: interloper-google-cloud
-Version: 0.76.0
+Version: 0.78.0
 Summary: Interloper Google Cloud integration: BigQuery and Cloud Storage destinations
 Author: Guillaume Onfroy
 Author-email: Guillaume Onfroy <guillaume@digitlcloud.com>
@@ -10,6 +10,7 @@ Requires-Dist: interloper-core
 Requires-Dist: interloper-pandas
 Requires-Dist: pyarrow>=14
 Requires-Dist: db-dtypes>=1.0
+Requires-Dist: pandas-gbq>=0.26.1
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 

{interloper_google_cloud-0.76.0 → interloper_google_cloud-0.78.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "interloper-google-cloud"
-version = "0.76.0"
+version = "0.78.0"
 description = "Interloper Google Cloud integration: BigQuery and Cloud Storage destinations"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -11,6 +11,7 @@ dependencies = [
     "interloper-pandas",
     "pyarrow>=14",
     "db-dtypes>=1.0",
+    "pandas-gbq>=0.26.1",
 ]
 
 [[project.authors]]
@@ -21,7 +22,7 @@ email = "guillaume@digitlcloud.com"
 google_cloud = "interloper_google_cloud"
 
 [build-system]
-requires = ["uv_build>=0.11.5,<0.12"]
+requires = ["uv_build>=0.12.9,<0.13"]
 build-backend = "uv_build"
 
 [tool.uv.sources.interloper-core]
@@ -61,4 +62,6 @@ convention = "google"
     "D102",
     "D103",
     "D104",
+    "RUF069",
+    "PLW0108",
 ]

{interloper_google_cloud-0.76.0 → interloper_google_cloud-0.78.0}/pyproject.toml.orig

@@ -3,7 +3,7 @@
 # ###############
 [project]
 name = "interloper-google-cloud"
-version = "0.76.0"
+version = "0.78.0"
 description = "Interloper Google Cloud integration: BigQuery and Cloud Storage destinations"
 readme = "README.md"
 authors = [{ name = "Guillaume Onfroy", email = "guillaume@digitlcloud.com" }]
@@ -15,13 +15,14 @@ dependencies = [
     "interloper-pandas",
     "pyarrow>=14",
     "db-dtypes>=1.0",
+    "pandas-gbq>=0.26.1",
 ]
 
 [project.entry-points."interloper.components"]
 google_cloud = "interloper_google_cloud"
 
 [build-system]
-requires = ["uv_build>=0.11.5,<0.12"]
+requires = ["uv_build>=0.12.9,<0.13"]
 build-backend = "uv_build"
 
 [tool.uv.sources]
@@ -43,4 +44,4 @@ convention = "google"
 
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401", "F403"]
-"tests/**" = ["ANN", "F811", "D101", "D102", "D103", "D104"]
+"tests/**" = ["ANN", "F811", "D101", "D102", "D103", "D104", "RUF069", "PLW0108"]

interloper_google_cloud-0.78.0/src/interloper_google_cloud/bigquery/destination.py

@@ -0,0 +1,588 @@
+"""BigQuery destination implementation."""
+
+from __future__ import annotations
+
+import datetime
+import inspect
+import json
+import warnings
+from collections.abc import Sequence
+from functools import cached_property
+from typing import Any
+
+import google.auth
+import pandas as pd
+from google.cloud import bigquery
+from google.cloud.exceptions import Conflict, NotFound
+from google.oauth2 import service_account
+from interloper.destination import IOContext, destination
+from interloper.destination.database import DatabaseDestination, PartitionFilter
+from interloper.errors import ConfigError, DataNotFoundError
+from interloper.partitioning import PartitionConfig, TimeGranularity, TimePartitionConfig
+from interloper.representation import Representation
+from interloper.resource.fields import FetchField, InputField, SelectField
+
+from interloper_google_cloud.bigquery.types import TIME_PARTITIONABLE, column_type, parameter_type, to_fields
+from interloper_google_cloud.connection import GoogleCloudConnection
+
+
+@destination(
+    key="bigquery_destination",
+    name="BigQuery",
+    icon="icon:bigquery",
+    tags=["Cloud"],
+)
+class BigQueryDestination(DatabaseDestination):
+    """BigQuery destination."""
+
+    connection: GoogleCloudConnection
+
+    project: str = FetchField(
+        provider="connection.projects",
+        label_key="name",
+        value_key="project_id",
+        description="Google Cloud project ID",
+        discriminator=True,
+    )
+    location: str = SelectField(
+        description="BigQuery dataset location",
+        options=[
+            {"label": "EU", "value": "EU"},
+            {"label": "US", "value": "US"},
+        ],
+    )
+    default_dataset: str | None = InputField(default=None, description="Default BigQuery dataset")
+
+    @cached_property
+    def client(self) -> bigquery.Client:
+        """The BigQuery client every write goes through.
+
+        Built from the connection's service-account key when there is one,
+        else from ambient credentials (workload identity in-cluster).
+
+        Returns:
+            The client, cached per destination instance.
+        """
+        if self.connection and self.connection.service_account_key:
+            key_info = json.loads(self.connection.service_account_key)
+            credentials = service_account.Credentials.from_service_account_info(key_info)
+        else:
+            credentials, _ = google.auth.default()
+
+        return bigquery.Client(
+            project=self.project,
+            credentials=credentials,
+            location=self.location,
+        )
+
+    # -- Helpers ---------------------------------------------------------------
+
+    def _resolve_dataset(self, dataset: str | None) -> str:
+        """Return the BigQuery dataset to use.
+
+        Prefers *dataset* (the asset's).  Falls back to
+        the destination's ``dataset`` field.
+
+        Args:
+            dataset: The asset's dataset, or ``None`` to fall back to the destination's default.
+
+        Returns:
+            The resolved dataset name.
+
+        Raises:
+            ConfigError: If neither the asset nor the destination names a dataset.
+        """
+        ds = dataset or self.default_dataset
+        if ds is None:
+            raise ConfigError(
+                "BigQueryDestination requires a dataset. Either set 'dataset' on the asset "
+                "or provide 'default_dataset' on the destination."
+            )
+        return ds
+
+    def _table_ref(self, table: str, dataset: str | None) -> str:
+        """Build a fully-qualified BigQuery table reference.
+
+        Args:
+            table: Table name.
+            dataset: The BigQuery dataset, or ``None`` for the destination's default.
+
+        Returns:
+            ``project.dataset.table`` string.
+        """
+        ds = self._resolve_dataset(dataset)
+        return f"{self.project}.{ds}.{table}"
+
+    def _get_table(self, table: str, dataset: str | None) -> bigquery.Table | None:
+        """Fetch a BigQuery table.
+
+        Args:
+            table: Table name.
+            dataset: The BigQuery dataset, or ``None`` for the destination's default.
+
+        Returns:
+            The table, or ``None`` if it does not exist.
+        """
+        try:
+            return self.client.get_table(self._table_ref(table, dataset))
+        except NotFound:
+            return None
+
+    def _table_exists(self, table: str, dataset: str | None) -> bool:
+        """Check whether a BigQuery table exists.
+
+        Args:
+            table: Table name.
+            dataset: The BigQuery dataset, or ``None`` for the destination's default.
+
+        Returns:
+            ``True`` if the table exists, ``False`` otherwise.
+        """
+        return self._get_table(table, dataset) is not None
+
+    def _create_table(
+        self,
+        table: str,
+        dataset: str | None,
+        bq_schema: list[bigquery.SchemaField],
+        time_partitioning: bigquery.TimePartitioning | None = None,
+        description: str | None = None,
+    ) -> None:
+        """Create a BigQuery table with an explicit schema, unless one just appeared.
+
+        Two runs writing different partitions of the same new table race on its
+        creation (a backfill, or a queue burst after downtime): whichever loses
+        gets a 409 from BigQuery, which is not an error for it, since the table
+        it wanted now exists with the same schema, so it loads into that one.
+
+        Args:
+            table: Target table name.
+            dataset: The BigQuery dataset, or ``None`` for the destination's default.
+            bq_schema: BigQuery field definitions.
+            time_partitioning: Time partitioning spec, if the asset is partitioned.
+            description: Table description (the asset's description).
+        """
+        bq_table = bigquery.Table(self._table_ref(table, dataset), schema=bq_schema)
+        bq_table.time_partitioning = time_partitioning
+        bq_table.description = description
+        try:
+            self.client.create_table(bq_table)
+        except Conflict:
+            pass  # Created by a concurrent run of the same asset
+
+    def _sync_table_metadata(
+        self,
+        bq_table: bigquery.Table,
+        bq_schema: list[bigquery.SchemaField] | None,
+        description: str | None,
+    ) -> None:
+        """Push field and table descriptions onto an existing table.
+
+        Keeps BigQuery metadata in sync when descriptions change on the asset
+        or its schema after the table was created.  Only descriptions are
+        updated (types, modes, and partitioning are immutable here), empty
+        descriptions never clear existing ones, and no API call is made when
+        nothing changed.
+
+        Args:
+            bq_table: The existing table.
+            bq_schema: Field definitions carrying the wanted descriptions.
+            description: Wanted table description (the asset's description).
+        """
+        update_fields = []
+        if bq_schema is not None:
+            merged, changed = _merge_field_descriptions(bq_table.schema, bq_schema)
+            if changed:
+                bq_table.schema = merged
+                update_fields.append("schema")
+        if description and bq_table.description != description:
+            bq_table.description = description
+            update_fields.append("description")
+        if update_fields:
+            self.client.update_table(bq_table, update_fields)
+
+    def _ensure_dataset(self, dataset: str | None) -> None:
+        """Create the BigQuery dataset if it does not already exist.
+
+        Args:
+            dataset: The BigQuery dataset, or ``None`` for the destination's default.
+        """
+        ds = self._resolve_dataset(dataset)
+        dataset_ref = bigquery.DatasetReference(self.project, ds)
+        try:
+            self.client.get_dataset(dataset_ref)
+        except NotFound:
+            bq_dataset = bigquery.Dataset(dataset_ref)
+            bq_dataset.location = self.client.location
+            try:
+                self.client.create_dataset(bq_dataset)
+            except Conflict:
+                pass  # Created by a concurrent asset — already exists
+
+    # -- DatabaseDestination hooks ---------------------------------------------
+
+    def insert(self, table: str, dataset: str | None, data: Any, context: IOContext) -> None:
+        """Insert data into BigQuery through one Parquet load job, whatever its representation.
+
+        The data is converted to a DataFrame (``Representation.of(data).to("dataframe")``)
+        and loaded with ``load_table_from_dataframe``. The effective schema
+        from the IO context (declared on the asset, or inferred during
+        conform) drives both table DDL and the load job's schema, so the
+        table shape is deterministic and stable across partitions. Without a
+        schema, the load job creates the table from the frame's dtypes.
+
+        New tables are created with the asset's partitioning (time
+        partitioning on the partition column at the asset's granularity) and
+        carry field and table descriptions; on existing tables, descriptions
+        are kept in sync.
+
+        Args:
+            table: Target table name.
+            dataset: The BigQuery dataset, or ``None`` for the destination's default.
+            data: The data in its native representation.
+            context: IO context carrying the asset and effective schema.
+        """
+        frame = Representation.of(data).to("dataframe")
+        bq_schema = to_fields(context.schema.field_specs()) if context.schema is not None else None
+        description = _asset_description(context.asset)
+        partitioning = context.asset.partitioning
+
+        bq_table = self._get_table(table, dataset)
+        time_partitioning = None
+        if bq_table is not None:
+            self._sync_table_metadata(bq_table, bq_schema, description)
+        elif bq_schema is not None:
+            self._ensure_dataset(dataset)
+            tp = _time_partitioning(partitioning, bq_schema)
+            self._create_table(table, dataset, bq_schema, time_partitioning=tp, description=description)
+        else:
+            self._ensure_dataset(dataset)
+            time_partitioning = _time_partitioning(partitioning, None)
+
+        self._load(self._table_ref(table, dataset), frame, bq_schema, time_partitioning=time_partitioning)
+
+    def _load(
+        self,
+        ref: str,
+        df: pd.DataFrame,
+        bq_schema: list[bigquery.SchemaField] | None,
+        time_partitioning: bigquery.TimePartitioning | None = None,
+    ) -> None:
+        """Load a DataFrame via a Parquet load job.
+
+        When a schema is available, columns are aligned to it: extra columns
+        are dropped (with a warning) and the load job receives explicit field
+        types, so pyarrow casts values (including ``NaN`` → ``NULL``) instead
+        of relying on dtype autodetection.
+
+        Args:
+            ref: Fully-qualified table reference.
+            df: The DataFrame to load.
+            bq_schema: BigQuery field definitions, or ``None`` to autodetect.
+            time_partitioning: Partitioning spec for the table the load job is
+                about to create; ``None`` when the table already exists.
+        """
+        job_config = bigquery.LoadJobConfig(write_disposition=bigquery.WriteDisposition.WRITE_APPEND)
+        if time_partitioning is not None:
+            job_config.time_partitioning = time_partitioning
+
+        if bq_schema is not None:
+            schema_columns = [field.name for field in bq_schema]
+            extras = [str(c) for c in df.columns if str(c) not in schema_columns]
+            if extras:
+                warnings.warn(
+                    f"Columns {extras} are not in the schema for '{ref}' and will not be written.",
+                    UserWarning,
+                    stacklevel=2,
+                )
+            present = [c for c in schema_columns if c in df.columns]
+            df = df[present]
+            job_config.schema = [field for field in bq_schema if field.name in present]
+
+        # The client deprecates this in favour of pandas_gbq.to_gbq(), which
+        # wraps this same call without exposing the job config we rely on.
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=PendingDeprecationWarning, module="google.cloud.bigquery")
+            job = self.client.load_table_from_dataframe(df, ref, job_config=job_config)
+        job.result()
+
+    def delete(self, table: str, dataset: str | None, where: PartitionFilter | None) -> None:
+        """Delete the rows a filter selects, or truncate the table.
+
+        A table that does not exist has nothing to delete.
+
+        Args:
+            table: Target table name.
+            dataset: The BigQuery dataset, or ``None`` for the destination's default.
+            where: The rows to delete; ``None`` for the whole table.
+        """
+        bq_table = self._get_table(table, dataset)
+        if bq_table is None:
+            return
+        ref = self._table_ref(table, dataset)
+        if where is None:
+            self.client.query(f"TRUNCATE TABLE `{ref}`").result()
+            return
+        predicate, parameters = _predicate(bq_table, where)
+        job_config = bigquery.QueryJobConfig(query_parameters=parameters)
+        self.client.query(f"DELETE FROM `{ref}` WHERE {predicate}", job_config=job_config).result()
+
+    def select(self, table: str, dataset: str | None, where: PartitionFilter | None) -> pd.DataFrame:
+        """Select the rows a filter selects, or every row, as a DataFrame.
+
+        The client builds the frame from the query's Arrow result, so column
+        types survive the read without a pass through Python records.
+
+        Args:
+            table: Target table name.
+            dataset: The BigQuery dataset, or ``None`` for the destination's default.
+            where: The rows to select; ``None`` for the whole table.
+
+        Returns:
+            The selected rows.
+
+        Raises:
+            DataNotFoundError: If the table does not exist yet.
+        """
+        bq_table = self._get_table(table, dataset)
+        ref = self._table_ref(table, dataset)
+        if bq_table is None:
+            raise DataNotFoundError(f"Table '{ref}' does not exist. Has the asset been materialized?")
+        if where is None:
+            return self.client.query(f"SELECT * FROM `{ref}`").result().to_dataframe()
+        predicate, parameters = _predicate(bq_table, where)
+        job_config = bigquery.QueryJobConfig(query_parameters=parameters)
+        query = self.client.query(f"SELECT * FROM `{ref}` WHERE {predicate}", job_config=job_config)
+        return query.result().to_dataframe()
+
+    # -- Introspection ---------------------------------------------------------
+
+    def count(self, table: str, dataset: str | None, column: str) -> dict[str, int]:
+        """Return row counts grouped by partition column via BigQuery SQL.
+
+        Args:
+            table: Target table name.
+            dataset: The BigQuery dataset, or ``None`` for the destination's default.
+            column: Column to group by.
+
+        Returns:
+            Mapping from partition value (as string) to row count.
+
+        Raises:
+            DataNotFoundError: If the table does not exist.
+        """
+        if not self._table_exists(table, dataset):
+            ref = self._table_ref(table, dataset)
+            raise DataNotFoundError(f"Table '{ref}' does not exist. Has the asset been materialized?")
+
+        ref = self._table_ref(table, dataset)
+        query = f"SELECT CAST(`{column}` AS STRING) AS partition_value, COUNT(*) AS cnt FROM `{ref}` GROUP BY 1"
+        rows = self.client.query(query).result()
+        return {row["partition_value"]: row["cnt"] for row in rows}
+
+
+# -- Utility functions ---------------------------------------------------------
+
+
+def _asset_description(asset: Any) -> str | None:
+    """Return the asset's description (its class docstring), cleaned.
+
+    This mirrors how ``Component.definition()`` derives descriptions.
+
+    Args:
+        asset: The asset whose docstring is read.
+
+    Returns:
+        The cleaned docstring, or ``None`` when the asset has none.
+    """
+    doc = type(asset).__doc__
+    return inspect.cleandoc(doc) if doc else None
+
+
+# BigQuery time partitioning only supports DATE / DATETIME / TIMESTAMP columns.
+_GRANULARITY_TO_BQ_TYPE = {
+    TimeGranularity.HOUR: bigquery.TimePartitioningType.HOUR,
+    TimeGranularity.DAY: bigquery.TimePartitioningType.DAY,
+    TimeGranularity.MONTH: bigquery.TimePartitioningType.MONTH,
+    TimeGranularity.YEAR: bigquery.TimePartitioningType.YEAR,
+}
+
+
+def _time_partitioning(
+    config: PartitionConfig | None,
+    bq_schema: list[bigquery.SchemaField] | None,
+) -> bigquery.TimePartitioning | None:
+    """Resolve the asset's partition config into a BigQuery time partitioning spec.
+
+    Partitioning at the asset's declared granularity, when BigQuery supports
+    it: the column must be DATE / DATETIME / TIMESTAMP, and hourly requires a
+    sub-day type (BigQuery rejects HOUR partitioning on a DATE column). When
+    the column type is known (from the schema) and does not support the
+    granularity, or the config is not time-based and no schema is available,
+    returns ``None`` — the table is created unpartitioned, which is always
+    valid.
+
+    Args:
+        config: The asset's partition config, if any.
+        bq_schema: The table's field definitions, when known.
+
+    Returns:
+        A ``TimePartitioning`` at the asset's granularity, or ``None``.
+    """
+    if config is None:
+        return None
+
+    granularity = config.granularity if isinstance(config, TimePartitionConfig) else TimeGranularity.DAY
+    if bq_schema is not None:
+        field = next((f for f in bq_schema if f.name == config.column), None)
+        unsupported = (
+            field is None
+            or field.field_type not in TIME_PARTITIONABLE
+            or (granularity is TimeGranularity.HOUR and field.field_type == "DATE")
+        )
+        if unsupported:
+            if isinstance(config, TimePartitionConfig):
+                reason = (
+                    "missing from the schema"
+                    if field is None
+                    else f"of type {field.field_type}"
+                    + (" (hourly partitioning needs DATETIME or TIMESTAMP)" if field.field_type == "DATE" else "")
+                )
+                warnings.warn(
+                    f"Partition column '{config.column}' is {reason}; "
+                    "the BigQuery table will not be time-partitioned.",
+                    UserWarning,
+                    stacklevel=2,
+                )
+            return None
+    elif not isinstance(config, TimePartitionConfig):
+        return None
+
+    return bigquery.TimePartitioning(type_=_GRANULARITY_TO_BQ_TYPE[granularity], field=config.column)
+
+
+def _merge_field_descriptions(
+    existing: Sequence[bigquery.SchemaField],
+    desired: Sequence[bigquery.SchemaField],
+) -> tuple[list[bigquery.SchemaField], bool]:
+    """Overlay desired field descriptions onto an existing table schema.
+
+    Only descriptions are touched — types and modes stay as they are in the
+    table, so the result is always a valid ``update_table`` schema.  Empty
+    desired descriptions never clear an existing one (e.g. set manually in
+    the BigQuery console).
+
+    Args:
+        existing: The table's current field definitions.
+        desired: Field definitions carrying the wanted descriptions.
+
+    Returns:
+        The merged field list and whether anything changed.
+    """
+    desired_by_name = {f.name: f for f in desired}
+    merged: list[bigquery.SchemaField] = []
+    changed = False
+    for field in existing:
+        want = desired_by_name.get(field.name)
+        if want is None:
+            merged.append(field)
+            continue
+        api = field.to_api_repr()
+        if want.description and want.description != field.description:
+            api["description"] = want.description
+            changed = True
+        if field.field_type == "RECORD" and want.fields:
+            sub_fields, sub_changed = _merge_field_descriptions(field.fields, want.fields)
+            if sub_changed:
+                api["fields"] = [f.to_api_repr() for f in sub_fields]
+                changed = True
+        merged.append(bigquery.SchemaField.from_api_repr(api))
+    return merged, changed
+
+
+# BigQuery column type -> query parameter type, for partition predicates.
+def _predicate(bq_table: bigquery.Table, where: PartitionFilter) -> tuple[str, list[bigquery.ScalarQueryParameter]]:
+    """Render a partition filter as a parameterised SQL predicate.
+
+    Args:
+        bq_table: The target table, for the column's type.
+        where: The filter to render.
+
+    Returns:
+        The predicate text and the typed parameters it names.
+    """
+    column = where.column
+    if where.bounds is None:
+        return f"`{column}` = @partition_value", [_partition_param(bq_table, column, where.value)]
+    start, end = where.bounds
+    return (
+        f"`{column}` >= @partition_start AND `{column}` < @partition_end",
+        [
+            _partition_param(bq_table, column, start, name="partition_start"),
+            _partition_param(bq_table, column, end, name="partition_end"),
+        ],
+    )
+
+
+def _partition_param(
+    bq_table: bigquery.Table,
+    column: str,
+    value: Any,
+    name: str = "partition_value",
+) -> bigquery.ScalarQueryParameter:
+    """Build a partition-predicate query parameter, typed from the table.
+
+    Partition values arrive as strings (``Partition.id``) or as the period
+    bounds of a time partition (dates/datetimes), but the column may be
+    DATE / TIMESTAMP / INTEGER — BigQuery does not coerce a STRING parameter
+    in a comparison predicate, so the parameter type must match the actual
+    column type.  Falls back to inferring from the value when the column is
+    not in the table schema.
+
+    Args:
+        bq_table: The target table (for column type lookup).
+        column: Partition column name.
+        value: Partition value or bound.
+        name: The query parameter's name.
+
+    Returns:
+        A scalar parameter with the matching type.
+    """
+    field = next((f for f in bq_table.schema if f.name == column), None)
+    if field is not None:
+        param_type = parameter_type(field.field_type)
+    else:
+        param_type = column_type(type(value))
+    if param_type in ("TIMESTAMP", "DATETIME") and isinstance(value, str):
+        # The client serializes these from datetime objects; a date-only
+        # string like "2024-01-01" (a TimePartition id) fails to format.
+        try:
+            value = datetime.datetime.fromisoformat(value)
+        except ValueError:
+            pass
+    if param_type in ("TIMESTAMP", "DATETIME") and isinstance(value, datetime.date) and not isinstance(
+        value, datetime.datetime
+    ):
+        # A date bound against a datetime-typed column: promote to midnight so
+        # the client serializes it in the parameter's declared type.
+        value = datetime.datetime(value.year, value.month, value.day)
+    if param_type == "DATE" and isinstance(value, datetime.datetime):
+        # A datetime bound against a DATE column loses sub-day precision by
+        # definition; the caller guards hourly-on-DATE at table creation.
+        value = value.date()
+    if param_type == "STRING" and not isinstance(value, str):
+        value = _iso_string(value)
+    return bigquery.ScalarQueryParameter(name, param_type, value)
+
+
+def _iso_string(value: Any) -> str:
+    """Render a bound as an ISO-8601 string for STRING-typed columns.
+
+    Args:
+        value: The bound to render.
+
+    Returns:
+        The ISO rendering of *value*.
+    """
+    return value.isoformat() if isinstance(value, (datetime.date, datetime.datetime)) else str(value)
+