python-documentcloud 4.1.3__tar.gz → 4.3.0__tar.gz

{python-documentcloud-4.1.3 → python_documentcloud-4.3.0}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.1
 Name: python-documentcloud
-Version: 4.1.3
+Version: 4.3.0
 Summary: A simple Python wrapper for the DocumentCloud API
 Home-page: https://github.com/muckrock/python-documentcloud
 Author: Mitchell Kotler
 Author-email: mitch@muckrock.com
 License: MIT
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -19,9 +18,28 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: future
+Requires-Dist: listcrunch>=1.0.1
+Requires-Dist: python-dateutil
+Requires-Dist: ratelimit
+Requires-Dist: requests
+Requires-Dist: urllib3
+Requires-Dist: pyyaml
+Requires-Dist: fastjsonschema
+Requires-Dist: python-squarelet
 Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: twine; extra == "dev"
 Provides-Extra: test
-License-File: LICENSE
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: pytest-recording; extra == "test"
+Requires-Dist: vcrpy; extra == "test"
 
 <pre><code>  ____                                        _    ____ _                 _
  |  _ \  ___   ___ _   _ _ __ ___   ___ _ __ | |_ / ___| | ___  _   _  __| |
@@ -48,5 +66,3 @@ Installation is as easy as...
 ```bash
 $ pip install python-documentcloud
 ```
-
-

python_documentcloud-4.3.0/documentcloud/client.py

@@ -0,0 +1,62 @@
+# Import SquareletClient from python-squarelet
+# Standard Library
+import logging
+
+# Third Party
+from squarelet import SquareletClient
+
+# Local
+# Local Imports
+from .documents import DocumentClient
+from .organizations import OrganizationClient
+from .projects import ProjectClient
+from .users import UserClient
+
+logger = logging.getLogger("documentcloud")
+
+class DocumentCloud(SquareletClient):
+    """
+    The public interface for the DocumentCloud API, now integrated with SquareletClient
+    """
+    # pylint:disable=too-many-positional-arguments
+    def __init__(
+        self,
+        username=None,
+        password=None,
+        base_uri="https://api.www.documentcloud.org/api/",
+        auth_uri="https://accounts.muckrock.com/api/",
+        timeout=20,
+        loglevel=None,
+        rate_limit=True,
+        rate_limit_sleep=True,
+    ):
+       # Initialize SquareletClient for authentication and request handling
+        super().__init__(
+            base_uri=base_uri,
+            username=username,
+            password=password,
+            auth_uri=auth_uri,
+            timeout=timeout,
+            rate_limit=rate_limit,
+            rate_limit_sleep=rate_limit_sleep
+        )
+
+        # Set up logging
+        if loglevel:
+            logging.basicConfig(
+                level=loglevel,
+                format="%(asctime)s %(levelname)-8s %(name)-25s %(message)s",
+            )
+        else:
+            logger.addHandler(logging.NullHandler())
+
+        # Initialize the sub-clients using SquareletClient
+        self.documents = DocumentClient(self)
+        self.projects = ProjectClient(self)
+        self.users = UserClient(self)
+        self.organizations = OrganizationClient(self)
+
+    """def _request(self, method, url, raise_error=True, **kwargs):
+        Delegates request to the SquareletClient's _request method
+        return self.squarelet_client.request(method, url, raise_error, **kwargs)
+        """

{python-documentcloud-4.1.3 → python_documentcloud-4.3.0}/documentcloud/constants.py

@@ -8,7 +8,7 @@ RATE_PERIOD = 1
 SUPPORTED_EXTENSIONS = [
     ".abw",
     ".zabw",
-    ".md",
+    ".pmd",
     ".pm3",
     ".pm4",
     ".pm5",
@@ -51,11 +51,16 @@ SUPPORTED_EXTENSIONS = [
     ".wk4",
     ".pct",
     ".mml",
+    ".xml",
+    ".xls",
+    ".xlw",
+    ".xlt",
     ".xls",
     ".xlw",
     ".xlt",
     ".xlsx",
     ".docx",
+    ".xlsx",
     ".pptx",
     ".ppt",
     ".pps",
@@ -97,5 +102,41 @@ SUPPORTED_EXTENSIONS = [
     ".pcx",
     ".pcd",
     ".psd",
+    ".txt",
     ".pdf",
+    ".png",
+    ".qxp",
+    ".wb2",
+    ".wq1",
+    ".wq2",
+    ".svg",
+    ".sgv",
+    ".602",
+    ".txt",
+    ".sdc",
+    ".vor",
+    ".sda",
+    ".sdd",
+    ".sdp",
+    ".vor",
+    ".sdw",
+    ".sgl",
+    ".vor",
+    ".sgf",
+    ".rlf",
+    ".ras",
+    ".svm",
+    ".slk",
+    ".tif",
+    ".tiff",
+    ".tga",
+    ".uof",
+    ".uot",
+    ".uos",
+    ".uop",
+    ".wpd",
+    ".wps",
+    ".xbm",
+    ".xpm",
+    ".zmf",
 ]

python_documentcloud-4.3.0/documentcloud/exceptions.py

@@ -0,0 +1,12 @@
+"""
+Custom exceptions for python-documentcloud
+"""
+
+# pylint: disable=unused-import
+# Import exceptions from python-squarelet
+from squarelet.exceptions import SquareletError as DocumentCloudError
+from squarelet.exceptions import DuplicateObjectError
+from squarelet.exceptions import CredentialsFailedError
+from squarelet.exceptions import APIError
+from squarelet.exceptions import DoesNotExistError
+from squarelet.exceptions import MultipleObjectsReturnedError

{python-documentcloud-4.1.3 → python_documentcloud-4.3.0}/python_documentcloud.egg-info/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.1
 Name: python-documentcloud
-Version: 4.1.3
+Version: 4.3.0
 Summary: A simple Python wrapper for the DocumentCloud API
 Home-page: https://github.com/muckrock/python-documentcloud
 Author: Mitchell Kotler
 Author-email: mitch@muckrock.com
 License: MIT
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -19,9 +18,28 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: future
+Requires-Dist: listcrunch>=1.0.1
+Requires-Dist: python-dateutil
+Requires-Dist: ratelimit
+Requires-Dist: requests
+Requires-Dist: urllib3
+Requires-Dist: pyyaml
+Requires-Dist: fastjsonschema
+Requires-Dist: python-squarelet
 Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: twine; extra == "dev"
 Provides-Extra: test
-License-File: LICENSE
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: pytest-recording; extra == "test"
+Requires-Dist: vcrpy; extra == "test"
 
 <pre><code>  ____                                        _    ____ _                 _
  |  _ \  ___   ___ _   _ _ __ ___   ___ _ __ | |_ / ___| | ___  _   _  __| |
@@ -48,5 +66,3 @@ Installation is as easy as...
 ```bash
 $ pip install python-documentcloud
 ```
-
-

{python-documentcloud-4.1.3 → python_documentcloud-4.3.0}/python_documentcloud.egg-info/SOURCES.txt

@@ -19,4 +19,13 @@ python_documentcloud.egg-info/PKG-INFO
 python_documentcloud.egg-info/SOURCES.txt
 python_documentcloud.egg-info/dependency_links.txt
 python_documentcloud.egg-info/requires.txt
-python_documentcloud.egg-info/top_level.txt
+python_documentcloud.egg-info/top_level.txt
+tests/test_annotations.py
+tests/test_base.py
+tests/test_client.py
+tests/test_documents.py
+tests/test_organizations.py
+tests/test_projects.py
+tests/test_sections.py
+tests/test_toolbox.py
+tests/test_users.py

{python-documentcloud-4.1.3 → python_documentcloud-4.3.0}/python_documentcloud.egg-info/requires.txt

@@ -1,11 +1,12 @@
-fastjsonschema
 future
 listcrunch>=1.0.1
 python-dateutil
-pyyaml
 ratelimit
 requests
 urllib3
+pyyaml
+fastjsonschema
+python-squarelet
 
 [dev]
 black

{python-documentcloud-4.1.3 → python_documentcloud-4.3.0}/setup.py

@@ -7,7 +7,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="python-documentcloud",
-    version="4.1.3",
+    version="4.3.0",
     description="A simple Python wrapper for the DocumentCloud API",
     author="Mitchell Kotler",
     author_email="mitch@muckrock.com",
@@ -26,6 +26,7 @@ setup(
         "urllib3",
         "pyyaml",
         "fastjsonschema",
+        "python-squarelet",
     ),
     extras_require={
         "dev": [

python_documentcloud-4.3.0/tests/test_annotations.py

@@ -0,0 +1,50 @@
+# Future
+from __future__ import division, print_function, unicode_literals
+
+# Standard Library
+from builtins import str
+
+# Third Party
+import pytest
+
+# DocumentCloud
+from documentcloud.annotations import Annotation
+
+
+class TestAnnotation:
+    def test_create_delete(self, document):
+        assert len(document.notes.list().results) == 1
+        note = document.notes.create(
+            "Test Note", 0, "<p>Note content!</p>", x1=0.1, y1=0.1, x2=0.2, y2=0.2
+        )
+        assert len(document.notes.list().results) == 2
+        for note in document.notes:
+            assert isinstance(note, Annotation)
+        note.delete()
+        assert len(document.notes.list().results) == 1
+
+    def test_create_page_note(self, document):
+        note = document.notes.create("Test Note", 0, "<p>Page note!</p>")
+        assert note
+        note.delete()
+
+    def test_create_partial_coords(self, document):
+        with pytest.raises(ValueError):
+            document.notes.create("Test Note", 0, "<p>Page note!</p>", x1=0.5)
+
+    def test_create_invalid_coords(self, document):
+        with pytest.raises(ValueError):
+            document.notes.create(
+                "Test Note", 0, "<p>Page note!</p>", x1=0.5, y1=1.5, x2=2, y2=3
+            )
+
+    def test_str(self, document):
+        assert str(document.notes[0])
+
+    def test_alias(self, document):
+        assert document.notes is document.annotations
+
+    def test_location(self, document):
+        note = document.notes[0]
+        assert note.location.top < note.location.bottom
+        assert note.location.left < note.location.right

python_documentcloud-4.3.0/tests/test_base.py

@@ -0,0 +1,114 @@
+# Future
+from __future__ import division, print_function, unicode_literals
+
+# Standard Library
+from builtins import str
+
+# Third Party
+import pytest
+
+# DocumentCloud
+from documentcloud.documents import Document
+from documentcloud.exceptions import DuplicateObjectError
+
+
+class TestAPIResults:
+    def test_str(self, client):
+        results = client.documents.list()
+        assert str(results)
+
+    def test_getitem(self, client):
+        results = client.documents.list()
+        assert isinstance(results[0], Document)
+
+    def test_getitem_paginate(self, client):
+        results = client.documents.list(per_page=2)
+        assert isinstance(results[3], Document)
+
+    def test_getitem_index_error(self, client):
+        # pylint: disable=pointless-statement
+        results = client.documents.list()
+        index = len(list(results)) + 1
+        with pytest.raises(IndexError):
+            results[index]
+
+    def test_len(self, client):
+        results = client.documents.list()
+        assert len(results.results) > 0
+
+    def test_iter(self, client):
+        results = client.documents.list()
+        for doc in results:
+            assert isinstance(doc, Document)
+
+    def test_next(self, client):
+        results = client.documents.list(user=client.user_id, per_page=1)
+        assert len(results.results) > 0
+        while results.next is not None:
+            results = results.next
+
+    def test_previous(self, client):
+        results = client.documents.list(user=client.user_id, per_page=1).next
+        assert results.previous
+        assert results.previous.previous is None
+
+
+class TestAPISet:
+    def test_init(self, project_factory, document):
+        project = project_factory()
+        document_list = project.document_list
+        project.document_list = [document]
+        project.document_list = document_list
+
+    def test_init_bad_types(self, project):
+        with pytest.raises(TypeError):
+            project.document_list = [1, 2, 3]
+
+    def test_init_dupes(self, project, document):
+        with pytest.raises(DuplicateObjectError):
+            project.document_list = [document, document]
+
+    def test_append(self, project, document_factory):
+        document = document_factory()
+        project.document_list.append(document)
+        assert project.document_list[-1] == document
+        project.document_list.remove(document)
+
+    def test_append_bad_type(self, project):
+        with pytest.raises(TypeError):
+            project.document_list.append(1)
+
+    def test_append_dupes(self, project, document):
+        with pytest.raises(DuplicateObjectError):
+            project.document_list.append(document)
+
+    def test_add(self, project, document_factory):
+        document = document_factory()
+        project.document_list.add(document)
+        assert document in project.document_list
+        project.document_list.remove(document)
+
+    def test_add_bad_type(self, project):
+        with pytest.raises(TypeError):
+            project.document_list.add(1)
+
+    def test_add_dupe(self, project, document):
+        assert document in project.document_list
+        length = len(project.document_list)
+        project.document_list.add(document)
+        assert document in project.document_list
+        assert len(project.document_list) == length
+
+    def test_extend(self, project, document_factory):
+        document = document_factory()
+        project.document_list.extend([document])
+        assert document == project.document_list[-1]
+        project.document_list.remove(document)
+
+    def test_extend_bad_type(self, project):
+        with pytest.raises(TypeError):
+            project.document_list.extend([1])
+
+    def test_extend_dupe(self, project, document):
+        with pytest.raises(DuplicateObjectError):
+            project.document_list.extend([document])

python_documentcloud-4.3.0/tests/test_client.py

@@ -0,0 +1,113 @@
+# Future
+from __future__ import division, print_function, unicode_literals
+
+# Standard Library
+import time
+
+# Third Party
+import pytest
+import ratelimit
+
+# DocumentCloud
+from documentcloud.constants import RATE_LIMIT
+from documentcloud.exceptions import APIError, CredentialsFailedError
+
+# pylint: disable=protected-access
+
+
+def test_set_tokens_credentials(client):
+    """Test setting the tokens using credentials"""
+    client.refresh_token = None
+    del client.session.headers["Authorization"]
+    client._set_tokens()
+    assert client.refresh_token
+    assert "Authorization" in client.session.headers
+
+
+def test_set_tokens_refresh(client):
+    """Test setting the tokens using refresh token"""
+    # first set tokens sets, refresh token, second one uses it
+    client.refresh_token = None
+    del client.session.headers["Authorization"]
+    client._set_tokens()
+    client._set_tokens()
+    assert client.refresh_token
+    assert "Authorization" in client.session.headers
+
+
+def test_set_tokens_none(public_client):
+    """Test setting the tokens with no credentials"""
+    public_client._set_tokens()
+    assert public_client.refresh_token is None
+    assert "Authorization" not in public_client.session.headers
+
+
+def test_get_tokens(client):
+    """Test getting access and refresh tokens using valid credentials"""
+    access, refresh = client._get_tokens(client.username, client.password)
+    assert access
+    assert refresh
+
+
+def test_get_tokens_bad_credentials(client):
+    """Test getting access and refresh tokens using invalid credentials"""
+    with pytest.raises(CredentialsFailedError):
+        client._get_tokens(client.username, "foo")
+
+
+def test_refresh_tokens(client):
+    """Test refreshing the tokens"""
+    access, refresh = client._refresh_tokens(client.refresh_token)
+    assert access
+    assert refresh
+
+
+def test_user_id(client):
+    assert client.user_id
+
+
+def test_user_id_public(public_client):
+    # pylint: disable=pointless-statement
+    with pytest.raises(APIError, match=r"404"):
+        public_client.user_id
+
+
+def test_bad_attr(client):
+    with pytest.raises(AttributeError):
+        assert client.foo
+
+
+def test_rate_limit(rate_client):
+    with pytest.raises(ratelimit.RateLimitException):
+        for _ in range(RATE_LIMIT * 2):
+            rate_client.users.get("me")
+
+
+@pytest.mark.short
+@pytest.mark.vcr(cassette_library_dir="tests/cassettes/short_fixtures")
+def test_expired_access_token(short_client, record_mode):
+    # get fresh tokens
+    short_client._set_tokens()
+    old_refresh_token = short_client.refresh_token
+    # wait for the access token to expire
+    if record_mode == "all":
+        time.sleep(3)
+    # make a request
+    assert short_client.users.get("me")
+    # check the refresh token was updated
+    assert old_refresh_token != short_client.refresh_token
+
+
+@pytest.mark.short
+@pytest.mark.vcr(cassette_library_dir="tests/cassettes/short_fixtures")
+def test_expired_refresh_token(short_client, record_mode):
+    # get fresh tokens
+    short_client._set_tokens()
+    old_refresh_token = short_client.refresh_token
+    # wait for the access and refresh tokens to expire
+    if record_mode == "all":
+        time.sleep(6)
+    # make a request
+    assert short_client.users.get("me")
+    # check the refresh token was updated
+    assert old_refresh_token != short_client.refresh_token

python_documentcloud-4.3.0/tests/test_documents.py

@@ -0,0 +1,238 @@
+# Future
+from __future__ import division, print_function, unicode_literals
+
+# Standard Library
+from builtins import str
+from datetime import datetime
+
+# Third Party
+import pytest
+
+# DocumentCloud
+from documentcloud.documents import Mention
+from documentcloud.exceptions import APIError, DoesNotExistError
+from documentcloud.organizations import Organization
+from documentcloud.users import User
+
+# pylint: disable=protected-access
+
+
+class TestDocument:
+    def test_str(self, document):
+        assert str(document) == document.title
+
+    def test_dates(self, document):
+        for date_field in document.date_fields:
+            assert isinstance(getattr(document, date_field), datetime)
+
+    @pytest.mark.parametrize(
+        "attr",
+        [
+            "full_text_url",
+            "full_text",
+            "thumbnail_image_url",
+            "small_image",
+            "normal_image_url_list",
+            "large_image_url",
+            "page_text",
+            "json_text_url",
+            "pdf",
+        ],
+    )
+    def test_getattr(self, document, attr):
+        assert getattr(document, attr)
+
+    @pytest.mark.parametrize(
+        "attr",
+        [
+            "get_full_text_url",
+            "get_full_text",
+            "get_thumbnail_image_url",
+            "get_small_image",
+            "get_normal_image_url_list",
+            "get_large_image_url",
+            "get_page_text",
+            "get_json_text_url",
+            "get_pdf",
+        ],
+    )
+    def test_getattr_method(self, document, attr):
+        assert getattr(document, attr)()
+
+    @pytest.mark.parametrize(
+        "attr",
+        [
+            "full_text_url",
+            "get_full_text",
+            "thumbnail_image_url",
+            "get_small_image",
+            "normal_image_url_list",
+            "get_large_image_url",
+        ],
+    )
+    def test_dir(self, document, attr):
+        assert attr in dir(document)
+
+    def test_mentions(self, client, document):
+        document = client.documents.search(
+            f"document:{document.id} text", mentions="true"
+        )[0]
+        assert document.mentions
+        mention = document.mentions[0]
+        assert mention.page
+        assert "<em>text</em>" in mention.text
+
+    def test_mentions_nosearch(self, document):
+        assert not document.mentions
+
+    def test_user(self, document):
+        assert document._user is None
+        assert isinstance(document.user, User)
+        assert document.user == document._user
+
+    def test_user_expanded(self, client, document):
+        document = client.documents.get(document.id, expand=["user"])
+        assert document._user is not None
+        assert document._user == document.user
+
+    def test_organization(self, document):
+        assert document._organization is None
+        assert isinstance(document.organization, Organization)
+        assert document.organization == document._organization
+
+    @pytest.mark.parametrize(
+        "attr",
+        [
+            "id",
+            "access",
+            "asset_url",
+            "canonical_url",
+            "created_at",
+            "data",
+            "description",
+            "edit_access",
+            "language",
+            "organization_id",
+            "page_count",
+            "page_spec",
+            "projects",
+            "related_article",
+            "published_url",
+            "slug",
+            "source",
+            "status",
+            "title",
+            "updated_at",
+            "user_id",
+            "pages",
+            "contributor",
+            "contributor_organization",
+            "contributor_organization_slug",
+        ],
+    )
+    def test_attrs(self, document, attr):
+        assert getattr(document, attr)
+
+    def test_save(self, client, document):
+        assert document.source == "DocumentCloud"
+        document.source = "MuckRock"
+        document.save()
+        document = client.documents.get(document.id)
+        assert document.source == "MuckRock"
+
+    def test_delete(self, client, document_factory):
+        document = document_factory()
+        document.delete()
+
+        with pytest.raises(DoesNotExistError):
+            client.documents.get(document.id)
+
+    def test_section(self, document_factory):
+        document = document_factory()
+        assert len(document.sections.list().results) == 0
+        section = document.sections.create("Test Section", 0)
+        assert str(section) == "Test Section - p0"
+        assert section.page == 0
+        assert section == document.sections.list()[0]
+
+
+class TestDocumentClient:
+    def test_search(self, client, document):
+        documents = client.documents.search(
+            f"document:{document.id} simple"
+        )
+        assert documents
+
+    def test_list(self, client):
+        # list and all are aliases
+        all_documents = client.documents.all()
+        my_documents = client.documents.list(user=client.user_id)
+        assert len(list(all_documents)) > len(list(my_documents.results))
+
+    def test_upload_url(self, document_factory):
+        document = document_factory()
+        assert document.status == "success"
+
+    def test_public_upload(self, public_client):
+        with pytest.raises(APIError, match=r"403"):
+            public_client.documents.upload("tests/test.pdf")
+
+    def test_upload_file(self, document_factory):
+        with open("tests/test.pdf", "rb") as pdf:
+            document = document_factory(pdf)
+        assert document.status == "success"
+
+
+    def test_upload_file_path(self, document_factory):
+        document = document_factory("tests/test.pdf")
+        assert document.status == "success"
+
+    def test_upload_big_file(self, client, mocker):
+        mocker.patch("os.path.getsize", return_value=502 * 1024 * 1024)
+        with pytest.raises(ValueError):
+            client.documents.upload("tests/test.pdf")
+
+    def test_upload_dir(self, client):
+        documents = client.documents.upload_directory("tests/pdfs/")
+        assert len(documents) == 2
+
+    def test_format_upload_parameters(self, client):
+        with pytest.warns(UserWarning):
+            params = client.documents._format_upload_parameters(
+                "tests/test.pdf", access="private", secure=True, project=2, foo="bar"
+            )
+        assert params == {"title": "test", "access": "private", "projects": [2]}
+
+    def test_delete(self, document_factory, client):
+        document = document_factory()
+        client.documents.delete(document.id)
+
+        with pytest.raises(DoesNotExistError):
+            client.documents.get(document.id)
+
+
+class TestMention:
+    def test_mention(self):
+        mention = Mention("page_no_42", "text")
+        assert str(mention) == '42 - "text"'
+
+
+class TestSection:
+    def test_create_delete(self, document_factory):
+        document = document_factory()
+        assert len(document.sections.list().results) == 0
+        section = document.sections.create("Test Section", 0)
+        assert len(document.sections.list().results) == 1
+
+        # may not have two sections on the same page
+        with pytest.raises(APIError):
+            document.sections.create("Test Section 2", 0)
+
+        section.delete()
+        assert len(document.sections.list().results) == 0
+
+    def test_str(self, document):
+        assert str(document.sections[0])
+
+    def test_page(self, document):
+        assert document.sections[0].page == 0

python_documentcloud-4.3.0/tests/test_organizations.py

@@ -0,0 +1,11 @@
+# Future
+from __future__ import division, print_function, unicode_literals
+
+# Standard Library
+from builtins import str
+
+
+def test_organization(client):
+    user = client.users.get(client.user_id)
+    organization = client.organizations.get(user.organization)
+    assert str(organization) == organization.name

python_documentcloud-4.3.0/tests/test_projects.py

@@ -0,0 +1,111 @@
+# Future
+from __future__ import division, print_function, unicode_literals
+
+# Standard Library
+from builtins import str
+
+# Third Party
+import pytest
+
+# DocumentCloud
+from documentcloud.documents import Document
+from documentcloud.exceptions import DoesNotExistError, MultipleObjectsReturnedError
+
+
+class TestProject:
+    def test_str(self, project):
+        assert str(project) == project.title
+
+    def test_save(self, client, project, document_factory):
+        document = document_factory()
+        assert document not in project.documents
+        project.documents.append(document)
+        # put is an alias for save
+        project.put()
+        project = client.projects.get(project.id)
+        assert document in project.documents
+
+    def test_document_list(self, project):
+        assert len(project.document_list) > 0
+        assert all(isinstance(d, Document) for d in project.document_list)
+
+    def test_document_list_paginate(self, project):
+        # pylint: disable=protected-access
+        length = len(project.document_list)
+        assert length > 1
+        # clear cache
+        project._document_list = None
+        # set per page to 1 to force pagination
+        project._per_page = 1
+        assert len(project.document_list) == length
+
+    def test_document_list_setter(self, project, document):
+        assert document in project.document_list
+        # setting to none clears it and sets to an empty list
+        project.document_list = None
+        assert document not in project.document_list
+        # documents is an alias for document_list
+        project.documents = [document]
+        assert document in project.document_list
+        with pytest.raises(TypeError):
+            project.document_list = document
+
+    def test_document_ids(self, project, document):
+        assert document.id in project.document_ids
+
+    def test_get_document(self, project, document):
+        assert project.get_document(document.id)
+
+    def test_get_document_missing(self, project, document_factory):
+        document = document_factory()
+        with pytest.raises(DoesNotExistError):
+            project.get_document(document.id)
+
+
+class TestProjectClient:
+    def test_list(self, client):
+        all_projects = client.projects.list()
+        my_projects = client.projects.all()
+        # assert len(all_projects.results) > len(my_projects.results)
+        assert len(client.projects.list(user=client.user_id).results) == len(
+            my_projects.results
+        )
+
+    def test_get_id(self, client, project):
+        assert client.projects.get(id=project.id)
+
+    def test_get_title(self, client, project):
+        assert client.projects.get(title=project.title)
+
+    def test_get_nothing(self, client):
+        with pytest.raises(ValueError):
+            client.projects.get()
+
+    def test_get_both(self, client, project):
+        with pytest.raises(ValueError):
+            client.projects.get(id=project.id, title=project.title)
+
+    def test_get_by_id(self, client, project):
+        assert client.projects.get_by_id(project.id)
+
+    def test_get_by_title(self, client, project):
+        assert client.projects.get_by_title(project.title)
+
+    def test_get_by_title_multiple(self, client, project_factory):
+        for _ in range(2):
+            project_factory(title="Dupe")
+        with pytest.raises(MultipleObjectsReturnedError):
+            client.projects.get_by_title("Dupe")
+
+    def test_get_or_create_by_title_get(self, client, project):
+        title = project.title
+        project, created = client.projects.get_or_create_by_title(title)
+        assert project.title == title
+        assert not created
+
+    def test_get_or_create_by_title_create(self, client):
+        title = "Created Title"
+        project, created = client.projects.get_or_create_by_title(title)
+        assert project.title == title
+        project.delete()
+        assert created

python_documentcloud-4.3.0/tests/test_sections.py

@@ -0,0 +1,32 @@
+# Future
+from __future__ import division, print_function, unicode_literals
+
+# Standard Library
+from builtins import str
+
+# Third Party
+import pytest
+
+# DocumentCloud
+from documentcloud.exceptions import APIError
+
+
+class TestSection:
+    def test_create_delete(self, document_factory):
+        document = document_factory()
+        assert len(document.sections.list().results) == 0
+        section = document.sections.create("Test Section", 0)
+        assert len(document.sections.list().results) == 1
+
+        # may not have two sections on the same page
+        with pytest.raises(APIError):
+            document.sections.create("Test Section 2", 0)
+
+        section.delete()
+        assert len(document.sections.list().results) == 0
+
+    def test_str(self, document):
+        assert str(document.sections[0])
+
+    def test_page(self, document):
+        assert document.sections[0].page == 0

python_documentcloud-4.3.0/tests/test_toolbox.py

@@ -0,0 +1,25 @@
+# Future
+from __future__ import division, print_function, unicode_literals
+
+# DocumentCloud
+from documentcloud.toolbox import get_id
+
+
+def test_get_id_number():
+    assert get_id(42) == 42
+
+
+def test_get_id_str():
+    assert get_id("42") == "42"
+
+
+def test_get_id_prefix():
+    assert get_id("42-foo-bar") == "42"
+
+
+def test_get_id_postfix():
+    assert get_id("foo-bar-42") == "42"
+
+
+def test_get_id_both():
+    assert get_id("42-foo-bar-123") == "42"

python_documentcloud-4.3.0/tests/test_users.py

@@ -0,0 +1,10 @@
+# Future
+from __future__ import division, print_function, unicode_literals
+
+# Standard Library
+from builtins import str
+
+
+def test_user(client):
+    user = client.users.get(client.user_id)
+    assert str(user) == user.username

python-documentcloud-4.1.3/documentcloud/client.py

@@ -1,177 +0,0 @@
-"""
-The public interface for the DocumentCloud API
-"""
-
-# Standard Library
-import logging
-from functools import partial
-from urllib.parse import parse_qs, urlparse
-
-# Third Party
-import ratelimit
-import requests
-
-# Local
-from .constants import AUTH_URI, BASE_URI, RATE_LIMIT, RATE_PERIOD, TIMEOUT
-from .documents import DocumentClient
-from .exceptions import APIError, CredentialsFailedError, DoesNotExistError
-from .organizations import OrganizationClient
-from .projects import ProjectClient
-from .toolbox import requests_retry_session
-from .users import UserClient
-
-logger = logging.getLogger("documentcloud")
-
-
-class DocumentCloud(object):
-    """
-    The public interface for the DocumentCloud API
-    """
-
-    def __init__(
-        self,
-        username=None,
-        password=None,
-        base_uri=BASE_URI,
-        auth_uri=AUTH_URI,
-        timeout=TIMEOUT,
-        loglevel=None,
-        rate_limit=True,
-        rate_limit_sleep=True,
-    ):
-        self.base_uri = base_uri
-        self.auth_uri = auth_uri
-        self.username = username
-        self.password = password
-        self._user_id = None
-        self.timeout = timeout
-        self.refresh_token = None
-        self.session = requests.Session()
-        self._set_tokens()
-
-        if loglevel:  # pragma: no cover
-            logging.basicConfig(
-                level=loglevel,
-                format="%(asctime)s %(levelname)-8s %(name)-25s %(message)s",
-            )
-        else:
-            logger.addHandler(logging.NullHandler())
-
-        self.documents = DocumentClient(self)
-        self.projects = ProjectClient(self)
-        self.users = UserClient(self)
-        self.organizations = OrganizationClient(self)
-
-        if rate_limit:
-            self._request = ratelimit.limits(calls=RATE_LIMIT, period=RATE_PERIOD)(
-                self._request
-            )
-            if rate_limit_sleep:
-                self._request = ratelimit.sleep_and_retry(self._request)
-
-    def _set_tokens(self):
-        """Set the refresh and access tokens"""
-        if self.refresh_token:
-            access_token, self.refresh_token = self._refresh_tokens(self.refresh_token)
-        elif self.username and self.password:
-            access_token, self.refresh_token = self._get_tokens(
-                self.username, self.password
-            )
-        else:
-            access_token = None
-
-        if access_token:
-            self.session.headers.update({"Authorization": f"Bearer {access_token}"})
-
-    def _get_tokens(self, username, password):
-        """Get an access and refresh token in exchange for the username and password"""
-        response = requests_retry_session().post(
-            f"{self.auth_uri}token/",
-            json={"username": username, "password": password},
-            timeout=self.timeout,
-        )
-
-        if response.status_code == requests.codes.UNAUTHORIZED:
-            raise CredentialsFailedError("The username and password are incorrect")
-
-        self.raise_for_status(response)
-
-        json = response.json()
-        return (json["access"], json["refresh"])
-
-    def _refresh_tokens(self, refresh_token):
-        """Refresh the access and refresh tokens"""
-        response = requests_retry_session().post(
-            f"{self.auth_uri}refresh/",
-            json={"refresh": refresh_token},
-            timeout=self.timeout,
-        )
-
-        if response.status_code == requests.codes.UNAUTHORIZED:
-            # refresh token is expired
-            return self._get_tokens(self.username, self.password)
-
-        self.raise_for_status(response)
-
-        json = response.json()
-        return (json["access"], json["refresh"])
-
-    @property
-    def user_id(self):
-        if self._user_id is None:
-            user = self.users.get("me")
-            self._user_id = user.id
-        return self._user_id
-
-    def _request(self, method, url, raise_error=True, **kwargs):
-        """Generic method to make API requests"""
-        # pylint: disable=method-hidden
-        logger.info("request: %s - %s - %s", method, url, kwargs)
-        set_tokens = kwargs.pop("set_tokens", True)
-        full_url = kwargs.pop("full_url", False)
-
-        if not full_url:
-            url = f"{self.base_uri}{url}"
-
-        # set the API to version 2.0
-        parsed_url = urlparse(url)
-        if "version" not in parse_qs(parsed_url.query):
-            # check to avoid double setting version
-            kwargs.setdefault("params", {}).update({"version": "2.0"})
-
-        response = requests_retry_session(session=self.session).request(
-            method, url, timeout=self.timeout, **kwargs
-        )
-        logger.debug("response: %s - %s", response.status_code, response.content)
-        if (
-            response.status_code in [requests.codes.FORBIDDEN, requests.codes.TOO_MANY]
-            and set_tokens
-        ):
-            self._set_tokens()
-            # track set_tokens to not enter an infinite loop
-            kwargs["set_tokens"] = False
-            return self._request(method, url, full_url=True, **kwargs)
-
-        if raise_error:
-            self.raise_for_status(response)
-
-        return response
-
-    def __getattr__(self, attr):
-        """Generate methods for each HTTP request type"""
-        methods = ["get", "options", "head", "post", "put", "patch", "delete"]
-        if attr in methods:
-            return partial(self._request, attr)
-        raise AttributeError(
-            f"'{self.__class__.__name__}' object has no attribute '{attr}'"
-        )
-
-    def raise_for_status(self, response):
-        """Raise for status with a custom error class"""
-        try:
-            response.raise_for_status()
-        except requests.exceptions.RequestException as exc:
-            if exc.response.status_code == 404:
-                raise DoesNotExistError(response=exc.response) from exc
-            else:
-                raise APIError(response=exc.response) from exc

python-documentcloud-4.1.3/documentcloud/exceptions.py

@@ -1,39 +0,0 @@
-"""
-Custom exceptions for python-documentcloud
-"""
-
-
-class DocumentCloudError(Exception):
-    """Base class for errors for python-documentcloud"""
-
-    def __init__(self, *args, **kwargs):
-        self.response = kwargs.pop("response", None)
-        if self.response is not None:
-            self.error = self.response.text
-            self.status_code = self.response.status_code
-            if not args:
-                args = [f"{self.status_code} - {self.error}"]
-        else:
-            self.error = None
-            self.status_code = None
-        super().__init__(*args, **kwargs)
-
-
-class DuplicateObjectError(DocumentCloudError):
-    """Raised when an object is added to a unique list more than once"""
-
-
-class CredentialsFailedError(DocumentCloudError):
-    """Raised if unable to obtain an access token due to bad login credentials"""
-
-
-class APIError(DocumentCloudError):
-    """Any other error calling the API"""
-
-
-class DoesNotExistError(APIError):
-    """Raised when the user asks the API for something it cannot find"""
-
-
-class MultipleObjectsReturnedError(APIError):
-    """Raised when the API returns multiple objects when it expected one"""