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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: logos-sdk
-Version: 0.0.25.dev9
+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.dev9 → 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.dev9 → 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.dev9 → 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.dev9 → 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.dev9 → 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
     ):

{logos_sdk-0.0.25.dev9 → 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.dev9 → 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)
@@ -74,6 +76,7 @@ class SklikService:
         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
@@ -99,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
@@ -113,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
@@ -166,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
@@ -213,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
@@ -256,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
@@ -310,12 +332,52 @@ class SklikService:
             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
@@ -329,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}
@@ -351,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
@@ -371,4 +433,4 @@ class SklikService:
             service_response = response.json()
             return service_response["data"]
         else:
-            raise SklikServiceException(response.content)
+            raise SklikServiceException(response.content)

{logos_sdk-0.0.25.dev9 → 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.dev9
+Version: 0.0.25.dev10
 Summary: SDK for Logos platform
 Home-page: https://bitbucket.org/databy/logos-sdk-pip/src/master/
 Author: Databy.io