pytolino 1.7__py3-none-any.whl → 2.0__py3-none-any.whl

pytolino/tolino_cloud.py

@@ -1,329 +1,182 @@
 #!/usr/bin/env python3
 
 
-import os
-import configparser
-import platform
 import logging
-from urllib.parse import urlparse, parse_qs
-from urllib3.util import Retry
 import json
 import time
+import tomllib
+from pathlib import Path
 
 
 import requests
-from requests.adapters import HTTPAdapter
-import mechanize
+import curl_cffi
+from varboxes import VarBox
 
 
 class PytolinoException(Exception):
     pass
 
 
-SERVERS_SETTINGS_FN = 'servers_settings.ini'
-SERVERS_SETTINGS_FILE_PATH = os.path.join(
-        os.path.dirname(__file__),
-        SERVERS_SETTINGS_FN,
-        )
-servers_settings = configparser.ConfigParser()
-servers_settings.read(SERVERS_SETTINGS_FILE_PATH)
+class ExpirationError(PytolinoException):
+    pass
+
 
-PARTNERS = servers_settings.sections()
-TOTAL_RETRY = 5
-STATUS_FORCELIST = [404]
+SERVERS_SETTINGS_FN = 'servers_settings.toml'
+SERVERS_SETTINGS_FP = Path(__file__).parent / SERVERS_SETTINGS_FN
+servers_settings = tomllib.loads(SERVERS_SETTINGS_FP.read_text())
+PARTNERS = servers_settings.keys()
 
 
 def main():
-    print(SERVERS_SETTINGS_FILE_PATH)
-    print(servers_settings.sections())
+    for partner in PARTNERS:
+        print(partner)
+        for key, val in servers_settings[partner].items():
+            print(key, val)
 
 
 class Client(object):
 
     """create a client to communicate with a tolino partner (login, etc..)"""
 
-    def _log_requests(self, host_response, error: True or None=None):
-        if host_response.status_code >= 400 or error is True:
-            logger = logging.error
-        else:
-            logger = logging.debug
-        logger('log request')
-        logger('---------------- HTTP response (requests)----------')
-        logger(f'status code: {host_response.status_code}')
-        logger(f'cookies: {host_response.cookies}')
-        logger(f'headers: {host_response.headers}')
-        try:
-            j = host_response.json()
-            logger(f'json: {j}')
-        except requests.JSONDecodeError:
-            logger(f'text: {host_response.text}')
-        logger('-------------------------------------------------------')
+    def store_token(
+                    account_name,
+                    refresh_token: str,
+                    expires_in: int,
+                    hardward_id: str,
+                    access_token='',
+                    ):
+        """after one has connected in a browser,
+        one can store the token for the app.
+
+        :account_name: internal name for reference
+        :refresh_token: given by server after a token POST request
+        :expires_in: time in seconds
+        :hardward_id: present in payload for every request to API.
 
-        try:
-            host_response.raise_for_status()
-        except requests.exceptions.HTTPError as e:
-            raise PytolinoException
-        except requests.exceptions.RequestException as e:
-            raise PytolinoException
-
-    def _log_mechanize(self, host_response):
-        logging.debug('-------------- HTTP response (mechanize)--------------')
-        logging.debug(f'status code: {host_response.code}')
-        logging.debug(f'headers: {host_response.info()}')
-        logging.debug('-------------------------------------------------------')
-        if host_response.code >= 400:
-            logging.error('-------------- HTTP response (mechanize)----------')
-            logging.error(f'status code: {host_response.code}')
-            logging.error(f'headers: {host_response.info()}')
-            logging.error('--------------------------------------------------')
-            raise PytolinoException('http error')
-
-    def _hardware_id():
-
-        # tolino wants to know a few details about the HTTP client hardware
-        # when it connects.
-        #
-        # 1233X-44XXX-XXXXX-XXXXX-XXXXh
-        #
-        # 1  = os id
-        # 2  = browser engine id
-        # 33 = browser id
-        # 44 = browser version
-        # X  = the result of a fingerprinting image
-
-        os_id = {
-            'Windows': '1',
-            'Darwin': '2',
-            'Linux': '3'
-            }.get(platform.system(), 'x')
-
-        # The hardware id contains some info about the browser
-        #
-        # Hey, tolino developers: Let me know which id values to use here
-        engine_id = 'x'
-        browser_id = 'xx'
-        version_id = '00'
-
-        # For some odd reason, the tolino javascript draws the text
-        # "www.tolino.de" and a rectangle filled with the offical Telekom
-        # magenta #E20074 (http://de.wikipedia.org/wiki/Magenta_%28Farbe%29)
-        # into an image canvas and then fuddles around with the
-        # base64-encoded PNG. Probably to gain some sort of fingerprint,
-        # but it's not quite clear how this would help the tolino API.
-        #
-        # Hey, tolino developers: Let me know what you need here.
-
-        fingerprint = 'ABCDEFGHIJKLMNOPQR'
-
-        return (
-                os_id +
-                engine_id +
-                browser_id +
-                fingerprint[0:1] +
-                '-' +
-                version_id +
-                fingerprint[1:4] +
-                '-' +
-                fingerprint[4:9] +
-                '-' +
-                fingerprint[9:14] +
-                '-' +
-                fingerprint[14:18] +
-                'h'
-                )
+        """
+        vb = VarBox('pytolino', app_name=account_name)
+        vb.refresh_token = refresh_token
+        vb.hardware_id = hardward_id
+        vb.expires_in = expires_in
+        vb.timestamp = time.time()
+        vb.access_token = access_token
 
