logos-sdk 0.0.25.dev8__tar.gz → 0.0.25.dev10__tar.gz

{logos_sdk-0.0.25.dev8 → logos_sdk-0.0.25.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: logos-sdk
-Version: 0.0.25.dev8
+Version: 0.0.25.dev10
 Summary: SDK for Logos platform
 Home-page: https://bitbucket.org/databy/logos-sdk-pip/src/master/
 Author: Databy.io

{logos_sdk-0.0.25.dev8 → logos_sdk-0.0.25.dev10}/logos_sdk/big_query/BigQuery.py

@@ -36,6 +36,19 @@ class BigQuery:
         except DefaultCredentialsError:
             self.logger = None
 
+    def parse_fields(self, fields):
+        result = []
+        for row in fields:
+            result.append(
+                bigquery.schema.SchemaField(
+                    row["name"],
+                    row["col_type"],
+                    mode=row["mode"],
+                    fields=self.parse_fields(row["fields"]) if "fields" in row else [],
+                )
+            )
+        return result
+
     def get_dataset(self, dataset_id: str):
         return self._service.get_dataset(dataset_id)
 
@@ -57,17 +70,17 @@ class BigQuery:
         return self._service.get_table(sql_format)
 
     def insert_into_table(
-            self, dataset_id: str, table_id: str, records: List[Dict]
+        self, dataset_id: str, table_id: str, records: List[Dict]
     ) -> None:
         bq_table = self.get_table(dataset_id, table_id)
         self._insert_into_table(bq_table, records)
 
     def insert_create_table(
-            self,
-            dataset_id: str,
-            table_id: str,
-            records: List[Dict],
-            schema_columns: List[Dict],
+        self,
+        dataset_id: str,
+        table_id: str,
+        records: List[Dict],
+        schema_columns: List[Dict],
     ) -> None:
         bq_table = self.check_table_exists(dataset_id, table_id)
         if bq_table is None:
@@ -87,10 +100,15 @@ class BigQuery:
             return None
 
     def create_table(
-            self, dataset_id: str, table_id: str, schema_columns: List[Dict]
+        self, dataset_id: str, table_id: str, schema_columns: List[Dict]
     ) -> Union[bool, Table]:
         table_schema = [
-            bigquery.schema.SchemaField(row["name"], row["col_type"], mode=row["mode"])
+            bigquery.schema.SchemaField(
+                row["name"],
+                row["col_type"],
+                mode=row["mode"],
+                fields=self.parse_fields(row["fields"]) if "fields" in row else [],
+            )
             for row in schema_columns
         ]
         try:
@@ -132,13 +150,13 @@ class BigQuery:
 
     @retry_on_not_found
     def _insert_into_table(
-            self, bq_table: Table, records: List[Dict], attempts: int
+        self, bq_table: Table, records: List[Dict], attempts: int
     ) -> None:
         if len(records) > self.BQ_ROWS_LIMIT:
             for index in range(0, len(records), self.BQ_ROWS_LIMIT):
                 errors = self._service.insert_rows(
                     bq_table,
-                    records[index: (index + self.BQ_ROWS_LIMIT)],
+                    records[index : (index + self.BQ_ROWS_LIMIT)],
                     retry=Retry(
                         total=2, connect=4, backoff_factor=2, allowed_methods=None
                     ),

{logos_sdk-0.0.25.dev8 → logos_sdk-0.0.25.dev10}/logos_sdk/services/CampaignManager.py

@@ -30,6 +30,8 @@ class CampaignManagerService:
         self._GET_FILE = self._URL + "/get-file"
         self._GET_FILE_MEDIA_REQUEST = self._URL + "/get-file-media-request"
         self._QUERY_DIMENSION_VALUES = self._URL + "/query-dimension-values"
+        self._GET_ACCESSIBLE_PARENT_ACCOUNTS = self._URL + "/get-parent-accounts"
+        self._GET_ACCESSIBLE_ADVERTISERS = self._URL + "/get-advertisers"
 
     def create_report(
         self,
@@ -397,3 +399,48 @@ class CampaignManagerService:
                     report_id=report["id"],
                     secret_id=secret_id,
                 )
+
+    def get_accessible_parent_accounts(self, secret_id):
+        """
+        Returns accessible parent accounts
+        :param secret_id: The ID of the secret in secret manager
+        :return: list of parent accounts
+        """
+
+        header = get_headers(self._GET_ACCESSIBLE_PARENT_ACCOUNTS)
+        body = {"secret_id": secret_id}
+
+        response = request(
+            "post", url=self._GET_ACCESSIBLE_PARENT_ACCOUNTS, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise CampaignManagerServiceException(response.content)
+
+    def get_accessible_advertisers(self, secret_id):
+        """
+        Returns accessible advertisers
+        :param secret_id: The ID of the secret in secret manager
+        :return: list of advertisers
+        """
+
+        header = get_headers(self._GET_ACCESSIBLE_ADVERTISERS)
+        body = {
+            "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True,
+            },
+        }
+
+        response = request(
+            "post", url=self._GET_ACCESSIBLE_ADVERTISERS, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise CampaignManagerServiceException(response.content)

{logos_sdk-0.0.25.dev8 → logos_sdk-0.0.25.dev10}/logos_sdk/services/DV360.py

@@ -34,6 +34,8 @@ class DV360Service:
         self._GET_QUERY_METADATA = self._URL + "/get-query-metadata"
         self._RUN_QUERY = self._URL + "/run-query"
         self._DELETE_QUERY = self._URL + "/delete-query"
+        self._GET_ACCESSIBLE_PARTNERS = self._URL + "/get-accessible-partners"
+        self._GET_ACCESSIBLE_ADVERTISERS = self._URL + "/get-accessible-advertisers"
 
     def list_line_items(self, advertiser_id, secret_id, filter_string=None):
         """
@@ -301,6 +303,56 @@ class DV360Service:
         else:
             raise DV360ServiceException(response.content)
 
+    def get_accessible_partners(self, secret_id):
+        """
+        Returns accessible partners
+        :param secret_id: The ID of the secret in secret manager
+        :return: list of partners
+        """
+
+        header = get_headers(self._GET_ACCESSIBLE_PARTNERS)
+        body = {
+            "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True,
+            },
+        }
+
+        response = request(
+            "post", url=self._GET_ACCESSIBLE_PARTNERS, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise DV360ServiceException(response.content)
+
+    def get_accessible_advertisers(self, secret_id):
+        """
+        Returns accessible advertisers
+        :param secret_id: The ID of the secret in secret manager
+        :return: list of advertisers
+        """
+
+        header = get_headers(self._GET_ACCESSIBLE_ADVERTISERS)
+        body = {
+            "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True,
+            },
+        }
+
+        response = request(
+            "post", url=self._GET_ACCESSIBLE_ADVERTISERS, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise DV360ServiceException(response.content)
+
     def _check_report_ready_with_exponential_backoff(
         self, secret_id: str, query_id: str, report_id: str, backoff_attempts: int = 10
     ) -> bool:
@@ -393,5 +445,5 @@ class DV360Service:
 
         if response.status_code == HTTPStatus.OK:
             return True
-        print("Query was not deleted!")
+
         return False

{logos_sdk-0.0.25.dev8 → logos_sdk-0.0.25.dev10}/logos_sdk/services/Facebook.py

@@ -38,7 +38,12 @@ class FacebookService:
         :return: all accessible accounts List(Dict)
         """
 
-        body = {"secret_id": secret_id}
+        body = {
+            "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True,
+            }
+        }
 
         header = get_headers(self._ACCESSIBLE_ACCOUNTS)
 

{logos_sdk-0.0.25.dev8 → logos_sdk-0.0.25.dev10}/logos_sdk/services/GoogleAds.py

@@ -21,6 +21,7 @@ class GoogleAdsService:
         self._SEARCH = self._URL + "/search"
         self._EXCLUDE_FOR_ACCOUNT = self._URL + "/exclude-for-account"
         self._EXCLUDE_FOR_AD_GROUP = self._URL + "/exclude-for-ad-group"
+        self._GET_ACCESSIBLE_ACCOUNTS = self._URL + "/list-accessible-accounts"
 
     @staticmethod
     def fetch_with_retry_on_timeout(url, json, headers):
@@ -28,8 +29,10 @@ class GoogleAdsService:
             try:
                 return request("post", url, json=json, headers=headers, timeout=25)
             except Timeout:
-                delay = 2 * (2 ** attempt) + random.randint(0, 9)
-                print(f"there was a timeout when contacting the service, going to sleep for {delay} seconds")
+                delay = 2 * (2**attempt) + random.randint(0, 9)
+                print(
+                    f"there was a timeout when contacting the service, going to sleep for {delay} seconds"
+                )
                 time.sleep(delay)
 
         raise Exception("The service is not able to reply within 30 seconds.")
@@ -53,7 +56,9 @@ class GoogleAdsService:
         }
 
         header = get_headers(self._SEARCH_STREAM)
-        response = self.fetch_with_retry_on_timeout(url=self._SEARCH_STREAM, json=body, headers=header)
+        response = self.fetch_with_retry_on_timeout(
+            url=self._SEARCH_STREAM, json=body, headers=header
+        )
 
         if response.status_code == HTTPStatus.OK:
             service_response = response.json()
@@ -84,7 +89,9 @@ class GoogleAdsService:
         }
 
         header = get_headers(self._SEARCH)
