django-rest-spreadsheets 1.0.0__tar.gz

django_rest_spreadsheets-1.0.0/LICENCE

@@ -0,0 +1,7 @@
+Copyright 2025 Gerben van Eerten
+
+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.

django_rest_spreadsheets-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+recursive-include spreadsheet/static *
+recursive-include spreadsheet/templates *

django_rest_spreadsheets-1.0.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: django-rest-spreadsheets
+Version: 1.0.0
+Summary: Spreadsheets based on django rest framework
+Home-page: https://github.com/g3rb3n/django-rest-spreadsheets/
+Author: gerben van Eerten
+Author-email: Gerben van Eerten <info@gerbenvaneerten.nl>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/g3rb3n/django-rest-spreadsheets
+Project-URL: Issues, https://github.com/g3rb3n/django-rest-spreadsheets/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+
+# Introduction
+Spreadsheets based on django models and django rest framework.
+
+# Setup
+`make setup`
+
+# Run
+`make run`
+
+# Open browser
+`make open-browser`
+
+# Testing
+`make test`

django_rest_spreadsheets-1.0.0/README.md

@@ -0,0 +1,14 @@
+# Introduction
+Spreadsheets based on django models and django rest framework.
+
+# Setup
+`make setup`
+
+# Run
+`make run`
+
+# Open browser
+`make open-browser`
+
+# Testing
+`make test`

django_rest_spreadsheets-1.0.0/django_rest_spreadsheets.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: django-rest-spreadsheets
+Version: 1.0.0
+Summary: Spreadsheets based on django rest framework
+Home-page: https://github.com/g3rb3n/django-rest-spreadsheets/
+Author: gerben van Eerten
+Author-email: Gerben van Eerten <info@gerbenvaneerten.nl>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/g3rb3n/django-rest-spreadsheets
+Project-URL: Issues, https://github.com/g3rb3n/django-rest-spreadsheets/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+
+# Introduction
+Spreadsheets based on django models and django rest framework.
+
+# Setup
+`make setup`
+
+# Run
+`make run`
+
+# Open browser
+`make open-browser`
+
+# Testing
+`make test`

django_rest_spreadsheets-1.0.0/django_rest_spreadsheets.egg-info/SOURCES.txt

@@ -0,0 +1,38 @@
+LICENCE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+django_rest_spreadsheets.egg-info/PKG-INFO
+django_rest_spreadsheets.egg-info/SOURCES.txt
+django_rest_spreadsheets.egg-info/dependency_links.txt
+django_rest_spreadsheets.egg-info/top_level.txt
+spreadsheet/__init__.py
+spreadsheet/fields.py
+spreadsheet/schema.py
+spreadsheet/serializers.py
+spreadsheet/urls.py
+spreadsheet/util.py
+spreadsheet/views.py
+spreadsheet/migrations/__init__.py
+spreadsheet/static/deps/jquery-ui.css
+spreadsheet/static/deps/jquery-ui.js
+spreadsheet/static/deps/jquery.datetimepicker.css
+spreadsheet/static/deps/jquery.datetimepicker.full.js
+spreadsheet/static/deps/jquery.datetimepicker.js
+spreadsheet/static/deps/jquery.datetimepicker.min.css
+spreadsheet/static/deps/moment.js
+spreadsheet/static/spreadsheet/css/menu.css
+spreadsheet/static/spreadsheet/css/reset.css
+spreadsheet/static/spreadsheet/css/screen.css
+spreadsheet/static/spreadsheet/css/spreadsheet.css
+spreadsheet/static/spreadsheet/img/cancel.svg
+spreadsheet/static/spreadsheet/img/create.svg
+spreadsheet/static/spreadsheet/img/delete.svg
+spreadsheet/static/spreadsheet/img/icon.png
+spreadsheet/static/spreadsheet/img/update.svg
+spreadsheet/static/spreadsheet/js/RestApi6.js
+spreadsheet/static/spreadsheet/js/ScreenStack.js
+spreadsheet/static/spreadsheet/js/SpreadSheet.js
+spreadsheet/static/spreadsheet/js/menu.js
+spreadsheet/templates/index.html

