pyzotero 1.6.1__py3-none-any.whl → 1.6.2__py3-none-any.whl

_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.6.1'
-__version_tuple__ = version_tuple = (1, 6, 1)
+__version__ = version = '1.6.2'
+__version_tuple__ = version_tuple = (1, 6, 2)

pyzotero/zotero.py

@@ -37,9 +37,9 @@ from urllib.parse import (
 
 import bibtexparser
 import feedparser
+import httpx
 import pytz
-import requests
-from requests import Request
+from httpx import Request
 
 import pyzotero as pz
 
@@ -97,11 +97,14 @@ def tcache(func):
             "GET",
             build_url(self.endpoint, query_string),
             params=params,
-        ).prepare()
+        )
+        with httpx.Client() as client:
+            response = client.send(r)
+
         # now split up the URL
-        result = urlparse(r.url)
+        result = urlparse(str(response.url))
         # construct cache key
-        cachekey = result.path + "_" + result.query
+        cachekey = f"{result.path}_{result.query}"
         if self.templates.get(cachekey) and not self._updated(
             query_string, self.templates[cachekey], cachekey
         ):
@@ -132,7 +135,7 @@ def backoff_check(func):
         resp = func(self, *args, **kwargs)
         try:
             resp.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self, resp, exc)
         self.request = resp
         backoff = resp.headers.get("backoff") or resp.headers.get("retry-after")
@@ -166,8 +169,8 @@ def retrieve(func):
         self.links = self._extract_links()
         # determine content and format, based on url params
         content = (
-            self.content.search(self.request.url)
-            and self.content.search(self.request.url).group(0)
+            self.content.search(str(self.request.url))
+            and self.content.search(str(self.request.url)).group(0)
             or "bib"
         )
         # JSON by default
@@ -223,7 +226,7 @@ def retrieve(func):
                 file = retrieved.content
             return file
         # check to see whether it's tag data
-        if "tags" in self.request.url:
+        if "tags" in str(self.request.url):
             self.tag_data = False
             return self._tags_data(retrieved.json())
         if fmt == "atom":
@@ -277,6 +280,7 @@ class Zotero:
         locale="en-US",
         local=False,
     ):
+        self.client = None
         """Store Zotero credentials"""
         if not local:
             self.endpoint = "https://api.zotero.org"
@@ -300,6 +304,7 @@ class Zotero:
         self.tag_data = False
         self.request = None
         self.snapshot = False
+        self.client = httpx.Client(headers=self.default_headers())
         # these aren't valid item fields, so never send them to the server
         self.temp_keys = set(["key", "etag", "group_id", "updated"])
         # determine which processor to use for the parsed content
@@ -331,6 +336,11 @@ class Zotero:
         self.backoff = False
         self.backoff_duration = 0.0
 
+    def __del__(self):
+        # this isn't guaranteed to run, but that's OK
+        if c := self.client:
+            c.close()
+
     def _check_for_component(self, url, component):
         """Check a url path query fragment for a specific query parameter"""
         if parse_qs(url).get(component):
