openmetadata-ingestion 1.5.13.1__py3-none-any.whl → 1.6.0.0__py3-none-any.whl

metadata/ingestion/source/api/rest/connection.py

@@ -0,0 +1,93 @@
+#  Copyright 2024 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Source connection handler
+"""
+from typing import Optional
+
+import requests
+from requests.models import Response
+
+from metadata.generated.schema.entity.automations.workflow import (
+    Workflow as AutomationWorkflow,
+)
+from metadata.generated.schema.entity.services.connections.api.restConnection import (
+    RestConnection,
+)
+from metadata.generated.schema.entity.services.connections.testConnectionResult import (
+    TestConnectionResult,
+)
+from metadata.ingestion.connections.test_connections import test_connection_steps
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.utils.constants import THREE_MIN
+
+
+class SchemaURLError(Exception):
+    """
+    Class to indicate schema url is invalid
+    """
+
+
+class InvalidOpenAPISchemaError(Exception):
+    """
+    Class to indicate openapi schema is invalid
+    """
+
+
+def get_connection(connection: RestConnection) -> Response:
+    """
+    Create connection
+    """
+    if connection.token:
+        headers = {"Authorization": f"Bearer {connection.token.get_secret_value()}"}
+        return requests.get(connection.openAPISchemaURL, headers=headers)
+    return requests.get(connection.openAPISchemaURL)
+
+
+def test_connection(
+    metadata: OpenMetadata,
+    client: Response,
+    service_connection: RestConnection,
+    automation_workflow: Optional[AutomationWorkflow] = None,
+    timeout_seconds: Optional[int] = THREE_MIN,
+) -> TestConnectionResult:
+    """
+    Test connection. This can be executed either as part
+    of a metadata workflow or during an Automation Workflow
+    """
+
+    def custom_url_exec():
+        if (
+            "application/json" in client.headers.get("content-type")
+            and client.status_code == 200
+        ):
+            return []
+        raise SchemaURLError(
+            "Failed to parse JSON schema url. Please check if provided url is valid JSON schema."
+        )
+
+    def custom_schema_exec():
+        if client.json().get("openapi") is not None:
+            return []
+        raise InvalidOpenAPISchemaError(
+            "Provided schema is not valid OpenAPI JSON schema"
+        )
+
+    test_fn = {"CheckURL": custom_url_exec, "CheckSchema": custom_schema_exec}
+
+    return test_connection_steps(
+        metadata=metadata,
+        test_fn=test_fn,
+        service_type=service_connection.type.value,
+        automation_workflow=automation_workflow,
+        timeout_seconds=timeout_seconds,
+    )

metadata/ingestion/source/api/rest/metadata.py

@@ -0,0 +1,278 @@
+#  Copyright 2024 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""REST source module"""
+
+import traceback
+from typing import Iterable, List, Optional
+
+from pydantic import AnyUrl
+
+from metadata.generated.schema.api.data.createAPICollection import (
+    CreateAPICollectionRequest,
+)
+from metadata.generated.schema.api.data.createAPIEndpoint import (
+    CreateAPIEndpointRequest,
+)
+from metadata.generated.schema.entity.data.apiCollection import APICollection
+from metadata.generated.schema.entity.data.apiEndpoint import ApiRequestMethod
+from metadata.generated.schema.entity.services.connections.api.restConnection import (
+    RestConnection,
+)
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
+from metadata.generated.schema.metadataIngestion.workflow import (
+    Source as WorkflowSource,
+)
+from metadata.generated.schema.type.apiSchema import APISchema
+from metadata.generated.schema.type.basic import FullyQualifiedEntityName
+from metadata.generated.schema.type.schema import DataTypeTopic, FieldModel
+from metadata.ingestion.api.models import Either
+from metadata.ingestion.api.steps import InvalidSourceException
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.source.api.api_service import ApiServiceSource
+from metadata.ingestion.source.api.rest.models import RESTCollection, RESTEndpoint
+from metadata.utils import fqn
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
+
+
+class RestSource(ApiServiceSource):
+    """
+    Source implementation to ingest REST data.
+
+    We will iterate on the registered collections, endpoints
+    and prepare an iterator of
+    """
+
+    def __init__(self, config: WorkflowSource, metadata: OpenMetadata):
+        super().__init__(config, metadata)
+
+    @classmethod
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: RestConnection = config.serviceConnection.root.config
+        if not isinstance(connection, RestConnection):
+            raise InvalidSourceException(
+                f"Expected RestConnection, but got {connection}"
+            )
+        return cls(config, metadata)
+
+    def get_api_collections(self, *args, **kwargs) -> Iterable[RESTCollection]:
+        """
+        Method to list all collections to process.
+        Here is where filtering happens
+        """
+        try:
+            self.json_response = self.connection.json()
+            if self.json_response.get("tags", []):
+                # Works only if list of tags are present in schema so we can fetch collection names
+                for collection in self.json_response.get("tags", []):
+                    if not collection.get("name"):
+                        continue
+                    yield RESTCollection(**collection)
+            else:
+                # in other case collect tags from paths because we have to yield collection/tags first
+                collections_set = set()
+                for path, methods in self.json_response.get("paths", {}).items():
+                    for method_type, info in methods.items():
+                        collections_set.update({tag for tag in info.get("tags", [])})
+                for collection_name in collections_set:
+                    data = {"name": collection_name}
+                    yield RESTCollection(**data)
+        except Exception as err:
+            logger.error(f"Error while fetching collections from schema URL :{err}")
+
+    def yield_api_collection(
+        self, collection: RESTCollection
+    ) -> Iterable[Either[CreateAPICollectionRequest]]:
+        """Method to return api collection Entities"""
+        try:
+            collection.url = self._generate_collection_url(collection.name.root)
+            collection_request = CreateAPICollectionRequest(
+                name=collection.name,
+                displayName=collection.display_name,
+                description=collection.description,
+                service=FullyQualifiedEntityName(self.context.get().api_service),
+                endpointURL=collection.url,
+            )
+            yield Either(right=collection_request)
+            self.register_record(collection_request=collection_request)
+        except Exception as exc:
+            yield Either(
+                left=StackTraceError(
+                    name=collection.name.root,
+                    error=f"Error creating api collection request: {exc}",
+                    stackTrace=traceback.format_exc(),
+                )
+            )
+
+    def yield_api_endpoint(
+        self, collection: RESTCollection
+    ) -> Iterable[Either[CreateAPIEndpointRequest]]:
+        """Method to return api endpoint Entities"""
+        filtered_endpoints = self._filter_collection_endpoints(collection) or {}
+        for path, methods in filtered_endpoints.items():
+            for method_type, info in methods.items():
+                try:
+                    endpoint = self._prepare_endpoint_data(path, method_type, info)
+                    if not endpoint:
+                        continue
+                    yield Either(
+                        right=CreateAPIEndpointRequest(
+                            name=endpoint.name,
+                            displayName=endpoint.display_name,
+                            description=endpoint.description,
+                            endpointURL=endpoint.url,
+                            requestMethod=self._get_api_request_method(method_type),
+                            requestSchema=self._get_request_schema(info),
+                            responseSchema=self._get_response_schema(info),
+                            apiCollection=FullyQualifiedEntityName(
+                                fqn.build(
+                                    self.metadata,
+                                    entity_type=APICollection,
+                                    service_name=self.context.get().api_service,
+                                    api_collection_name=collection.name.root,
+                                )
+                            ),
+                        )
+                    )
+                except Exception as exc:  # pylint: disable=broad-except
+                    yield Either(
+                        left=StackTraceError(
+                            name=endpoint.name,
+                            error=f"Error creating API Endpoint request [{info.get('operationId')}]: {exc}",
+                            stackTrace=traceback.format_exc(),
+                        )
+                    )
+
+    def _filter_collection_endpoints(
+        self, collection: RESTCollection
+    ) -> Optional[dict]:
+        """filter endpoints related to specific collection"""
+        try:
+            filtered_paths = {}
+            for path, methods in self.json_response.get("paths", {}).items():
+                for method_type, info in methods.items():
+                    if collection.name.root in info.get("tags", []):
+                        # path & methods are part of collection
+                        filtered_paths.update({path: methods})
+                    break
+            return filtered_paths
+        except Exception as err:
+            logger.info(
+                f"Error while filtering endpoints for collection {collection.name.root}"
+            )
+            return None
+
+    def _prepare_endpoint_data(self, path, method_type, info) -> Optional[RESTEndpoint]:
+        try:
+            endpoint = RESTEndpoint(**info)
+            endpoint.url = self._generate_endpoint_url(endpoint.name)
+            if not endpoint.name:
+                endpoint.name = f"{path} - {method_type}"
+            return endpoint
+        except Exception as err:
+            logger.info(f"Error while parsing endpoint data: {err}")
+        return None
+
+    def _generate_collection_url(self, collection_name: str) -> Optional[AnyUrl]:
+        """generate collection url"""
+        try:
+            if collection_name:
+                return AnyUrl(
+                    f"{self.config.serviceConnection.root.config.openAPISchemaURL}#tag/{collection_name}"
+                )
+        except Exception as err:
+            logger.info(f"Error while generating collection url: {err}")
+        return None
+
+    def _generate_endpoint_url(self, endpoint_name: str) -> AnyUrl:
+        """generate endpoint url"""
+        base_url = self.config.serviceConnection.root.config.openAPISchemaURL
+        if endpoint_name:
+            return AnyUrl(f"{base_url}#operation/{endpoint_name}")
+        else:
+            return AnyUrl(base_url)
+
+    def _get_api_request_method(self, method_type: str) -> Optional[str]:
+        """fetch endpoint request method"""
+        try:
+            return ApiRequestMethod[method_type.upper()]
+        except KeyError as err:
+            logger.info(f"Keyerror while fetching request method: {err}")
+        return None
+
+    def _get_request_schema(self, info: dict) -> Optional[APISchema]:
+        """fetch request schema"""
+        try:
+            schema_ref = (
+                info.get("requestBody", {})
+                .get("content", {})
+                .get("application/json", {})
+                .get("schema", {})
+                .get("$ref")
+            )
+            if not schema_ref:
+                logger.debug("No request schema found for the endpoint")
+                return None
+            return self._process_schema(schema_ref)
+        except Exception as err:
+            logger.info(f"Error while parsing request schema: {err}")
+        return None
+
+    def _get_response_schema(self, info: dict) -> Optional[APISchema]:
+        """fetch response schema"""
+        try:
+            schema_ref = (
+                info.get("responses", {})
+                .get("200", {})
+                .get("content", {})
+                .get("application/json", {})
+                .get("schema", {})
+                .get("$ref", {})
+            )
+            if not schema_ref:
+                logger.debug("No response schema found for the endpoint")
+                return None
+            return self._process_schema(schema_ref)
+        except Exception as err:
+            logger.info(f"Error while parsing response schema: {err}")
+        return None
+
+    def _process_schema(self, schema_ref: str) -> Optional[List[APISchema]]:
+        """process schema"""
+        try:
+            schema_ref = schema_ref.split("/")[-1]
+            schema_fields = (
+                self.json_response.get("components").get("schemas").get(schema_ref)
+            )
+
+            fetched_fields = []
+            for key, val in schema_fields.get("properties", {}).items():
+                dtype = val.get("type")
+                if not dtype:
+                    continue
+                fetched_fields.append(
+                    FieldModel(
+                        name=key,
+                        dataType=DataTypeTopic[dtype.upper()]
+                        if dtype.upper() in DataTypeTopic.__members__
+                        else DataTypeTopic.UNKNOWN,
+                    )
+                )
+            return APISchema(schemaFields=fetched_fields)
+        except Exception as err:
+            logger.info(f"Error while processing request schema: {err}")
+        return None

