catalogue-client 0.1.0__py3-none-any.whl

catalogue_client/__init__.py

@@ -0,0 +1,3 @@
+"""Client-side integration for a catalogue-server API."""
+
+__version__ = "0.1.0"

catalogue_client/api.py

@@ -0,0 +1,102 @@
+"""Cached HTTP interface to catalogue-server's read-only API."""
+import hashlib
+import json
+from urllib.parse import urljoin
+
+import requests
+from django.core.cache import cache
+
+from .conf import get_setting
+from .models import get_product_class
+
+
+class CatalogueError(RuntimeError):
+    pass
+
+
+class CatalogueUnavailable(CatalogueError):
+    pass
+
+
+class CatalogueResponseError(CatalogueError):
+    pass
+
+
+class CatalogueClient:
+    def __init__(self, base_url=None, *, timeout=None, session=None, cache_backend=None):
+        base = (base_url or get_setting("CATALOGUE_SERVER_URL") or "").strip()
+        if not base:
+            raise CatalogueError("Set CATALOGUE_SERVER_URL to the catalogue-server origin.")
+        self.base_url = base.rstrip("/") + "/"
+        api_path = str(get_setting("CATALOGUE_CLIENT_API_PATH")).strip("/")
+        self.api_url = urljoin(self.base_url, f"{api_path}/")
+        self.timeout = timeout if timeout is not None else get_setting("CATALOGUE_CLIENT_TIMEOUT")
+        self.session = session or requests.Session()
+        self.cache = cache_backend or cache
+
+    def _cache_key(self, endpoint, params):
+        encoded = json.dumps([self.api_url, endpoint, params], sort_keys=True, separators=(",", ":"))
+        return "catalogue-client:" + hashlib.sha256(encoded.encode("utf-8")).hexdigest()
+
+    def _get(self, endpoint, params=None):
+        params = {key: value for key, value in (params or {}).items() if value not in (None, "", [], ())}
+        key = self._cache_key(endpoint, params)
+        cached = self.cache.get(key)
+        if cached is not None:
+            return cached
+        try:
+            response = self.session.get(
+                urljoin(self.api_url, endpoint.lstrip("/")),
+                params=params,
+                headers={"Accept": "application/json"},
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            payload = response.json()
+        except (requests.RequestException, ValueError) as exc:
+            raise CatalogueUnavailable(f"Could not retrieve the catalogue: {exc}") from exc
+        if not isinstance(payload, dict):
+            raise CatalogueResponseError("The catalogue returned a non-object JSON response.")
+        self.cache.set(key, payload, get_setting("CATALOGUE_CLIENT_CACHE_SECONDS"))
+        return payload
+
+    def list_products(self, *, country=None, slugs=None, kinds=None, groups=None, q=None, attributes=None):
+        """Every matching product. *attributes* maps an attribute name to a value or list of values."""
+        params = {
+            "country": country,
+            "slug": _csv(slugs),
+            "kind": _csv(kinds),
+            "group": _csv(groups),
+            "q": q,
+            "limit": 200,
+            "offset": 0,
+        }
+        for name, value in (attributes or {}).items():
+            params[f"attributes.{name}"] = _csv(value)
+        rows = []
+        while True:
+            payload = self._get("products/", params)
+            page = payload.get("results")
+            if not isinstance(page, list):
+                raise CatalogueResponseError("The catalogue products response has no results list.")
+            rows.extend(page)
+            if len(rows) >= int(payload.get("count", len(rows))) or not page:
+                break
+            params["offset"] = len(rows)
+        product_class = get_product_class()
+        return [product_class.from_dict(row) for row in rows]
+
+    def get_product(self, slug, *, country=None):
+        if not slug:
+            return None
+        return get_product_class().from_dict(self._get(f"products/{slug}/", {"country": country}))
+
+
+def _csv(value):
+    if isinstance(value, (list, tuple, set)):
+        return ",".join(str(item) for item in value if item)
+    return value
+
+
+def get_client():
+    return CatalogueClient()

catalogue_client/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class CatalogueClientConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "catalogue_client"
+    verbose_name = "Catalogue client"

catalogue_client/conf.py

@@ -0,0 +1,21 @@
+from django.conf import settings
+
+
+DEFAULTS = {
+    "CATALOGUE_SERVER_URL": "",
+    "CATALOGUE_CLIENT_API_PATH": "/api/v1/",
+    "CATALOGUE_CLIENT_TIMEOUT": 10,
+    "CATALOGUE_CLIENT_CACHE_SECONDS": 3600,
+    "CATALOGUE_CLIENT_DEFAULT_COUNTRY": "",
+    "CATALOGUE_CLIENT_TEMPLATE": "catalogue_client/product_list.html",
+    # Dotted path to a Product subclass that every returned product is built as.
+    "CATALOGUE_CLIENT_PRODUCT_CLASS": "",
+    # Dotted path to ``(site) -> dict`` of list_products() filters that apply to a
+    # site, e.g. ``{"attributes": {"language": "cs"}}`` for a Czech site.
+    "CATALOGUE_CLIENT_SITE_FILTERS": "",
+}
+
+
+def get_setting(name):
+    """Read a client setting at call time so override_settings works in tests."""
+    return getattr(settings, name, DEFAULTS[name])

catalogue_client/forms.py

@@ -0,0 +1,10 @@
+from django import forms
+
+
+class CatalogueProductChoiceField(forms.ChoiceField):
+    """A slug choice listing catalogue products by their ``choice_label``."""
+
+    def __init__(self, *args, products=(), empty_label="---------", **kwargs):
+        super().__init__(*args, **kwargs)
+        choices = [(product.slug, product.choice_label) for product in products]
+        self.choices = ([("", empty_label)] if empty_label is not None else []) + choices

catalogue_client/migrations/__init__.py

@@ -0,0 +1 @@
+

catalogue_client/models.py

@@ -0,0 +1,160 @@
+"""Value objects built from catalogue-server's API (there are no local ORM models).
+
+A site that needs its own vocabulary (a book's author, a garment's size) subclasses
+``Product`` and names the subclass in ``CATALOGUE_CLIENT_PRODUCT_CLASS``: every
+product the client returns is then an instance of it.
+"""
+from dataclasses import dataclass, field, fields
+from datetime import date
+
+from django.urls import NoReverseMatch, reverse
+from django.utils.module_loading import import_string
+
+from .conf import get_setting
+
+
+@dataclass(frozen=True)
+class Image:
+    url: str
+
+    def get_absolute_url(self):
+        return self.url
+
+
+@dataclass
+class PurchaseInfo:
+    """Buying information for one country, as catalogue-server computed it."""
+
+    country: str = ""
+    is_country_specific: bool = False
+    region_label: str = ""
+    currency: str = ""
+    price: str = ""
+    formatted_price: str = ""
+    best_offer: dict | None = None
+    offers: list = field(default_factory=list)
+    other_offers: list = field(default_factory=list)
+    store_links: list = field(default_factory=list)
+    note: str = ""
+    available_from: str | None = None
+    distributors: list = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data):
+        data = data if isinstance(data, dict) else {}
+        return cls(
+            country=str(data.get("country") or ""),
+            is_country_specific=bool(data.get("is_country_specific")),
+            region_label=str(data.get("region_label") or ""),
+            currency=str(data.get("currency") or ""),
+            price=str(data.get("price") or ""),
+            formatted_price=str(data.get("formatted_price") or ""),
+            best_offer=data.get("best_offer") if isinstance(data.get("best_offer"), dict) else None,
+            offers=list(data.get("offers") or []),
+            other_offers=list(data.get("other_offers") or []),
+            store_links=list(data.get("store_links") or []),
+            note=str(data.get("note") or ""),
+            available_from=data.get("available_from") or None,
+            distributors=list(data.get("distributors") or []),
+        )
+
+    @property
+    def has_buy_options(self):
+        return bool(self.store_links or self.offers or self.note)
+
+    @property
+    def direct_buy_link(self):
+        """The only store link when there is nothing else to say, else None."""
+        if len(self.store_links) == 1 and not (self.note or "").strip():
+            return self.store_links[0]
+        return None
+
+    @property
+    def is_upcoming(self):
+        if not self.available_from:
+            return False
+        try:
+            return date.fromisoformat(self.available_from) > date.today()
+        except (TypeError, ValueError):
+            return False
+
+
+@dataclass
+class Product:
+    """One published product. ``attributes`` holds the server site's own fields;
+    ``extra`` holds keys the server site added with CATALOGUE_API_PRODUCT_DATA."""
+
+    slug: str
+    title: str
+    subtitle: str = ""
+    kind: str = ""
+    identifier: str = ""
+    attributes: dict = field(default_factory=dict)
+    group: dict | None = None
+    short_description: str = ""
+    description_html: str = ""
+    image_url: str = ""
+    images: list = field(default_factory=list)
+    url: str = ""
+    external_url: str = ""
+    related_products: list = field(default_factory=list)
+    purchase: PurchaseInfo = field(default_factory=PurchaseInfo)
+    extra: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data):
+        data = data if isinstance(data, dict) else {}
+        known = {item.name for item in fields(Product)}
+        return cls(
+            slug=str(data.get("slug") or ""),
+            title=str(data.get("title") or ""),
+            subtitle=str(data.get("subtitle") or ""),
+            kind=str(data.get("kind") or ""),
+            identifier=str(data.get("identifier") or ""),
+            attributes=data.get("attributes") if isinstance(data.get("attributes"), dict) else {},
+            group=data.get("group") if isinstance(data.get("group"), dict) else None,
+            short_description=str(data.get("short_description") or ""),
+            description_html=str(data.get("description_html") or ""),
+            image_url=str(data.get("image_url") or ""),
+            images=list(data.get("images") or []),
+            url=str(data.get("url") or ""),
+            external_url=str(data.get("external_url") or ""),
+            related_products=list(data.get("related_products") or []),
+            purchase=PurchaseInfo.from_dict(data.get("purchase")),
+            extra={key: value for key, value in data.items() if key not in known},
+        )
+
+    def attr(self, name, default=""):
+        """An attribute of the product, or *default* when the server has none."""
+        value = self.attributes.get(name)
+        return default if value in (None, "") else value
+
+    @property
+    def pk(self):
+        """A stable, template-friendly identity (there is no local database row)."""
+        return self.slug
+
+    @property
+    def anchor_id(self):
+        return f"product-{self.slug}"
+
+    @property
+    def image(self):
+        return Image(self.image_url) if self.image_url else None
+
+    @property
+    def choice_label(self):
+        """How a choice field lists the product; subclasses add what tells products apart."""
+        return f"{self.title} ({self.kind})" if self.kind else self.title
+
+    def get_absolute_url(self):
+        """This site's product list when catalogue_client.urls is mounted, else the server's page."""
+        try:
+            return f"{reverse('catalogue_client:list')}?product={self.slug}#{self.anchor_id}"
+        except NoReverseMatch:
+            return self.url
+
+
+def get_product_class():
+    path = get_setting("CATALOGUE_CLIENT_PRODUCT_CLASS")
+    return import_string(path) if path else Product

