Merge pull request #10 from getslash/updates

Updates

Author: ayalash

.github/workflows/main.yml

@@ -0,0 +1,65 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+    # manually triggered
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+    env:
+      UV_PYTHON: ${{ matrix.python-version }}
+
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@main
+      - name: Install the default version of uv
+        id: setup-uv
+        uses: astral-sh/setup-uv@v3
+      - name: Print the installed version
+        run: echo "Installed uv version is ${{ steps.setup-uv.outputs.uv-version }}"
+      - name: Install Python ${{ matrix.python-version }}
+        run: uv python install  ${{ matrix.python-version }}
+
+      - name: Tests
+        run: |
+          uv venv
+          uv pip install ".[testing]"
+          .venv/bin/pytest tests
+          .venv/bin/pylint --rcfile=.pylintrc mailboxer tests
+
+  publish:
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: test
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install hatch
+        run: pip install hatch
+
+      - name: Build package
+        run: hatch build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          attestations: true
+          skip-existing: true

.pylintrc

@@ -0,0 +1,10 @@
+[MESSAGES CONTROL]
+disable=missing-docstring,too-many-public-methods,too-few-public-methods,no-self-use,import-error,locally-disabled,invalid-name,wrong-import-order,,bad-option-value,ungrouped-imports,too-many-arguments,useless-object-inheritance,consider-using-f-string,unnecessary-lambda-assignment,raise-missing-from,unspecified-encoding
+
+[FORMAT]
+max-line-length=120
+
+[REPORTS]
+reports=no
+score=no
+output-format=parseable

Makefile

@@ -1,16 +1,9 @@
 default: test
 
 test: env
-	.env/bin/pytest -x tests
+	.venv/bin/pytest -x tests
 
-travis_test: env
-	PYTHONPATH=.env/mailboxer .env/bin/pytest
-
-env: .env/.up-to-date
-
-
-.env/.up-to-date: setup.py Makefile
-	python -m virtualenv .env
-	.env/bin/pip install -e ".[testing]"
-	touch $@
+env:
+	uv venv
+	uv pip install -e ".[testing]"
 

mailboxer/mailboxer.py

@@ -5,10 +5,9 @@
 from .query import Query
 
 
-class Mailboxer(object):
-
+class Mailboxer:
     def __init__(self, url):
-        super(Mailboxer, self).__init__()
+        super().__init__()
         self.url = URL(url).add_path("v2")
 
     def create_mailbox(self, address):
@@ -18,7 +17,7 @@ def create_mailbox(self, address):
     def delete_mailbox(self, address):
         return self.get_mailbox(address).delete()
 
-    def get_emails(self, address, unread = False):
+    def get_emails(self, address, unread=False):
         return self.get_mailbox(address).get_emails(unread)
 
     def get_mailboxes(self, **kwargs):
@@ -31,48 +30,56 @@ def does_mailbox_exist(self, address):
         return Mailbox(self, address).exists()
 
     def _post(self, url, data):
-        returned = requests.post(url, data=json.dumps(data),
-                      headers={"Content-type": "application/json"})
+        returned = requests.post(
+            url,
+            data=json.dumps(data),
+            headers={"Content-type": "application/json"},
+            timeout=30,
+        )
         returned.raise_for_status()
         return returned
 
     def _get_paged(self, url, obj):
-        response = requests.get(url)
+        response = requests.get(url, timeout=30)
         response.raise_for_status()
         return [obj(data) for data in response.json()["result"]]
 
     def _mailbox_url(self, address):
         return self.url.add_path("mailboxes").add_path(address)
 
-class Mailbox(object):
 
+class Mailbox:
     def __init__(self, mailboxer, address):
-        super(Mailbox, self).__init__()
+        super().__init__()
         self.mailboxer = mailboxer
         self.address = address
         self.url = self.mailboxer.url.add_path("mailboxes").add_path(self.address)
 
     @classmethod
-    def from_query_json(cls, mailboxer, json):
+    def from_query_json(cls, mailboxer, json):  # pylint: disable=redefined-outer-name
         return cls(mailboxer, json["address"])
 
-    def get_emails(self, unread = False):
-        url = self.url.add_path("unread_emails") if unread else self.url.add_path("emails")
-        return self.mailboxer._get_paged(url, Email)
+    def get_emails(self, unread=False):
+        url = (
+            self.url.add_path("unread_emails")
+            if unread
+            else self.url.add_path("emails")
+        )
+        return self.mailboxer._get_paged(url, Email)  # pylint: disable=protected-access
 
     def exists(self):
         url = self.url.add_path("emails")
-        response = requests.get(url)
-        if(response.status_code == requests.codes.not_found):
+        response = requests.get(url, timeout=30)
+        if response.status_code == requests.codes.not_found:  # pylint: disable=no-member
             return False
         response.raise_for_status()
         return True
 
     def delete(self):
-        requests.delete(self.url).raise_for_status()
+        requests.delete(self.url, timeout=30).raise_for_status()
 
-class Email(object):
 
+class Email:
     def __init__(self, email_dict):
