blockquote-agents 0.1.2__tar.gz

blockquote_agents-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arne Kellmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

blockquote_agents-0.1.2/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: blockquote-agents
+Version: 0.1.2
+Summary: Official Blockquote SDK and CLI for blockquote.io: Python API client for AI citability scans and report comparisons.
+License: MIT
+Project-URL: Homepage, https://blockquote.io
+Project-URL: Repository, https://github.com/ArneFfm/blockquote-agents
+Project-URL: Documentation, https://blockquote.io/developers
+Project-URL: Bug Tracker, https://github.com/ArneFfm/blockquote-agents/issues
+Keywords: blockquote,blockquote.io,sdk,api-client,cli,ai-citability
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Blockquote Python SDK and CLI
+
+Official client for [Blockquote](https://blockquote.io). Requires Python 3.10 or later. No runtime dependencies.
+
+```sh
+pip install blockquote-agents
+```
+
+```python
+import os
+import uuid
+from blockquote_agents import Blockquote, BlockquoteError
+
+client = Blockquote(api_key=os.getenv("BLOCKQUOTE_API_KEY"))
+started = client.start_scan("https://example.com", idempotency_key=str(uuid.uuid4()))
+print(started.data, started.headers.get("Retry-After"))
+# Wait for Retry-After, then read the returned id.
+report = client.get_scan(started.data["id"])
+comparison = client.compare_scans(from_id="BASELINE_ID", to_id="NEW_ID")
+```
+
+Each call returns a `Response` with `data`, `status`, and HTTP `headers`.
+`BlockquoteError` retains `data`, `status`, `headers`, and `retry_after`. Network errors pass through.
+Requests time out after 30 seconds. Set `timeout` in the constructor to change this.
+The client does not retry or poll automatically. Scans can return a cached result or pending status.
+Reuse an idempotency key only when you repeat the same scan request.
+
+Public report reads need no key. Account access uses an optional bearer key from [your account](https://blockquote.io/account).
+Keys require Pro or Agency. Unattended scan creation can require a paid key with the `scan` scope.
+Human verification still applies where required. Pass `turnstile_token` when available; the SDK does not obtain or bypass verification.
+Pass `refresh=True` to request a fresh scan with account authentication. Scan quotas still apply.
+Read access and comparison output follow your account plan.
+
+See the [API reference](https://blockquote.io/api/docs) and [OpenAPI document](https://blockquote.io/api/v1/openapi.json).
+
+Run tests from this package directory:
+
+```sh
+python3 -m unittest discover -s tests
+```
+
+## Command line
+
+The package installs the `blockquote` command. `python -m blockquote_agents` runs the same CLI.
+
+```sh
+python -m pip install --upgrade blockquote-agents
+blockquote --help
+blockquote read SCAN_ID
+blockquote scan https://example.com --idempotency-key UNIQUE_REQUEST_ID
+blockquote compare BASELINE_ID NEW_ID
+```
+
+Set `BLOCKQUOTE_API_KEY` for account access. Set `BLOCKQUOTE_TURNSTILE_TOKEN` only when you have a human verification token.
+Use `--refresh` with `scan` to request a fresh scan. Authentication and quota rules remain the same.
+The CLI prints JSON with `data`, `status`, and `headers`. It does not poll or retry.
+HTTP failures print server data, headers, status, and `retryAfter` to stderr with exit code 1.
+Other request failures print only their error type to avoid exposing credentials. Invalid arguments exit with code 2.

blockquote_agents-0.1.2/README.md

@@ -0,0 +1,58 @@
+# Blockquote Python SDK and CLI
+
+Official client for [Blockquote](https://blockquote.io). Requires Python 3.10 or later. No runtime dependencies.
+
+```sh
+pip install blockquote-agents
+```
+
+```python
+import os
+import uuid
+from blockquote_agents import Blockquote, BlockquoteError
+
+client = Blockquote(api_key=os.getenv("BLOCKQUOTE_API_KEY"))
+started = client.start_scan("https://example.com", idempotency_key=str(uuid.uuid4()))
+print(started.data, started.headers.get("Retry-After"))
+# Wait for Retry-After, then read the returned id.
+report = client.get_scan(started.data["id"])
+comparison = client.compare_scans(from_id="BASELINE_ID", to_id="NEW_ID")
+```
+
+Each call returns a `Response` with `data`, `status`, and HTTP `headers`.
+`BlockquoteError` retains `data`, `status`, `headers`, and `retry_after`. Network errors pass through.
+Requests time out after 30 seconds. Set `timeout` in the constructor to change this.
+The client does not retry or poll automatically. Scans can return a cached result or pending status.
+Reuse an idempotency key only when you repeat the same scan request.
+
+Public report reads need no key. Account access uses an optional bearer key from [your account](https://blockquote.io/account).
+Keys require Pro or Agency. Unattended scan creation can require a paid key with the `scan` scope.
+Human verification still applies where required. Pass `turnstile_token` when available; the SDK does not obtain or bypass verification.
+Pass `refresh=True` to request a fresh scan with account authentication. Scan quotas still apply.
+Read access and comparison output follow your account plan.
+
+See the [API reference](https://blockquote.io/api/docs) and [OpenAPI document](https://blockquote.io/api/v1/openapi.json).
+
+Run tests from this package directory:
+
+```sh
+python3 -m unittest discover -s tests
+```
+
+## Command line
+
+The package installs the `blockquote` command. `python -m blockquote_agents` runs the same CLI.
+
+```sh
+python -m pip install --upgrade blockquote-agents
+blockquote --help
+blockquote read SCAN_ID
+blockquote scan https://example.com --idempotency-key UNIQUE_REQUEST_ID
+blockquote compare BASELINE_ID NEW_ID
+```
+
+Set `BLOCKQUOTE_API_KEY` for account access. Set `BLOCKQUOTE_TURNSTILE_TOKEN` only when you have a human verification token.
+Use `--refresh` with `scan` to request a fresh scan. Authentication and quota rules remain the same.
+The CLI prints JSON with `data`, `status`, and `headers`. It does not poll or retry.
+HTTP failures print server data, headers, status, and `retryAfter` to stderr with exit code 1.
+Other request failures print only their error type to avoid exposing credentials. Invalid arguments exit with code 2.

blockquote_agents-0.1.2/blockquote_agents/__init__.py

@@ -0,0 +1,82 @@
+"""Official Blockquote client. Uses Python's standard library."""
+import json
+from dataclasses import dataclass
+from urllib.error import HTTPError
+from urllib.parse import quote, urlencode, urlsplit
+from urllib.request import HTTPRedirectHandler, Request, build_opener
+
+
+@dataclass
+class Response:
+    data: object
+    status: int
+    headers: object
+
+
+class BlockquoteError(Exception):
+    def __init__(self, response):
+        super().__init__(f"Blockquote HTTP {response.status}")
+        self.data = response.data
+        self.status = response.status
+        self.headers = response.headers
+        self.retry_after = response.headers.get("Retry-After")
+
+
+class _NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+class Blockquote:
+    def __init__(self, api_key=None, base_url="https://blockquote.io/api/v1", timeout=30):
+        base = urlsplit(base_url)
+        if base.scheme != "https" or not base.netloc or base.username or base.password or base.query or base.fragment:
+            raise ValueError("base_url must be an HTTPS URL without credentials, query, or fragment")
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self._opener = build_opener(_NoRedirect())
+
+    def _request(self, path, body=None, idempotency_key=None):
+        headers = {"Accept": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+        request = Request(self.base_url + path, headers=headers,
+                          data=None if body is None else json.dumps(body).encode())
+        try:
+            raw = self._opener.open(request, timeout=self.timeout)
+        except HTTPError as error:
+            raw = error
+        with raw:
+            text = raw.read().decode("utf-8", errors="replace")
+            try:
+                data = json.loads(text)
+            except ValueError:
+                data = text
+            response = Response(data, raw.status, raw.headers)
+        if not 200 <= response.status < 300:
+            raise BlockquoteError(response)
+        return response
+
+    def start_scan(self, url, *, refresh=None, turnstile_token=None, idempotency_key=None):
+        body = {"url": url}
+        if refresh is not None:
+            body["refresh"] = refresh
+        if turnstile_token is not None:
+            body["turnstileToken"] = turnstile_token
+        return self._request("/scan", body, idempotency_key)
+
+    def get_scan(self, scan_id):
+        if not isinstance(scan_id, str) or not scan_id.strip() or scan_id in (".", ".."):
+            raise ValueError("A scan id is required")
+        return self._request("/scan/" + quote(scan_id, safe=""))
+
+    def compare_scans(self, *, from_id=None, to_id=None, url=None):
+        if (url and (from_id is not None or to_id is not None)) or (not url and (not from_id or not to_id)):
+            raise ValueError("Use url or both from_id and to_id")
+        query = {"url": url} if url else {"from": from_id, "to": to_id}
+        return self._request("/compare?" + urlencode(query))

blockquote_agents-0.1.2/blockquote_agents/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

blockquote_agents-0.1.2/blockquote_agents/cli.py

@@ -0,0 +1,57 @@
+"""Command-line access to the Blockquote client."""
+import argparse
+import json
+import os
+import sys
+
+from . import Blockquote, BlockquoteError
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="blockquote",
+        description="Read and start Blockquote AI visibility scans.",
+        epilog=("Set BLOCKQUOTE_API_KEY for account access. Public reads need no key. "
+                "Scan creation can require a paid key or human verification. "
+                "Set BLOCKQUOTE_TURNSTILE_TOKEN for a human verification token. "
+                "Scans are asynchronous. Wait for Retry-After before reading the returned id. "
+                "No automatic retries are made."),
+    )
+    commands = parser.add_subparsers(dest="command")
+    scan = commands.add_parser("scan", help="Start a scan")
+    scan.add_argument("url")
+    scan.add_argument("--refresh", action="store_true", default=None)
+    scan.add_argument("--idempotency-key")
+    read = commands.add_parser("read", help="Read a report or pending status")
+    read.add_argument("scan_id")
+    compare = commands.add_parser("compare", help="Compare two scans")
+    compare.add_argument("from_id")
+    compare.add_argument("to_id")
+    args = parser.parse_args(argv)
+    if args.command is None:
+        parser.print_help()
+        return 0
+    try:
+        client = Blockquote(api_key=os.getenv("BLOCKQUOTE_API_KEY"))
+        if args.command == "scan":
+            result = client.start_scan(
+                args.url, refresh=args.refresh,
+                idempotency_key=args.idempotency_key,
+                turnstile_token=os.getenv("BLOCKQUOTE_TURNSTILE_TOKEN"),
+            )
+        elif args.command == "read":
+            result = client.get_scan(args.scan_id)
+        else:
+            result = client.compare_scans(from_id=args.from_id, to_id=args.to_id)
+        print(json.dumps({"data": result.data, "status": result.status,
+                          "headers": dict(result.headers.items())}, indent=2))
+        return 0
+    except BlockquoteError as error:
+        print(json.dumps({"error": str(error), "status": error.status, "data": error.data,
+                          "headers": dict(error.headers.items()),
+                          "retryAfter": error.retry_after}), file=sys.stderr)
+        return 1
+    except Exception as error:
+        # Header validation errors can contain credentials; print the error type only.
+        print(json.dumps({"error": f"Request failed ({type(error).__name__})."}), file=sys.stderr)
+        return 1

blockquote_agents-0.1.2/blockquote_agents.egg-info/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: blockquote-agents
+Version: 0.1.2
+Summary: Official Blockquote SDK and CLI for blockquote.io: Python API client for AI citability scans and report comparisons.
+License: MIT
+Project-URL: Homepage, https://blockquote.io
+Project-URL: Repository, https://github.com/ArneFfm/blockquote-agents
+Project-URL: Documentation, https://blockquote.io/developers
+Project-URL: Bug Tracker, https://github.com/ArneFfm/blockquote-agents/issues
+Keywords: blockquote,blockquote.io,sdk,api-client,cli,ai-citability
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Blockquote Python SDK and CLI
+
+Official client for [Blockquote](https://blockquote.io). Requires Python 3.10 or later. No runtime dependencies.
+
+```sh
+pip install blockquote-agents
+```
+
+```python
+import os
+import uuid
+from blockquote_agents import Blockquote, BlockquoteError
+
+client = Blockquote(api_key=os.getenv("BLOCKQUOTE_API_KEY"))
+started = client.start_scan("https://example.com", idempotency_key=str(uuid.uuid4()))
+print(started.data, started.headers.get("Retry-After"))
+# Wait for Retry-After, then read the returned id.
+report = client.get_scan(started.data["id"])
+comparison = client.compare_scans(from_id="BASELINE_ID", to_id="NEW_ID")
+```
+
+Each call returns a `Response` with `data`, `status`, and HTTP `headers`.
+`BlockquoteError` retains `data`, `status`, `headers`, and `retry_after`. Network errors pass through.
+Requests time out after 30 seconds. Set `timeout` in the constructor to change this.
+The client does not retry or poll automatically. Scans can return a cached result or pending status.
+Reuse an idempotency key only when you repeat the same scan request.
+
+Public report reads need no key. Account access uses an optional bearer key from [your account](https://blockquote.io/account).
+Keys require Pro or Agency. Unattended scan creation can require a paid key with the `scan` scope.
+Human verification still applies where required. Pass `turnstile_token` when available; the SDK does not obtain or bypass verification.
+Pass `refresh=True` to request a fresh scan with account authentication. Scan quotas still apply.
+Read access and comparison output follow your account plan.
+
+See the [API reference](https://blockquote.io/api/docs) and [OpenAPI document](https://blockquote.io/api/v1/openapi.json).
+
+Run tests from this package directory:
+
+```sh
+python3 -m unittest discover -s tests
+```
+
+## Command line
+
+The package installs the `blockquote` command. `python -m blockquote_agents` runs the same CLI.
+
+```sh
+python -m pip install --upgrade blockquote-agents
+blockquote --help
+blockquote read SCAN_ID
+blockquote scan https://example.com --idempotency-key UNIQUE_REQUEST_ID
+blockquote compare BASELINE_ID NEW_ID
+```
+
+Set `BLOCKQUOTE_API_KEY` for account access. Set `BLOCKQUOTE_TURNSTILE_TOKEN` only when you have a human verification token.
+Use `--refresh` with `scan` to request a fresh scan. Authentication and quota rules remain the same.
+The CLI prints JSON with `data`, `status`, and `headers`. It does not poll or retry.
+HTTP failures print server data, headers, status, and `retryAfter` to stderr with exit code 1.
+Other request failures print only their error type to avoid exposing credentials. Invalid arguments exit with code 2.

blockquote_agents-0.1.2/blockquote_agents.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+blockquote_agents/__init__.py
+blockquote_agents/__main__.py
+blockquote_agents/cli.py
+blockquote_agents.egg-info/PKG-INFO
+blockquote_agents.egg-info/SOURCES.txt
+blockquote_agents.egg-info/dependency_links.txt
+blockquote_agents.egg-info/entry_points.txt
+blockquote_agents.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_client.py

blockquote_agents-0.1.2/blockquote_agents.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

blockquote_agents-0.1.2/blockquote_agents.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+blockquote = blockquote_agents.cli:main

blockquote_agents-0.1.2/blockquote_agents.egg-info/top_level.txt

@@ -0,0 +1 @@
+blockquote_agents

blockquote_agents-0.1.2/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "blockquote-agents"
+version = "0.1.2"
+description = "Official Blockquote SDK and CLI for blockquote.io: Python API client for AI citability scans and report comparisons."
+keywords = ["blockquote", "blockquote.io", "sdk", "api-client", "cli", "ai-citability"]
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+
+[project.scripts]
+blockquote = "blockquote_agents.cli:main"
+
+[project.urls]
+Homepage = "https://blockquote.io"
+Repository = "https://github.com/ArneFfm/blockquote-agents"
+Documentation = "https://blockquote.io/developers"
+"Bug Tracker" = "https://github.com/ArneFfm/blockquote-agents/issues"
+
+[tool.setuptools.packages.find]
+include = ["blockquote_agents*"]

blockquote_agents-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

blockquote_agents-0.1.2/tests/test_cli.py

@@ -0,0 +1,68 @@
+import contextlib
+import io
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import unittest
+from unittest.mock import patch
+
+from blockquote_agents import BlockquoteError, Response
+from blockquote_agents.cli import main
+
+
+class CliTest(unittest.TestCase):
+    def test_module_help_and_invalid_arguments_are_offline(self):
+        for args in ([], ["--help"]):
+            result = subprocess.run([sys.executable, "-m", "blockquote_agents", *args],
+                                    cwd=Path(__file__).resolve().parents[1],
+                                    capture_output=True, text=True)
+            self.assertEqual(result.returncode, 0)
+            self.assertIn("BLOCKQUOTE_API_KEY", result.stdout)
+        result = subprocess.run([sys.executable, "-m", "blockquote_agents", "read", "id", "--refresh"],
+                                cwd=Path(__file__).resolve().parents[1], capture_output=True, text=True)
+        self.assertEqual(result.returncode, 2)
+
+    def test_commands_forward_options_and_preserve_response(self):
+        response = Response({"id": "scan-id"}, 202, {"Retry-After": "5"})
+        with patch("blockquote_agents.cli.Blockquote") as factory, patch.dict(os.environ, {
+            "BLOCKQUOTE_API_KEY": "test-key", "BLOCKQUOTE_TURNSTILE_TOKEN": "test-token"
+        }):
+            client = factory.return_value
+            for args, method in [(["scan", "https://example.com", "--refresh", "--idempotency-key", "key-1"], client.start_scan),
+                                 (["read", "scan-id"], client.get_scan),
+                                 (["compare", "old", "new"], client.compare_scans)]:
+                method.return_value = response
+                output = io.StringIO()
+                with contextlib.redirect_stdout(output):
+                    self.assertEqual(main(args), 0)
+                self.assertEqual(json.loads(output.getvalue()), {
+                    "data": {"id": "scan-id"}, "status": 202, "headers": {"Retry-After": "5"}
+                })
+            factory.assert_called_with(api_key="test-key")
+            client.start_scan.assert_called_once_with("https://example.com", refresh=True,
+                                                     idempotency_key="key-1", turnstile_token="test-token")
+            client.get_scan.assert_called_once_with("scan-id")
+            client.compare_scans.assert_called_once_with(from_id="old", to_id="new")
+
+    def test_http_errors_retain_retry_guidance_and_other_errors_hide_secrets(self):
+        for error in [BlockquoteError(Response({"error": "quota"}, 429, {"Retry-After": "60"})),
+                      ValueError("invalid header with secret-test-token")]:
+            with patch("blockquote_agents.cli.Blockquote") as factory:
+                factory.return_value.get_scan.side_effect = error
+                output = io.StringIO()
+                with contextlib.redirect_stderr(output):
+                    self.assertEqual(main(["read", "scan-id"]), 1)
+                payload = json.loads(output.getvalue())
+                if isinstance(error, BlockquoteError):
+                    self.assertEqual(payload["status"], 429)
+                    self.assertEqual(payload["retryAfter"], "60")
+                    self.assertEqual(payload["data"], {"error": "quota"})
+                else:
+                    self.assertNotIn("secret-test-token", output.getvalue())
+                factory.return_value.get_scan.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()

blockquote_agents-0.1.2/tests/test_client.py

@@ -0,0 +1,58 @@
+import io
+import json
+import unittest
+from email.message import Message
+from unittest.mock import Mock
+from urllib.error import HTTPError
+from blockquote_agents import Blockquote, BlockquoteError
+
+
+class Raw(io.BytesIO):
+    status = 202
+    headers = Message()
+    headers["Retry-After"] = "3"
+
+
+class ClientTest(unittest.TestCase):
+    def test_wire_contract(self):
+        client = Blockquote(api_key="test-key")
+        client._opener = Mock()
+        client._opener.open.side_effect = lambda *args, **kwargs: Raw(b'{"id":"scan-id"}')
+        result = client.start_scan("https://example.com", refresh=True, idempotency_key="request-1")
+        request = client._opener.open.call_args.args[0]
+        self.assertEqual(request.full_url, "https://blockquote.io/api/v1/scan")
+        self.assertEqual(json.loads(request.data), {"url": "https://example.com", "refresh": True})
+        self.assertEqual(request.get_header("Authorization"), "Bearer test-key")
+        self.assertEqual(request.get_header("Idempotency-key"), "request-1")
+        self.assertEqual(result.headers.get("Retry-After"), "3")
+        client.get_scan("a/b")
+        self.assertTrue(client._opener.open.call_args.args[0].full_url.endswith("/scan/a%2Fb"))
+        client.compare_scans(from_id="a", to_id="b")
+        self.assertTrue(client._opener.open.call_args.args[0].full_url.endswith("/compare?from=a&to=b"))
+
+    def test_http_error_preserves_payload_and_retry(self):
+        for body in (b'{"error":"quota"}', b'upstream unavailable'):
+            client = Blockquote()
+            client._opener = Mock()
+            headers = Message()
+            headers["Retry-After"] = "60"
+            client._opener.open.side_effect = HTTPError("https://blockquote.io", 429, "Limited", headers, io.BytesIO(body))
+            with self.assertRaises(BlockquoteError) as caught:
+                client.get_scan("id")
+            self.assertEqual(caught.exception.status, 429)
+            self.assertEqual(caught.exception.retry_after, "60")
+            self.assertIn(caught.exception.data, ({"error": "quota"}, "upstream unavailable"))
+            self.assertEqual(client._opener.open.call_count, 1)
+            self.assertIsNone(client._opener.open.call_args.args[0].get_header("Authorization"))
+
+    def test_invalid_inputs(self):
+        with self.assertRaises(ValueError):
+            Blockquote(base_url="http://example.com")
+        with self.assertRaises(ValueError):
+            Blockquote().get_scan("..")
+        with self.assertRaises(ValueError):
+            Blockquote().compare_scans(url="example.com", from_id="a")
+
+
+if __name__ == "__main__":
+    unittest.main()