-    hardware_id = _hardware_id()
+    @property
+    def refresh_token(self) -> str:
+        """refresh token to get new access token"""
+        return self._refresh_token
 
-    def __init__(self, server_name='www.buecher.de'):
+    @property
+    def hardware_id(self) -> str:
+        """hardware id that is sent in request payloads"""
+        return self._hardware_id
+
+    def __init__(self, server_name='orellfuessli'):
 
         if server_name not in servers_settings:
             raise PytolinoException(
                     f'the partner {server_name} was not found.'
                     f'please choose one of the list: {PARTNERS}')
 
-        self.access_token = None
-        self.refresh_token = None
-        self.token_expires = None
-
-        self.server_settings = servers_settings[server_name]
-        self.session = requests.Session()
-        retry_strategy = Retry(
-                total=TOTAL_RETRY,
-                status_forcelist=STATUS_FORCELIST,
-                backoff_factor=2,
-                allowed_methods=frozenset(['GET', 'POST']))
-        adapter = HTTPAdapter(max_retries=retry_strategy)
-        self.session.mount('http://', adapter)
-        self.session.mount('https://', adapter)
-        self.browser = mechanize.Browser()
-        self.browser.set_handle_robots(False)
-        self.server_name = server_name
-
-    def login(self, username, password):
-        """login to the partner and get access token.
+        self._access_token = None
+        self._refresh_token = None
+        self._token_expires = None
+        self._hardware_id = None
 
-        :username: str
-        :password: str
-        :returns: None, but raises pytolino exceptions if fail
-        """
-        logging.info(f'login to {self.server_name}...')
+        self._server_settings = servers_settings[server_name]
+        self._session = requests.Session()
+        self._session_cffi = curl_cffi.Session()
+        self._server_name = server_name
 
-        self.browser.open(self.server_settings['login_url'])
-        self.browser.select_form(id=self.server_settings['form_id'])
-        self.browser[self.server_settings['username_field']] = username
-        self.browser[self.server_settings['password_field']] = password
-        host_response = self.browser.submit()
+    def retrieve_token(
+            self,
+            account_name,
+            ) -> tuple[str, str]:
+        """get the token and data that were stored previousely.
+        raise error if expired
 
-        for cookie in self.browser.cookiejar:
-            self.session.cookies.set(cookie.name, cookie.value)
+        :account_name: internal name under which token was stored
+        :returns: refresh_token, hardware_id
 
-        logging.debug(self.server_settings['login_cookie'])
-        self._log_mechanize(host_response)
-        if not self.server_settings['login_cookie'] in self.session.cookies:
-            raise PytolinoException(f'login to {self.server_name} failed.')
+        """
+        vb = VarBox('pytolino', app_name=account_name)
+        if not hasattr(vb, 'refresh_token'):
+            raise PytolinoException(
+                    'there was no refresh token stored for that name')
+        now = time.time()
+        expiration_time = vb.timestamp + vb.expires_in
+        if now > expiration_time:
+            raise ExpirationError('the refresh token has expired')
+        else:
+            self._refresh_token = vb.refresh_token
+            self._hardware_id = vb.hardware_id
+            self._access_token = vb.access_token
 