-        super(Email, self).__init__()
+        super().__init__()
         self.__dict__.update(email_dict)

mailboxer/query.py

@@ -1,11 +1,11 @@
 import requests
 
-class Query(object):
 
+class Query:
     _metadata = None
 
     def __init__(self, client, url, objtype, page_size=100):
-        super(Query, self).__init__()
+        super().__init__()
         self.client = client
         self.url = url.set_query_param("page_size", str(page_size))
         self.objtype = objtype
@@ -14,7 +14,9 @@ def __init__(self, client, url, objtype, page_size=100):
 
     def _fetch_page(self, page_index):
         assert page_index > 0
-        result = requests.get(self.url.set_query_param("page", str(page_index)))
+        result = requests.get(
+            self.url.set_query_param("page", str(page_index)), timeout=30
+        )
         result.raise_for_status()
         result_json = result.json()
         if self._objects is None:
@@ -28,7 +30,7 @@ def __iter__(self):
 
     def get_json_objects(self):
         for i in range(len(self)):
-            obj = self._objects[i]
+            assert self._objects is not None
             if self._objects[i] is None:
                 self._fetch_page((i // self.page_size) + 1)
             assert self._objects[i] is not None
@@ -37,4 +39,5 @@ def get_json_objects(self):
     def __len__(self):
         if self._objects is None:
             self._fetch_page(1)
+        assert self._objects is not None
         return len(self._objects)

pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling>=0.25.1", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mailboxer-python"
+description = "Client library for Mailboxer"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "BSD 3-Clause License" }
+
+classifiers = [
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+dependencies = ["requests", "URLObject"]
+dynamic = ["version"]
+
+authors = [{ name = "Rotem Yaari", email = "vmalloc@gmail.com" }]
+
+[project.urls]
+"Homepage" = "https://github.com/getslash/mailboxer-python"
+
+[project.optional-dependencies]
+testing = ["dataclasses_json", "Flask-Loopback", "pylint", "pytest"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["mailboxer"]
+
+[tool.hatch.version]
+source = "vcs"

requirements.txt

@@ -1,8 +1,3 @@
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
 import uuid
 
 from urlobject import URLObject as URL
@@ -11,63 +6,42 @@
 import pytest
 from mailboxer import Mailboxer
 
-sys.path.insert(0, os.path.join(
-    os.path.abspath(os.path.dirname(__file__)),
-    "..", ".env", "mailboxer"))
-from flask_app.app import create_app
-from flask_app import models
+from .flask_app import create_app, app_initializations
 
-def pytest_addoption(parser):
-    parser.addoption("--setup-db", action="store_true", default=False)
 
-@pytest.fixture(scope="session")
-def db_engine(request):
-    if request.config.getoption("--setup-db"):
-        tmpdir = tempfile.mkdtemp()
-        subprocess.check_call("pg_ctl init -D {0} -w".format(tmpdir), shell=True)
-        subprocess.check_call("pg_ctl start -D {0} -w".format(tmpdir), shell=True)
-
-        @request.addfinalizer
-        def finalize():
-            subprocess.check_call("pg_ctl stop -D {0} -w -m immediate".format(tmpdir), shell=True)
-            shutil.rmtree(tmpdir)
-
-        subprocess.check_call("createdb mailboxer", shell=True)
-
-    with create_app().app_context():
-        models.db.session.close()
-        models.db.drop_all()
-        models.db.create_all()
-
-
-@pytest.fixture(scope="session")
-def mailboxer_url(request, db_engine):
-    loopback = FlaskLoopback(create_app())
+@pytest.fixture(scope="session", name="mailboxer_url")
+def mailboxer_url_fx():
+    app = create_app()
+    loopback = FlaskLoopback(app)
     hostname = str(uuid.uuid1())
-    loopback.activate_address((hostname, 80))
-    @request.addfinalizer
-    def close():
-        loopback.deactivate_address((hostname, 80))
-    return URL("http://{0}".format(hostname))
+    port = 80
+    loopback.activate_address((hostname, port))
+    with app.app_context():
+        app_initializations()
+        yield URL(f"http://{hostname}:{port}")
+        loopback.deactivate_address((hostname, port))
 
-@pytest.fixture
-def mailboxer(mailboxer_url):
+
+@pytest.fixture(name="mailboxer")
+def mailboxer_fx(mailboxer_url):
     return Mailboxer(mailboxer_url)
 
-@pytest.fixture(
-    params=[10]
-    )
-def num_objects(request):
+
+@pytest.fixture(params=[10], name="num_objects")
+def num_objects_fx(request):
     return request.param
 
+
 @pytest.fixture
 def mailbox(request, mailboxer):
     returned = mailboxer.create_mailbox("mailbox@mailboxer.com")
     request.addfinalizer(returned.delete)
     return returned
 
+
 @pytest.fixture
 def mailboxes(mailboxer, num_objects):
     return [
         mailboxer.create_mailbox("mailbox{0}@mailboxer.com".format(i))
-        for i in range(num_objects)]
+        for i in range(num_objects)
+    ]