metadata/ingestion/source/api/rest/models.py

@@ -0,0 +1,41 @@
+#  Copyright 2024 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""
+OpenAPI REST API Models
+"""
+from typing import Optional
+
+from pydantic import AnyUrl, BaseModel, Field
+
+from metadata.generated.schema.entity.data.apiEndpoint import ApiRequestMethod
+from metadata.generated.schema.type import basic
+from metadata.generated.schema.type.apiSchema import APISchema
+
+
+class RESTCollection(BaseModel):
+    """REST colleciton model"""
+
+    name: basic.EntityName
+    display_name: Optional[str] = None
+    description: Optional[basic.Markdown] = None
+    url: Optional[AnyUrl] = None
+
+
+class RESTEndpoint(BaseModel):
+    """REST endpoint model"""
+
+    name: Optional[str] = Field(None, alias="operationId")
+    display_name: Optional[str] = None
+    description: Optional[basic.Markdown] = None
+    url: Optional[AnyUrl] = None
+    request_method: Optional[ApiRequestMethod] = None
+    request_schema: Optional[APISchema] = None
+    response_schema: Optional[APISchema] = None

metadata/ingestion/source/api/rest/service_spec.py

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.api.rest.metadata import RestSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=RestSource)

metadata/ingestion/source/dashboard/dashboard_service.py

@@ -479,6 +479,7 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
         to_entity: Union[Dashboard, DashboardDataModel],
         from_entity: Union[Table, DashboardDataModel, Dashboard],
         column_lineage: List[ColumnLineage] = None,
+        sql: Optional[str] = None,
     ) -> Optional[Either[AddLineageRequest]]:
         if from_entity and to_entity:
             return Either(
@@ -494,6 +495,7 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
                         ),
                         lineageDetails=LineageDetails(
                             source=LineageSource.DashboardLineage,
+                            sqlQuery=sql,
                             columnsLineage=column_lineage,
                         ),
                     )

metadata/ingestion/source/dashboard/domodashboard/service_spec.py

@@ -0,0 +1,6 @@
+from metadata.ingestion.source.dashboard.domodashboard.metadata import (
+    DomodashboardSource,
+)
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=DomodashboardSource)

metadata/ingestion/source/dashboard/lightdash/service_spec.py

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.lightdash.metadata import LightdashSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=LightdashSource)

metadata/ingestion/source/dashboard/looker/metadata.py

@@ -28,6 +28,7 @@ from typing import Dict, Iterable, List, Optional, Sequence, Set, Type, Union, c
 
 import giturlparse
 import lkml
+from liquid import Template
 from looker_sdk.sdk.api40.methods import Looker40SDK
 from looker_sdk.sdk.api40.models import Dashboard as LookerDashboard
 from looker_sdk.sdk.api40.models import (
@@ -450,11 +451,11 @@ class LookerSource(DashboardServiceSource):
                                 view.name, "Data model (View) filtered out."
                             )
                             continue
-
+                        view_name = view.from_ if view.from_ else view.name
                         yield from self._process_view(
-                            view_name=ViewName(view.name), explore=model
+                            view_name=ViewName(view_name), explore=model
                         )
-                    if len(model.joins) == 0 and model.sql_table_name:
+                    if model.view_name:
                         yield from self._process_view(
                             view_name=ViewName(model.view_name), explore=model
                         )
@@ -570,7 +571,8 @@ class LookerSource(DashboardServiceSource):
             db_service_names = self.get_db_service_names()
 
             if view.sql_table_name:
-                source_table_name = self._clean_table_name(view.sql_table_name)
+                sql_table_name = self._render_table_name(view.sql_table_name)
+                source_table_name = self._clean_table_name(sql_table_name)
 
                 # View to the source is only there if we are informing the dbServiceNames
                 for db_service_name in db_service_names or []:
@@ -726,6 +728,33 @@ class LookerSource(DashboardServiceSource):
 
         return table_name.lower().split(" as ")[0].strip()
 
+    @staticmethod
+    def _render_table_name(table_name: str) -> str:
+        """
+        sql_table_names might contain Liquid templates
+        when defining an explore. e.g,:
+        sql_table_name:
+            {% if openmetadata %}
+                event
+            {% elsif event.created_week._in_query %}
+                event_by_week
+            {% else %}
+                event
+            {% endif %} ;;
+        we should render the template and give the option
+        to render a specific value during metadata ingestion
+        using the "openmetadata" context argument
+        :param table_name: table name with possible templating
+        :return: rendered table name
+        """
+        try:
+            context = {"openmetadata": True}
+            template = Template(table_name)
+            sql_table_name = template.render(context)
+        except Exception:
+            sql_table_name = table_name
+        return sql_table_name
+
     @staticmethod
     def get_dashboard_sources(dashboard_details: LookerDashboard) -> Set[str]:
         """