catalogue_client/templates/catalogue_client/product_list.html

@@ -0,0 +1,21 @@
+<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><title>Products</title></head>
+<body>
+  <main>
+    <h1>Products</h1>
+    {% if catalogue_error %}<p role="alert">{{ catalogue_error }}</p>{% endif %}
+    {% for product in products %}
+      <article id="{{ product.anchor_id }}">
+        {% if product.image_url %}<a href="{{ product.url }}"><img src="{{ product.image_url }}" alt="" loading="lazy"></a>{% endif %}
+        <h2><a href="{{ product.url }}">{{ product.title }}</a></h2>
+        {% if product.subtitle %}<p>{{ product.subtitle }}</p>{% endif %}
+        {% if product.short_description %}<p>{{ product.short_description }}</p>{% endif %}
+        {% if product.purchase.formatted_price %}<p>{{ product.purchase.formatted_price }}</p>{% endif %}
+      </article>
+    {% empty %}
+      {% if not catalogue_error %}<p>No products are available.</p>{% endif %}
+    {% endfor %}
+  </main>
+</body>
+</html>

catalogue_client/tests/test_client.py

@@ -0,0 +1,115 @@
+from unittest.mock import Mock
+
+from django.test import RequestFactory, SimpleTestCase, override_settings
+
+from catalogue_client.api import CatalogueClient
+from catalogue_client.forms import CatalogueProductChoiceField
+from catalogue_client.models import Product
+from catalogue_client.utils import products_for_request
+
+
+PRODUCT = {
+    "slug": "sport-and-meditation",
+    "title": "Sport and Meditation",
+    "kind": "book",
+    "identifier": "9780884971234",
+    "attributes": {"author": "Sri Chinmoy", "language": "en"},
+    "group": {"slug": "sport-and-meditation", "title": "Sport and Meditation"},
+    "image_url": "https://books.example/media/cover.jpg",
+    "url": "https://books.example/books/sport-and-meditation/",
+    "description_html": "<p>Description</p>",
+    "purchase": {
+        "country": "GB",
+        "currency": "GBP",
+        "price": "16.99",
+        "formatted_price": "£16.99",
+        "store_links": [{"label": "Shop", "url": "https://shop.example/book"}],
+    },
+    "reading_age": "12+",
+}
+
+
+class MemoryCache:
+    def __init__(self):
+        self.values = {}
+
+    def get(self, key):
+        return self.values.get(key)
+
+    def set(self, key, value, timeout):
+        self.values[key] = value
+
+
+class Book(Product):
+    """What a consuming site's own subclass looks like."""
+
+    @property
+    def author(self):
+        return self.attr("author")
+
+    @property
+    def choice_label(self):
+        return f"{self.title} ({self.attr('language').upper()})"
+
+
+def czech_sites(site):
+    return {"attributes": {"language": "cs"}}
+
+
+def session_returning(payload):
+    response = Mock()
+    response.raise_for_status.return_value = None
+    response.json.return_value = payload
+    session = Mock()
+    session.get.return_value = response
+    return session
+
+
+class ProductValueTests(SimpleTestCase):
+    def test_api_data_exposes_the_display_interface(self):
+        product = Product.from_dict(PRODUCT)
+        self.assertEqual(product.pk, "sport-and-meditation")
+        self.assertEqual(product.image.get_absolute_url(), PRODUCT["image_url"])
+        self.assertEqual(product.attr("author"), "Sri Chinmoy")
+        self.assertEqual(product.attr("isbn", "none"), "none")
+        self.assertEqual(product.purchase.formatted_price, "£16.99")
+        self.assertEqual(product.purchase.direct_buy_link["label"], "Shop")
+
+    def test_keys_added_by_the_server_site_are_kept(self):
+        self.assertEqual(Product.from_dict(PRODUCT).extra, {"reading_age": "12+"})
+
+
+@override_settings(CATALOGUE_CLIENT_CACHE_SECONDS=60)
+class ApiClientTests(SimpleTestCase):
+    def test_list_products_passes_filters_and_caches(self):
+        session = session_returning({"count": 1, "results": [PRODUCT]})
+        client = CatalogueClient("https://books.example", session=session, cache_backend=MemoryCache())
+
+        first = client.list_products(country="GB", kinds=["book"], attributes={"language": ["en", "cs"]})
+        second = client.list_products(country="GB", kinds=["book"], attributes={"language": ["en", "cs"]})
+
+        self.assertEqual(first[0].slug, "sport-and-meditation")
+        self.assertEqual(second[0].purchase.country, "GB")
+        self.assertEqual(session.get.call_count, 1)
+        self.assertTrue(session.get.call_args.args[0].endswith("/api/v1/products/"))
+        params = session.get.call_args.kwargs["params"]
+        self.assertEqual((params["country"], params["kind"], params["attributes.language"]), ("GB", "book", "en,cs"))
+
+    @override_settings(CATALOGUE_CLIENT_PRODUCT_CLASS="catalogue_client.tests.test_client.Book")
+    def test_products_are_built_as_the_site_class(self):
+        session = session_returning(PRODUCT)
+        client = CatalogueClient("https://books.example", session=session, cache_backend=MemoryCache())
+        book = client.get_product("sport-and-meditation", country="GB")
+        self.assertIsInstance(book, Book)
+        self.assertEqual(book.author, "Sri Chinmoy")
+        field = CatalogueProductChoiceField(products=[book])
+        self.assertEqual(field.choices[1], ("sport-and-meditation", "Sport and Meditation (EN)"))
+
+    @override_settings(CATALOGUE_CLIENT_SITE_FILTERS="catalogue_client.tests.test_client.czech_sites")
+    def test_site_filters_apply_to_request_lookups(self):
+        session = session_returning({"count": 0, "results": []})
+        client = CatalogueClient("https://books.example", session=session, cache_backend=MemoryCache())
+        request = RequestFactory().get("/", {"country": "cz"})
+        products_for_request(request, client=client)
+        params = session.get.call_args.kwargs["params"]
+        self.assertEqual((params["country"], params["attributes.language"]), ("CZ", "cs"))