-        response = self.fetch_with_retry_on_timeout(url=self._SEARCH, json=body, headers=header)
+        response = self.fetch_with_retry_on_timeout(
+            url=self._SEARCH, json=body, headers=header
+        )
 
         if response.status_code != HTTPStatus.OK:
             raise GoogleAdsServiceException(response.content)
@@ -163,3 +170,42 @@ class GoogleAdsService:
             return
         else:
             raise GoogleAdsServiceException(response.content)
+
+    def get_accessible_accounts(
+        self,
+        secret_id: str,
+        page_size: int = 1000,
+    ) -> List[Dict]:
+        body = {
+            "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True,
+            },
+            "page_token": None,
+            "page_size": page_size,
+        }
+
+        header = get_headers(self._GET_ACCESSIBLE_ACCOUNTS)
+        response = self.fetch_with_retry_on_timeout(
+            url=self._GET_ACCESSIBLE_ACCOUNTS, json=body, headers=header
+        )
+
+        if response.status_code != HTTPStatus.OK:
+            raise GoogleAdsServiceException(response.content)
+
+        service_response = response.json()
+        all_results = service_response["data"]["results"]
+
+        while service_response["data"]["next_page_token"]:
+            body["page_token"] = service_response["data"]["next_page_token"]
+            response = request(
+                "post", url=self._GET_ACCESSIBLE_ACCOUNTS, json=body, headers=header
+            )
+
+            if response.status_code != HTTPStatus.OK:
+                raise GoogleAdsServiceException(response.content)
+
+            service_response = response.json()
+            all_results.extend(service_response["data"]["results"])
+
+        return all_results