-        auth_code = ""
+    def get_new_token(self, account_name):
+        """look at the store token, and get a new access and refresh tokens.
 
-        params = {
-            'client_id': self.server_settings['client_id'],
-            'response_type': 'code',
-            'scope': self.server_settings['scope'],
-            'redirect_uri': self.server_settings['reader_url']
-        }
-        if 'login_form_url' in self.server_settings:
-            params['x_buchde.skin_id'] = self.server_settings[
-                    'x_buchde.skin_id']
-            params['x_buchde.mandant_id'] = self.server_settings[
-                    'x_buchde.mandant_id']
-        host_response = self.session.get(
-                self.server_settings['auth_url'],
-                params=params,
-                verify=True,
-                allow_redirects=False,
-                )
+        :account_name: TODO
+        :returns: TODO
 
-        self._log_requests(host_response)
+        """
+        self.retrieve_token(account_name)
 
-        try:
-            params = parse_qs(urlparse(
-                host_response.headers['Location']
-                ).query)
-            auth_code = params['code'][0]
-        except KeyError:
-            self._log_requests(host_response, error=True)
-            raise PytolinoException('oauth code request failed.')
-
-        # Fetch OAUTH access token
-        host_response = self.session.post(
-                self.server_settings['token_url'],
-                data={
-                    'client_id': self.server_settings['client_id'],
-                    'grant_type': 'authorization_code',
-                    'code': auth_code,
-                    'scope': self.server_settings['scope'],
-                    'redirect_uri': self.server_settings['reader_url']
-                    },
+        headers = {
+                'Referer': 'https://webreader.mytolino.com/',
+                }
+        payload = {
+            'client_id': 'webreader',
+            'grant_type': 'refresh_token',
+            'refresh_token': self.refresh_token,
+            'scope': 'SCOPE_BOSH',
+        }
+        host_response = self._session_cffi.post(
+                self._server_settings['token_url'],
+                data=payload,
                 verify=True,
-                allow_redirects=False,
+                allow_redirects=True,
+                headers=headers,
+                impersonate='chrome',
                 )
-        self._log_requests(host_response)
-
-        try:
+        if not host_response.ok:
+            msg = str(host_response)
+            logging.error('failed to get a new token')
+            logging.error(msg)
+            raise PytolinoException('failed to get a new token')
+        else:
             j = host_response.json()
-            self.access_token = j['access_token']
-            self.refresh_token = j['refresh_token']
-            self.token_expires = int(j['expires_in'])
-        except requests.JSONDecodeError:
-            raise PytolinoException('oauth access token request failed.')
+            self._access_token = j['access_token']
+            self._refresh_token = j['refresh_token']
+            self._token_expires = int(j['expires_in'])
+            Client.store_token(
+                    account_name,
+                    self.refresh_token,
+                    self._token_expires,
+                    self.hardware_id,
+                    access_token=self._access_token,
+                    )
+            logging.info('got a new access token!')
+
+    def login(self, username, password, fp=None):
+        """login to the partner and get access token.
+
+        """
+        msg = 'login does not work anymore because of bot protection'
+        'connect manualy (once) and use store_token and retrieve token'
+        'methods instead'
+        raise NotImplementedError(msg)
 
     def logout(self):
         """logout from tolino partner host
 
         """
-        if 'revoke_url' in self.server_settings:
-            host_response = self.session.post(
-                    self.server_settings['revoke_url'],
-                    data={
-                        'client_id': self.server_settings['client_id'],
-                        'token_type': 'refresh_token',
-                        'token': self.refresh_token,
-                        }
-                    )
-            self._log_requests(host_response)
-            if host_response.status_code != 200:
-                raise PytolinoException('logout failed.')
-        else:
-            host_response = self.session.post(
-                    self.server_settings['logout_url'],
-                    )
-            self._log_requests(host_response)
-            if host_response.status_code != 200:
-                raise PytolinoException('logout failed.')
+        raise NotImplementedError('logout is not necessary with tokens')
 
     def register(self):
-        """register your device. Needs to done only once! necessary to
-        upload files. you need to login first.
-
-        """
-        host_response = self.session.post(
-                self.server_settings['register_url'],
-                data=json.dumps({'hardware_name': 'tolino sync reader'}),
-                headers={
-                    'content-type': 'application/json',
-                    't_auth_token': self.access_token,
-                    'hardware_id': self.hardware_id,
-                    'reseller_id': self.server_settings['partner_id'],
-                    'client_type': 'TOLINO_WEBREADER',
-                    'client_version': '4.4.1',
-                    'hardware_type': 'HTML5',
-                    }
-                )
-        self._log_requests(host_response)
-        if host_response.status_code != 200:
-            raise PytolinoException(f'register {self.hardware_id} failed.')
+        raise NotImplementedError('register is not necessary with tokens')
 
     def unregister(self, device_id=None):
-        """unregister a device from the host partner. If no device is given,
-        it is assumed the device in use will be removed
-
-        :device_id: None or str if we want to unregister another device
-        :returns: None
-
-        """
-        if device_id is None:
-            device_id = self.hardware_id
-
-        host_response = self.session.post(
-                self.server_settings['unregister_url'],
-                data=json.dumps({
-                    'deleteDevicesRequest': {
-                        'accounts': [{
-                            'auth_token': self.access_token,
-                            'reseller_id': self.server_settings['partner_id'],
-                            }],
-                        'devices': [{
-                            'device_id': device_id,
-                            'reseller_id': self.server_settings['partner_id'],
-                            }]
-                        }
-                    }),
-                headers={
-                    'content-type': 'application/json',
-                    't_auth_token': self.access_token,
-                    'reseller_id': self.server_settings['partner_id'],
-                    }
-                )
-        self._log_requests(host_response)
-        if host_response.status_code != 200:
-            try:
-                j = host_response.json()
-                raise PytolinoException(
-                        f"unregister {device_id} failed: ",
-                        f"{j['ResponseInfo']['message']}"
-                        )
-            except KeyError:
-                raise PytolinoException(
-                        f'unregister {device_id} failed: reason unknown.')
+        raise NotImplementedError('unregister is not necessary with tokens')
 
     def get_inventory(self):
         """download a list of the books on the cloud and their information
@@ -331,19 +184,19 @@ class Client(object):
 
         """
 
-        host_response = self.session.get(
-                self.server_settings['inventory_url'],
+        host_response = self._session.get(
+                self._server_settings['inventory_url'],
                 params={'strip': 'true'},
                 headers={
-                    't_auth_token': self.access_token,
-                    'hardware_id': self.hardware_id,
-                    'reseller_id': self.server_settings['partner_id'],
+                    't_auth_token': self._access_token,
+                    'hardware_id': self._hardware_id,
+                    'reseller_id': self._server_settings['partner_id'],
                     }
                 )
 
-        self._log_requests(host_response)
-        if host_response.status_code != 200:
-            raise PytolinoException('invetory request failed')
+        if not host_response.ok:
+            raise PytolinoException(
+                    f'inventory request failed {host_response}')
 
         try:
             j = host_response.json()
@@ -386,20 +239,21 @@ class Client(object):
                     }]
                 }
 
