reader

django_spire.contrib.sync.django.storage.reader

logger = logging.getLogger(__name__) module-attribute

DjangoRecordReader

Source code in django_spire/contrib/sync/django/storage/reader.py

def __init__(
    self,
    models: list[type[SyncableMixin]],
    identity_field: str = 'id',
) -> None:
    self._identity_field = identity_field

    self._models: dict[str, type[SyncableMixin]] = {
        model._meta.label: model
        for model in models
    }

    self._serializers: dict[str, SyncFieldSerializer] = {
        model._meta.label: SyncFieldSerializer(model)
        for model in models
    }

get_changed_since

Source code in django_spire/contrib/sync/django/storage/reader.py

def get_changed_since(
    self,
    model_label: str,
    sequence: int,
    peer_node_id: str,
    sequence_max: int | None = None,
    limit: int | None = None,
    after_key: str | None = None,
) -> dict[str, SyncRecord]:
    model = self._get_model(model_label)
    many_to_many_names = self._get_many_to_many_names(model)

    if after_key:
        identity_gt = {
            f'{self._identity_field}__gt': after_key,
        }

        queryset = model.objects.filter(
            Q(sync_field_sequence__gt=sequence) |
            Q(
                sync_field_sequence=sequence,
                **identity_gt,
            ),
        )
    else:
        queryset = model.objects.filter(
            sync_field_sequence__gt=sequence,
        )

    if sequence_max is not None:
        queryset = queryset.filter(
            sync_field_sequence__lte=sequence_max,
        )

    if peer_node_id:
        queryset = queryset.exclude(
            sync_field_origin_node=peer_node_id,
        )

    queryset = queryset.order_by(
        'sync_field_sequence',
        self._identity_field,
    )

    if limit is not None:
        queryset = queryset[:limit]

    if many_to_many_names:
        queryset = queryset.prefetch_related(
            *many_to_many_names,
        )

    return {
        str(getattr(instance, self._identity_field)): self._instance_to_record(instance)
        for instance in queryset
    }

get_deletes_since

Source code in django_spire/contrib/sync/django/storage/reader.py

def get_deletes_since(
    self,
    model_label: str,
    sequence: int,
    peer_node_id: str,
    sequence_max: int | None = None,
) -> dict[str, int]:
    from django_spire.contrib.sync.django.models.tombstone import SyncTombstone  # noqa: PLC0415

    queryset = SyncTombstone.objects.filter(
        model_label=model_label,
        sequence__gt=sequence,
    )

    if sequence_max is not None:
        queryset = queryset.filter(sequence__lte=sequence_max)

    if peer_node_id:
        queryset = queryset.exclude(origin_node=peer_node_id)

    rows = queryset.values_list('record_key', 'timestamp')

    return dict(rows)

get_records

Source code in django_spire/contrib/sync/django/storage/reader.py

def get_records(
    self,
    model_label: str,
    keys: set[str],
) -> dict[str, SyncRecord]:
    if not keys:
        return {}

    model = self._get_model(model_label)
    many_to_many_names = self._get_many_to_many_names(model)

    identity_lookup = {f'{self._identity_field}__in': keys}
    queryset = model.objects.filter(**identity_lookup)

    if many_to_many_names:
        queryset = queryset.prefetch_related(*many_to_many_names)

    return {
        str(getattr(instance, self._identity_field)): self._instance_to_record(instance)
        for instance in queryset
    }

get_syncable_models

Source code in django_spire/contrib/sync/django/storage/reader.py

def get_syncable_models(self) -> list[str]:
    return sorted(self._models.keys())

get_tombstones

Source code in django_spire/contrib/sync/django/storage/reader.py

def get_tombstones(
    self,
    model_label: str,
    keys: set[str],
) -> dict[str, int]:
    if not keys:
        return {}

    from django_spire.contrib.sync.django.models.tombstone import SyncTombstone  # noqa: PLC0415

    rows = (
        SyncTombstone.objects
        .filter(model_label=model_label, record_key__in=keys)
        .values_list('record_key', 'timestamp')
    )

    return dict(rows)