{logos_sdk-0.0.25.dev8 → logos_sdk-0.0.25.dev10}/logos_sdk/services/MerchantCenter.py

@@ -14,6 +14,7 @@ class MerchantCenterService:
         load_dotenv()
         self._URL = url or os.environ.get("MERCHANT_CENTER_SERVICE_PATH")
         self._LIST_ACCOUNTS = self._URL + "/account-service/accounts"
+        self._LIST_ACCESSIBLE_ACCOUNTS = self._URL + "/account-service/list-accessible-accounts"
         self._LIST_ACCOUNT_STATUSES = self._URL + "/account-service/account-statuses"
         self._LIST_PRODUCTS = self._URL + "/product-service/products"
         self._LIST_PRODUCT_STATUSES = self._URL + "/product-service/product-statuses"
@@ -36,6 +37,22 @@ class MerchantCenterService:
         else:
             raise MerchantServiceException(response.content)
 
+    def list_accessible_accounts(self, secret_id: str):
+        """
+        Lists accessible accounts in Merchant Center
+        :param secret_id: The ID of the secret in secret manager
+        :return: List[Dict]
+        """
+        body = {"secret_id": secret_id}
+        header = get_headers(self._LIST_ACCESSIBLE_ACCOUNTS)
+        response = request("post", url=self._LIST_ACCESSIBLE_ACCOUNTS, json=body, headers=header)
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise MerchantServiceException(response.content)
+
     def list_account_statuses(
             self, merchant_account_id: str, account_id: str, secret_id: str
     ):
@@ -92,26 +109,39 @@ class MerchantCenterService:
             service_response = response.json()
             yield service_response["data"]["results"]
 
-    def list_products_statuses(self, merchant_account_id: str, secret_id: str):
+    def list_products_statuses(self, merchant_account_id: str, secret_id: str, page_size: int = 250):
         """
         Lists the statuses of the products in your Merchant Center account
         :param merchant_account_id: The ID of the
         account that contains the products. This account cannot be a multi-client account
         :param secret_id: The ID of the secret in secret manager
+        :param page_size: size of the page
         :return: List[Dict]
         """
-        body = {"merchant_account_id": merchant_account_id, "secret_id": secret_id}
+        body = {"merchant_account_id": merchant_account_id, "secret_id": secret_id, "page_size": page_size}
         header = get_headers(self._LIST_PRODUCT_STATUSES)
         response = request(
             "post", url=self._LIST_PRODUCT_STATUSES, json=body, headers=header
         )
 