-        host_response = self.session.patch(
-                self.server_settings['sync_data_url'],
+        host_response = self._session.patch(
+                self._server_settings['sync_data_url'],
                 data=json.dumps(payload),
                 headers={
                     'content-type': 'application/json',
-                    't_auth_token': self.access_token,
+                    't_auth_token': self._access_token,
                     'hardware_id': self.hardware_id,
-                    'reseller_id': self.server_settings['partner_id'],
+                    'reseller_id': self._server_settings['partner_id'],
                     'client_type': 'TOLINO_WEBREADER',
                     }
                 )
-        self._log_requests(host_response)
-        if host_response.status_code != 200:
-            raise PytolinoException('add to collection failed')
+
+        if not host_response.ok:
+            raise PytolinoException(
+                    f'collection add failed {host_response}')
 
     def upload_metadata(self, book_id, **new_metadata):
         """upload some metadata to a specific book on the cloud
@@ -409,20 +263,19 @@ class Client(object):
 
         """
 
-        url = self.server_settings['meta_url'] + f'/?deliverableId={book_id}'
-        host_response = self.session.get(
+        url = self._server_settings['meta_url'] + f'/?deliverableId={book_id}'
+        host_response = self._session.get(
                 url,
                 headers={
-                    't_auth_token': self.access_token,
+                    't_auth_token': self._access_token,
                     'hardware_id': self.hardware_id,
-                    'reseller_id': self.server_settings['partner_id'],
+                    'reseller_id': self._server_settings['partner_id'],
                   }
                 )
 
         book = host_response.json()
-        self._log_requests(host_response)
-        if host_response.status_code != 200:
-            raise PytolinoException('metadata upload failed')
+        if not host_response.ok:
+            raise PytolinoException(f'metadata upload failed {host_response}')
 
         for key, value in new_metadata.items():
             book['metadata'][key] = value
@@ -431,20 +284,19 @@ class Client(object):
                 'uploadMetaData': book['metadata']
                 }
 
-        host_response = self.session.put(
+        host_response = self._session.put(
                 url,
                 data=json.dumps(payload),
                 headers={
                     'content-type': 'application/json',
-                    't_auth_token': self.access_token,
+                    't_auth_token': self._access_token,
                     'hardware_id': self.hardware_id,
-                    'reseller_id': self.server_settings['partner_id'],
+                    'reseller_id': self._server_settings['partner_id'],
                     }
                 )
 
-        self._log_requests(host_response)
-        if host_response.status_code != 200:
-            raise PytolinoException('metadata upload failed')
+        if not host_response.ok:
+            raise PytolinoException(f'metadata upload failed {host_response}')
 
     def upload(self, file_path, name=None, extension=None):
         """upload an ebook to your cloud
@@ -466,8 +318,8 @@ class Client(object):
                 'epub': 'application/epub+zip',
                 }.get(extension.lower(), 'application/pdf')
 
-        host_response = self.session.post(
-                self.server_settings['upload_url'],
+        host_response = self._session.post(
+                self._server_settings['upload_url'],
                 files=[(
                     'file',
                     (
@@ -477,14 +329,15 @@ class Client(object):
                         ),
                     )],
                 headers={
-                    't_auth_token': self.access_token,
+                    't_auth_token': self._access_token,
                     'hardware_id': self.hardware_id,
-                    'reseller_id': self.server_settings['partner_id'],
+                    'reseller_id': self._server_settings['partner_id'],
                     }
                 )
-        self._log_requests(host_response)
-        if host_response.status_code != 200:
-            raise PytolinoException('file upload failed.')
+
+        if not host_response.ok:
+            raise PytolinoException(f'upload failed {host_response}')
+
         try:
             j = host_response.json()
         except requests.JSONDecodeError:
@@ -502,18 +355,17 @@ class Client(object):
         :returns: None
 
         """
-        host_response = self.session.get(
-                self.server_settings['delete_url'],
+        host_response = self._session.get(
+                self._server_settings['delete_url'],
                 params={'deliverableId': ebook_id},
                 headers={
-                    't_auth_token': self.access_token,
+                    't_auth_token': self._access_token,
                     'hardware_id': self.hardware_id,
-                    'reseller_id': self.server_settings['partner_id'],
+                    'reseller_id': self._server_settings['partner_id'],
                     }
                 )
-        self._log_requests(host_response)
 
-        if host_response.status_code != 200:
+        if not host_response.ok:
             try:
                 j = host_response.json()
                 raise PytolinoException(
@@ -543,21 +395,19 @@ class Client(object):
                 'jpg': 'image/jpeg'
                 }.get(ext.lower(), 'application/jpeg')
 
-        host_response = self.session.post(
-                self.server_settings['cover_url'],
+        host_response = self._session.post(
+                self._server_settings['cover_url'],
                 files=[('file', ('1092560016', open(filepath, 'rb'), mime))],
                 data={'deliverableId': book_id},
                 headers={
-                    't_auth_token': self.access_token,
+                    't_auth_token': self._access_token,
                     'hardware_id': self.hardware_id,
-                    'reseller_id': self.server_settings['partner_id'],
+                    'reseller_id': self._server_settings['partner_id'],
                     },
                 )
 
-        self._log_requests(host_response)
-
-        if host_response.status_code != 200:
-            raise PytolinoException('cover upload failed.')
+        if not host_response.ok:
+            raise PytolinoException(f'cover upload failed. {host_response}')
 
 
 if __name__ == '__main__':

{pytolino-1.7.dist-info → pytolino-2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytolino
-Version: 1.7
+Version: 2.0
 Summary: client for tolino cloud
 Author: Imam Usmani
 Project-URL: Source Code, https://github.com/ImamAzim/pytolino
@@ -15,6 +15,8 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: requests
 Requires-Dist: mechanize
+Requires-Dist: curl_cffi
+Requires-Dist: varboxes
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
@@ -25,10 +27,16 @@ Requires-Dist: twine; extra == "dev"
 Requires-Dist: sphinx-rtd-theme; extra == "dev"
 Dynamic: license-file
 
+UPDATE
+===========
+
+because of heavy anti-bot protection, it is no longer possible to make a fully automatic login. One can however reuse authorization token after a manual login. The token can then be refreshed automatically, for example with a cronjob (at least once per hour.)
+
+
 pytolino
 ===================
 
-A client to interact (login, upload, delete ebooks, etc..) with the tolino cloud with python. Most of the code is forked from https://github.com/darkphoenix/tolino-calibre-sync
+A client to interact (login, upload, delete ebooks, etc..) with the tolino cloud with python. thanks to https://github.com/darkphoenix/tolino-calibre-sync for the inspiration.
 
 One difference is that I aim to create a python package from it and to put it on pypi, so that one can use this python module in other projects.
 
@@ -42,48 +50,50 @@ Installation
 Usage
 =====
 
+First, login manually, and use an inspector tool in the browser to inspect the requests. After connecting to the digital libray of tolino, there is POST request (named token). From the request response, copy the value of the refresh token (and the expiration time in seconds). Then, in a PATH request, in the request header, find the device_id number.
 
-Before being able to send requests, you need to register your computer on which you will run the code:
+You can then store the token:
 
 .. code-block:: python
 
-    from pytolino.tolino_cloud import Client, PytolinoException
-    client = Client()
-    client.login(USERNAME, PASSWORD)
-    client.register() # do this only once!
-    client.logout()
+    from pytolino.tolino_cloud import Client
+    partner = 'orellfuessli'
+    account_name = 'any name for reference'
+    client = Client(partner)
+    print('login on your browser and get the token.')
+    refresh_token = input('refresh token:\n')
+    expires_in = int(input('expires_in:\n'))
+    hardware_id = input('hardware id:\n')
+    Client.store_token(
+    account_name, refresh_token, expires_in, hardware_id)
 
-You can then upload, add to a collection or delete ebook on your cloud:
+Then, get a new access token. It will expires in 1 hours, so you might want to create a crontab job to do it regularely:
 
 .. code-block:: python
 
-    from pytolino.tolino_cloud import Client, PytolinoException
-    client = Client()
-    client.login(USERNAME, PASSWORD)
+    from pytolino.tolino_cloud import Client
+    partner = 'orellfuessli'
+    account_name = 'any name for reference'
+    client = Client(partner)
+    client.get_new_token(account_name)
+
+After this, instead of login, you only need to retrieve the access token that is stored on disk and upload, delete books, etc...
+
+.. code-block:: python
+
+    from pytolino.tolino_cloud import Client
+    partner = 'orellfuessli'
+    account_name = 'any name for reference'
+    client = Client(partner)
+    client.retrieve_token(account_name)
+
     ebook_id = client.upload(EPUB_FILE_PATH) # return a unique id that can be used for reference
     client.add_collection(epub_id, 'science fiction') # add the previous book to the collection science-fiction
     client.add_cover(epub_id, cover_path) # to upload a cover on the book.
     client.delete_ebook(epub_id) # delete the previousely uploaded ebook
     inventory = client.get_inventory() # get a list of all the books on the cloud and their metadata
     client.upload_metadata(epub_id, title='my title', author='someone') # you can upload various kind of metadata
-    client.logout()
-
 
-if you want to unregister your computer:
-
-.. code-block:: python
-
-    from pytolino.tolino_cloud import Client, PytolinoException
-    client = Client()
-    client.login(USERNAME, PASSWORD)
-    client.register() # now you will not be able to upload books from this computer
-    client.logout()
-
-By default, it will connect to 'www.buecher.de'. In principle you could change the partner with:
-
-.. code-block:: python
-
-   client = Client(server_name='www.orelfuessli') # for example if you have an account at orel fuessli.
 
 To get a list of the supported partners:
 
@@ -92,22 +102,17 @@ To get a list of the supported partners:
    from pytolino.tolino_cloud import PARTNERS
    print(PARTNERS)
 
-Unfortunately, the only supported partner now is 'www.buecher.de', because it has a different way of connection... So for now, the only solution is to create an account there and link it to your original account.
-
+for now, only orelfuessli is supported, but it should be easy to include the others (but always need of a manual login)
 
 
 Features
 ========
 
-* login to tolino partner (for now works only with buecher.de)
-* register device
-* unregister device
 * upload ebook
 * delete ebook from the cloud
 * add a book to a collection
 * download inventory
 * upload metadata
-* more to come...
 
 
 License

pytolino-2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pytolino/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytolino/tolino_cloud.py,sha256=siPo3jsvtya2zCqsrQhc8ca9wyCC3SaCp0JM2Cw8IFI,13616
+pytolino-2.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pytolino-2.0.dist-info/METADATA,sha256=jsrSK9m6lTbYoXNlgnIftWndbA3rXzdqeN9N4BbUXvI,4265
+pytolino-2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pytolino-2.0.dist-info/top_level.txt,sha256=3stGCqihEMMqlWGkME45OTJ0Prg-FO_kl554rtYNeuU,9
+pytolino-2.0.dist-info/RECORD,,

{pytolino-1.7.dist-info → pytolino-2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pytolino/servers_settings.ini

@@ -1,29 +0,0 @@
-# buecher.de
-[www.buecher.de]
-partner_id = 30
-client_id  = dte_ereader_app_01
-scope = ebook_library
-signup_url = https://www.buecher.de/go/my_dry/my_register_aos/
-profile_url = https://www.buecher.de/go/my_dry/my_login/receiver_object/my_login/
-token_url = https://www.buecher.de/oauth2/token
-revoke_url = https://www.buecher.de/oauth2/revoke
-auth_url = https://www.buecher.de/oauth2/authorize
-login_url = https://www.buecher.de/go/my_dry/my_login/
-username_field = form[login]
-password_field = form[password]
-form_id = login
-x_buecherde.skin_id = de_dte_tolino
-login_cookie     = session
-logout_url       = https://www.buecher.de/go/my_dry/my_logout/
-reader_url       = https://webreader.mytolino.com/library/
-register_url     = https://bosh.pageplace.de/bosh/rest/v2/registerhw
-devices_url      = https://bosh.pageplace.de/bosh/rest/handshake/devices/list
-unregister_url   = https://bosh.pageplace.de/bosh/rest/handshake/devices/delete
-upload_url      = https://bosh.pageplace.de/bosh/rest/upload
-meta_url         = https://bosh.pageplace.de/bosh/rest/meta
-cover_url        = https://bosh.pageplace.de/bosh/rest/cover
-sync_data_url    = https://bosh.pageplace.de/bosh/rest/sync-data?paths=publications,audiobooks
-delete_url       = https://bosh.pageplace.de/bosh/rest/deletecontent
-inventory_url    = https://bosh.pageplace.de/bosh/rest/inventory/delta
-downloadinfo_url = https://bosh.pageplace.de/bosh/rest//cloud/downloadinfo/{}/{}/type/external-download
-form_send = 1

pytolino-1.7.dist-info/RECORD

@@ -1,8 +0,0 @@
-pytolino/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytolino/servers_settings.ini,sha256=IDhstCWbLHaMj3qEOYcbDABaIUKHIz1jEBke3uSE8bI,1473
-pytolino/tolino_cloud.py,sha256=K3eeV2Zj6IgyoGEhCerTnawBJkOm8aUhz4ZrojQUayQ,20072
-pytolino-1.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pytolino-1.7.dist-info/METADATA,sha256=UsWaJ9s46hClOr2k6rKSwNPjCUTmEJ6nF82JAvVC1r4,3725
-pytolino-1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytolino-1.7.dist-info/top_level.txt,sha256=3stGCqihEMMqlWGkME45OTJ0Prg-FO_kl554rtYNeuU,9
-pytolino-1.7.dist-info/RECORD,,