@@ -381,11 +391,11 @@ class Zotero:
         It's always OK to include these headers
         """
         _headers = {
-            "User-Agent": "Pyzotero/%s" % pz.__version__,
-            "Zotero-API-Version": "%s" % __api_version__,
+            "User-Agent": f"Pyzotero/{pz.__version__}",
+            "Zotero-API-Version": f"{__api_version__}",
         }
         if self.api_key:
-            _headers["Authorization"] = "Bearer %s" % self.api_key
+            _headers["Authorization"] = f"Bearer {self.api_key}"
         return _headers
 
     def _cache(self, response, key):
@@ -442,13 +452,17 @@ class Zotero:
                 params["locale"] = self.locale
             else:
                 params = {"locale": self.locale}
-        self.request = requests.get(
-            url=full_url, headers=self.default_headers(), params=params
-        )
+        # we now have to merge self.url_params (default params, and those supplied by the user)
+        if not params:
+            params = {}
+        if not self.url_params:
+            self.url_params = {}
+        merged_params = params | self.url_params
+        self.request = self.client.get(url=full_url, params=merged_params)
         self.request.encoding = "utf-8"
         try:
             self.request.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self, self.request, exc)
         backoff = self.request.headers.get("backoff") or self.request.headers.get(
             "retry-after"
@@ -465,7 +479,7 @@ class Zotero:
         try:
             for key, value in self.request.links.items():
                 parsed = urlparse(value["url"])
-                fragment = "{path}?{query}".format(path=parsed[2], query=parsed[4])
+                fragment = f"{parsed[2]}?{parsed[4]}"
                 extracted[key] = fragment
             # add a 'self' link
             parsed = list(urlparse(self.self_link))
@@ -510,13 +524,12 @@ class Zotero:
                     "%a, %d %b %Y %H:%M:%S %Z"
                 )
             }
-            headers.update(self.default_headers())
             # perform the request, and check whether the response returns 304
             self._check_backoff()
-            req = requests.get(query, headers=headers)
+            req = self.client.get(query, headers=headers)
             try:
                 req.raise_for_status()
-            except requests.exceptions.HTTPError as exc:
+            except httpx.HTTPError as exc:
                 error_handler(self, req, exc)
             backoff = self.request.headers.get("backoff") or self.request.headers.get(
                 "retry-after"
@@ -550,7 +563,7 @@ class Zotero:
         # bib format can't have a limit
         if params.get("format") == "bib":
             del params["limit"]
-        self.url_params = urlencode(params, doseq=True)
+        self.url_params = params
 
     def _build_query(self, query_string, no_params=False):
         """
@@ -560,12 +573,11 @@ class Zotero:
         try:
             query = quote(query_string.format(u=self.library_id, t=self.library_type))
         except KeyError as err:
-            raise ze.ParamNotPassed("There's a request parameter missing: %s" % err)
+            raise ze.ParamNotPassed(f"There's a request parameter missing: {err}")
         # Add the URL parameters and the user key, if necessary
         if no_params is False:
             if not self.url_params:
                 self.add_parameters()
-            query = "%s?%s" % (query, self.url_params)
         return query
 
     @retrieve
@@ -638,9 +650,9 @@ class Zotero:
         For text documents, 'indexedChars' and 'totalChars' OR
         For PDFs, 'indexedPages' and 'totalPages'.
         """
-        headers = self.default_headers()
+        headers = {}
         headers.update({"Content-Type": "application/json"})
-        return requests.put(
+        return self.client.put(
             url=build_url(
                 self.endpoint,
                 "/{t}/{u}/items/{k}/fulltext".format(
@@ -648,7 +660,7 @@ class Zotero:
                 ),
             ),
             headers=headers,
-            data=json.dumps(payload),
+            content=json.dumps(payload),
         )
 
     def new_fulltext(self, since):
@@ -656,15 +668,18 @@ class Zotero:
         Retrieve list of full-text content items and versions which are newer
         than <since>
         """