-        if response.status_code == HTTPStatus.OK:
-            service_response = response.json()
-            return service_response["data"]
-        else:
+        if response.status_code != HTTPStatus.OK:
             raise MerchantServiceException(response.content)
 
+        service_response = response.json()
+        yield service_response["data"]["results"]
+
+        while service_response["data"]["nextPageToken"] is not None:
+            body["page_token"] = service_response["data"]["nextPageToken"]
+            response = request(
+                "post", url=self._LIST_PRODUCT_STATUSES, json=body, headers=header
+            )
+
+            if response.status_code != HTTPStatus.OK:
+                raise MerchantServiceException(response.content)
+
+            service_response = response.json()
+            yield service_response["data"]["results"]
+
     def reports_search(
             self,
             merchant_account_id: str,

{logos_sdk-0.0.25.dev8 → logos_sdk-0.0.25.dev10}/logos_sdk/services/MicrosoftAdvertising.py

@@ -212,6 +212,9 @@ class MicrosoftAdvertising:
         """
         body = {
             "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True
+            }
         }
         header = get_headers(self._GET_ACCESSIBLE_ACCOUNTS)
         response = request(

{logos_sdk-0.0.25.dev8 → logos_sdk-0.0.25.dev10}/logos_sdk/services/Sklik.py

@@ -46,13 +46,15 @@ def get_session_if_malformed(wrapped_function):
 
     return inner
 
+
 def get_report_results_if_expired(wrapped_function):
     @wraps(wrapped_function)
     def inner(*args, **kwargs):
         try:
             return wrapped_function(*args, **kwargs)
         except SklikServiceException as err:
-            if json.loads(err.args[0].decode("utf8")).get("detail") == "Requested report has expired. Please create a new report by calling createReport endpoint.":
+            if json.loads(err.args[0].decode("utf8")).get(
+                    "detail") == "Requested report has expired. Please create a new report by calling createReport endpoint.":
                 print("Report expired, creating new report")
                 args[0].get_session(args[0]._secret_id, args[0]._account_email)
                 return wrapped_function(*args, **kwargs)
@@ -69,10 +71,12 @@ class SklikService:
         self._CREATE_REPORT = self._URL + "/create-report"
         self._READ_REPORT = self._URL + "/read-report"
         self._API = self._URL + "/call-api"
+        self._GET_CLIENT = self._URL + "/get-client"
         self._CHECK_DATA_READY = self._URL + "/check-data-ready"
         self._LOGOUT = self._URL + "/logout"
         self._API_LIMITS = self._URL + "/api-limits"
         self._GET_SESSION = self._URL + "/get-session"
+        self._GET_SESSION_WITHOUT_ACCOUNT = self._URL + "/get-session-without-account"
         self.session = None  # dict {"sklik_session": "", "user_id": ""}
         self._secret_id = None
         self._account_email = None
@@ -98,6 +102,25 @@ class SklikService:
         else:
             raise SklikServiceException(response.content)
 
+    def get_session_without_account(self, secret_id: str) -> None:
+        """
+        Manages initial login of the sessions, returns dict with sklik session string without user id int
+        :param secret_id: The ID of the secret in secret manager
+        :return: Dict
+        """
+        body = {"secret_id": secret_id}
+        response = execute_request("post", url=self._GET_SESSION_WITHOUT_ACCOUNT, json=body)
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            self.session = {
+                "sklik_session": service_response["data"]["sklik_session"],
+                "user_id": None,
+            }
+            self._secret_id = secret_id
+        else:
+            raise SklikServiceException(response.content)
+
     def logout_of_current_session(self) -> None:
         """
         Attempts to log out of the current session, nothing happens if not ok
@@ -112,15 +135,15 @@ class SklikService:
     @get_session_if_malformed
     @get_report_results_if_expired
     def get_report_results(
-        self,
-        secret_id: str,
-        account_email: str,
-        report_type: str,
-        date_from: str,
-        date_to: str,
-        columns: List[str],
-        create_params: Dict[str, Union[int, str]] = None,
-        read_params: Dict[str, Union[int, str]] = None,
+            self,
+            secret_id: str,
+            account_email: str,
+            report_type: str,
+            date_from: str,
+            date_to: str,
+            columns: List[str],
+            create_params: Dict[str, Union[int, str]] = None,
+            read_params: Dict[str, Union[int, str]] = None,
     ) -> List[Dict]:
         """
         It creates sklik report with /create-report call in sklik service and reads sklik report with pagination
@@ -165,14 +188,14 @@ class SklikService:
 
     @get_session_if_malformed
     def get_streamed_report_results(
-        self,
-        secret_id: str,
-        account_email: str,
-        report_type: str,
-        date_from: str,
-        date_to: str,
-        columns: List[str],
-        create_params: Dict[str, Union[int, str]] = None,
+            self,
+            secret_id: str,
+            account_email: str,
+            report_type: str,
+            date_from: str,
+            date_to: str,
+            columns: List[str],
+            create_params: Dict[str, Union[int, str]] = None,
     ) -> List[Dict]:
         """
         It creates sklik report with /create-report call in sklik service and reads sklik report with pagination
@@ -212,13 +235,13 @@ class SklikService:
                 raise SklikServiceException(response.content)
 
     def _create_report(
-        self,
-        secret_id: str,
-        account_email: str,
-        report_type: str,
-        date_from: str,
-        date_to: str,
-        params: Dict[str, Union[int, str]] = None,
+            self,
+            secret_id: str,
+            account_email: str,
+            report_type: str,
+            date_from: str,
+            date_to: str,
+            params: Dict[str, Union[int, str]] = None,
     ) -> Dict:
         """
          Function creates sklik report with /create-report call
@@ -255,7 +278,7 @@ class SklikService:
 
     @get_session_if_malformed
     def call_api(
-        self, secret_id: str, account_email: str, method: str, params: List[Dict]
+            self, secret_id: str, account_email: str, method: str, params: List[Dict]
     ) -> Union[List, Dict]:
         """
         Function to call SklikService get-api route
@@ -282,12 +305,79 @@ class SklikService:
         else:
             raise SklikServiceException(response.content)
 
+    @get_session_if_malformed
+    def get_client(
+            self,
+            secret_id: str,
+            account_email: str,
+    ) -> Union[List, Dict]:
+        """
+        Function to call SklikService get-client route
+        :param secret_id: The ID of the secret in secret manager
+        :param account_email: Account email to refers to Sklik accountId
+        :return:
+        """
+
+        if self.session is None:
+            self.get_session(secret_id, account_email)
+
+        response = execute_request(
+            "post",
+            url=self._GET_CLIENT,
+            json={"sklik_session": self.session["sklik_session"]},
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise SklikServiceException(response.content)
+
+    @get_session_if_malformed
+    def get_accessible_accounts(
+            self,
+            secret_id: str,
+    ) -> Union[List, Dict]:
+        """
+        Function to retrieve accessible accounts
+        :param secret_id: The ID of the secret in secret manager
+        :return:
+        """
+
+        if self.session is None:
+            self.get_session_without_account(secret_id)
+
+        response = execute_request(
+            "post",
+            url=self._GET_CLIENT,
+            json={
+                "sklik_session": self.session["sklik_session"],
+                "filters": {
+                    "hide_inactive": True
+                }
+            },
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            accounts = []
+            service_response = response.json()
+            data = service_response["data"]
+            for account in data["foreignAccounts"]:
+                accounts.append({
+                    "id": account['userId'],
+                    "name": account['username'],
+                    "active": account["relationStatus"] == "live"
+                })
+            return accounts
+        else:
+            raise SklikServiceException(response.content)
+
     @get_session_if_malformed
     def check_data_ready(
-        self,
-        secret_id: str,
-        account_email: str,
-        date: str = None,
+            self,
+            secret_id: str,
+            account_email: str,
+            date: str = None,
     ) -> int:
         """
         Checks if data on server are ready
@@ -301,8 +391,8 @@ class SklikService:
             self.get_session(secret_id, account_email)
 
         date = date or (
-            datetime.now(timezone("UTC")).astimezone(timezone("Europe/Prague"))
-            - timedelta(days=1)
+                datetime.now(timezone("UTC")).astimezone(timezone("Europe/Prague"))
+                - timedelta(days=1)
         ).strftime("%Y-%m-%d")
 
         body = {"date": date}
@@ -323,9 +413,9 @@ class SklikService:
 
     @get_session_if_malformed
     def fetch_api_limits(
-        self,
-        secret_id: str,
-        account_email: str,
+            self,
+            secret_id: str,
+            account_email: str,
     ) -> Union[List, Dict]:
         """
         Function to call SklikService api/limits route

{logos_sdk-0.0.25.dev8 → logos_sdk-0.0.25.dev10}/logos_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: logos-sdk
-Version: 0.0.25.dev8
+Version: 0.0.25.dev10
 Summary: SDK for Logos platform
 Home-page: https://bitbucket.org/databy/logos-sdk-pip/src/master/
 Author: Databy.io