metadata/ingestion/source/dashboard/looker/service_spec.py

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.looker.metadata import LookerSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=LookerSource)

metadata/ingestion/source/dashboard/metabase/service_spec.py

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.metabase.metadata import MetabaseSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=MetabaseSource)

metadata/ingestion/source/dashboard/{mstr → microstrategy}/client.py

@@ -9,19 +9,19 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 """
-REST Auth & Client for Mstr
+REST Auth & Client for MicroStrategy
 """
 import traceback
 from typing import List, Optional
 
 import requests
 
-from metadata.generated.schema.entity.services.connections.dashboard.mstrConnection import (
-    MstrConnection,
+from metadata.generated.schema.entity.services.connections.dashboard.microStrategyConnection import (
+    MicroStrategyConnection,
 )
 from metadata.ingestion.connections.test_connections import SourceConnectionException
 from metadata.ingestion.ometa.client import REST, ClientConfig
-from metadata.ingestion.source.dashboard.mstr.models import (
+from metadata.ingestion.source.dashboard.microstrategy.models import (
     AuthHeaderCookie,
     MstrDashboard,
     MstrDashboardDetails,
@@ -37,80 +37,91 @@ from metadata.utils.logger import ingestion_logger
 logger = ingestion_logger()
 
 API_VERSION = "MicroStrategyLibrary/api"
-LOGIN_MODE_GUEST = 1
+HEADERS = {"Content-Type": "application/json"}
 APPLICATION_TYPE = 35
 
 
-class MSTRClient:
+class MicroStrategyClient:
     """
-    Client Handling API communication with Metabase
+    Client Handling API communication with MicroStrategy
     """
 
     def _get_base_url(self, path=None):
         if not path:
-            return f"{clean_uri(self.config.hostPort)}/{API_VERSION}"
-        return f"{clean_uri(self.config.hostPort)}/{API_VERSION}/{path}"
+            return f"{clean_uri(str(self.config.hostPort))}/{API_VERSION}"
+        return f"{clean_uri(str(self.config.hostPort))}/{API_VERSION}/{path}"
 
     def __init__(
         self,
-        config: MstrConnection,
+        config: MicroStrategyConnection,
     ):
         self.config = config
 
-        self.auth_params: AuthHeaderCookie = self._get_auth_header_and_cookies()
+        self.auth_params = self._get_auth_header_and_cookies()
 
         client_config = ClientConfig(
-            base_url=clean_uri(config.hostPort),
+            base_url=clean_uri(str(self.config.hostPort)),
             api_version=API_VERSION,
-            extra_headers=self.auth_params.auth_header,
+            extra_headers=self.auth_params.auth_header if self.auth_params else None,
             allow_redirects=True,
-            cookies=self.auth_params.auth_cookies,
+            cookies=self.auth_params.auth_cookies if self.auth_params else None,
         )
 
         self.client = REST(client_config)
-        self._set_api_session()
 
-    def _get_auth_header_and_cookies(self) -> Optional[AuthHeaderCookie]:
+    def get_auth_params(self) -> AuthHeaderCookie:
         """
-        Send a request to authenticate the user and get headers and
-
-        To know about the data params below please visit
-        https://demo.microstrategy.com/MicroStrategyLibrary/api-docs/index.html#/Authentication/postLogin
+        Test whether we can fetch auth_token from the api
         """
         data = {
             "username": self.config.username,
             "password": self.config.password.get_secret_value(),
-            "loginMode": LOGIN_MODE_GUEST,
+            "loginMode": int(self.config.loginMode),
             "applicationType": APPLICATION_TYPE,
         }
         response = requests.post(
-            url=self._get_base_url("auth/login"), data=data, timeout=60
+            url=self._get_base_url("auth/login"), json=data, headers=HEADERS, timeout=60
         )
-        if not response.status_code == 204:
-            logger.error(
-                f"Auth Failed with login mode: {LOGIN_MODE_GUEST}, Error: {response.text}"
+        response.raise_for_status()
+        if (
+            not response.ok
+            or response.status_code != 204
+            or "X-MSTR-AuthToken" not in response.headers
+        ):
+            raise SourceConnectionException(
+                f"Failed to Fetch Token, please validate your credentials and login_mode : {response.text}"
             )
-            logger.error("Trying with login mode: 8")
-            data["loginMode"] = 8
-            response = requests.post(
-                url=self._get_base_url("auth/login"), data=data, timeout=60
-            )
-            if not response.status_code == 204:
-                raise SourceConnectionException(
-                    f"Auth Failed with login mode: 8 and {LOGIN_MODE_GUEST}, Error: {response.text}"
-                )
         return AuthHeaderCookie(
             auth_header=response.headers, auth_cookies=response.cookies
         )
 
-    def _set_api_session(self) -> bool:
+    def _get_auth_header_and_cookies(self) -> Optional[AuthHeaderCookie]:
+        """
+        Send a request to authenticate the user and get headers and
+
+        To know about the data params below please visit
+        https://demo.microstrategy.com/MicroStrategyLibrary/api-docs/index.html#/Authentication/postLogin
+        """
+        try:
+            auth_data = self.get_auth_params()
+            if auth_data:
+                self._set_api_session(auth_data)
+                return auth_data
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.error(
+                f"Failed to fetch the auth header and cookies due to : [{exc}]"
+            )
+        return None
+
+    def _set_api_session(self, auth_data: AuthHeaderCookie) -> bool:
         """
         Set the user api session to active this will keep the connection alive
         """
         api_session = requests.put(
             url=self._get_base_url("sessions"),
-            headers=self.auth_params.auth_header,
-            cookies=self.auth_params.auth_cookies,
+            headers=auth_data.auth_header,
+            cookies=auth_data.auth_cookies,
             timeout=60,
         )
         if api_session.ok: