humanoid-crud 0.1.0__tar.gz

humanoid_crud-0.1.0/LICENSE

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

humanoid_crud-0.1.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: humanoid-crud
+Version: 0.1.0
+Summary: One-line CRUD registration for Django REST Framework. Built on top of DRF's mixins/generics so you never have to write a Serializer, ViewSet, or router.register() by hand for the common case.
+Author: Your Name
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourname/humanoid-crud
+Project-URL: Repository, https://github.com/yourname/humanoid-crud
+Keywords: django,django-rest-framework,drf,crud,api,rest
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4
+Classifier: Framework :: Django :: 5
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: djangorestframework>=3.14
+Provides-Extra: filters
+Requires-Dist: django-filter>=23.0; extra == "filters"
+Dynamic: license-file
+
+# humanoid-crud
+
+A one-line CRUD registrar for Django REST Framework. Built **on top of** DRF's
+mixins/generics (it generates real `ModelSerializer` and `ModelViewSet`
+classes for you) — the point isn't to avoid mixins, it's that you never have
+to write or stack them by hand.
+
+## Install
+
+```bash
+pip install humanoid-crud
+```
+
+If you want `filterset_fields` (exact-match filtering), install the extra:
+
+```bash
+pip install humanoid-crud[filters]
+```
+
+Note: the **package name on PyPI** is `humanoid-crud` (hyphen, matching PyPI
+convention), but you **import it in Python** as `humanoid_crud` (underscore,
+since hyphens aren't valid in Python identifiers). This is normal — the same
+is true for packages like `django-rest-framework` → `import rest_framework`.
+
+## The problem this solves
+
+The normal DRF CRUD recipe for one model is:
+
+```python
+# serializers.py
+class BookSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Book
+        fields = '__all__'
+
+# views.py
+class BookViewSet(viewsets.ModelViewSet):
+    queryset = Book.objects.all()
+    serializer_class = BookSerializer
+
+# urls.py
+router.register('books', BookViewSet)
+```
+
+Three files, three pieces of boilerplate, for every single model.
+`humanoid_crud` collapses that to:
+
+```python
+import humanoid_crud
+humanoid_crud.register(Book)
+```
+
+## Quick start
+
+1. `pip install humanoid-crud`
+2. Add `'rest_framework'` to `INSTALLED_APPS` in `settings.py` if it isn't
+   already there.
+3. Create a small file — e.g. `myapp/api.py` — where you register your
+   models:
+
+```python
+# myapp/api.py
+import humanoid_crud
+from myapp.models import Book, Author
+
+humanoid_crud.register(Author)
+humanoid_crud.register(Book)
+```
+
+4. In your project's `urls.py`, import that file (so the registrations run)
+   and add the generated routes:
+
+```python
+from django.contrib import admin
+from django.urls import path
+
+from myapp import api          # running this import triggers registration
+import humanoid_crud
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+] + humanoid_crud.urls
+```
+
+That's it. You now have, for each model:
+
+| Method | URL              | Action          |
+|--------|-------------------|-----------------|
+| GET    | `/books/`         | list            |
+| POST   | `/books/`         | create          |
+| GET    | `/books/<pk>/`     | retrieve        |
+| PUT    | `/books/<pk>/`     | full update     |
+| PATCH  | `/books/<pk>/`     | partial update  |
+| DELETE | `/books/<pk>/`     | delete          |
+
+All validation, 404 handling, and FK integrity checks are standard DRF
+behavior — nothing is hidden or changed, just wired up for you.
+
+## Going beyond the default
+
+Every option is optional — pass only what you need:
+
+```python
+from rest_framework.permissions import IsAuthenticated
+
+humanoid_crud.register(
+    Book,
+    fields=["title", "author", "price"],     # restrict exposed fields
+    read_only_fields=["created_at"],
+    permissions=[IsAuthenticated],            # default is AllowAny — lock this down!
+    search_fields=["title"],                  # enables ?search=
+    ordering_fields=["price", "created_at"],  # enables ?ordering=
+    filterset_fields=["author"],              # exact-match filtering (needs the [filters] extra)
+    lookup="slug",                            # use a non-pk field in the URL
+    url="library-books",                      # custom URL segment
+)
+```
+
+### Escape hatch: bring your own serializer or viewset
+
+If one model needs custom logic (e.g. a custom `create()`, extra validation,
+nested writes), you don't lose `humanoid_crud`'s URL registration — just hand
+it your own class:
+
+```python
+class BookViewSet(viewsets.ModelViewSet):
+    queryset = Book.objects.all()
+    serializer_class = BookSerializer
+
+    def perform_create(self, serializer):
+        serializer.save(added_by=self.request.user)
+
+humanoid_crud.register(Book, viewset_class=BookViewSet)
+```
+
+The generated classes are ordinary `ModelSerializer` / `ModelViewSet`
+subclasses — if you ever outgrow the one-liner for a specific model, you
+write that one model the normal DRF way and `humanoid_crud` still handles
+the routing.
+
+## Important: default permissions are wide open
+
+If you don't pass `permissions=[...]`, every registered model defaults to
+`AllowAny` — anyone can read and write it, no login required. Fine for local
+prototyping. **Set explicit permissions before deploying anything real.**
+
+## License
+
+MIT

humanoid_crud-0.1.0/README.md

@@ -0,0 +1,149 @@
+# humanoid-crud
+
+A one-line CRUD registrar for Django REST Framework. Built **on top of** DRF's
+mixins/generics (it generates real `ModelSerializer` and `ModelViewSet`
+classes for you) — the point isn't to avoid mixins, it's that you never have
+to write or stack them by hand.
+
+## Install
+
+```bash
+pip install humanoid-crud
+```
+
+If you want `filterset_fields` (exact-match filtering), install the extra:
+
+```bash
+pip install humanoid-crud[filters]
+```
+
+Note: the **package name on PyPI** is `humanoid-crud` (hyphen, matching PyPI
+convention), but you **import it in Python** as `humanoid_crud` (underscore,
+since hyphens aren't valid in Python identifiers). This is normal — the same
+is true for packages like `django-rest-framework` → `import rest_framework`.
+
+## The problem this solves
+
+The normal DRF CRUD recipe for one model is:
+
+```python
+# serializers.py
+class BookSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Book
+        fields = '__all__'
+
+# views.py
+class BookViewSet(viewsets.ModelViewSet):
+    queryset = Book.objects.all()
+    serializer_class = BookSerializer
+
+# urls.py
+router.register('books', BookViewSet)
+```
+
+Three files, three pieces of boilerplate, for every single model.
+`humanoid_crud` collapses that to:
+
+```python
+import humanoid_crud
+humanoid_crud.register(Book)
+```
+
+## Quick start
+
+1. `pip install humanoid-crud`
+2. Add `'rest_framework'` to `INSTALLED_APPS` in `settings.py` if it isn't
+   already there.
+3. Create a small file — e.g. `myapp/api.py` — where you register your
+   models:
+
+```python
+# myapp/api.py
+import humanoid_crud
+from myapp.models import Book, Author
+
+humanoid_crud.register(Author)
+humanoid_crud.register(Book)
+```
+
+4. In your project's `urls.py`, import that file (so the registrations run)
+   and add the generated routes:
+
+```python
+from django.contrib import admin
+from django.urls import path
+
+from myapp import api          # running this import triggers registration
+import humanoid_crud
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+] + humanoid_crud.urls
+```
+
+That's it. You now have, for each model:
+
+| Method | URL              | Action          |
+|--------|-------------------|-----------------|
+| GET    | `/books/`         | list            |
+| POST   | `/books/`         | create          |
+| GET    | `/books/<pk>/`     | retrieve        |
+| PUT    | `/books/<pk>/`     | full update     |
+| PATCH  | `/books/<pk>/`     | partial update  |
+| DELETE | `/books/<pk>/`     | delete          |
+
+All validation, 404 handling, and FK integrity checks are standard DRF
+behavior — nothing is hidden or changed, just wired up for you.
+
+## Going beyond the default
+
+Every option is optional — pass only what you need:
+
+```python
+from rest_framework.permissions import IsAuthenticated
+
+humanoid_crud.register(
+    Book,
+    fields=["title", "author", "price"],     # restrict exposed fields
+    read_only_fields=["created_at"],
+    permissions=[IsAuthenticated],            # default is AllowAny — lock this down!
+    search_fields=["title"],                  # enables ?search=
+    ordering_fields=["price", "created_at"],  # enables ?ordering=
+    filterset_fields=["author"],              # exact-match filtering (needs the [filters] extra)
+    lookup="slug",                            # use a non-pk field in the URL
+    url="library-books",                      # custom URL segment
+)
+```
+
+### Escape hatch: bring your own serializer or viewset
+
+If one model needs custom logic (e.g. a custom `create()`, extra validation,
+nested writes), you don't lose `humanoid_crud`'s URL registration — just hand
+it your own class:
+
+```python
+class BookViewSet(viewsets.ModelViewSet):
+    queryset = Book.objects.all()
+    serializer_class = BookSerializer
+
+    def perform_create(self, serializer):
+        serializer.save(added_by=self.request.user)
+
+humanoid_crud.register(Book, viewset_class=BookViewSet)
+```
+
+The generated classes are ordinary `ModelSerializer` / `ModelViewSet`
+subclasses — if you ever outgrow the one-liner for a specific model, you
+write that one model the normal DRF way and `humanoid_crud` still handles
+the routing.
+
+## Important: default permissions are wide open
+
+If you don't pass `permissions=[...]`, every registered model defaults to
+`AllowAny` — anyone can read and write it, no login required. Fine for local
+prototyping. **Set explicit permissions before deploying anything real.**
+
+## License
+
+MIT

humanoid_crud-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "humanoid-crud"
+version = "0.1.0"
+description = "One-line CRUD registration for Django REST Framework. Built on top of DRF's mixins/generics so you never have to write a Serializer, ViewSet, or router.register() by hand for the common case."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+    { name = "Your Name" }
+]
+keywords = ["django", "django-rest-framework", "drf", "crud", "api", "rest"]
+classifiers = [
+    "Framework :: Django",
+    "Framework :: Django :: 4",
+    "Framework :: Django :: 5",
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "djangorestframework>=3.14",
+]
+
+[project.optional-dependencies]
+filters = ["django-filter>=23.0"]
+
+[project.urls]
+Homepage = "https://github.com/yourname/humanoid-crud"
+Repository = "https://github.com/yourname/humanoid-crud"
+
+# Tell setuptools the package lives under src/, named humanoid_crud
+[tool.setuptools.packages.find]
+where = ["src"]

humanoid_crud-0.1.0/setup.cfg

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

humanoid_crud-0.1.0/src/humanoid_crud/__init__.py

@@ -0,0 +1,13 @@
+from .registry import register, router, _registry as registry  # noqa: F401
+
+__version__ = "0.1.0"
+
+
+def __getattr__(name):
+    # `humanoid_crud.urls` must be evaluated lazily, not at import time —
+    # otherwise it gets cached empty before any register() calls happen.
+    # This module-level __getattr__ (PEP 562) makes `import humanoid_crud;
+    # humanoid_crud.urls` always reflect the router's *current* state.
+    if name == "urls":
+        return router.urls
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

humanoid_crud-0.1.0/src/humanoid_crud/registry.py

@@ -0,0 +1,178 @@
+"""
+HumanoidCRUD — a one-line CRUD registrar built on top of DRF's mixins/generics.
+
+Goal: you should never have to write a Serializer, a ViewSet, or a router.register()
+line by hand for the common case. Everything is inferred from the model, with
+optional overrides for when you need more control.
+
+Usage (the entire API, in your urls.py, api.py, or apps.py):
+
+    import humanoid_crud
+    humanoid_crud.register(Book)
+
+That's it. GET/POST /books/, GET/PUT/PATCH/DELETE /books/<pk>/ all work.
+
+Overrides when you need them:
+
+    humanoid_crud.register(
+        Book,
+        fields=["title", "author", "price"],   # restrict serializer fields
+        read_only_fields=["created_at"],
+        permissions=[IsAuthenticatedOrReadOnly],
+        search_fields=["title", "author"],
+        ordering_fields=["price", "created_at"],
+        lookup="slug",                          # use a non-pk field in the URL
+        url="library-books",                    # custom URL segment
+    )
+"""
+from __future__ import annotations
+
+from rest_framework import serializers, viewsets, permissions as drf_permissions
+from rest_framework.routers import DefaultRouter
+
+# A single shared router. Every call to register() adds to this.
+# The project's urls.py just does: urlpatterns += humanoid_crud.urls
+router = DefaultRouter()
+
+# Keep track of what's registered, mostly useful for introspection/debugging.
+_registry: dict[str, dict] = {}
+
+
+def _default_url_name(model) -> str:
+    """books, not book — DRF routers expect a plural-ish URL segment."""
+    name = model._meta.model_name  # e.g. "book"
+    return name if name.endswith("s") else f"{name}s"
+
+
+def _make_serializer(model, *, fields=None, read_only_fields=None, extra_kwargs=None):
+    """Build a ModelSerializer class on the fly. This is the auto-inferred part."""
+    meta_attrs = {
+        "model": model,
+        "fields": fields or "__all__",
+    }
+    if read_only_fields:
+        meta_attrs["read_only_fields"] = read_only_fields
+    if extra_kwargs:
+        meta_attrs["extra_kwargs"] = extra_kwargs
+
+    Meta = type("Meta", (), meta_attrs)
+    serializer_cls = type(
+        f"{model.__name__}AutoSerializer",
+        (serializers.ModelSerializer,),
+        {"Meta": Meta},
+    )
+    return serializer_cls
+
+
+def _make_viewset(
+    model,
+    serializer_cls,
+    *,
+    queryset=None,
+    permissions=None,
+    search_fields=None,
+    ordering_fields=None,
+    filterset_fields=None,
+    lookup="pk",
+):
+    """Build a ModelViewSet — this is the part that replaces hand-stacked mixins."""
+    from rest_framework import filters as drf_filters
+
+    attrs = {
+        "queryset": queryset if queryset is not None else model.objects.all(),
+        "serializer_class": serializer_cls,
+        "lookup_field": lookup,
+        "permission_classes": permissions or [drf_permissions.AllowAny],
+    }
+
+    filter_backends = []
+
+    if search_fields:
+        attrs["search_fields"] = search_fields
+        filter_backends.append(drf_filters.SearchFilter)
+    if ordering_fields:
+        attrs["ordering_fields"] = ordering_fields
+        filter_backends.append(drf_filters.OrderingFilter)
+    if filterset_fields:
+        # django-filter is an optional dependency — only import if actually used.
+        try:
+            from django_filters.rest_framework import DjangoFilterBackend
+        except ImportError as exc:
+            raise ImportError(
+                "filterset_fields requires django-filter. "
+                "Install it with: pip install django-filter"
+            ) from exc
+        attrs["filterset_fields"] = filterset_fields
+        filter_backends.append(DjangoFilterBackend)
+
+    if filter_backends:
+        attrs["filter_backends"] = filter_backends
+
+    viewset_cls = type(
+        f"{model.__name__}AutoViewSet",
+        (viewsets.ModelViewSet,),
+        attrs,
+    )
+    return viewset_cls
+
+
+def register(
+    model,
+    *,
+    fields=None,
+    read_only_fields=None,
+    extra_kwargs=None,
+    queryset=None,
+    permissions=None,
+    search_fields=None,
+    ordering_fields=None,
+    filterset_fields=None,
+    lookup="pk",
+    url=None,
+    serializer_class=None,
+    viewset_class=None,
+):
+    """
+    Register full CRUD for `model` in one call.
+
+    Required:
+        model: a Django model class.
+
+    Everything else is optional. If you don't pass anything, you get a
+    sensible default: all fields exposed, AllowAny permissions, pk lookup,
+    URL inferred from the model name.
+
+    Escape hatches:
+        serializer_class / viewset_class: pass your own hand-written class
+        if auto-inference isn't enough for this one model. HumanoidCRUD will
+        still handle the router registration for you.
+    """
+    url_name = url or _default_url_name(model)
+
+    serializer_cls = serializer_class or _make_serializer(
+        model,
+        fields=fields,
+        read_only_fields=read_only_fields,
+        extra_kwargs=extra_kwargs,
+    )
+
+    viewset_cls = viewset_class or _make_viewset(
+        model,
+        serializer_cls,
+        queryset=queryset,
+        permissions=permissions,
+        search_fields=search_fields,
+        ordering_fields=ordering_fields,
+        filterset_fields=filterset_fields,
+        lookup=lookup,
+    )
+
+    router.register(url_name, viewset_cls, basename=url_name)
+
+    _registry[url_name] = {
+        "model": model,
+        "serializer": serializer_cls,
+        "viewset": viewset_cls,
+    }
+
+    return viewset_cls  # handy if caller wants to extend it further

humanoid_crud-0.1.0/src/humanoid_crud.egg-info/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: humanoid-crud
+Version: 0.1.0
+Summary: One-line CRUD registration for Django REST Framework. Built on top of DRF's mixins/generics so you never have to write a Serializer, ViewSet, or router.register() by hand for the common case.
+Author: Your Name
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourname/humanoid-crud
+Project-URL: Repository, https://github.com/yourname/humanoid-crud
+Keywords: django,django-rest-framework,drf,crud,api,rest
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4
+Classifier: Framework :: Django :: 5
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: djangorestframework>=3.14
+Provides-Extra: filters
+Requires-Dist: django-filter>=23.0; extra == "filters"
+Dynamic: license-file
+
+# humanoid-crud
+
+A one-line CRUD registrar for Django REST Framework. Built **on top of** DRF's
+mixins/generics (it generates real `ModelSerializer` and `ModelViewSet`
+classes for you) — the point isn't to avoid mixins, it's that you never have
+to write or stack them by hand.
+
+## Install
+
+```bash
+pip install humanoid-crud
+```
+
+If you want `filterset_fields` (exact-match filtering), install the extra:
+
+```bash
+pip install humanoid-crud[filters]
+```
+
+Note: the **package name on PyPI** is `humanoid-crud` (hyphen, matching PyPI
+convention), but you **import it in Python** as `humanoid_crud` (underscore,
+since hyphens aren't valid in Python identifiers). This is normal — the same
+is true for packages like `django-rest-framework` → `import rest_framework`.
+
+## The problem this solves
+
+The normal DRF CRUD recipe for one model is:
+
+```python
+# serializers.py
+class BookSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Book
+        fields = '__all__'
+
+# views.py
+class BookViewSet(viewsets.ModelViewSet):
+    queryset = Book.objects.all()
+    serializer_class = BookSerializer
+
+# urls.py
+router.register('books', BookViewSet)
+```
+
+Three files, three pieces of boilerplate, for every single model.
+`humanoid_crud` collapses that to:
+
+```python
+import humanoid_crud
+humanoid_crud.register(Book)
+```
+
+## Quick start
+
+1. `pip install humanoid-crud`
+2. Add `'rest_framework'` to `INSTALLED_APPS` in `settings.py` if it isn't
+   already there.
+3. Create a small file — e.g. `myapp/api.py` — where you register your
+   models:
+
+```python
+# myapp/api.py
+import humanoid_crud
+from myapp.models import Book, Author
+
+humanoid_crud.register(Author)
+humanoid_crud.register(Book)
+```
+
+4. In your project's `urls.py`, import that file (so the registrations run)
+   and add the generated routes:
+
+```python
+from django.contrib import admin
+from django.urls import path
+
+from myapp import api          # running this import triggers registration
+import humanoid_crud
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+] + humanoid_crud.urls
+```
+
+That's it. You now have, for each model:
+
+| Method | URL              | Action          |
+|--------|-------------------|-----------------|
+| GET    | `/books/`         | list            |
+| POST   | `/books/`         | create          |
+| GET    | `/books/<pk>/`     | retrieve        |
+| PUT    | `/books/<pk>/`     | full update     |
+| PATCH  | `/books/<pk>/`     | partial update  |
+| DELETE | `/books/<pk>/`     | delete          |
+
+All validation, 404 handling, and FK integrity checks are standard DRF
+behavior — nothing is hidden or changed, just wired up for you.
+
+## Going beyond the default
+
+Every option is optional — pass only what you need:
+
+```python
+from rest_framework.permissions import IsAuthenticated
+
+humanoid_crud.register(
+    Book,
+    fields=["title", "author", "price"],     # restrict exposed fields
+    read_only_fields=["created_at"],
+    permissions=[IsAuthenticated],            # default is AllowAny — lock this down!
+    search_fields=["title"],                  # enables ?search=
+    ordering_fields=["price", "created_at"],  # enables ?ordering=
+    filterset_fields=["author"],              # exact-match filtering (needs the [filters] extra)
+    lookup="slug",                            # use a non-pk field in the URL
+    url="library-books",                      # custom URL segment
+)
+```
+
+### Escape hatch: bring your own serializer or viewset
+
+If one model needs custom logic (e.g. a custom `create()`, extra validation,
+nested writes), you don't lose `humanoid_crud`'s URL registration — just hand
+it your own class:
+
+```python
+class BookViewSet(viewsets.ModelViewSet):
+    queryset = Book.objects.all()
+    serializer_class = BookSerializer
+
+    def perform_create(self, serializer):
+        serializer.save(added_by=self.request.user)
+
+humanoid_crud.register(Book, viewset_class=BookViewSet)
+```
+
+The generated classes are ordinary `ModelSerializer` / `ModelViewSet`
+subclasses — if you ever outgrow the one-liner for a specific model, you
+write that one model the normal DRF way and `humanoid_crud` still handles
+the routing.
+
+## Important: default permissions are wide open
+
+If you don't pass `permissions=[...]`, every registered model defaults to
+`AllowAny` — anyone can read and write it, no login required. Fine for local
+prototyping. **Set explicit permissions before deploying anything real.**
+
+## License
+
+MIT

humanoid_crud-0.1.0/src/humanoid_crud.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/humanoid_crud/__init__.py
+src/humanoid_crud/registry.py
+src/humanoid_crud.egg-info/PKG-INFO
+src/humanoid_crud.egg-info/SOURCES.txt
+src/humanoid_crud.egg-info/dependency_links.txt
+src/humanoid_crud.egg-info/requires.txt
+src/humanoid_crud.egg-info/top_level.txt

humanoid_crud-0.1.0/src/humanoid_crud.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

humanoid_crud-0.1.0/src/humanoid_crud.egg-info/requires.txt

@@ -0,0 +1,4 @@
+djangorestframework>=3.14
+
+[filters]
+django-filter>=23.0

humanoid_crud-0.1.0/src/humanoid_crud.egg-info/top_level.txt

@@ -0,0 +1 @@
+humanoid_crud