django_rest_spreadsheets-1.0.0/django_rest_spreadsheets.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_rest_spreadsheets-1.0.0/django_rest_spreadsheets.egg-info/top_level.txt

@@ -0,0 +1 @@
+spreadsheet

django_rest_spreadsheets-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "django-rest-spreadsheets"
+version = "1.0.0"
+authors = [
+  { name="Gerben van Eerten", email="info@gerbenvaneerten.nl" },
+]
+description = "Spreadsheets based on django rest framework"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICENCE*"]
+
+[project.urls]
+Homepage = "https://github.com/g3rb3n/django-rest-spreadsheets"
+Issues = "https://github.com/g3rb3n/django-rest-spreadsheets/issues"

django_rest_spreadsheets-1.0.0/setup.cfg

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

django_rest_spreadsheets-1.0.0/setup.py

@@ -0,0 +1,24 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="django-rest-spreadsheets",
+    version="1.0.0",
+    author="gerben van Eerten",
+    author_email="info@gerbenvaneerten.nl",
+    description="Spreadsheets based on django rest framework",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/g3rb3n/django-rest-spreadsheets/",
+    packages=setuptools.find_packages(exclude=['testproject*']),
+    package_data={'django-rest-spreadsheets': ['spreadsheet/static', 'spreadsheet/templates', 'spreadsheet/migrations']},
+    include_package_data=True,
+
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+)

django_rest_spreadsheets-1.0.0/spreadsheet/fields.py

@@ -0,0 +1,196 @@
+import logging
+
+from django.utils.translation import gettext_lazy as _
+from django.urls import NoReverseMatch, Resolver404, get_script_prefix, resolve
+from django.utils.encoding import uri_to_iri
+from rest_framework import relations
+from rest_framework.reverse import reverse
+from urllib.parse import urlparse
+
+
+logger = logging.getLogger(__name__)
+
+
+class Ref(str):
+    """
+    A string like object that additionally has an associated name.
+    We use this for hyperlinked URLs that may render as a named link
+    in some contexts, or render as a plain URL in others.
+    """
+    def __new__(self, url, obj):
+        ret = super().__new__(self, url)
+        ret.obj = obj
+        return ret
+
+    def __getnewargs__(self):
+        return(str(self), self.name,)
+
+    @property
+    def name(self):
+        # This ensures that we only called `__str__` lazily,
+        # as in some cases calling __str__ on a model instances *might*
+        # involve a database lookup.
+        return str(self.obj)
+
+    is_hyperlink = True
+
+
+class RefRelatedField(relations.RelatedField):
+    lookup_field = 'pk'
+    view_name = None
+
+    default_error_messages = {
+        'required': _('This field is required.'),
+        'no_match': _('Invalid hyperlink - No URL match.'),
+        'incorrect_match': _('Invalid hyperlink - Incorrect URL match.'),
+        'does_not_exist': _('Invalid hyperlink - Object does not exist.'),
+        'incorrect_type': _('Incorrect type. Expected URL string, received {data_type}.'),
+    }
+
+    def __init__(self, view_name=None, **kwargs):
+        assert view_name is not None, 'The `view_name` argument is required.'
+        self.view_name = view_name
+        self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
+        self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field)
+        self.format = kwargs.pop('format', None)
+
+        # We include this simply for dependency injection in tests.
+        # We can't add it as a class attributes or it would expect an
+        # implicit `self` argument to be passed.
+        self.reverse = reverse
+
+        super(RefRelatedField, self).__init__(**kwargs)
+
+    def use_pk_only_optimization(self):
+        return False
+        #return self.lookup_field == 'pk'
+
+    def get_object(self, view_name, view_args, view_kwargs):
+        """
+        Return the object corresponding to a matched URL.
+
+        Takes the matched URL conf arguments, and should return an
+        object instance, or raise an `ObjectDoesNotExist` exception.
+        """
+        lookup_value = view_kwargs[self.lookup_url_kwarg]
+        lookup_kwargs = {self.lookup_field: lookup_value}
+        return self.get_queryset().get(**lookup_kwargs)
+
+    def get_url(self, obj, view_name, request, format):
+        """
+        Given an object, return the URL that hyperlinks to the object.
+
+        May raise a `NoReverseMatch` if the `view_name` and `lookup_field`
+        attributes are not configured to correctly match the URL conf.
+        """
+        # Unsaved objects will not yet have a valid URL.
+        if hasattr(obj, 'pk') and obj.pk in (None, ''):
+            return None
+
+        lookup_value = getattr(obj, self.lookup_field)
+        kwargs = {self.lookup_url_kwarg: lookup_value}
+        return self.reverse(view_name, kwargs=kwargs, request=request, format=format)
+
+    def to_internal_value(self, data):
+        request = self.context.get('request', None)
+        try:
+            http_prefix = data.startswith(('http:', 'https:'))
+        except AttributeError:
+            self.fail('incorrect_type', data_type=type(data).__name__)
+
+        if http_prefix:
+            # If needed convert absolute URLs to relative path
+            data = urlparse(data).path
+            prefix = get_script_prefix()
+            if data.startswith(prefix):
+                data = '/' + data[len(prefix):]
+
+        data = uri_to_iri(data)
+
+        try:
+            match = resolve(data)
+        except Resolver404:
+            self.fail('no_match')
+
+        try:
+            expected_viewname = request.versioning_scheme.get_versioned_viewname(
+                self.view_name, request
+            )
+        except AttributeError:
+            expected_viewname = self.view_name
+
+        if match.view_name != expected_viewname:
+            self.fail('incorrect_match')
+
+        try:
+            return self.get_object(match.view_name, match.args, match.kwargs)
+        except (ObjectDoesNotExist, TypeError, ValueError):
+            self.fail('does_not_exist')
+
+    def to_representation(self, value):
+        assert 'request' in self.context, (
+            "`%s` requires the request in the serializer"
+            " context. Add `context={'request': request}` when instantiating "
+            "the serializer." % self.__class__.__name__
+        )
+
+        request = self.context['request']
+        format = self.context.get('format', None)
+
+        # By default use whatever format is given for the current context
+        # unless the target is a different type to the source.
+        #
+        # Eg. Consider a HyperlinkedIdentityField pointing from a json
+        # representation to an html property of that representation...
+        #
+        # '/snippets/1/' should link to '/snippets/1/highlight/'
+        # ...but...
+        # '/snippets/1/.json' should link to '/snippets/1/highlight/.html'
+        if format and self.format and self.format != format:
+            format = self.format
+
+        # Return the hyperlink, or error if incorrectly configured.
+        try:
+            url = self.get_url(value, self.view_name, request, format)
+            logger.debug(url)
+            logger.debug(value)
+        except NoReverseMatch:
+            msg = (
+                'Could not resolve URL for hyperlinked relationship using '
+                'view name "%s". You may have failed to include the related '
+                'model in your API, or incorrectly configured the '
+                '`lookup_field` attribute on this field.'
+            )
+            if value in ('', None):
+                value_string = {'': 'the empty string', None: 'None'}[value]
+                msg += (
+                    " WARNING: The value of the field on the model instance "
+                    "was %s, which may be why it didn't match any "
+                    "entries in your URL conf." % value_string
+                )
+            raise ImproperlyConfigured(msg % self.view_name)
+
+        if url is None:
+            return None
+
+        return Ref(url, value)
+
+
+class RefIdentityField(RefRelatedField):
+    """
+    A read-only field that represents the identity URL for an object, itself.
+
+    This is in contrast to `HyperlinkedRelatedField` which represents the
+    URL of relationships to other objects.
+    """
+
+    def __init__(self, view_name=None, **kwargs):
+        assert view_name is not None, 'The `view_name` argument is required.'
+        kwargs['read_only'] = True
+        kwargs['source'] = '*'
+        super().__init__(view_name, **kwargs)
+
+    def use_pk_only_optimization(self):
+        # We have the complete object instance already. We don't need
+        # to run the 'only get the pk for this relationship' code.
+        return False

django_rest_spreadsheets-1.0.0/spreadsheet/schema.py

@@ -0,0 +1,116 @@
+import django
+import inspect
+import logging
+import sys
+
+from collections import OrderedDict
+from rest_framework import serializers
+from rest_framework import fields as rffields
+
+from . import util
+
+
+logger = logging.getLogger(__name__)
+
+
+def generate_field_schema(field):
+    data_type = get_type(field)
+    schema = {
+        'name': field.name,
+        'type': data_type
+    }
+    if field.name == 'id':
+        schema['isKey'] = True
+    if isinstance(field, django.db.models.fields.Field):
+        schema['title'] = field.verbose_name
+    if isinstance(field, django.db.models.fields.related.ForeignKey):
+        schema['$ref'] = field.related_model.__name__
+        schema['count'] = field.related_model.objects.count()
+        schema['multiple'] = False
+    if isinstance(field, django.db.models.fields.related.ManyToManyField):
+        schema['$ref'] = field.related_model.__name__
+        schema['multiple'] = True
+    if isinstance(field, django.db.models.fields.reverse_related.ForeignObjectRel):
+        if (field.remote_field.name[-4:] == '_ptr'):
+            return None
+        schema['$ref'] = field.related_model.__name__
+        schema['multiple'] = field.multiple
+        schema['title'] = field.related_model._meta.verbose_name_plural
+        schema['lookup'] = field.remote_field.name
+    if hasattr(field, 'blank'):
+        schema['required'] = not field.blank
+    if hasattr(field, 'choices') and field.choices:
+        sorted_choices = sorted(field.get_choices(), key=lambda tup: tup[1])
+        schema['type'] = 'oneOf'
+        schema['oneOf'] = OrderedDict(sorted_choices)
+    if data_type == 'string':
+        schema['length'] = field.max_length
+    return schema
+
+
+def generate_model_schema(model_class):
+    name = model_class.__name__
+    model_schema = {
+        '$schema': 'http://json-schema.org/draft-06/schema#',
+        'title': name,
+        'description': name,
+        'type': 'object',
+        'properties': {}
+    }
+    fields = model_class._meta.get_fields()
+    required = []
+    order = []
+    for field in fields:
+        if field.name[-4:] == '_ptr':
+            continue
+        field_schema = generate_field_schema(field)
+        if not field_schema:
+            continue
+        order.append(field.name)
+        model_schema['properties'][field.name] = field_schema
+    model_schema['fields'] = order
+    return model_schema
+
+
+def get_type(field):
+    t = field.get_internal_type()
+    if t == 'CharField': return 'string'
+    if t == 'BooleanField': return 'boolean'
+    if t == 'IntegerField': return 'integer'
+    if t == 'DecimalField': return 'number'
+    if t == 'DateTimeField': return 'datetime'
+    if t == 'DateField': return 'date'
+    if t == 'TimeField': return 'time'
+    if t == 'AutoField': return 'integer'
+    if t == 'ForeignKey': return 'object'
+    if t == 'OneToOneField': return 'object'
+    if t == 'ManyToManyField': return 'many'
+    if t == 'OneToOneRel': return 'object'
+    if t == 'OneToManyRel': return 'object'
+    if t == 'ManyToOneRel': return 'object'
+    if t == 'ManyToManyRel': return 'object'
+    logger.error('Unsupported field in get_type %s for %s', t, field)
+    return t
+
+
+def get_django_models(module):
+    classes = inspect.getmembers(module, inspect.isclass)
+    models = {}
+    for name, cls in classes:
+        mro = inspect.getmro(cls)
+        if django.db.models.base.Model in mro:
+            models[name] = cls
+    return models
+
+
+def generate(models_module):
+    schema = {}
+    schema['$schema'] = 'http://json-schema.org/draft-06/schema#'
+    title = ''
+    model_classes = get_django_models(models_module)
+    for name, model_class in model_classes.items():
+        if util.model_is_abstract(model_class):
+            continue
+        logger.info('Schema: generate %s' % name)
+        schema[name] = generate_model_schema(model_class)
+    return schema

django_rest_spreadsheets-1.0.0/spreadsheet/serializers.py

@@ -0,0 +1,142 @@
+import sys, inspect
+import logging
+
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+from rest_framework import fields as rffields
+from rest_framework.reverse import reverse
+from rest_framework.utils.field_mapping import (
+    get_nested_relation_kwargs,
+    get_relation_kwargs, get_url_kwargs
+)
+
+from .fields import *
+
+
+logger = logging.getLogger(__name__)
+
+
+class RefModelSerializer(serializers.ModelSerializer):
+    """
+    A type of `ModelSerializer` that uses hyperlinked relationships instead
+    of primary key relationships. Specifically:
+
+    * A 'url' field is included instead of the 'id' field.
+    * Relationships to other instances are hyperlinks, instead of primary keys.
+    """
+    #setattr(serializers.ModelSerializer, 'serializer_url_field', RefRelatedField)
+    serializer_related_field = RefRelatedField
+    meta_serializer_field = RefRelatedField
+    meta_serializer_identity_field = RefIdentityField
+    meta_field_name = '_'
+
+    def build_meta_field(self, field_name, model_class):
+        """
+        Create a field representing the object's own URL.
+        """
+        #field_class = self.serializer_url_field
+        field_class = self.meta_serializer_identity_field
+        field_kwargs = get_url_kwargs(model_class)
+
+        return field_class, field_kwargs
+
+    def build_relational_field(self, field_name, relation_info):
+        """
+        Create fields for forward and reverse relationships.
+        """
+        field_class = self.serializer_related_field
+        field_kwargs = get_relation_kwargs(field_name, relation_info)
+
+        to_field = field_kwargs.pop('to_field', None)
+        if to_field and not relation_info.reverse and not relation_info.related_model._meta.get_field(to_field).primary_key:
+            field_kwargs['slug_field'] = to_field
+            field_class = self.serializer_related_to_field
+
+        # `view_name` is only valid for hyperlinked relationships.
+        if not issubclass(field_class, RefRelatedField):
+            field_kwargs.pop('view_name', None)
+
+        return field_class, field_kwargs
+
+    def to_representation(self, instance):
+        representation = super().to_representation(instance);
+        representation['_str'] = str(instance)
+        #representation['_'] = {
+        #    'url': '',
+        #    'id': instance.pk,
+        #    'string': str(instance)
+        #}
+        #RefRelatedField().to_representation(instance)
+        return representation
+
+    def build_field(self, field_name, info, model_class, nested_depth):
+        """
+        Return a two tuple of (cls, kwargs) to build a serializer field with.
+        """
+        if field_name == '_':
+            return self.build_meta_field(field_name, model_class)
+        if field_name == '_str':
+            return rffields.CharField, {'read_only': True}
+        return super().build_field(field_name, info, model_class, nested_depth)
+
+    def get_fields(self):
+        fields = super().get_fields()
+        logger.debug('get_fields')
+        logger.debug(fields)
+        return fields
+
+    def get_default_field_names(self, declared_fields, model_info):
+        """
+        Return the default list of field names that will be used if the
+        `Meta.fields` option is not specified.
+        """
+        logger.debug('get_default_field_names')
+        logger.debug(model_info)
+        return (
+            ['_'] +
+            ['_str'] +
+            list(declared_fields) +
+            list(model_info.fields) +
+            list(model_info.forward_relations) +
+            list(model_info.reverse_relations)
+        )
+
+    def build_nested_field(self, field_name, relation_info, nested_depth):
+        """
+        Create nested fields for forward and reverse relationships.
+        """
+        class NestedSerializer(RefModelSerializer):
+            class Meta:
+                model = relation_info.related_model
+                depth = nested_depth - 1
+                fields = '__all__'
+
+        field_class = NestedSerializer
+        field_kwargs = get_nested_relation_kwargs(relation_info)
+
+        return field_class, field_kwargs
+
+
+def s(m):
+    class Serializer(RefModelSerializer):
+        class Meta:
+            model = m
+            exclude = ()
+
+    return Serializer
+
+
+def generate(models_module, serializers_module):
+    generated = {}
+    model_classes = inspect.getmembers(models_module, inspect.isclass)
+    #serializer_module = sys.modules[__name__]
+    serializer_classes = dir(serializers_module)
+    for name, cls in model_classes:
+        logger.debug('Serializers: generate %s' % name)
+        if name + 'Serializer' in serializer_classes:
+            logger.info('already defined %s' % name)
+            generated[name] = getattr(serializers_module, name + 'Serializer')
+        else:
+            logger.info('generate %s' % name)
+            generated[name] = s(cls)
+    return generated