catalogue_client/urls.py

@@ -0,0 +1,9 @@
+from django.urls import path
+
+from . import views
+
+app_name = "catalogue_client"
+
+urlpatterns = [
+    path("", views.product_list, name="list"),
+]

catalogue_client/utils.py

@@ -0,0 +1,61 @@
+import random
+
+from django.utils.module_loading import import_string
+
+from .api import get_client
+from .conf import get_setting
+
+
+def site_country(site):
+    domain_settings = getattr(site, "domain_settings", None) if site else None
+    return (
+        getattr(domain_settings, "country", "")
+        or get_setting("CATALOGUE_CLIENT_DEFAULT_COUNTRY")
+    ).strip().upper()
+
+
+def country_for_request(request):
+    """?country=, then Cloudflare's CF-IPCountry, then the site's country.
+
+    Always pass a country to the server: without one it would locate the web
+    server's IP address instead of the visitor's.
+    """
+    if request is None:
+        return get_setting("CATALOGUE_CLIENT_DEFAULT_COUNTRY")
+    explicit = (request.GET.get("country") or "").strip().upper()
+    if len(explicit) == 2:
+        return explicit
+    cloudflare = (request.META.get("HTTP_CF_IPCOUNTRY") or "").strip().upper()
+    if len(cloudflare) == 2 and cloudflare not in {"XX", "T1"}:
+        return cloudflare
+    return site_country(getattr(request, "site", None))
+
+
+def site_filters(site):
+    """The CATALOGUE_CLIENT_SITE_FILTERS filters for *site* ({} without the setting)."""
+    path = get_setting("CATALOGUE_CLIENT_SITE_FILTERS")
+    return dict(import_string(path)(site) or {}) if path else {}
+
+
+def products_for_site(site, *, country=None, client=None, **filters):
+    return (client or get_client()).list_products(
+        country=country if country is not None else site_country(site),
+        **{**site_filters(site), **filters},
+    )
+
+
+def products_for_request(request, *, client=None, **filters):
+    site = getattr(request, "site", None)
+    return (client or get_client()).list_products(
+        country=country_for_request(request),
+        **{**site_filters(site), **filters},
+    )
+
+
+def random_products_for_request(request, limit, *, client=None, **filters):
+    products = products_for_request(request, client=client, **filters)
+    return random.sample(products, min(max(int(limit), 0), len(products)))
+
+
+def product_for_request(request, slug, *, client=None):
+    return (client or get_client()).get_product(slug, country=country_for_request(request))

catalogue_client/views.py

@@ -0,0 +1,21 @@
+from django.shortcuts import render
+
+from .api import CatalogueError
+from .conf import get_setting
+from .utils import products_for_request
+
+
+def product_list(request):
+    error = ""
+    try:
+        products = products_for_request(request)
+    except CatalogueError as exc:
+        products = []
+        error = str(exc)
+    selected_slug = (request.GET.get("product") or "").strip()
+    selected_product = next((product for product in products if product.slug == selected_slug), None)
+    return render(request, get_setting("CATALOGUE_CLIENT_TEMPLATE"), {
+        "products": products,
+        "selected_product": selected_product,
+        "catalogue_error": error,
+    })

catalogue_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: catalogue-client
+Version: 0.1.0
+Summary: Django client for showing products from a catalogue-server site
+Author: Vasudeva Server
+License-Expression: MIT
+Project-URL: Homepage, https://vasudevaserver.org
+Project-URL: Source, https://gitlab.com/vasudeva-server/catalogue-client
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django<6.0,>=5.2
+Requires-Dist: requests>=2.31
+Dynamic: license-file
+
+# catalogue-client
+
+`catalogue-client` lets a Django site show products from another site that runs
+[catalogue-server](https://gitlab.com/vasudeva-server/catalogue-server): titles,
+descriptions, images, and the buying options for the visitor's country. It
+stores nothing locally. Every product is a Python value object built from the
+server's read-only JSON API and cached.
+
+## Setup
+
+```python
+INSTALLED_APPS += ["catalogue_client.apps.CatalogueClientConfig"]
+
+CATALOGUE_SERVER_URL = "https://catalogue.example.org"
+```
+
+Optionally mount the list page:
+
+```python
+path("products/", include("catalogue_client.urls")),
+```
+
+## Reading products
+
+```python
+from catalogue_client.utils import products_for_request, product_for_request
+
+products = products_for_request(request, kinds=["book"], attributes={"language": "en"})
+product = product_for_request(request, "trail-pack")
+```
+
+Filters: `slugs`, `kinds`, `groups`, `q`, and `attributes` (attribute name to one
+value or a list of values). Calls made for a request pass the visitor's country
+(`?country=`, Cloudflare's `CF-IPCountry`, then the site's country), because
+without one the server would locate the web server instead of the visitor.
+`products_for_site(site)` does the same outside a request, for example in a
+management command.
+
+A `Product` has the server's generic fields (`slug`, `title`, `subtitle`,
+`kind`, `identifier`, `group`, `short_description`, `description_html`,
+`image_url`, `images`, `url`, `external_url`, `related_products`) and a
+`purchase` (`PurchaseInfo`: price, offers, store links, note, distributors).
+
+## Fields the server site added
+
+A catalogue-server site keeps its own fields in each product's `attributes`
+(a books site stores the author, language, publisher and so on there), and can
+add computed keys to the API with its `CATALOGUE_API_PRODUCT_DATA` setting. Both
+reach the client unchanged: `product.attributes` and `product.attr("author")`
+for the first, `product.extra` for the second.
+
+To give them names, subclass `Product` in your own app and point
+`CATALOGUE_CLIENT_PRODUCT_CLASS` at it. Every product the client returns is then
+built as your class:
+
+```python
+# my_site/catalogue.py
+from catalogue_client.models import Product
+
+
+class Book(Product):
+    @property
+    def author(self):
+        return self.attr("author")
+
+    @property
+    def choice_label(self):  # how CatalogueProductChoiceField lists it
+        return f"{self.title} ({self.attr('language').upper()})"
+```
+
+```python
+CATALOGUE_CLIENT_PRODUCT_CLASS = "my_site.catalogue.Book"
+```
+
+Filters that always apply to a site, such as showing a Czech site only Czech
+editions, come from `CATALOGUE_CLIENT_SITE_FILTERS`, a function
+`(site) -> dict` of the filters above.
+
+## Settings
+
+| Setting | Default | |
+|---|---|---|
+| `CATALOGUE_SERVER_URL` | (required) | catalogue-server origin, no path |
+| `CATALOGUE_CLIENT_API_PATH` | `/api/v1/` | |
+| `CATALOGUE_CLIENT_TIMEOUT` | `10` | seconds |
+| `CATALOGUE_CLIENT_CACHE_SECONDS` | `3600` | |
+| `CATALOGUE_CLIENT_DEFAULT_COUNTRY` | `""` | when neither the request nor the site gives one |
+| `CATALOGUE_CLIENT_TEMPLATE` | `catalogue_client/product_list.html` | template of the list page (context: `products`, `selected_product`, `catalogue_error`) |
+| `CATALOGUE_CLIENT_PRODUCT_CLASS` | `""` | dotted path to your `Product` subclass |
+| `CATALOGUE_CLIENT_SITE_FILTERS` | `""` | dotted path to `(site) -> dict` of filters |
+
+The site's country is read from `site.domain_settings.country` when the site
+uses [servicetrees](https://gitlab.com/vasudeva-server/servicetrees); otherwise
+set `CATALOGUE_CLIENT_DEFAULT_COUNTRY`.
+
+## Status
+
+Unmaintained and provided as-is. There is no commitment to updates, security fixes, or support.
+
+Pull requests are welcome and may be looked at. There is no commitment to review or merge them. Contributions are licensed under the same license as this project.
+
+Issues are not tracked. Please do not open bug reports or feature requests.
+
+This repository is [MIT licensed](LICENSE).
+
+[Vasudeva Server](https://vasudevaserver.org)

catalogue_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+catalogue_client/__init__.py,sha256=e3DYJHa2s-GWNRNAJRDyEH8YI0WjWZLmZhZ6SHJKH0E,81
+catalogue_client/api.py,sha256=4sCXvWxHlvYqzYMFOf_5FqkQHSSgt3EgCreGYz8s17E,3851
+catalogue_client/apps.py,sha256=SIr4IkR_FI94z3Lw1P0G4UBopZN4h5fUyVNkcNRS7es,201
+catalogue_client/conf.py,sha256=rZ9XIFJnh2Ca9z3WsKlsFnmycn2TyWcIRFHXxyLR9qc,801
+catalogue_client/forms.py,sha256=IzdZqT6PcTyKVe48xgcxjQzJjN5pLY1f8E32i2wf15w,452
+catalogue_client/models.py,sha256=ptJOTCCT1eNAlK5JwYEycqsM4BCBP5aFM6h8R7LOOVw,5863
+catalogue_client/urls.py,sha256=AeZLnDOrS1WpPIbYsCXMhBB9JPuYaDMN8Pb4HO84N-U,147
+catalogue_client/utils.py,sha256=IQlYHWQ5hNERuWAuvChhSonShjLILuPfIHYC7wWn1D8,2161
+catalogue_client/views.py,sha256=xekV_r6fbc_Dg-kGmuqvBUtMDvS6BgThFwddAdR8cy4,675
+catalogue_client/migrations/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+catalogue_client/templates/catalogue_client/product_list.html,sha256=0R5BXhlmRPxjASzgKKEyIF9iE01W3IdLp3nrStRdddI,921
+catalogue_client/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+catalogue_client/tests/test_client.py,sha256=KMBMXY2tbFckLQ9lDfX_3Jnmks9lMudiO3_FF-oKVUE,4694
+catalogue_client-0.1.0.dist-info/licenses/LICENSE,sha256=cjw5dL5wDMy6mDzC1e2pA6_73FVPaDJnoO1Nxmr582Q,1072
+catalogue_client-0.1.0.dist-info/METADATA,sha256=VPEHiK_YPF_To-9Wo-i970wYzSMf9Ds9Wutm7sa4j64,4705
+catalogue_client-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+catalogue_client-0.1.0.dist-info/top_level.txt,sha256=8KQTQydDz3d9uZdQYBLgzYnUOO2XwuIq8IeqKjaMbcQ,17
+catalogue_client-0.1.0.dist-info/RECORD,,

catalogue_client-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

catalogue_client-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vasudeva Server
+
+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.

catalogue_client-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+catalogue_client