Use httpx instead of hyper

Author: phillmac

orbitdbapi/client.py

@@ -1,19 +1,21 @@
 import json
 import logging
-import requests
-from .db import DB
-from hypertemp.contrib import HTTP20Adapter
+from pprint import pformat
 from urllib.parse import quote as urlquote
 
+import httpx
+
+from .db import DB
+
+
 class OrbitDbAPI ():
     def __init__ (self, **kwargs):
         self.logger = logging.getLogger(__name__)
         self.__config = kwargs
         self.__base_url = self.__config.get('base_url')
         self.__use_db_cache = self.__config.get('use_db_cache', True)
         self.__timeout = self.__config.get('timeout', 30)
-        self.__session = requests.Session()
-        self.__session.mount(self.__base_url, HTTP20Adapter(timeout=self.__timeout))
+        self.__session = httpx.Client()
         self.logger.debug('Base url: ' + self.__base_url)
 
     @property
@@ -29,6 +31,7 @@ def use_db_cache(self):
         return self.__use_db_cache
 
     def _do_request(self, *args, **kwargs):
+        self.logger.log(15, json.dumps([args, kwargs]))
         kwargs['timeout'] = kwargs.get('timeout', self.__timeout)
         try:
             return self.__session.request(*args, **kwargs)
@@ -40,8 +43,8 @@ def _call_raw(self, method, endpoint, **kwargs):
         url = '/'.join([self.__base_url, endpoint])
         return self._do_request(method, url, **kwargs)
 
-    def _call(self, method, endpoint, body=None):
-        res = self._call_raw(method, endpoint, json=body)
+    def _call(self, method, endpoint,  **kwargs):
+        res = self._call_raw(method, endpoint, **kwargs)
         try:
             result = res.json()
         except:
@@ -52,16 +55,16 @@ def _call(self, method, endpoint, body=None):
             res.raise_for_status()
         except:
             self.logger.exception('Server Error')
-            self.logger.debug(result)
+            self.logger.error(pformat(result))
             raise
         return result
 
     def list_dbs(self):
-        return self._call('get', 'dbs')
+        return self._call('GET', 'dbs')
 
     def db(self, dbname, **kwargs):
         return DB(self, self.open_db(dbname, **kwargs), **self.__config)
 
     def open_db(self, dbname, **kwargs):
         endpoint = '/'.join(['db', urlquote(dbname, safe='')])
-        return self._call('post', endpoint, kwargs)
+        return self._call('POST', endpoint, **kwargs)

orbitdbapi/db.py

@@ -1,10 +1,11 @@
 import json
 import logging
-from copy import deepcopy
-from sseclient import SSEClient
 from collections.abc import Hashable, Iterable
+from copy import deepcopy
 from urllib.parse import quote as urlquote
 
+from sseclient import SSEClient
+
 
 class DB ():
     def __init__(self, client, params, **kwargs):
@@ -56,32 +57,37 @@ def dbname(self):
     def dbtype(self):
         return self.__type
 
+    @property
+    def capabilities(self):
+        return deepcopy(self.__params.get('capabilities', []))
+
     @property
     def queryable(self):
-        return 'query' in self.__params.get('capabilities', {})
+        return 'query' in self.__params.get('capabilities', [])
+
     @property
     def putable(self):
-        return 'put' in self.__params.get('capabilities', {})
+        return 'put' in self.__params.get('capabilities', [])
 
     @property
     def removeable(self):
-        return 'remove' in self.__params.get('capabilities', {})
+        return 'remove' in self.__params.get('capabilities', [])
 
     @property
     def iterable(self):
-        return 'iterator' in self.__params.get('capabilities', {})
+        return 'iterator' in self.__params.get('capabilities', [])
 
     @property
     def addable(self):
-        return 'add' in self.__params.get('capabilities', {})
+        return 'add' in self.__params.get('capabilities', [])
 
     @property
     def valuable(self):
-        return 'value' in self.__params.get('capabilities', {})
+        return 'value' in self.__params.get('capabilities', [])
 
     @property
     def incrementable(self):
-        return 'inc' in self.__params.get('capabilities', {})
+        return 'inc' in self.__params.get('capabilities', [])
 
     @property
     def indexed(self):
@@ -97,7 +103,7 @@ def write_access(self):
 
     def info(self):
         endpoint = '/'.join(['db', self.__id_safe])
-        return self.__client._call('get', endpoint)
+        return self.__client._call('GET', endpoint)
 
     def get(self, item, cache=None, unpack=False):
         if cache is None: cache = self.__use_cache
@@ -106,7 +112,7 @@ def get(self, item, cache=None, unpack=False):
             result = self.__cache[item]
         else:
             endpoint = '/'.join(['db', self.__id_safe, item])
-            result = self.__client._call('get', endpoint)
+            result = self.__client._call('GET', endpoint)
             if cache: self.__cache[item] = result
         if isinstance(result, Hashable): return deepcopy(result)
         if isinstance(result, Iterable): return deepcopy(result)
