gooddata-sdk 1.63.1.dev1__tar.gz → 1.63.1.dev3__tar.gz

gooddata_sdk-1.63.1.dev3/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: gooddata-sdk
+Version: 1.63.1.dev3
+Summary: GoodData Cloud Python SDK
+Project-URL: Documentation, https://www.gooddata.com/docs/python-sdk/1.63.1.dev3
+Project-URL: Source, https://github.com/gooddata/gooddata-python-sdk
+Author-email: GoodData <support@gooddata.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Keywords: analytics,api,business,cloud,gooddata,headless,headless-bi,intelligence,layer,metrics,native,sdk,semantic,sql
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Requires-Python: <4.0,>=3.10
+Requires-Dist: attrs<=24.2.0,>=21.4.0
+Requires-Dist: brotli==1.2.0
+Requires-Dist: cattrs<=24.1.1,>=22.1.0
+Requires-Dist: gooddata-api-client~=1.63.1.dev3
+Requires-Dist: gooddata-code-convertors
+Requires-Dist: python-dateutil>=2.5.3
+Requires-Dist: python-dotenv<2.0.0,>=1.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: requests~=2.32.0
+Provides-Extra: arrow
+Requires-Dist: pyarrow>=23.0.1; extra == 'arrow'
+Description-Content-Type: text/markdown
+
+# GoodData Python SDK
+
+The `gooddata-sdk` package provides a clean and convenient Python API to interact with [GoodData](https://www.gooddata.com/).
+
+At the moment the SDK provides services to inspect and interact with the Semantic Model and consume analytics:
+* Catalog Workspaces Service
+* Catalog Workspace Content Service
+* Catalog Data Source Service
+* Catalog User Service
+* Catalog Permission Service
+* Catalog Organization Service
+* Catalog Appearance Service
+* Visualizations Service
+* Compute Service
+* Table Service
+
+See [DOCUMENTATION](https://www.gooddata.com/docs/python-sdk/1.63.1.dev3) for more details.
+
+## Requirements
+
+-  GoodData Cloud or GoodData.CN installation
+-  Python 3.10 or newer
+
+## Installation
+
+Run the following command to install the `gooddata-sdk` package on your system:
+
+    pip install gooddata-sdk
+
+## Example
+
+Compute an visualization:
+```python
+import gooddata_sdk
+
+# GoodData host in the form of uri
+host = "http://localhost:3000"
+# GoodData user token
+token = "some_user_token"
+sdk = gooddata_sdk.GoodDataSdk.create(host, token)
+
+workspace_id = "demo"
+visualization_id = "customers_trend"
+# reads visualization from workspace
+visualization = sdk.visualizations.get_visualization(workspace_id, visualization_id)
+# triggers computation for the visualization. the result will be returned in a tabular form
+table = sdk.tables.for_visualization(workspace_id, visualization)
+
+# and this is how you can read data row-by-row and do something with it
+for row in table.read_all():
+    print(row)
+```
+
+
+## Bugs & Requests
+
+Please use the [GitHub issue tracker](https://github.com/gooddata/gooddata-python-sdk/issues) to submit bugs
+or request features.
+
+## Changelog
+
+See  [Github releases](https://github.com/gooddata/gooddata-python-sdk/releases) for released versions
+and a list of changes.

gooddata_sdk-1.63.1.dev3/README.md

@@ -0,0 +1,63 @@
+# GoodData Python SDK
+
+The `gooddata-sdk` package provides a clean and convenient Python API to interact with [GoodData](https://www.gooddata.com/).
+
+At the moment the SDK provides services to inspect and interact with the Semantic Model and consume analytics:
+* Catalog Workspaces Service
+* Catalog Workspace Content Service
+* Catalog Data Source Service
+* Catalog User Service
+* Catalog Permission Service
+* Catalog Organization Service
+* Catalog Appearance Service
+* Visualizations Service
+* Compute Service
+* Table Service
+
+See [DOCUMENTATION](https://www.gooddata.com/docs/python-sdk/1.63.1.dev3) for more details.
+
+## Requirements
+
+-  GoodData Cloud or GoodData.CN installation
+-  Python 3.10 or newer
+
+## Installation
+
+Run the following command to install the `gooddata-sdk` package on your system:
+
+    pip install gooddata-sdk
+
+## Example
+
+Compute an visualization:
+```python
+import gooddata_sdk
+
+# GoodData host in the form of uri
+host = "http://localhost:3000"
+# GoodData user token
+token = "some_user_token"
+sdk = gooddata_sdk.GoodDataSdk.create(host, token)
+
+workspace_id = "demo"
+visualization_id = "customers_trend"
+# reads visualization from workspace
+visualization = sdk.visualizations.get_visualization(workspace_id, visualization_id)
+# triggers computation for the visualization. the result will be returned in a tabular form
+table = sdk.tables.for_visualization(workspace_id, visualization)
+
+# and this is how you can read data row-by-row and do something with it
+for row in table.read_all():
+    print(row)
+```
+
+
+## Bugs & Requests
+
+Please use the [GitHub issue tracker](https://github.com/gooddata/gooddata-python-sdk/issues) to submit bugs
+or request features.
+
+## Changelog
+
+See  [Github releases](https://github.com/gooddata/gooddata-python-sdk/releases) for released versions
+and a list of changes.

gooddata_sdk-1.63.1.dev3/pyproject.toml

@@ -0,0 +1,95 @@
+# (C) 2025 GoodData Corporation
+[project]
+name = "gooddata-sdk"
+version = "1.63.1.dev3"
+description = "GoodData Cloud Python SDK"
+readme = "README.md"
+license = "MIT"
+authors = [
+    {name = "GoodData", email = "support@gooddata.com"}
+]
+keywords = [
+    "gooddata",
+    "sdk",
+    "api",
+    "analytics",
+    "headless",
+    "business",
+    "intelligence",
+    "headless-bi",
+    "cloud",
+    "native",
+    "semantic",
+    "layer",
+    "sql",
+    "metrics",
+]
+requires-python = ">=3.10,<4.0"
+dependencies = [
+    "gooddata-api-client~=1.63.1.dev3",
+    "python-dateutil>=2.5.3",
+    "pyyaml>=6.0",
+    "attrs>=21.4.0,<=24.2.0",
+    "cattrs>=22.1.0,<=24.1.1",
+    "brotli==1.2.0",
+    "requests~=2.32.0",
+    "python-dotenv>=1.0.0,<2.0.0",
+    "gooddata-code-convertors",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Database",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development",
+    "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+arrow = ["pyarrow>=23.0.1"]
+
+[project.urls]
+Documentation = "https://www.gooddata.com/docs/python-sdk/1.63.1.dev3"
+Source = "https://github.com/gooddata/gooddata-python-sdk"
+
+[project.scripts]
+gdc = "gooddata_sdk.cli.gdc_core:main"
+
+[dependency-groups]
+test = [
+    "pytest~=8.3.4",
+    "pytest-cov~=6.0.0",
+    "pytest-json-report==1.5.0",
+    "pytest-snapshot==0.9.0",
+    "pytest-order~=1.3.0",
+    "vcrpy~=8.0.0",
+    "urllib3~=2.6.0",
+    "python-dotenv~=1.0.0",
+    "deepdiff~=8.5.0",
+    "tests_support",
+    "pyarrow>=23.0.1",
+]
+
+[tool.ty.analysis]
+allowed-unresolved-imports = ["gooddata_api_client.**"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/gooddata_sdk"]
+
+[tool.coverage.run]
+source = ["gooddata_sdk"]
+
+[tool.coverage.paths]
+source = [
+    "src/gooddata_sdk",
+    "**/site-packages/gooddata_sdk",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

gooddata_sdk-1.63.1.dev3/src/gooddata_sdk/catalog/data_source/entity_model/data_source.py

@@ -0,0 +1,320 @@
+# (C) 2022 GoodData Corporation
+from __future__ import annotations
+
+import builtins
+from typing import Any, ClassVar, TypeVar
+
+from attrs import Attribute, asdict, define, field
+from cattrs import structure
+from gooddata_api_client.model.json_api_data_source_in import JsonApiDataSourceIn
+from gooddata_api_client.model.json_api_data_source_in_attributes import JsonApiDataSourceInAttributes
+from gooddata_api_client.model.json_api_data_source_in_document import JsonApiDataSourceInDocument
+from gooddata_api_client.model.json_api_data_source_patch import JsonApiDataSourcePatch
+from gooddata_api_client.model.json_api_data_source_patch_attributes import JsonApiDataSourcePatchAttributes
+from gooddata_api_client.model.json_api_data_source_patch_document import JsonApiDataSourcePatchDocument
+
+from gooddata_sdk.catalog.base import Base, value_in_allowed
+from gooddata_sdk.catalog.entity import (
+    BasicCredentials,
+    ClientSecretCredentials,
+    Credentials,
+    KeyPairCredentials,
+    TokenCredentials,
+    TokenCredentialsFromFile,
+)
+
+U = TypeVar("U", bound="CatalogDataSourceBase")
+
+
+def db_attrs_with_template(instance: CatalogDataSource, *args: Any) -> None:
+    if instance.db_specific_attributes is not None and instance.url_template is None:
+        raise ValueError("_URL_TMPL needs to be set when db_specific_attributes is not None.")
+
+
+@define(kw_only=True, eq=False)
+class CatalogDataSourceBase(Base):
+    _SUPPORTED_CREDENTIALS: ClassVar[list[builtins.type[Credentials]]] = [
+        BasicCredentials,
+        ClientSecretCredentials,
+        TokenCredentials,
+        TokenCredentialsFromFile,
+        KeyPairCredentials,
+    ]
+    _DELIMITER: ClassVar[str] = "&"
+    _ATTRIBUTES: ClassVar[list[str]] = [
+        "cache_strategy",
+        "url",
+        "parameters",
+        "name",
+        "type",
+        "schema",
+        "alternative_data_source_id",
+    ]
+
+    id: str
+    name: str
+    type: str = field()
+    schema: str
+    url: str | None = None
+    cache_strategy: str | None = None
+    parameters: list[dict[str, str]] | None = None
+    decoded_parameters: list[dict[str, str]] | None = None
+    credentials: Credentials = field(repr=False)
+    alternative_data_source_id: str | None = None
+
+    @type.validator  # type: ignore
+    def _check_allowed_values(self, attribute: Attribute, value: str) -> None:
+        value_in_allowed(self.__class__, attribute, value, JsonApiDataSourceInAttributes)
+
+    def to_api(self) -> Any:
+        kwargs = self.credentials.to_api_args()
+        attributes = asdict(
+            self, filter=lambda attribute, value: attribute.name in self._ATTRIBUTES and value is not None
+        )
+        kwargs = {**kwargs, **attributes}
+        return JsonApiDataSourceInDocument(
+            data=JsonApiDataSourceIn(
+                id=self.id,
+                attributes=JsonApiDataSourceInAttributes(
+                    **kwargs,
+                ),
+            )
+        )
+
+    @classmethod
+    def from_api(cls: builtins.type[U], entity: dict[str, Any]) -> U:
+        attributes = entity["attributes"]
+        credentials = Credentials.create(cls._SUPPORTED_CREDENTIALS, entity)
+        return structure({"id": entity["id"], "credentials": credentials, **attributes}, cls)
+
+    @classmethod
+    def to_api_patch(cls, data_source_id: str, attributes: dict) -> JsonApiDataSourcePatchDocument:
+        return JsonApiDataSourcePatchDocument(
+            data=JsonApiDataSourcePatch(id=data_source_id, attributes=JsonApiDataSourcePatchAttributes(**attributes))
+        )
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            self.id == other.id
+            and self.name == other.name
+            and self.type == other.type
+            and self.schema == other.schema
+            and self.parameters == other.parameters
+        )
+
+
+@define(kw_only=True, eq=False)
+class CatalogDataSource(CatalogDataSourceBase):
+    _URL_TMPL: ClassVar[str | None] = None
+    _DATA_SOURCE_TYPE: ClassVar[str | None] = None
+
+    db_vendor: str | None = field(default=None, init=False)
+    db_specific_attributes: DatabaseAttributes | None = field(default=None, validator=db_attrs_with_template)
+    url_params: list[tuple[str, str]] | None = None
+
+    def __attrs_post_init__(self) -> None:
+        self.db_vendor = self.db_vendor or self.type.lower()
+        self.url = self._make_url()
+
+    def _make_url(self) -> str | None:
+        parameters = self._join_params()
+        if self.url:
+            return f"{self.url}?{parameters}" if parameters else self.url
+        elif self.db_specific_attributes and self._URL_TMPL:
+            base_url = self._URL_TMPL.format(
+                **self.db_specific_attributes.str_attributes,
+                # url contains {db_vendor}, e.g. jdbc:{db_vendor}://....
+                # we inject custom or default (DS_TYPE.lower()) value there
+                db_vendor=self.db_vendor,
+                schema=self.schema,
+            )
+            return f"{base_url}?{parameters}" if parameters else base_url
+        else:
+            return None
+
+    def _join_params(self) -> str | None:
+        if self.url_params:
+            return self._DELIMITER.join([f"{p[0]}={p[1]}" for p in self.url_params])
+        return None
+
+    @property
+    def url_template(self) -> str | None:
+        return self._URL_TMPL
+
+
+@define(kw_only=True)
+class DatabaseAttributes:
+    @property
+    def str_attributes(self) -> dict[str, str]:
+        return asdict(self)
+
+
+@define(kw_only=True)
+class PostgresAttributes(DatabaseAttributes):
+    host: str
+    db_name: str
+    port: str = "5432"
+
+
+@define(kw_only=True)
+class RedshiftAttributes(PostgresAttributes):
+    port: str = "5439"
+
+
+@define(kw_only=True)
+class VerticaAttributes(PostgresAttributes):
+    port: str = "5433"
+
+
+@define(kw_only=True)
+class GreenplumAttributes(PostgresAttributes):
+    pass
+
+
+@define(kw_only=True)
+class MySqlAttributes(DatabaseAttributes):
+    host: str
+    port: str = "3306"
+
+
+@define(kw_only=True)
+class MariaDbAttributes(MySqlAttributes):
+    pass
+
+
+@define(kw_only=True)
+class CatalogDataSourcePostgres(CatalogDataSource):
+    _URL_TMPL: ClassVar[str] = "jdbc:{db_vendor}://{host}:{port}/{db_name}"
+    type: str = "POSTGRESQL"
+
+
+@define(kw_only=True)
+class CatalogDataSourceRedshift(CatalogDataSourcePostgres):
+    type: str = "REDSHIFT"
+
+
+@define(kw_only=True)
+class CatalogDataSourceVertica(CatalogDataSourcePostgres):
+    type: str = "VERTICA"
+
+
+@define(kw_only=True)
+class SnowflakeAttributes(DatabaseAttributes):
+    account: str
+    warehouse: str
+    db_name: str
+    port: str = "443"
+
+
+@define(kw_only=True)
+class CatalogDataSourceSnowflake(CatalogDataSource):
+    _URL_TMPL: ClassVar[str] = (
+        "jdbc:{db_vendor}://{account}.snowflakecomputing.com:{port}?warehouse={warehouse}&db={db_name}"
+    )
+    type: str = "SNOWFLAKE"
+    db_specific_attributes: DatabaseAttributes
+
+    def _make_url(self) -> str:
+        parameters = self._join_params()
+        base_url = self._URL_TMPL.format(
+            **self.db_specific_attributes.str_attributes,
+            # url contains {db_vendor}, e.g. jdbc:{db_vendor}://....
+            # we inject custom or default (DS_TYPE.lower()) value there
+            db_vendor=self.db_vendor,
+        )
+        return f"{base_url}{self._DELIMITER}{parameters}" if parameters else base_url
+
+
+@define(kw_only=True)
+class CatalogDataSourceBigQuery(CatalogDataSource):
+    type: str = "BIGQUERY"
+
+
+@define(kw_only=True)
+class CatalogDataSourceGreenplum(CatalogDataSourcePostgres):
+    type: str = "GREENPLUM"
+    db_vendor: str = "postgresql"
+
+
+@define(kw_only=True)
+class MsSqlAttributes(DatabaseAttributes):
+    host: str
+    db_name: str
+    port: str = "1433"
+
+
+@define(kw_only=True)
+class CatalogDataSourceMsSql(CatalogDataSource):
+    _URL_TMPL: ClassVar[str] = "jdbc:{db_vendor}://{host}:{port};databaseName={db_name}"
+    type: str = "MSSQL"
+    db_vendor: str = "sqlserver"
+    db_specific_attributes: MsSqlAttributes
+
+
+@define(kw_only=True)
+class DatabricksAttributes(DatabaseAttributes):
+    host: str
+    http_path: str
+    port: str = "443"
+
+
+@define(kw_only=True)
+class CatalogDataSourceDatabricks(CatalogDataSource):
+    _URL_TMPL: ClassVar[str] = "jdbc:{db_vendor}://{host}:{port}/default;httpPath={http_path}"
+    type: str = "DATABRICKS"
+    parameters: list[dict[str, str]]
+    db_specific_attributes: DatabricksAttributes
+
+    def __attrs_post_init__(self) -> None:
+        mandatory_parameter = [parameter.get("name") == "catalog" for parameter in self.parameters]
+        if not any(mandatory_parameter):
+            raise ValueError(f"'catalog' is mandatory parameter for data source type {self.type}")
+
+        self.db_vendor = self.type.lower()
+        self.url = self._make_url()
+
+
+@define(kw_only=True)
+class CatalogDataSourceMySql(CatalogDataSource):
+    _URL_TMPL: ClassVar[str] = "jdbc:{db_vendor}://{host}:{port}/{schema}"
+    type: str = "MYSQL"
+    db_vendor: str = "mysql"
+
+
+@define(kw_only=True)
+class CatalogDataSourceMariaDb(CatalogDataSourceMySql):
+    type: str = "MARIADB"
+    db_vendor: str = "mariadb"
+
+
+@define(kw_only=True)
+class MotherDuckAttributes(DatabaseAttributes):
+    db_name: str
+
+
+@define(kw_only=True)
+class CatalogDataSourceMotherDuck(CatalogDataSource):
+    _URL_TMPL: ClassVar[str] = "jdbc:duckdb:md:{db_name}"
+    type: str = "MOTHERDUCK"
+
+
+class _NoCredentials(Credentials):
+    """Placeholder credentials for data sources that do not require authentication."""
+
+    def to_api_args(self) -> dict[str, Any]:
+        return {}
+
+    @classmethod
+    def is_part_of_api(cls, entity: dict[str, Any]) -> bool:
+        return True
+
+    @classmethod
+    def from_api(cls, entity: dict[str, Any]) -> _NoCredentials:
+        return cls()
+
+
+@define(kw_only=True, eq=False)
+class CatalogDataSourceGdStorage(CatalogDataSource):
+    type: str = "GDSTORAGE"
+    schema: str = ""
+    credentials: Credentials = field(factory=_NoCredentials, repr=False)