-        query_string = "/{t}/{u}/fulltext?since={version}".format(
-            t=self.library_type, u=self.library_id, version=since
+        query_string = "/{t}/{u}/fulltext".format(
+            t=self.library_type, u=self.library_id
         )
-        headers = self.default_headers()
+        headers = {}
+        params = {"since": since}
         self._check_backoff()
-        resp = requests.get(build_url(self.endpoint, query_string), headers=headers)
+        resp = self.client.get(
+            build_url(self.endpoint, query_string), params=params, headers=headers
+        )
         try:
             resp.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self, resp, exc)
         backoff = self.request.headers.get("backoff") or self.request.headers.get(
             "retry-after"
@@ -984,17 +999,17 @@ class Zotero:
     def item_template(self, itemtype, linkmode=None):
         """Get a template for a new item"""
         # if we have a template and it hasn't been updated since we stored it
-        template_name = "{}_{}_{}".format(*["item_template", itemtype, linkmode or ""])
-        query_string = "/items/new?itemType={i}".format(i=itemtype)
+        template_name = f"item_template_{itemtype}_{linkmode or ''}"
+        params = {"itemType": itemtype}
+        # Set linkMode parameter for API request if itemtype is attachment
+        if itemtype == "attachment":
+            params["linkMode"] = linkmode
+        self.add_parameters(**params)
+        query_string = "/items/new"
         if self.templates.get(template_name) and not self._updated(
             query_string, self.templates[template_name], template_name
         ):
             return copy.deepcopy(self.templates[template_name]["tmplt"])
-
-        # Set linkMode parameter for API request if itemtype is attachment
-        if itemtype == "attachment":
-            query_string = "{}&linkMode={}".format(query_string, linkmode)
-
         # otherwise perform a normal request and cache the response
         retrieved = self._retrieve_data(query_string)
         return self._cache(retrieved, template_name)
@@ -1050,20 +1065,19 @@ class Zotero:
         self.savedsearch._validate(conditions)
         payload = [{"name": name, "conditions": conditions}]
         headers = {"Zotero-Write-Token": token()}
-        headers.update(self.default_headers())
         self._check_backoff()
-        req = requests.post(
+        req = self.client.post(
             url=build_url(
                 self.endpoint,
                 "/{t}/{u}/searches".format(t=self.library_type, u=self.library_id),
             ),
             headers=headers,
-            data=json.dumps(payload),
+            content=json.dumps(payload),
         )
         self.request = req
         try:
             req.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self, req, exc)
         backoff = self.request.headers.get("backoff") or self.request.headers.get(
             "retry-after"
@@ -1078,9 +1092,8 @@ class Zotero:
         unique search keys
         """
         headers = {"Zotero-Write-Token": token()}
-        headers.update(self.default_headers())
         self._check_backoff()
-        req = requests.delete(
+        req = self.client.delete(
             url=build_url(
                 self.endpoint,
                 "/{t}/{u}/searches".format(t=self.library_type, u=self.library_id),
@@ -1091,7 +1104,7 @@ class Zotero:
         self.request = req
         try:
             req.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self, req, exc)
         backoff = self.request.headers.get("backoff") or self.request.headers.get(
             "retry-after"
@@ -1117,7 +1130,7 @@ class Zotero:
         except AssertionError:
             item["data"]["tags"] = list()
         for tag in tags:
-            item["data"]["tags"].append({"tag": "%s" % tag})
+            item["data"]["tags"].append({"tag": f"{tag}"})
         # make sure everything's OK
         assert self.check_items([item])
         return self.update_item(item)
@@ -1134,9 +1147,11 @@ class Zotero:
             "GET",
             build_url(self.endpoint, query_string),
             params=params,
-        ).prepare()
+        )
+        with httpx.Client() as client:
+            response = client.send(r)
         # now split up the URL
-        result = urlparse(r.url)
+        result = urlparse(str(response.url))
         # construct cache key
         cachekey = result.path + "_" + result.query
         if self.templates.get(cachekey) and not self._updated(
@@ -1189,8 +1204,7 @@ class Zotero:
             difference = to_check.difference(template)
             if difference:
                 raise ze.InvalidItemFields(
-                    "Invalid keys present in item %s: %s"
-                    % (pos + 1, " ".join(i for i in difference))
+                    f"Invalid keys present in item {pos + 1}: {' '.join(i for i in difference)}"
                 )
         return items
 
@@ -1254,20 +1268,19 @@ class Zotero:
         if last_modified is not None:
             headers["If-Unmodified-Since-Version"] = str(last_modified)
         to_send = json.dumps([i for i in self._cleanup(*payload, allow=("key"))])
-        headers.update(self.default_headers())
         self._check_backoff()
-        req = requests.post(
+        req = self.client.post(
             url=build_url(
                 self.endpoint,
                 "/{t}/{u}/items".format(t=self.library_type, u=self.library_id),
             ),
-            data=to_send,
+            content=to_send,
             headers=dict(headers),
         )
         self.request = req
         try:
             req.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self, req, exc)
         resp = req.json()
         backoff = self.request.headers.get("backoff") or self.request.headers.get(
@@ -1282,24 +1295,23 @@ class Zotero:
             uheaders = {
                 "If-Unmodified-Since-Version": req.headers["last-modified-version"]
             }
-            uheaders.update(self.default_headers())
             for value in resp["success"].values():
                 payload = json.dumps({"parentItem": parentid})
                 self._check_backoff()
-                presp = requests.patch(
+                presp = self.client.patch(
                     url=build_url(
                         self.endpoint,
                         "/{t}/{u}/items/{v}".format(
                             t=self.library_type, u=self.library_id, v=value
                         ),
                     ),
-                    data=payload,
+                    content=payload,
                     headers=dict(uheaders),
                 )
                 self.request = presp
                 try:
                     presp.raise_for_status()
-                except requests.exceptions.HTTPError as exc:
+                except httpx.HTTPError as exc:
                     error_handler(self, presp, exc)
                 backoff = presp.headers.get("backoff") or presp.headers.get(
                     "retry-after"
@@ -1330,20 +1342,19 @@ class Zotero:
         headers = {"Zotero-Write-Token": token()}
         if last_modified is not None:
             headers["If-Unmodified-Since-Version"] = str(last_modified)
-        headers.update(self.default_headers())
         self._check_backoff()
-        req = requests.post(
+        req = self.client.post(
             url=build_url(
                 self.endpoint,
                 "/{t}/{u}/collections".format(t=self.library_type, u=self.library_id),
             ),
             headers=headers,
-            data=json.dumps(payload),
+            content=json.dumps(payload),
         )
         self.request = req
         try:
             req.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self, req, exc)
         backoff = req.headers.get("backoff") or req.headers.get("retry-after")
         if backoff:
@@ -1362,9 +1373,8 @@ class Zotero:
             modified = last_modified
         key = payload["key"]
         headers = {"If-Unmodified-Since-Version": str(modified)}
-        headers.update(self.default_headers())
         headers.update({"Content-Type": "application/json"})
-        return requests.put(
+        return self.client.put(
             url=build_url(
                 self.endpoint,
                 "/{t}/{u}/collections/{c}".format(
@@ -1372,7 +1382,7 @@ class Zotero:
                 ),
             ),
             headers=headers,
-            data=json.dumps(payload),
+            content=json.dumps(payload),
         )
 
     def attachment_simple(self, files, parentid=None):
@@ -1422,8 +1432,7 @@ class Zotero:
             modified = last_modified
         ident = payload["key"]
         headers = {"If-Unmodified-Since-Version": str(modified)}
-        headers.update(self.default_headers())
-        return requests.patch(
+        return self.client.patch(
             url=build_url(
                 self.endpoint,
                 "/{t}/{u}/items/{id}".format(
@@ -1431,7 +1440,7 @@ class Zotero:
                 ),
             ),
             headers=headers,
-            data=json.dumps(to_send),
+            content=json.dumps(to_send),
         )
 
     def update_items(self, payload):
@@ -1440,24 +1449,21 @@ class Zotero:
         Accepts one argument, a list of dicts containing Item data
         """
         to_send = [self.check_items([p])[0] for p in payload]
-        headers = {}
-        headers.update(self.default_headers())
         # the API only accepts 50 items at a time, so we have to split
         # anything longer
         for chunk in chunks(to_send, 50):
             self._check_backoff()
-            req = requests.post(
+            req = self.client.post(
                 url=build_url(
                     self.endpoint,
                     "/{t}/{u}/items/".format(t=self.library_type, u=self.library_id),
                 ),
-                headers=headers,
-                data=json.dumps(chunk),
+                content=json.dumps(chunk),
             )
             self.request = req
             try:
                 req.raise_for_status()
-            except requests.exceptions.HTTPError as exc:
+            except httpx.HTTPError as exc:
                 error_handler(self, req, exc)
             backoff = req.headers.get("backoff") or req.headers.get("retry-after")
             if backoff:
@@ -1470,26 +1476,23 @@ class Zotero:
         Accepts one argument, a list of dicts containing Collection data
         """
         to_send = [self.check_items([p])[0] for p in payload]
-        headers = {}
-        headers.update(self.default_headers())
         # the API only accepts 50 items at a time, so we have to split
         # anything longer
         for chunk in chunks(to_send, 50):
             self._check_backoff()
-            req = requests.post(
+            req = self.client.post(
                 url=build_url(
                     self.endpoint,
                     "/{t}/{u}/collections/".format(
                         t=self.library_type, u=self.library_id
                     ),
                 ),
-                headers=headers,
-                data=json.dumps(chunk),
+                content=json.dumps(chunk),
             )
             self.request = req
             try:
                 req.raise_for_status()
-            except requests.exceptions.HTTPError as exc:
+            except httpx.HTTPError as exc:
                 error_handler(self, req, exc)
             backoff = req.headers.get("backoff") or req.headers.get("retry-after")
             if backoff:
@@ -1508,15 +1511,14 @@ class Zotero:
         # add the collection data from the item
         modified_collections = payload["data"]["collections"] + [collection]
         headers = {"If-Unmodified-Since-Version": str(modified)}
-        headers.update(self.default_headers())
-        return requests.patch(
+        return self.client.patch(
             url=build_url(
                 self.endpoint,
                 "/{t}/{u}/items/{i}".format(
                     t=self.library_type, u=self.library_id, i=ident
                 ),
             ),
-            data=json.dumps({"collections": modified_collections}),
+            content=json.dumps({"collections": modified_collections}),
             headers=headers,
         )
 
@@ -1534,15 +1536,14 @@ class Zotero:
             c for c in payload["data"]["collections"] if c != collection
         ]
         headers = {"If-Unmodified-Since-Version": str(modified)}
-        headers.update(self.default_headers())
-        return requests.patch(
+        return self.client.patch(
             url=build_url(
                 self.endpoint,
                 "/{t}/{u}/items/{i}".format(
                     t=self.library_type, u=self.library_id, i=ident
                 ),
             ),
-            data=json.dumps({"collections": modified_collections}),
+            content=json.dumps({"collections": modified_collections}),
             headers=headers,
         )
 
@@ -1561,8 +1562,7 @@ class Zotero:
         headers = {
             "If-Unmodified-Since-Version": self.request.headers["last-modified-version"]
         }
-        headers.update(self.default_headers())
-        return requests.delete(
+        return self.client.delete(
             url=build_url(
                 self.endpoint,
                 "/{t}/{u}/tags".format(t=self.library_type, u=self.library_id),
@@ -1603,8 +1603,7 @@ class Zotero:
                 ),
             )
         headers = {"If-Unmodified-Since-Version": str(modified)}
-        headers.update(self.default_headers())
-        return requests.delete(url=url, params=params, headers=headers)
+        return self.client.delete(url=url, params=params, headers=headers)
 
     @backoff_check
     def delete_collection(self, payload, last_modified=None):
@@ -1638,8 +1637,7 @@ class Zotero:
                 ),
             )
         headers = {"If-Unmodified-Since-Version": str(modified)}
-        headers.update(self.default_headers())
-        return requests.delete(url=url, params=params, headers=headers)
+        return self.client.delete(url=url, params=params, headers=headers)
 
 
 def error_handler(zot, req, exc=None):
@@ -1658,13 +1656,7 @@ def error_handler(zot, req, exc=None):
 
     def err_msg(req):
         """Return a nicely-formatted error message"""
-        return "\nCode: %s\nURL: %s\nMethod: %s\nResponse: %s" % (
-            req.status_code,
-            # error.msg,
-            req.url,
-            req.request.method,
-            req.text,
-        )
+        return f"\nCode: {req.status_code}\nURL: {str(req.url)}\nMethod: {req.request.method}\nResponse: {req.text}"
 
     if error_codes.get(req.status_code):
         # check to see whether its 429
@@ -1833,12 +1825,11 @@ class SavedSearch:
         for condition in conditions:
             if set(condition.keys()) != allowed_keys:
                 raise ze.ParamNotPassed(
-                    "Keys must be all of: %s" % ", ".join(self.searchkeys)
+                    f"Keys must be all of: {', '.join(self.searchkeys)}"
                 )
             if condition.get("operator") not in operators_set:
                 raise ze.ParamNotPassed(
-                    "You have specified an unknown operator: %s"
-                    % condition.get("operator")
+                    f"You have specified an unknown operator: {condition.get('operator')}"
                 )
             # dict keys of allowed operators for the current condition
             permitted_operators = self.conditions_operators.get(
@@ -1850,12 +1841,7 @@ class SavedSearch:
             )
             if condition.get("operator") not in permitted_operators_list:
                 raise ze.ParamNotPassed(
-                    "You may not use the '%s' operator when selecting the '%s' condition. \nAllowed operators: %s"
-                    % (
-                        condition.get("operator"),
-                        condition.get("condition"),
-                        ", ".join(list(permitted_operators_list)),
-                    )
+                    f"You may not use the '{condition.get('operator')}' operator when selecting the '{condition.get('condition')}' condition. \nAllowed operators: {', '.join(list(permitted_operators_list))}"
                 )
 
 
@@ -1893,14 +1879,12 @@ class Zupload:
                         pass
                 except IOError:
                     raise ze.FileDoesNotExist(
-                        "The file at %s couldn't be opened or found."
-                        % str(self.basedir.joinpath(templt["filename"]))
+                        f"The file at {str(self.basedir.joinpath(templt['filename']))} couldn't be opened or found."
                     )
             # no point in continuing if the file isn't a file
             else:
                 raise ze.FileDoesNotExist(
-                    "The file at %s couldn't be opened or found."
-                    % str(self.basedir.joinpath(templt["filename"]))
+                    f"The file at {str(self.basedir.joinpath(templt['filename']))} couldn't be opened or found."
                 )
 
     def _create_prelim(self):
@@ -1917,26 +1901,25 @@ class Zupload:
         liblevel = "/{t}/{u}/items"
         # Create one or more new attachments
         headers = {"Zotero-Write-Token": token(), "Content-Type": "application/json"}
-        headers.update(self.zinstance.default_headers())
         # If we have a Parent ID, add it as a parentItem
         if self.parentid:
             for child in self.payload:
                 child["parentItem"] = self.parentid
         to_send = json.dumps(self.payload)
         self.zinstance._check_backoff()
-        req = requests.post(
+        req = self.client.post(
             url=build_url(
                 self.zinstance.endpoint,
                 liblevel.format(
                     t=self.zinstance.library_type, u=self.zinstance.library_id
                 ),
             ),
-            data=to_send,
+            content=to_send,
             headers=headers,
         )
         try:
             req.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self.zinstance, req, exc)
         backoff = req.headers.get("backoff") or req.headers.get("retry-after")
         if backoff:
@@ -1961,7 +1944,6 @@ class Zupload:
         else:
             # docs specify that for existing file we use this
             auth_headers["If-Match"] = md5
-        auth_headers.update(self.zinstance.default_headers())
         data = {
             "md5": digest.hexdigest(),
             "filename": os.path.basename(attachment),
@@ -1972,7 +1954,7 @@ class Zupload:
             "params": 1,
         }
         self.zinstance._check_backoff()
-        auth_req = requests.post(
+        auth_req = self.zinstance.client.post(
             url=build_url(
                 self.zinstance.endpoint,
                 "/{t}/{u}/items/{i}/file".format(
@@ -1981,12 +1963,12 @@ class Zupload:
                     i=reg_key,
                 ),
             ),
-            data=data,
+            content=data,
             headers=auth_headers,
         )
         try:
             auth_req.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self.zinstance, auth_req, exc)
         backoff = auth_req.headers.get("backoff") or auth_req.headers.get("retry-after")
         if backoff:
@@ -2009,16 +1991,16 @@ class Zupload:
         upload_pairs = tuple(upload_list)
         try:
             self.zinstance._check_backoff()
-            upload = requests.post(
+            upload = self.client.post(
                 url=authdata["url"],
                 files=upload_pairs,
-                headers={"User-Agent": "Pyzotero/%s" % pz.__version__},
+                headers={"User-Agent": f"Pyzotero/{pz.__version__}"},
             )
-        except requests.exceptions.ConnectionError:
+        except httpx.ConnectionError:
             raise ze.UploadError("ConnectionError")
         try:
             upload.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self.zinstance, upload, exc)
         backoff = upload.headers.get("backoff") or upload.headers.get("retry-after")
         if backoff:
@@ -2034,10 +2016,9 @@ class Zupload:
             "Content-Type": "application/x-www-form-urlencoded",
             "If-None-Match": "*",
         }
-        reg_headers.update(self.zinstance.default_headers())
         reg_data = {"upload": authdata.get("uploadKey")}
         self.zinstance._check_backoff()
-        upload_reg = requests.post(
+        upload_reg = self.zinstane.client.post(
             url=build_url(
                 self.zinstance.endpoint,
                 "/{t}/{u}/items/{i}/file".format(
@@ -2046,12 +2027,12 @@ class Zupload:
                     i=reg_key,
                 ),
             ),
-            data=reg_data,
+            content=reg_data,
             headers=dict(reg_headers),
         )
         try:
             upload_reg.raise_for_status()
-        except requests.exceptions.HTTPError as exc:
+        except httpx.HTTPError as exc:
             error_handler(self.zinstance, upload_reg, exc)
         backoff = upload_reg.headers.get("backoff") or upload_reg.headers.get(
             "retry-after"

{pyzotero-1.6.1.dist-info → pyzotero-1.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyzotero
-Version: 1.6.1
+Version: 1.6.2
 Summary: Python wrapper for the Zotero API
 Author-email: Stephan Hügel <urschrei@gmail.com>
 License: # Blue Oak Model License
@@ -61,12 +61,13 @@ License-File: LICENSE.md
 License-File: AUTHORS
 Requires-Dist: feedparser>=6.0.11
 Requires-Dist: pytz
-Requires-Dist: requests>=2.21.0
 Requires-Dist: bibtexparser
+Requires-Dist: httpx>=0.28.1
 Provides-Extra: test
 Requires-Dist: pytest>=7.4.2; extra == "test"
 Requires-Dist: httpretty; extra == "test"
 Requires-Dist: python-dateutil; extra == "test"
+Requires-Dist: ipython; extra == "test"
 
 [![Supported Python versions](https://img.shields.io/pypi/pyversions/Pyzotero.svg?style=flat)](https://pypi.python.org/pypi/Pyzotero/) [![Docs](https://readthedocs.org/projects/pyzotero/badge/?version=latest)](http://pyzotero.readthedocs.org/en/latest/?badge=latest) [![PyPI Version](https://img.shields.io/pypi/v/Pyzotero.svg)](https://pypi.python.org/pypi/Pyzotero) [![Anaconda-Server Badge](https://anaconda.org/conda-forge/pyzotero/badges/version.svg)](https://anaconda.org/conda-forge/pyzotero) [![Downloads](https://pepy.tech/badge/pyzotero)](https://pepy.tech/project/pyzotero)  
 
@@ -86,7 +87,7 @@ Then:
 
 ``` python
 from pyzotero import zotero
-zot = zotero.Zotero(library_id, library_type, api_key)
+zot = zotero.Zotero(library_id, library_type, api_key) # local=True for read access to local Zotero
 items = zot.top(limit=5)
 # we've retrieved the latest five top-level items in our library
 # we can print each item's item type and ID
@@ -109,7 +110,7 @@ Example:
 ``` bash
 git clone git://github.com/urschrei/pyzotero.git
 cd pyzotero
-git checkout dev
+git checkout main
 pip install .
 ```
 
@@ -119,7 +120,7 @@ Run `pytest .` from the top-level directory.
 
 ## Issues
 
-The latest commits can be found on the [dev branch][9], although new features are currently rare. If you encounter an error, please open an issue.
+The latest commits can be found on the [main branch][9], although new features are currently rare. If you encounter an error, please open an issue.
 
 ## Pull Requests
 
@@ -145,14 +146,14 @@ A sample citation (APA 6th edition) might look like:
 
 # License
 
-Pyzotero is licensed under the [Blue Oak Model Licence 1.0.0][8]. See [LICENCE.md](LICENCE.md) for details.  
+Pyzotero is licensed under the [Blue Oak Model Licence 1.0.0][8]. See [LICENSE.md](LICENSE.md) for details.  
 
 [1]: https://www.zotero.org/support/dev/web_api/v3/start
 [2]: https://www.zotero.org/settings/keys/new
 [3]: http://pyzotero.readthedocs.org/en/latest/
 [7]: https://nose2.readthedocs.io/en/latest/
 [8]: https://opensource.org/license/blue-oak-model-license
-[9]: https://github.com/urschrei/pyzotero/tree/dev
+[9]: https://github.com/urschrei/pyzotero/tree/main
 [10]: http://www.pip-installer.org/en/latest/index.html
 † This isn't strictly true: you only need an API key for personal libraries and non-public group libraries.
 

pyzotero-1.6.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+_version.py,sha256=ay9A4GSmtr3NioHirRgXvWfXtjwRjzXIO_WPuFobCoI,411
+pyzotero/__init__.py,sha256=5QI4Jou9L-YJAf_oN9TgRXVKgt_Unc39oADo2Ch8bLI,243
+pyzotero/zotero.py,sha256=jnfqgwbn2nMxUnUNG98dm--AlE6CaLyJCuOizXOvJz4,75376
+pyzotero/zotero_errors.py,sha256=UPhAmf2K05cnoeIl2wjufWQedepg7vBKb-ShU0TdlL4,2582
+pyzotero-1.6.2.dist-info/AUTHORS,sha256=ZMicxg7lRScOYbxzMPznlzMbmrFIUIHwg-NvljEMbRQ,110
+pyzotero-1.6.2.dist-info/LICENSE.md,sha256=bhy1CPMj1zWffD9YifFmSeBzPylsrhb1qP8OCEx5Etw,1550
+pyzotero-1.6.2.dist-info/METADATA,sha256=aFEP8H1c0A7W75pQO_qBh6HNNcqDmnlRZ47llubffwc,7289
+pyzotero-1.6.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pyzotero-1.6.2.dist-info/top_level.txt,sha256=BOPNkPk5VtNDCy_li7Xftx6k0zG8STGxh-KgckcxLEw,18
+pyzotero-1.6.2.dist-info/RECORD,,

pyzotero-1.6.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-_version.py,sha256=edFVVa8HpVPfLqL2y6CKtViSqJREfmXxInA-HCy-134,411
-pyzotero/__init__.py,sha256=5QI4Jou9L-YJAf_oN9TgRXVKgt_Unc39oADo2Ch8bLI,243
-pyzotero/zotero.py,sha256=Qk3vuJxv4rbD_Q0sg_8nc8QXVAboJ9_eZWrLuJLkW_4,76313
-pyzotero/zotero_errors.py,sha256=UPhAmf2K05cnoeIl2wjufWQedepg7vBKb-ShU0TdlL4,2582
-pyzotero-1.6.1.dist-info/AUTHORS,sha256=ZMicxg7lRScOYbxzMPznlzMbmrFIUIHwg-NvljEMbRQ,110
-pyzotero-1.6.1.dist-info/LICENSE.md,sha256=bhy1CPMj1zWffD9YifFmSeBzPylsrhb1qP8OCEx5Etw,1550
-pyzotero-1.6.1.dist-info/METADATA,sha256=TCxweUVtZbjMDFDrFtZMDzKCFm4j8VMNkwzbJ2kJUZ0,7204
-pyzotero-1.6.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pyzotero-1.6.1.dist-info/top_level.txt,sha256=BOPNkPk5VtNDCy_li7Xftx6k0zG8STGxh-KgckcxLEw,18
-pyzotero-1.6.1.dist-info/RECORD,,