@@ -117,11 +123,11 @@ def get(self, item, cache=None, unpack=False):
 
     def get_raw(self, item):
         endpoint = '/'.join(['db', self.__id_safe, 'raw', str(item)])
-        return (self.__client._call('get', endpoint))
+        return (self.__client._call('GET', endpoint))
 
     def put(self,  item, cache=None):
         if self.__enforce_caps and not self.putable:
-            raise CapabilityError('Db {} does not have put capability'.format(self.__dbname))
+            raise CapabilityError(f'Db {self.__dbname} does not have put capability')
         if self.indexed and (not hasattr(item, self.__index_by)) and self.__enforce_indexby:
             raise MissingIndexError("The provided document doesn't contain field '{}'".format(self.__index_by))
 
@@ -134,59 +140,60 @@ def put(self,  item, cache=None):
             if index_val:
                 self.__cache[index_val] = item
         endpoint = '/'.join(['db', self.__id_safe, 'put'])
-        entry_hash = self.__client._call('post', endpoint, item).get('hash')
+        entry_hash = self.__client._call('POST', endpoint, item).get('hash')
         if cache and entry_hash: self.__cache[entry_hash] = item
         return entry_hash
 
     def add(self, item, cache=None):
         if self.__enforce_caps and not self.addable:
-            raise CapabilityError('Db {} does not have add capability'.format(self.__dbname))
+            raise CapabilityError(f'Db {self.__dbname} does not have add capability')
         if cache is None: cache = self.__use_cache
         endpoint = '/'.join(['db', self.__id_safe, 'add'])
-        entry_hash = self.__client._call('post', endpoint, item).get('hash')
+        entry_hash = self.__client._call('POST', endpoint, item).get('hash')
         if cache and entry_hash: self.__cache[entry_hash] = item
         return entry_hash
 
     def iterator_raw(self, **kwargs):
         if self.__enforce_caps and not self.iterable:
-            raise CapabilityError('Db {} does not have iterator capability'.format(self.__dbname))
+            raise CapabilityError(f'Db {self.__dbname} does not have iterator capability')
         endpoint =  '/'.join(['db', self.__id_safe, 'rawiterator'])
-        return self.__client._call('get', endpoint, kwargs)
+        return self.__client._call('GET', endpoint, json=kwargs)
 
     def iterator(self, **kwargs):
         if self.__enforce_caps and not self.iterable:
-            raise CapabilityError('Db {} does not have iterator capability'.format(self.__dbname))
+            raise CapabilityError(f'Db {self.__dbname} does not have iterator capability')
         endpoint =  '/'.join(['db', self.__id_safe, 'iterator'])
-        return self.__client._call('get', endpoint, kwargs)
+        return self.__client._call('GET', endpoint, json=kwargs)
 
     def index(self):
         endpoint = '/'.join(['db', self.__id_safe, 'index'])
-        result = self.__client._call('get', endpoint)
+        result = self.__client._call('GET', endpoint)
         return result
 
     def all(self):
         endpoint = '/'.join(['db', self.__id_safe, 'all'])
-        result = self.__client._call('get', endpoint)
+        result = self.__client._call('GET', endpoint)
         if isinstance(result, Hashable):
             self.__cache = result
         return result
 
     def remove(self, item):
         if self.__enforce_caps and not self.removeable:
-            raise CapabilityError('Db {} does not have remove capability'.format(self.__dbname))
+            raise CapabilityError(f'Db {self.__dbname} does not have remove capability')
         item = str(item)
         endpoint = '/'.join(['db', self.__id_safe, item])
-        return self.__client._call('delete', endpoint)
+        return self.__client._call('DELETE', endpoint)
 
     def unload(self):
         endpoint = '/'.join(['db', self.__id_safe])
-        return self.__client._call('delete', endpoint)
+        return self.__client._call('DELETE', endpoint)
 
     def events(self, eventname):
         endpoint = '/'.join(['db', self.__id_safe, 'events', urlquote(eventname, safe='')])
         #return SSEClient('{}/{}'.format(self.__client.base_url, endpoint), session=self.__client.session)
-        req = self.__client._call_raw('get', endpoint, stream=True)
-        return SSEClient(req).events()
+        res = self.__client._call_raw('GET', endpoint, stream=True)
+        res.raise_for_status()
+        return SSEClient(res.stream()).events()
 
 class CapabilityError(Exception):
     pass

orbitdbapi/version.py

@@ -1,2 +1,2 @@
-version = '0.3.0-dev0'
+version = '0.4.0-dev0'
 version_info = tuple([int(d) for d in version.split("-")[0].split(".")])

setup.py

@@ -13,8 +13,7 @@
     url='https://github.com/phillmac/py-orbit-db-http-client',
     packages=find_packages(),
     install_requires=[
-        'requests >= 2.11',
-        'hypertemp == 0.8.0',
+        'httpx >= 0.7.5',
         'sseclient==0.0.24'
         ],
     classifiers=[