adspower 1.0.0__tar.gz

adspower-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alexey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

adspower-1.0.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.1
+Name: adspower
+Version: 1.0.0
+Summary: The package for interacting with API of anti-detect browser AdsPower.
+Home-page: https://github.com/blnkoff/adspower
+License: MIT
+Author: Alexey
+Author-email: abelenkov2006@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: selenium (>=4.16.0,<5.0.0)
+Project-URL: Repository, https://github.com/blnkoff/adspower
+Description-Content-Type: text/markdown
+
+# adspower
+
+[![Croco Logo](https://i.ibb.co/G5Pjt6M/logo.png)](https://t.me/crocofactory)
+
+
+The package for interacting with API of anti-detect browser AdsPower.
+
+- **[Telegram channel](https://t.me/crocofactory)**
+- **[Bug reports](https://github.com/blnkoff/ether-wallet/issues)**
+
+adspower's source code is made available under the [MIT License](LICENSE)
+             
+# Restrictions
+1. During using the package, AdsPower must be opened. 
+2. The local API is available only in paid AdsPower subscriptions
+3. AdsPower has frequency control for all APIs, max. access frequency: 1 request/second 
+
+# Quick start
+
+For example, you can use driver by the following way.
+
+```python
+from adspower import AdsPower
+ads_power = AdsPower('ja54rwh')
+with ads_power as driver:
+  driver.get('https://github.com/blnkoff/adspower')
+```
+
+Here is example of usage of creating profiles from proxies
+
+```python
+from adspower import AdsPower, CreateProfileParams, UserProxyConfig
+
+def create_profiles(config: dict[str], proxies) -> list[AdsPower]:
+    group_name = config['ads_power']['group_name']
+
+    group_id = AdsPower.query_group(group_name=group_name)[0]['group_id']
+
+    data_set = []
+    for proxy in proxies:
+        proxy_config = UserProxyConfig(
+            proxy_soft='other',
+            proxy_type=proxy.type,
+            proxy_host=proxy.host,
+            proxy_port=proxy.port,
+            proxy_user=proxy.login,
+            proxy_password=proxy.password
+        )
+        data_set.append(CreateProfileParams(group_id=group_id, user_proxy_config=proxy_config))
+
+    profiles = []
+    for data in data_set:
+        profiles.append(AdsPower.create_profile(data))
+
+    return profiles
+```
+
+Here is example of retrieving profiles from AdsPower
+
+```python
+from adspower import AdsPower
+
+def retrieve_profiles(config: dict[str]):
+    group_name = config['ads_power']['group_name']
+
+    group_id = AdsPower.query_group(group_name=group_name)['group_id']
+
+    response = AdsPower.query_profiles(group_id=group_id)
+
+    profiles = [AdsPower(profile['user_id']) for profile in response]
+    return profiles
+```
+
+# Installing adspower
+To install the package from GitHub you can use that:
+```sh
+pip install git+https://github.com/blnkoff/adspower.git
+```
+
+To install the package from PyPi you can use that:
+```sh
+pip install adspower
+```
+

adspower-1.0.0/README.md

@@ -0,0 +1,83 @@
+# adspower
+
+[![Croco Logo](https://i.ibb.co/G5Pjt6M/logo.png)](https://t.me/crocofactory)
+
+
+The package for interacting with API of anti-detect browser AdsPower.
+
+- **[Telegram channel](https://t.me/crocofactory)**
+- **[Bug reports](https://github.com/blnkoff/ether-wallet/issues)**
+
+adspower's source code is made available under the [MIT License](LICENSE)
+             
+# Restrictions
+1. During using the package, AdsPower must be opened. 
+2. The local API is available only in paid AdsPower subscriptions
+3. AdsPower has frequency control for all APIs, max. access frequency: 1 request/second 
+
+# Quick start
+
+For example, you can use driver by the following way.
+
+```python
+from adspower import AdsPower
+ads_power = AdsPower('ja54rwh')
+with ads_power as driver:
+  driver.get('https://github.com/blnkoff/adspower')
+```
+
+Here is example of usage of creating profiles from proxies
+
+```python
+from adspower import AdsPower, CreateProfileParams, UserProxyConfig
+
+def create_profiles(config: dict[str], proxies) -> list[AdsPower]:
+    group_name = config['ads_power']['group_name']
+
+    group_id = AdsPower.query_group(group_name=group_name)[0]['group_id']
+
+    data_set = []
+    for proxy in proxies:
+        proxy_config = UserProxyConfig(
+            proxy_soft='other',
+            proxy_type=proxy.type,
+            proxy_host=proxy.host,
+            proxy_port=proxy.port,
+            proxy_user=proxy.login,
+            proxy_password=proxy.password
+        )
+        data_set.append(CreateProfileParams(group_id=group_id, user_proxy_config=proxy_config))
+
+    profiles = []
+    for data in data_set:
+        profiles.append(AdsPower.create_profile(data))
+
+    return profiles
+```
+
+Here is example of retrieving profiles from AdsPower
+
+```python
+from adspower import AdsPower
+
+def retrieve_profiles(config: dict[str]):
+    group_name = config['ads_power']['group_name']
+
+    group_id = AdsPower.query_group(group_name=group_name)['group_id']
+
+    response = AdsPower.query_profiles(group_id=group_id)
+
+    profiles = [AdsPower(profile['user_id']) for profile in response]
+    return profiles
+```
+
+# Installing adspower
+To install the package from GitHub you can use that:
+```sh
+pip install git+https://github.com/blnkoff/adspower.git
+```
+
+To install the package from PyPi you can use that:
+```sh
+pip install adspower
+```

adspower-1.0.0/adspower/__init__.py

@@ -0,0 +1,20 @@
+"""
+adspower
+~~~~~~~~~~~~~~
+The package for interacting with anti-detect browser APIs.
+Author's github - https://github.com/blnkoff
+
+Usage example:
+   >>> from adspower import AdsPower
+   >>> ads_power = AdsPower('ja54rwh')
+   >>> with ads_power as driver:
+   >>>      driver.get('https://github.com/blnkoff/adspower')
+:copyright: (c) 2023 by Alexey
+:license: Apache 2.0, see LICENSE for more details.
+"""
+
+__version__ = "1.0.0"
+
+from .adspower import AdsPower
+from .types import (UserProxyConfig, FingerprintConfig, CreateProfileParams, QueryProfilesParams, QueryGroupParams,
+                    GroupInfo, ProfileInfo)

adspower-1.0.0/adspower/adspower.py

@@ -0,0 +1,498 @@
+import time
+import requests
+from requests.exceptions import ConnectionError as RequestConnectionError, InvalidURL
+from urllib3.exceptions import MaxRetryError, NewConnectionError
+from .types import *
+from .exceptions import *
+from functools import wraps
+from selenium import webdriver
+from typing import Self, Optional, Any, Type, Iterable
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.chrome.webdriver import WebDriver
+from .utils import is_typed_dict
+
+_request_accessibility = 0
+
+__all__ = ['AdsPower']
+
+
+class AdsPower:
+    """Controls AdsPower overall and the instance of corresponding profile"""
+
+    def __init__(self, profile_id: Optional[str] = None, port: int = 50325):
+        """
+        :param profile_id: ID of existed profile in AdsPower
+        :param port: The port of AdsPower's API
+        """
+        self._driver = None
+        self.__profile_id = profile_id
+        self.__api_url = self._validate_api_url('http://local.adspower.net', port)
+
+    def __enter__(self):
+        driver = self.get_driver()
+        driver.maximize_window()
+        for _ in range(3):
+            time.sleep(1.5)
+            self.close_tabs()
+        return driver
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.quit()
+
+    @property
+    def driver(self) -> WebDriver | None:
+        """
+        :return: The driver instance or None if get_driver() was not called
+        """
+        return self._driver
+
+    @property
+    def api_url(self) -> str:
+        """
+        :return: The URL of API of an anti-detect browser
+        """
+        return self.__api_url
+
+    @property
+    def profile_id(self) -> str:
+        """
+        Returns ID of existed profile in anti-detect browser
+        :return: The ID of existed profile in anti-detect
+        """
+        return self.__profile_id
+
+    @profile_id.setter
+    def profile_id(self, value: str):
+        self.__profile_id = value
+
+    @staticmethod
+    def _wait_for_delay(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            current_time = time.time()
+            global _request_accessibility
+
+            if _request_accessibility < current_time:
+                result = func(*args, **kwargs)
+            else:
+                time.sleep(_request_accessibility - current_time)
+                result = func(*args, **kwargs)
+
+            _request_accessibility = time.time() + 0.7
+            return result
+
+        return wrapper
+
+    @staticmethod
+    def _validate_response(exception: Type[Exception], request: dict[str, Any], response: dict[str, Any]):
+        if response['code'] != 0:
+            if response['msg'] == 'Too many request per second, please check':
+                raise ExceededQPS
+            else:
+                raise exception(request, response)
+
+    @staticmethod
+    def _validate_api_url(api_url: str, port: int) -> str:
+        url = f'{api_url}:{port}'
+        try:
+            status_url = url + '/status'
+            requests.get(url=status_url)
+        except (MaxRetryError, RequestConnectionError, NewConnectionError, ConnectionRefusedError, InvalidURL):
+            raise UnavailableAPI(port)
+        else:
+            return url
+
+    @_wait_for_delay
+    def get_driver(self, profile_id: Optional[str] = None) -> WebDriver:
+        """
+        Returns a driver associated with profile_id
+
+        :raise ProfileNotFound: Raised when profile getting or deleting is failed
+        :raise NoProfileFound: Raised when profile ID is not specified
+        :return: A WebDriver instance associated with profile_id
+        """
+        profile_id = profile_id or self.profile_id
+        if not profile_id:
+            raise NoProfileIdFound
+
+        self.profile_id = profile_id
+        url = self.api_url + '/api/v1/browser/start'
+
+        params = {
+            'ip_tab': 0,
+            'user_id': profile_id
+        }
+
+        response = requests.get(url=url, params=params).json()
+        self._validate_response(ProfileNotFound, params, response)
+
+        debugger_address = response['data']['ws']['selenium']
+        chrome_driver = response['data']['webdriver']
+
+        options = Options()
+        options.add_experimental_option('debuggerAddress', debugger_address)
+        options.page_load_strategy = 'none'
+        options.add_argument('--headless=new')
+
+        service = Service(executable_path=chrome_driver)
+        self._driver = webdriver.Chrome(service=service, options=options)
+        return self.driver
+
+    @classmethod
+    @_wait_for_delay
+    def create_profile(
+            cls,
+            data: Optional[CreateProfileParams] = None,
+            port: int = 50325,
+            *,
+            group_id: Optional[int] = None,
+            name: Optional[str] = None,
+            user_proxy_config: Optional[UserProxyConfig] = None,
+            fingerprint_config: Optional[FingerprintConfig] = None
+    ) -> Self:
+        """
+        Returns an instance of class referring to a new profile
+
+        :param data: Keyword arguments as dictionary to create profile
+        :param port: The port of API
+        :param name: The name of the account, no more than 100 characters
+        :param group_id: The group ID corresponding to the group in which an account is to be created,
+        :param user_proxy_config: Dictionary arguments to update a proxy
+        :param fingerprint_config: Dictionary arguments to update a fingerprint
+
+        :raise ProfileCreationError: Raised when profile creation is failed
+        :return: An AdsPower instance with the specified profile ID
+
+        Request parameters
+        ----------
+            {
+                'name':
+                      The name of the account, no more than 100 characters,
+                'group_id':
+                          The group ID corresponding to the group in which an account is to be created,
+                'user_proxy_config': {
+                    'proxy_soft':
+                                The proxy software. Currently, supports:
+                                luminati, lumauto, oxylabsatuto, 922S5，ipideaauto，ipfoxyauto，ssh, other, no_proxy,
+                                Default value - no_proxy,
+                    'proxy_type':
+                                The proxy type. Currently, supports:
+                                http, https, socks5;
+                                For no_proxy, you may pass the parameter or not,
+                    'proxy_host':
+                                Address of the proxy server, users can enter domain name or IP;
+                                For no_proxy, you may pass the parameter or not,
+                    'proxy_port':
+                                Port of the proxy server;
+                                For no_proxy, you may pass the parameter or not,
+                    'proxy_user':
+                                The username of the proxy,
+                    'proxy_password':
+                                    The password of the proxy
+                },
+
+                'fingerprint_config': {
+                    'language_switch':
+                                     Configure languages based on IP country. Default value - 0
+                                     0: Off;
+                                     1: On.
+                    'ua':
+                        String containing user agent.
+                        When customizing please make sure that ua format and content meet
+                        the requirement.
+                }
+            }
+        """
+        kwargs = locals()
+        del kwargs['port']
+        del kwargs['data']
+        del kwargs['cls']
+
+        api_url = cls._validate_api_url('http://local.adspower.net', port)
+
+        url = api_url + '/api/v1/user/create'
+
+        data = data or kwargs
+        if not data.get('group_id'):
+            raise NoGroupIdFound
+
+        if not data.get('user_proxy_config'):
+            data['user_proxy_config'] = {'proxy_soft': 'no_proxy'}
+
+        response = requests.post(url=url, json=data).json()
+        cls._validate_response(ProfileCreationError, data, response)
+
+        return cls(response['data']['id'], port)
+
+    @classmethod
+    @_wait_for_delay
+    def delete_profiles(cls, profile_ids: str | Iterable[str], port: int = 50325) -> None:
+        """
+        Deletes profiles associated with specified profile_ids in AdsPower
+        :param profile_ids: Iterable containing profile_ids or one profile ID
+        :param port: The port of AdsPower's API
+
+        :raise ProfileNotFound: Raised when a profile does not exist
+        :return: None
+        """
+        if not profile_ids:
+            raise NoProfileIdFound
+
+        api_url = cls._validate_api_url('http://local.adspower.net', port)
+        url = api_url + '/api/v1/user/delete'
+
+        if isinstance(profile_ids, str):
+            profile_ids = [profile_ids]
+        else:
+            profile_ids_ = []
+            for profile_id in profile_ids:
+                profile_ids_.append(profile_id)
+            profile_ids = profile_ids_
+
+        data = {'user_ids': profile_ids}
+
+        response = requests.post(url=url, json=data).json()
+        cls._validate_response(ProfileNotFound, data, response)
+
+    @classmethod
+    @_wait_for_delay
+    def query_group(
+            cls,
+            params: Optional[QueryGroupParams] = None,
+            port: int = 50325,
+            *,
+            group_name: Optional[str] = None,
+            profile_id: Optional[str] = None,
+            page_size: Optional[int] = 100
+    ) -> GroupResponse:
+        """
+        Returns dictionaries containing information about the groups by specified parameters. If there are no
+        params, excluding page_size, it returns a list of dictionaries, containing information about all groups
+
+        :param params: Keyword arguments as dictionary to query groups
+        :param port: The port of AdsPower's API
+        :param group_name: The group name corresponding to the group
+        :param profile_id: ID of existed profile in AdsPower
+        :param page_size: The maximum length of returning list. Default value - 100
+
+        :raise GroupQueryError: Raised when group query is failed
+        :return: List of dictionaries containing information about corresponding groups
+
+        Request parameters
+        ----------
+            {
+                'group_name':
+                            The group name corresponding to the group,
+                'profile_id':
+                         ID of existed profile in AdsPower,
+                'page_size':
+                           The maximum length of returning list. Default value - 100
+            }
+        """
+        kwargs = locals()
+        del kwargs['cls']
+        del kwargs['params']
+        del kwargs['port']
+
+        api_url = cls._validate_api_url('http://local.adspower.net', port)
+        url = api_url + '/api/v1/group/list'
+
+        params = params or kwargs
+        if not params.get('page_size'):
+            params['page_size'] = 100
+
+        if len(params) == 1:
+            response = requests.get(url=url, params=params).json()
+            cls._validate_response(GroupQueryError, params, response)
+            return response['data']['list']
+        else:
+            params['user_id'] = params.pop('profile_id')
+            response = requests.get(url=url, params=params).json()
+            cls._validate_response(GroupQueryError, params, response)
+            return response['data']['list'][0]
+
+    @classmethod
+    @_wait_for_delay
+    def query_profiles(
+            cls,
+            params: Optional[QueryProfilesParams] = None,
+            port: int = 50325,
+            *,
+            group_id: Optional[int] = None,
+            page_size: Optional[int] = 100
+    ) -> ProfileResponse:
+        """
+        Returns a list consisting of dictionaries containing information about the profiles by specified parameters
+
+        :param params: Keyword arguments as dictionary to query profiles
+        :param port: The port of AdsPower's API
+        :param group_id: The group ID corresponding to the group in which an account is to be created,
+        :param page_size: The maximum length of returning list. Default value - 100
+
+        :raise ProfileQueryError: Raised when profile query is failed
+        :return: list[dict[str, str]]: List of dictionaries containing information about corresponding profiles
+
+        Request parameters
+        ----------
+            {
+                'group_id':
+                           The group ID corresponding to the group in which an account exists,
+                'page_size':
+                            The maximum length of returning list. Default value - 100
+            }
+        """
+        kwargs = locals()
+        del kwargs['cls']
+        del kwargs['params']
+        del kwargs['port']
+
+        api_url = cls._validate_api_url('http://local.adspower.net', port)
+        url = api_url + '/api/v1/user/list'
+
+        params = params or kwargs
+        if not params.get('page_size'):
+            params['page_size'] = 100
+
+        response = requests.get(url=url, params=params).json()
+
+        cls._validate_response(ProfileQueryError, params, response)
+
+        return response['data']['list']
+
+    @_wait_for_delay
+    def update_proxy(
+            self,
+            data: Optional[UpdatingProxyParams] = None,
+            *,
+            profile_id: Optional[str] = None,
+            proxy_soft: Optional[str] = None,
+            proxy_type: Optional[str] = None,
+            proxy_host: Optional[str] = None,
+            proxy_user: Optional[str] = None,
+            proxy_password: Optional[str] = None
+    ) -> None:
+        """
+        Updates proxy in current profile
+
+        :param data: Keyword arguments as dictionary to update proxy
+        :param profile_id: ID of existed profile in AdsPower
+        :param proxy_soft: The proxy software. Currently, supports:
+                            luminati, lumauto, oxylabsatuto, 922S5，ipideaauto，ipfoxyauto，ssh, other, noproxy,
+                            By default you should to set 'other'.
+        :param proxy_type: The proxy type. Currently, supports:
+                            http, https, socks5;
+                            For no_proxy, you may pass the parameter or not
+        :param proxy_host: Address of the proxy server, users can enter domain name or IP;
+                            For no_proxy, you may pass the parameter or not,
+        :param proxy_user: The username of the proxy,
+        :param proxy_password: The password of the proxy
+
+        :raise InvalidProxyConfig: Raised when proxy config is invalid
+        :raise ProxyUpdateError: Raised when proxy update is failed
+        :return: None
+
+        Request parameters
+        ----------
+            {
+                'profile_id':
+                            ID of existed profile in AdsPower
+                'proxy_soft':
+                            The proxy software. Currently, supports:
+                            luminati, lumauto, oxylabsatuto, 922S5，ipideaauto，ipfoxyauto，ssh, other, noproxy,
+                            By default you should to set 'other',
+                'proxy_type':
+                            The proxy type. Currently, supports:
+                            http, https, socks5;
+                            For no_proxy, you may pass the parameter or not,
+                'proxy_host':
+                            Address of the proxy server, users can enter domain name or IP;
+                            For no_proxy, you may pass the parameter or not,
+                'proxy_port':
+                            Port of the proxy server;
+                            For no_proxy, you may pass the parameter or not,
+                'proxy_user':
+                            The username of the proxy,
+                'proxy_password':
+                                The password of the proxy
+            }
+        """
+        kwargs = locals()
+        del kwargs['data']
+        del kwargs['self']
+
+        url = self.api_url + '/api/v1/user/update'
+
+        data = data or kwargs
+        if not data.get('profile_id'):
+            data['profile_id'] = self.profile_id
+
+        if not is_typed_dict(data, UpdatingProxyParams):
+            raise InvalidProxyConfig(data)
+
+        profile_id = data.pop('profile_id')
+        data_to_send = {
+            'user_id': profile_id,
+            'user_proxy_config': data
+        }
+
+        response = requests.post(url=url, json=data_to_send).json()
+        self._validate_response(ProxyUpdateError, data_to_send, response)
+
+    @_wait_for_delay
+    def update_user_agent(self, user_agent: str, profile_id: Optional[str] = None) -> None:
+        """
+        Updates user agent in current profile
+
+        :param profile_id: ID of existed profile in AdsPower
+        :param user_agent: String containing user agent.
+                           When customizing please make sure that ua format and content meet
+                           the requirement.
+
+        :raise NoUserAgentFound: Raised when user agent is not specified
+        :raise UserAgentUpdateError: Raised when user agent update is failed
+        :return: None
+        """
+        url = self.api_url + '/api/v1/user/update'
+        if not user_agent:
+            raise NoUserAgentFound
+
+        user_agent = user_agent
+        profile_id = self.profile_id or profile_id
+        data = {
+            'user_id': profile_id,
+            'fingerprint_config': {'ua': user_agent}
+        }
+        response = requests.post(url=url, json=data).json()
+
+        self._validate_response(UserAgentUpdateError, data, response)
+
+    def close_tabs(self) -> None:
+        """
+        Closes all tabs in anti-detect browser
+
+        :return: None
+        """
+        driver = self.driver
+        original_window_handle = driver.current_window_handle
+        windows = driver.window_handles
+        for window in windows:
+            if original_window_handle != window:
+                driver.switch_to.window(window)
+                driver.close()
+        driver.switch_to.window(original_window_handle)
+
+    @_wait_for_delay
+    def quit(self) -> None:
+        """
+        Closes current profile
+
+        :raise QuittingProfileError: Quitting profile is failed. Profile can be already closed
+        :return: None
+        """
+        self.driver.quit()
+        profile_id = self.profile_id
+        url = self.api_url + '/api/v1/browser/stop'
+        params = {'user_id': profile_id}
+        response = requests.get(url=url, params=params).json()
+        self._validate_response(QuittingProfileError, params, response)

adspower-1.0.0/adspower/exceptions.py

@@ -0,0 +1,93 @@
+from typing import Any
+from adspower.types import UpdatingProxyParams
+
+
+class NoParamsFound(Exception):
+    """Raised when params are not specified via positional arguments or keyword arguments"""
+    def __init__(self):
+        super().__init__("Params are not specified via positional arguments or keyword arguments")
+
+
+class ZeroResponse(Exception):
+    """Raised if response is 0"""
+    def __init__(self, message: str, request: dict[str, Any], response: dict[str]):
+        super().__init__(f"{message}. \nRequest: {request}. \nResponse: {response}")
+
+
+class ProxyUpdateError(ZeroResponse):
+    """Raised when proxy update is failed"""
+    def __init__(self, request: dict[str, Any], response: dict[str]):
+        super().__init__("The proxy update is failed", request, response)
+
+
+class UserAgentUpdateError(ZeroResponse):
+    """Raised when user agent update is failed"""
+    def __init__(self, request: dict[str, Any], response: dict[str]):
+        super().__init__("The user agent update is failed", request, response)
+
+
+class ProfileCreationError(ZeroResponse):
+    """Raised when profile creation is failed"""
+    def __init__(self, request: dict[str, Any], response: dict[str]):
+        super().__init__("The profile creation is failed", request, response)
+
+
+class GroupQueryError(ZeroResponse):
+    """Raised when group query is failed"""
+    def __init__(self, request: dict[str, Any], response: dict[str]):
+        super().__init__("The group query is failed", request, response)
+
+
+class ProfileQueryError(ZeroResponse):
+    """Raised when profile query is failed"""
+    def __init__(self, request: dict[str, Any], response: dict[str]):
+        super().__init__("The profile query is failed", request, response)
+
+
+class ProfileNotFound(ZeroResponse):
+    """Raised when profile getting or deleting is failed"""
+    def __init__(self, request: dict[str, Any], response: dict[str]):
+        super().__init__("Profile getting is failed", request, response)
+
+
+class QuittingProfileError(ZeroResponse):
+    """Raised when quitting profile is failed."""
+    def __init__(self, request: dict[str, Any], response: dict[str]):
+        super().__init__("Quitting profile is failed. Profile can be already closed", request, response)
+
+
+class NoGroupIdFound(Exception):
+    """Raised when group id is not specified"""
+    def __init__(self):
+        super().__init__("The id of a group isn't passed")
+
+
+class NoProfileIdFound(Exception):
+    """Raised when profile id is not specified"""
+    def __init__(self):
+        super().__init__("The id of a profile isn't passed")
+
+
+class NoUserAgentFound(Exception):
+    """Raised when user agent is not specified"""
+    def __init__(self):
+        super().__init__("The user agent isn't passed")
+
+
+class InvalidProxyConfig(Exception):
+    """Raised when proxy config is invalid"""
+
+    def __init__(self, proxy_config: dict[str] | UpdatingProxyParams):
+        super().__init__(f"The proxy config is invalid. Config: {proxy_config}")
+
+
+class ExceededQPS(Exception):
+    """Raised when amount of queries per second is exceeded"""
+    def __init__(self):
+        super().__init__("Too many request per second, please try later")
+
+
+class UnavailableAPI(Exception):
+    """Raised when API url specified with invalid port or AdsPower is not opened"""
+    def __init__(self, port: int):
+        super().__init__(f"Your API url is specified with invalid port or AdsPower is not opened. You provided port {port}")

adspower-1.0.0/adspower/types.py

@@ -0,0 +1,68 @@
+from typing import TypedDict, Literal, NotRequired
+
+ProxySoft = Literal['luminati', 'lumauto', 'oxylabsatuto', '922S5', 'ipideaauto',
+                    'ipfoxyauto', 'ssh', 'other', 'no_proxy']
+
+ProxyType = Literal['http', 'https', 'socks5']
+
+
+class UserProxyConfig(TypedDict):
+    proxy_soft: ProxySoft
+    proxy_type: ProxyType
+    proxy_host: str
+    proxy_port: int
+    proxy_user: str
+    proxy_password: str
+
+
+class UpdatingProxyParams(TypedDict):
+    profile_id: NotRequired[str]
+    proxy_config: UserProxyConfig
+
+
+class FingerprintConfig(TypedDict):
+    ua: str
+    language_switch: NotRequired[bool]
+
+
+class CreateProfileParams(TypedDict):
+    name: NotRequired[str]
+    group_id: int
+    user_proxy_config: NotRequired[UserProxyConfig]
+    fingerprint_config: NotRequired[FingerprintConfig]
+
+
+class QueryGroupParams(TypedDict):
+    group_name: NotRequired[str]
+    profile_id: NotRequired[str]
+    page_size: NotRequired[int]
+
+
+class QueryProfilesParams(TypedDict):
+    group_id: NotRequired[int]
+    page_size: NotRequired[int]
+
+
+class GroupInfo(TypedDict):
+    group_id: int
+    group_name: str
+
+
+class ProfileInfo(TypedDict):
+    serial_number: int
+    user_id: str
+    name: str
+    group_id: int
+    group_name: str
+    domain_name: str
+    username: str
+    remark: str
+    created_time: int
+    ip: str
+    ip_country: str
+    password: str
+    last_open_time: int
+
+
+GroupResponse = list[GroupInfo] | GroupInfo
+ProfileResponse = list[ProfileInfo]

adspower-1.0.0/adspower/utils.py

@@ -0,0 +1,12 @@
+from typing import Type, Any, TypedDict
+
+
+def is_typed_dict(value: Any, typed_dict: Type[TypedDict]) -> bool:
+    typed_dict_keys = typed_dict.__annotations__.keys()
+
+    try:
+        value_keys = value.keys()
+    except AttributeError:
+        return False
+
+    return typed_dict_keys == value_keys

adspower-1.0.0/pyproject.toml

@@ -0,0 +1,36 @@
+[tool.poetry]
+name = 'adspower'
+version = '1.0.0'
+description = 'The package for interacting with API of anti-detect browser AdsPower.'
+authors = ['Alexey <abelenkov2006@gmail.com>']
+license = 'MIT'
+readme = 'README.md'
+repository = 'https://github.com/blnkoff/adspower'
+homepage = 'https://github.com/blnkoff/adspower'
+classifiers = [
+    'Development Status :: 5 - Production/Stable',
+    'Intended Audience :: Developers',
+    'Topic :: Software Development :: Libraries :: Python Modules',
+    'Programming Language :: Python :: 3.11',
+    'Programming Language :: Python :: 3 :: Only',
+    'License :: OSI Approved :: MIT License',
+    'Operating System :: Microsoft :: Windows',
+    'Operating System :: MacOS'
+]
+packages = [{ include = 'adspower' }]
+
+[tool.poetry.dependencies]
+python = '^3.11'
+requests = "^2.31.0"
+selenium = "^4.16.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.3"
+twine = "^4.0.2"
+build = "^1.0.3"
+sphinx-rtd-theme = "^2.0.0"
+sphinx = "^7.2.6"
+
+[build-system]
+requires = ['poetry-core']
+build-backend = 'poetry.core.masonry.api'