django-dato-sync 0.0.1__tar.gz

django_dato_sync-0.0.1/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: django-dato-sync
+Version: 0.0.1
+Summary: A sync utility for storing DatoCMS objects in django.
+Home-page: https://www.dreipol.ch/
+Author: dreipol AG
+Author-email: Laila Becker <laila.becker@dreipol.ch>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/dreipol/django-dato-sync
+Project-URL: Issues, https://github.com/dreipol/django-dato-sync/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: home-page
+
+# django-dato-sync
+
+django-dato-sync enables you to easily sync Dato records into your django database. Features include:
+
+- Delta sync
+- Automatic sync via Dato webhooks
+- Localization support with [django-modeltranslation](https://github.com/deschler/django-modeltranslation)
+- Configuration of which fields to sync
+- Collecting information of multiple Dato records into a single django object
+
+## Installation
+
+1. Install the pip package:
+```shell
+pipenv install django-dato-sync
+```
+2. Add to your installed apps:
+```py
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.staticfiles",
+    ...
+    "dato_sync",
+]
+```
+3. Setup at least the following settings:
+```py
+DATOCMS_API_TOKEN: str = ...
+DATOCMS_API_URL: str = ...
+DATOCMS_ENVIRONMENT: str = ...
+```
+
+### Optional: Setup for automatic syncing via Webhooks
+1. Add the following to your `urls.py`:
+```py
+urlpatterns = [
+    ...
+    path("", include("dato_sync.urls"))
+]
+```
+2. Setup the authentication header Dato will use in your `settings.py`
+```py
+DATO_SYNC_WEBHOOK_EXPECTED_AUTH: str = "Basic ..."
+```
+3. In Dato navigate to Project Setting > Automations > Webhooks and click "Add a new webhook"
+4. Configure the webhook to trigger on "Publish", "Unpublish", and "Delete" for any records you want to sync to django
+5. Specify the URL as `https://<your-django-server-address>/dato-sync/sync/`
+6. Configure the "HTTP basic auth" to match the header you configured in step 2
+
+## Usage
+1. Create your local django model but make sure it inherits from `DatoModel` (it will automatically have fields for the `dato_identifier` (pk), `created` and `modified` dates (corresponding to changes made in Dato) and a `deleted` field indicating a soft delete)
+```py
+class MyModel(DatoModel):
+    name = models.TextField()
+    order = models.IntegerField()
+    note = models.TextField()
+```
+2. Create a `dato_sync.py` file in your app:
+```py
+@fetch_from_dato(MyModel)
+class MyModelSyncOptions(SyncOptions):
+    dato_model_path = "my_model"
+    field_mappings = [
+        "order" |position_in_parent,
+        "name",
+    ]
+```
+3. To sync either have Dato call the webhook (see above) or use
+```shell
+python manage.py sync_dato [--force-full-sync]
+```
+
+### Configuration Options
+#### dato_model_path
+Configure the dato entity your model corresponds to. If you are mapping a Dato model directly this is just its model id. If you're using blocks you can chain them like `my_model.parent_block.child_block`.
+
+⚠️ Make sure that all blocks have the same schema. Fields that can contain different types of blocks are currently not supported.
+
+#### field_mappings
+Here you specify which fields should be synced with dato. If you leave out fields (like the `notes` field in the example above they can be edited locally).
+
+In the simplest case when the name of your field in django corresponds to the api name in Dato, you can simply add it to the field mappings as we did with `"name"`. For more complicated scenarios you can write:
+```py
+field_mappings = [
+    "name" |from_dato_path("my_model.title", localized=True, absolute=True),
+]
+```
+This allows you to
+
+- specify a different name / path to take the value from
+- `localized` allows you to fetch localizations from Dato and store them using django-modeltranslation
+- `absolute` allows you to access properties of the parent entities by specifying the field to take the value from starting from the top of the Dato query rather than the path specified in `dato_model_path`
+
+Additonally the following are also available:
+- `|position_in_parent` to obtain the position of the item in its parent
+- `|flattened_position` to obtain a global order by flattening the list across all paths
+
+#### ArrayFields
+Postgres ArrayFields are supported ⚠️ so long as there is no nesting on either the Dato or django side ⚠️. Simply specify the path like:
+```py
+"tags" |from_dato_path("tags.name")
+```
+and django-dato-sync will automatically collect the names of all tags into an array.
+
+## Tips and Tricks
+- Foreign key relationships are not supported directly, but you can use django's `..._id` field to set the id of another Dato object
+  - ⚠️ Make sure to sync the related objects first to avoid foreign key constraint violations. Sync operations are executed in the same order they appear in the `dato_sync.py` file.
+  - For one-to-many relationships use absolute paths to access the parent's id
+- You can create multiple sync jobs for the same django model to collect all instances of a block across multiple models into one django table

django_dato_sync-0.0.1/README.md

@@ -0,0 +1,110 @@
+# django-dato-sync
+
+django-dato-sync enables you to easily sync Dato records into your django database. Features include:
+
+- Delta sync
+- Automatic sync via Dato webhooks
+- Localization support with [django-modeltranslation](https://github.com/deschler/django-modeltranslation)
+- Configuration of which fields to sync
+- Collecting information of multiple Dato records into a single django object
+
+## Installation
+
+1. Install the pip package:
+```shell
+pipenv install django-dato-sync
+```
+2. Add to your installed apps:
+```py
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.staticfiles",
+    ...
+    "dato_sync",
+]
+```
+3. Setup at least the following settings:
+```py
+DATOCMS_API_TOKEN: str = ...
+DATOCMS_API_URL: str = ...
+DATOCMS_ENVIRONMENT: str = ...
+```
+
+### Optional: Setup for automatic syncing via Webhooks
+1. Add the following to your `urls.py`:
+```py
+urlpatterns = [
+    ...
+    path("", include("dato_sync.urls"))
+]
+```
+2. Setup the authentication header Dato will use in your `settings.py`
+```py
+DATO_SYNC_WEBHOOK_EXPECTED_AUTH: str = "Basic ..."
+```
+3. In Dato navigate to Project Setting > Automations > Webhooks and click "Add a new webhook"
+4. Configure the webhook to trigger on "Publish", "Unpublish", and "Delete" for any records you want to sync to django
+5. Specify the URL as `https://<your-django-server-address>/dato-sync/sync/`
+6. Configure the "HTTP basic auth" to match the header you configured in step 2
+
+## Usage
+1. Create your local django model but make sure it inherits from `DatoModel` (it will automatically have fields for the `dato_identifier` (pk), `created` and `modified` dates (corresponding to changes made in Dato) and a `deleted` field indicating a soft delete)
+```py
+class MyModel(DatoModel):
+    name = models.TextField()
+    order = models.IntegerField()
+    note = models.TextField()
+```
+2. Create a `dato_sync.py` file in your app:
+```py
+@fetch_from_dato(MyModel)
+class MyModelSyncOptions(SyncOptions):
+    dato_model_path = "my_model"
+    field_mappings = [
+        "order" |position_in_parent,
+        "name",
+    ]
+```
+3. To sync either have Dato call the webhook (see above) or use
+```shell
+python manage.py sync_dato [--force-full-sync]
+```
+
+### Configuration Options
+#### dato_model_path
+Configure the dato entity your model corresponds to. If you are mapping a Dato model directly this is just its model id. If you're using blocks you can chain them like `my_model.parent_block.child_block`.
+
+⚠️ Make sure that all blocks have the same schema. Fields that can contain different types of blocks are currently not supported.
+
+#### field_mappings
+Here you specify which fields should be synced with dato. If you leave out fields (like the `notes` field in the example above they can be edited locally).
+
+In the simplest case when the name of your field in django corresponds to the api name in Dato, you can simply add it to the field mappings as we did with `"name"`. For more complicated scenarios you can write:
+```py
+field_mappings = [
+    "name" |from_dato_path("my_model.title", localized=True, absolute=True),
+]
+```
+This allows you to
+
+- specify a different name / path to take the value from
+- `localized` allows you to fetch localizations from Dato and store them using django-modeltranslation
+- `absolute` allows you to access properties of the parent entities by specifying the field to take the value from starting from the top of the Dato query rather than the path specified in `dato_model_path`
+
+Additonally the following are also available:
+- `|position_in_parent` to obtain the position of the item in its parent
+- `|flattened_position` to obtain a global order by flattening the list across all paths
+
+#### ArrayFields
+Postgres ArrayFields are supported ⚠️ so long as there is no nesting on either the Dato or django side ⚠️. Simply specify the path like:
+```py
+"tags" |from_dato_path("tags.name")
+```
+and django-dato-sync will automatically collect the names of all tags into an array.
+
+## Tips and Tricks
+- Foreign key relationships are not supported directly, but you can use django's `..._id` field to set the id of another Dato object
+  - ⚠️ Make sure to sync the related objects first to avoid foreign key constraint violations. Sync operations are executed in the same order they appear in the `dato_sync.py` file.
+  - For one-to-many relationships use absolute paths to access the parent's id
+- You can create multiple sync jobs for the same django model to collect all instances of a block across multiple models into one django table

django_dato_sync-0.0.1/dato_sync/apps.py

@@ -0,0 +1,11 @@
+from django.apps import AppConfig
+
+
+class DatoSyncConfig(AppConfig):
+    name = 'dato_sync'
+    verbose_name = "Dato Sync"
+
+    def ready(self):
+        from dato_sync.models import handle_dato_sync_registrations
+
+        handle_dato_sync_registrations()

django_dato_sync-0.0.1/dato_sync/datocms_api.py

@@ -0,0 +1,36 @@
+from django.conf import settings
+import requests
+from requests.auth import AuthBase
+
+
+class DatoTokenAuth(AuthBase):
+    """Implements a token authentication scheme."""
+
+    def __init__(self, token, environment):
+        self.token = token
+        self.environment = environment
+
+    def __call__(self, request):
+        """Attach an API token to the Authorization header."""
+        request.headers["Authorization"] = f"Bearer {self.token}"
+        request.headers["Content-Type"] = "application/json"
+        request.headers["Accept"] = "application/json"
+        request.headers["X-Environment"] = self.environment
+        return request
+
+
+def fetch_datocms_content(language: str, query: str) -> dict:
+    api_token = settings.DATOCMS_API_TOKEN
+    api_url = f"{settings.DATOCMS_API_URL}/"
+    environment = settings.DATOCMS_ENVIRONMENT
+    variables = {"locale": language}
+    response = requests.post(
+        api_url, auth=DatoTokenAuth(api_token, environment), json={"query": query, "variables": variables}
+    )
+
+    if response.status_code == 200:
+        data = response.json()
+        return data.get("data")
+    else:
+        print(f"Error: {response.status_code} - {response.text}")
+        return {}

django_dato_sync-0.0.1/dato_sync/decorators.py

@@ -0,0 +1,21 @@
+from typing import Type, TypeVar, Callable
+
+from dato_sync.fetcher import fetcher
+from dato_sync.models import DatoModel
+from dato_sync.sync_options import SyncOptions
+
+
+_OptionsTypeT = TypeVar("_OptionsTypeT", bound=type[SyncOptions])
+
+def fetch_from_dato(model_class: Type[DatoModel]) -> Callable[[_OptionsTypeT], _OptionsTypeT]:
+    """
+    Populate the model with objects managed in the dato CMS.
+    """
+    def wrapper(opts_class: _OptionsTypeT) -> _OptionsTypeT:
+        if not issubclass(opts_class, SyncOptions):
+            raise ValueError("Wrapped class must subclass SyncOptions.")
+
+        fetcher.register(model_class, opts_class)
+        return opts_class
+
+    return wrapper

django_dato_sync-0.0.1/dato_sync/errors.py

@@ -0,0 +1,16 @@
+class BadConfigurationError(Exception):
+    def __init__(self, message: str):
+        self.message = message
+
+    def __str__(self):
+        return f"Bad configuration of the dato_sync plugin: {self.message}"
+
+
+class IllegalSyncOptionsError(Exception):
+    def __init__(self, model: object, options_type: object, message: str):
+        self.model = model
+        self.options_type = options_type
+        self.message = message
+
+    def __str__(self):
+        return f"The sync options provided for {self.model} in {self.options_type} are illegal: {self.message}"

django_dato_sync-0.0.1/dato_sync/fetcher.py

@@ -0,0 +1,64 @@
+from typing import Type
+
+from django.conf import settings
+from django.db.models import Max
+
+from dato_sync.datocms_api import fetch_datocms_content
+from dato_sync.query_tree import QueryTree, QueryGenerator, ResponseParser
+from dato_sync.sync_options import SyncOptions, DatoFieldPath
+from search.config import DatoModel
+
+
+class Fetcher:
+    def __init__(self):
+        self.jobs: list[SyncOptions] = []
+
+    def register(self, model: Type[DatoModel], options: SyncOptions):
+        options.django_model = model
+        self.jobs.append(options)
+
+    def fetch(self, force_full_sync: bool):
+        default_locale = settings.LANGUAGE_CODE
+
+        seen_ids = dict()
+
+        for job in self.jobs:
+            sanitized_mappings = [
+                mapping if isinstance(mapping, DatoFieldPath) else DatoFieldPath(mapping)
+                for mapping in job.field_mappings]
+
+            if force_full_sync:
+                min_date = None
+            else:
+                min_date = job.django_model.objects.aggregate(max_date=Max("modified"))["max_date"]
+
+            query_tree = QueryTree(
+                job=job,
+                min_date=min_date,
+            )
+
+            for mapping in sanitized_mappings:
+                query_tree.insert_mapping(mapping, job)
+
+            base_query = QueryGenerator(for_localization=False).generate_query(query_tree)
+
+            response = fetch_datocms_content(default_locale, base_query)
+            if any(mapping.is_localized for mapping in sanitized_mappings):
+                localization_query = QueryGenerator(for_localization=True).generate_query(query_tree)
+                localization_responses = {language: fetch_datocms_content(language, localization_query)
+                 for language, _ in settings.LANGUAGES
+                 if language != default_locale}
+            else:
+                localization_responses = dict()
+
+            new_ids = ResponseParser(job).parse_response(response, localization_responses, query_tree)
+            ids_set: set[str] = seen_ids.get(job.django_model, set())
+            ids_set = ids_set.union(new_ids)
+            seen_ids[job.django_model] = ids_set
+
+        for model, ids_set in seen_ids.items():
+            (model.objects
+             .exclude(dato_identifier__in=ids_set)
+             .update(deleted=True))
+
+fetcher = Fetcher()

django_dato_sync-0.0.1/dato_sync/models.py

@@ -0,0 +1,59 @@
+from django.db import models
+
+
+class DatoModel(models.Model):
+    dato_identifier = models.TextField(
+        primary_key=True,
+        blank=False,
+        null=False,
+        max_length=255
+    )
+
+    created = models.DateTimeField(
+        verbose_name="created",
+        db_index=True,
+    )
+    modified = models.DateTimeField(
+        verbose_name="modified",
+        db_index=True,
+    )
+
+    deleted = models.BooleanField(default=False)
+
+    class Meta:
+        abstract = True
+
+
+def handle_dato_sync_registrations():
+    """
+        Auto-discover INSTALLED_APPS translation.py modules and fail silently when
+        not present. This forces an import on them to register.
+        Also import explicit modules.
+        """
+    import copy
+    from importlib import import_module
+
+    from django.apps import apps
+    from django.utils.module_loading import module_has_submodule
+
+    from dato_sync.fetcher import fetcher
+
+    mods = [(app_config.name, app_config.module) for app_config in apps.get_app_configs()]
+
+    for app, mod in mods:
+        # Attempt to import the app's dato_sync module.
+        module = "%s.dato_sync" % app
+        before_import_jobs = copy.copy(fetcher.jobs)
+        try:
+            import_module(module)
+        except ImportError:
+            # Reset the model registry to the state before the last import as
+            # this import will have to reoccur on the next request and this
+            # could raise NotRegistered and AlreadyRegistered exceptions
+            fetcher.jobs = before_import_jobs
+
+            # Decide whether to bubble up this error. If the app just
+            # doesn't have a dato_sync module, we can ignore the error
+            # attempting to import it, otherwise we want it to bubble up.
+            if module_has_submodule(mod, "dato_sync"):
+                raise

django_dato_sync-0.0.1/dato_sync/sync_options.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+
+
+class DatoFieldPath:
+    def __init__(
+            self,
+            django_field_name: str,
+            path: str | None = None,
+            is_localized: bool = False,
+            is_absolute: bool = False,
+    ):
+        self.django_field_name = django_field_name
+        self.path = path or django_field_name
+        self.is_localized = is_localized
+        self.is_absolute = is_absolute
+
+
+class SyncOptions(ABC):
+    @property
+    @abstractmethod
+    def dato_model_path(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def field_mappings(self) -> list[str | DatoFieldPath]:
+        pass

django_dato_sync-0.0.1/dato_sync/urls.py

@@ -0,0 +1,8 @@
+from django.urls import path
+
+from dato_sync import views
+
+app_name = 'dato_sync'
+urlpatterns = [
+    path("dato-sync/sync/", views.sync, name="dato_sync.sync"),
+]

django_dato_sync-0.0.1/dato_sync/util.py

@@ -0,0 +1,30 @@
+from typing import TypeVar, Callable, Generic
+
+from dato_sync.sync_options import DatoFieldPath
+
+T = TypeVar('T')
+R = TypeVar('R')
+
+_order_tag = '#order#'
+_flattened_order_tag = '#flattened_order#'
+
+
+class Suffix(Generic[T, R]):
+    def __init__(self, function: Callable[[T], R]):
+        self.function = function
+
+    def __ror__(self, other):
+        return self.function(other)
+
+
+def from_dato_path(path: str | None = None, localized: bool = False, absolute: bool = False) -> Suffix[str, DatoFieldPath]:
+    return Suffix(lambda field: DatoFieldPath(field, path, localized, absolute))
+
+position_in_parent = Suffix(lambda field: DatoFieldPath(django_field_name=field, path=_order_tag))
+flattened_position = Suffix(lambda field: DatoFieldPath(django_field_name=field, path=_flattened_order_tag))
+
+def to_camel_case(snake_str):
+    if snake_str.startswith('_'):
+        return snake_str
+    camel_string = "".join(x[0].upper() + x[1:] for x in snake_str.split("_"))
+    return snake_str[0].lower() + camel_string[1:]

django_dato_sync-0.0.1/dato_sync/views.py

@@ -0,0 +1,23 @@
+from django.conf import settings
+from django.core.handlers.wsgi import WSGIRequest
+from django.http import HttpResponse
+from django.views.decorators.csrf import csrf_exempt
+from django.views.decorators.http import require_POST
+
+from dato_sync.errors import BadConfigurationError
+from dato_sync.fetcher import fetcher
+
+
+@csrf_exempt
+@require_POST
+def sync(request: WSGIRequest) -> HttpResponse:
+    """Called by dato hook to initiate a delta sync"""
+    if not settings.DATO_SYNC_WEBHOOK_EXPECTED_AUTH:
+        raise BadConfigurationError("DATO_SYNC_WEBHOOK_EXPECTED_AUTH not configured")
+
+    if request.headers.get("Authorization") != settings.DATO_SYNC_WEBHOOK_EXPECTED_AUTH:
+        return HttpResponse("Unauthorized", status=401)
+
+    # TODO: use data from body
+    fetcher.fetch(force_full_sync=False)
+    return HttpResponse(status=204)

django_dato_sync-0.0.1/django_dato_sync.egg-info/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: django-dato-sync
+Version: 0.0.1
+Summary: A sync utility for storing DatoCMS objects in django.
+Home-page: https://www.dreipol.ch/
+Author: dreipol AG
+Author-email: Laila Becker <laila.becker@dreipol.ch>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/dreipol/django-dato-sync
+Project-URL: Issues, https://github.com/dreipol/django-dato-sync/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: home-page
+
+# django-dato-sync
+
+django-dato-sync enables you to easily sync Dato records into your django database. Features include:
+
+- Delta sync
+- Automatic sync via Dato webhooks
+- Localization support with [django-modeltranslation](https://github.com/deschler/django-modeltranslation)
+- Configuration of which fields to sync
+- Collecting information of multiple Dato records into a single django object
+
+## Installation
+
+1. Install the pip package:
+```shell
+pipenv install django-dato-sync
+```
+2. Add to your installed apps:
+```py
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.staticfiles",
+    ...
+    "dato_sync",
+]
+```
+3. Setup at least the following settings:
+```py
+DATOCMS_API_TOKEN: str = ...
+DATOCMS_API_URL: str = ...
+DATOCMS_ENVIRONMENT: str = ...
+```
+
+### Optional: Setup for automatic syncing via Webhooks
+1. Add the following to your `urls.py`:
+```py
+urlpatterns = [
+    ...
+    path("", include("dato_sync.urls"))
+]
+```
+2. Setup the authentication header Dato will use in your `settings.py`
+```py
+DATO_SYNC_WEBHOOK_EXPECTED_AUTH: str = "Basic ..."
+```
+3. In Dato navigate to Project Setting > Automations > Webhooks and click "Add a new webhook"
+4. Configure the webhook to trigger on "Publish", "Unpublish", and "Delete" for any records you want to sync to django
+5. Specify the URL as `https://<your-django-server-address>/dato-sync/sync/`
+6. Configure the "HTTP basic auth" to match the header you configured in step 2
+
+## Usage
+1. Create your local django model but make sure it inherits from `DatoModel` (it will automatically have fields for the `dato_identifier` (pk), `created` and `modified` dates (corresponding to changes made in Dato) and a `deleted` field indicating a soft delete)
+```py
+class MyModel(DatoModel):
+    name = models.TextField()
+    order = models.IntegerField()
+    note = models.TextField()
+```
+2. Create a `dato_sync.py` file in your app:
+```py
+@fetch_from_dato(MyModel)
+class MyModelSyncOptions(SyncOptions):
+    dato_model_path = "my_model"
+    field_mappings = [
+        "order" |position_in_parent,
+        "name",
+    ]
+```
+3. To sync either have Dato call the webhook (see above) or use
+```shell
+python manage.py sync_dato [--force-full-sync]
+```
+
+### Configuration Options
+#### dato_model_path
+Configure the dato entity your model corresponds to. If you are mapping a Dato model directly this is just its model id. If you're using blocks you can chain them like `my_model.parent_block.child_block`.
+
+⚠️ Make sure that all blocks have the same schema. Fields that can contain different types of blocks are currently not supported.
+
+#### field_mappings
+Here you specify which fields should be synced with dato. If you leave out fields (like the `notes` field in the example above they can be edited locally).
+
+In the simplest case when the name of your field in django corresponds to the api name in Dato, you can simply add it to the field mappings as we did with `"name"`. For more complicated scenarios you can write:
+```py
+field_mappings = [
+    "name" |from_dato_path("my_model.title", localized=True, absolute=True),
+]
+```
+This allows you to
+
+- specify a different name / path to take the value from
+- `localized` allows you to fetch localizations from Dato and store them using django-modeltranslation
+- `absolute` allows you to access properties of the parent entities by specifying the field to take the value from starting from the top of the Dato query rather than the path specified in `dato_model_path`
+
+Additonally the following are also available:
+- `|position_in_parent` to obtain the position of the item in its parent
+- `|flattened_position` to obtain a global order by flattening the list across all paths
+
+#### ArrayFields
+Postgres ArrayFields are supported ⚠️ so long as there is no nesting on either the Dato or django side ⚠️. Simply specify the path like:
+```py
+"tags" |from_dato_path("tags.name")
+```
+and django-dato-sync will automatically collect the names of all tags into an array.
+
+## Tips and Tricks
+- Foreign key relationships are not supported directly, but you can use django's `..._id` field to set the id of another Dato object
+  - ⚠️ Make sure to sync the related objects first to avoid foreign key constraint violations. Sync operations are executed in the same order they appear in the `dato_sync.py` file.
+  - For one-to-many relationships use absolute paths to access the parent's id
+- You can create multiple sync jobs for the same django model to collect all instances of a block across multiple models into one django table

django_dato_sync-0.0.1/django_dato_sync.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+setup.py
+dato_sync/__init__.py
+dato_sync/apps.py
+dato_sync/datocms_api.py
+dato_sync/decorators.py
+dato_sync/errors.py
+dato_sync/fetcher.py
+dato_sync/models.py
+dato_sync/sync_options.py
+dato_sync/urls.py
+dato_sync/util.py
+dato_sync/views.py
+django_dato_sync.egg-info/PKG-INFO
+django_dato_sync.egg-info/SOURCES.txt
+django_dato_sync.egg-info/dependency_links.txt
+django_dato_sync.egg-info/top_level.txt

django_dato_sync-0.0.1/django_dato_sync.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_dato_sync-0.0.1/django_dato_sync.egg-info/top_level.txt

@@ -0,0 +1 @@
+dato_sync

django_dato_sync-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-dato-sync"
+version = "0.0.1"
+authors = [
+  { name="Laila Becker", email="laila.becker@dreipol.ch" },
+]
+description = "A sync utility for storing DatoCMS objects in django."
+readme = "README.md"
+requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/dreipol/django-dato-sync"
+Issues = "https://github.com/dreipol/django-dato-sync/issues"

django_dato_sync-0.0.1/setup.cfg

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

django_dato_sync-0.0.1/setup.py

@@ -0,0 +1,35 @@
+import os
+
+from setuptools import setup
+
+README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
+
+reqs = ['Django>=5.0']
+
+# allow setup.py to be run from any path
+os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
+
+setup(
+    name='django-dato-sync',
+    version='1.0.0',
+    packages=['dato_sync'],
+    include_package_data=True,
+    license='MIT License',
+    description='django-dato-sync lets you import data from DatoCMS into the django DB',
+    long_description=README,
+    url='https://www.dreipol.ch/',
+    author='dreipol AG',
+    author_email='dev@dreipol.ch',
+    classifiers=[
+        'Environment :: Web Environment',
+        'Framework :: Django',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',  # example license
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3',
+        'Topic :: Internet :: WWW/HTTP',
+        'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
+    ],
+    install_requires=reqs,
+)