media-optimization-engine 1.4.0__py3-none-any.whl

media_engine/management/commands/media_engine_doctor.py

@@ -0,0 +1,15 @@
+from django.core.management.base import BaseCommand
+
+from media_engine.doctor import format_report, run_diagnostics
+
+
+class Command(BaseCommand):
+    help = "Diagnose Media Optimization Engine integration, migrations, storage and codecs."
+
+    def handle(self, *args, **options):
+        checks = run_diagnostics()
+        report = format_report(checks)
+        self.stdout.write(report)
+        errors = [c for c in checks if not c.ok and c.level != "WARN"]
+        if errors:
+            raise SystemExit(1)

media_engine/management/commands/media_engine_node_report.py

@@ -0,0 +1,24 @@
+import json
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from media_engine.control_plane import control_plane_status, load_last_known_good
+from media_engine.node import get_node_identity
+from media_engine.runtime_config import effective_profiles
+
+
+class Command(BaseCommand):
+    help = 'Print node identity, autonomy configuration and active image profiles.'
+
+    def handle(self, *args, **options):
+        payload = {
+            'version': getattr(settings, 'MEDIA_ENGINE_VERSION', '1.4.0'),
+            'pipeline_version': getattr(settings, 'MEDIA_ENGINE_PIPELINE_VERSION', 1),
+            'node': get_node_identity().as_dict(),
+            'require_api_key': getattr(settings, 'MEDIA_ENGINE_REQUIRE_API_KEY', False),
+            'control_plane_enabled': getattr(settings, 'MEDIA_ENGINE_CONTROL_PLANE_ENABLED', False),
+            'control_plane_runtime_dependency': False,
+            'control_plane_status': control_plane_status(),
+            'last_known_good': load_last_known_good(),
+            'profiles': effective_profiles(),
+        }
+        self.stdout.write(json.dumps(payload, indent=2, sort_keys=True))

media_engine/management/commands/rollback_media_engine_config.py

@@ -0,0 +1,14 @@
+import json
+from django.core.management.base import BaseCommand, CommandError
+from media_engine.control_plane import rollback_to_previous
+
+
+class Command(BaseCommand):
+    help = 'Rollback to the previous last-known-good control-plane profile configuration.'
+
+    def handle(self, *args, **options):
+        try:
+            result = rollback_to_previous()
+        except RuntimeError as exc:
+            raise CommandError(str(exc)) from exc
+        self.stdout.write(json.dumps(result, indent=2, sort_keys=True))

media_engine/management/commands/sync_media_engine_hub.py

@@ -0,0 +1,20 @@
+import json
+from django.core.management.base import BaseCommand
+from media_engine.control_plane import sync_from_control_plane
+
+
+class Command(BaseCommand):
+    help = 'Synchronize optional external control-plane configuration without making runtime depend on it.'
+
+    def add_arguments(self, parser):
+        parser.add_argument('--force', action='store_true')
+
+    def handle(self, *args, **options):
+        result = sync_from_control_plane(force=options['force'])
+        self.stdout.write(json.dumps(result, indent=2, sort_keys=True))
+        if result.get('state') == 'degraded':
+            self.stderr.write(
+                self.style.WARNING(
+                    'Control plane unavailable; engine continues with last-known-good/local config.'
+                )
+            )

media_engine/manifest.py

@@ -0,0 +1,89 @@
+from django.conf import settings
+from django.core.cache import cache
+from .models import MediaAsset, MediaVariant
+from .profiles import get_profile
+
+
+def manifest_cache_key(asset_id, profile='default'):
+    version = getattr(settings, 'MEDIA_ENGINE_PIPELINE_VERSION', 1)
+    return f'media-engine:manifest:v{version}:{asset_id}:{profile}'
+
+
+def invalidate_manifest(asset_id):
+    profiles = set(getattr(settings, 'MEDIA_ENGINE_PROFILES', {}).keys())
+    profiles.update({'panorama.multires', 'panorama.preview', 'panorama.marzipano', 'panorama.cube'})
+    for profile in profiles:
+        cache.delete(manifest_cache_key(asset_id, profile))
+
+
+def public_url(file_field):
+    url = file_field.url
+    cdn = getattr(settings, 'MEDIA_ENGINE_CDN_BASE_URL', '')
+    if cdn and url.startswith('/'):
+        return f'{cdn}{url}'
+    return url
+
+
+def _standard_manifest(asset, profile):
+    profile_cfg = get_profile(profile)
+    version = getattr(settings, 'MEDIA_ENGINE_PIPELINE_VERSION', 1)
+    variants = MediaVariant.objects.filter(
+        asset=asset,
+        profile=profile,
+        processor_version=version,
+        status=MediaVariant.Status.READY,
+    ).order_by('width')
+    grouped = {}
+    for variant in variants:
+        grouped.setdefault(variant.format, []).append({
+            'width': variant.width,
+            'height': variant.height,
+            'url': public_url(variant.file),
+            'bytes': variant.file_size,
+            'quality': variant.quality,
+        })
+    fallback_format = profile_cfg.get('fallback_format', 'jpeg')
+    fallback = (grouped.get(fallback_format) or grouped.get('webp') or grouped.get('avif') or [])[-1:] or None
+    return {
+        'id': str(asset.id),
+        'status': asset.status,
+        'media_kind': asset.media_kind,
+        'projection': asset.projection,
+        'sha256': asset.original_sha256,
+        'width': asset.width,
+        'height': asset.height,
+        'dominant_color': asset.dominant_color,
+        'blurhash': asset.blurhash,
+        'placeholder_data_url': asset.placeholder_data_url,
+        'profile': profile,
+        'processor': asset.processor,
+        'processor_version': version,
+        'variants': grouped,
+        'fallback': fallback[0] if fallback else None,
+        'original_url': public_url(asset.original_file) if getattr(settings, 'MEDIA_ENGINE_PUBLIC_ORIGINAL_FALLBACK', False) else None,
+    }
+
+
+def build_manifest(asset_or_id, profile='default'):
+    asset_id = getattr(asset_or_id, 'id', asset_or_id)
+    key = manifest_cache_key(asset_id, profile)
+    cached = cache.get(key)
+    if cached:
+        return cached
+    asset = asset_or_id if isinstance(asset_or_id, MediaAsset) else MediaAsset.objects.get(pk=asset_id)
+    if asset.media_kind == 'panorama' or profile.startswith('panorama.'):
+        from .processors.panorama.manifest import panorama_manifest
+        result = panorama_manifest(asset, profile=profile if profile.startswith('panorama.') else 'panorama.multires')
+        if result.get('preview'):
+            result['preview'] = public_url(asset.panorama_preview)
+        for level in result.get('levels', []):
+            for tiles in level.get('formats', {}).values():
+                for tile in tiles:
+                    url = tile.get('url', '')
+                    cdn = getattr(settings, 'MEDIA_ENGINE_CDN_BASE_URL', '')
+                    if cdn and url.startswith('/'):
+                        tile['url'] = f'{cdn}{url}'
+    else:
+        result = _standard_manifest(asset, profile)
+    cache.set(key, result, 3600)
+    return result

media_engine/metrics.py

@@ -0,0 +1,34 @@
+from django.http import HttpResponse
+
+try:
+    from prometheus_client import Counter, Histogram, Gauge, generate_latest, CONTENT_TYPE_LATEST
+except ImportError:
+    class _Metric:
+        def labels(self, *args, **kwargs):
+            return self
+        def inc(self, *args, **kwargs):
+            return None
+        def set(self, *args, **kwargs):
+            return None
+        def time(self):
+            class _Timer:
+                def __enter__(self): return self
+                def __exit__(self, *args): return False
+            return _Timer()
+    def Counter(*args, **kwargs): return _Metric()
+    def Histogram(*args, **kwargs): return _Metric()
+    def Gauge(*args, **kwargs): return _Metric()
+    def generate_latest(): return b''
+    CONTENT_TYPE_LATEST = 'text/plain; charset=utf-8'
+
+IMAGES_INGESTED = Counter('media_engine_images_ingested_total', 'Number of media assets ingested')
+VARIANTS_GENERATED = Counter('media_engine_variants_generated_total', 'Generated variants', ['format', 'profile'])
+VARIANT_FAILURES = Counter('media_engine_variant_failures_total', 'Failed variant generations', ['format', 'profile'])
+GENERATION_SECONDS = Histogram('media_engine_generation_seconds', 'Variant generation duration', ['format', 'profile'])
+ORIGINAL_BYTES = Counter('media_engine_original_bytes_total', 'Bytes ingested as originals')
+DERIVATIVE_BYTES = Counter('media_engine_derivative_bytes_total', 'Bytes written as derivatives', ['format'])
+READY_ASSETS = Gauge('media_engine_ready_assets', 'Number of ready media assets')
+
+
+def metrics_view(request):
+    return HttpResponse(generate_latest(), content_type=CONTENT_TYPE_LATEST)

media_engine/migrations/0001_initial.py

@@ -0,0 +1,87 @@
+# Generated for Media Optimization Engine 1.0.0
+import uuid
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    initial = True
+    dependencies = [('contenttypes', '0002_remove_content_type_name')]
+
+    operations = [
+        migrations.CreateModel(
+            name='MediaAsset',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('original_sha256', models.CharField(db_index=True, max_length=64, unique=True)),
+                ('original_file', models.FileField(upload_to='media_engine/originals/')),
+                ('original_name', models.CharField(blank=True, max_length=255)),
+                ('mime_type', models.CharField(max_length=100)),
+                ('width', models.PositiveIntegerField()),
+                ('height', models.PositiveIntegerField()),
+                ('original_size', models.BigIntegerField(default=0)),
+                ('dominant_color', models.CharField(blank=True, max_length=16)),
+                ('blurhash', models.CharField(blank=True, max_length=255)),
+                ('placeholder_data_url', models.TextField(blank=True)),
+                ('focal_x', models.FloatField(blank=True, null=True)),
+                ('focal_y', models.FloatField(blank=True, null=True)),
+                ('status', models.CharField(choices=[('PENDING', 'Pending'), ('PROCESSING', 'Processing'), ('READY', 'Ready'), ('PARTIAL', 'Partial'), ('FAILED', 'Failed')], default='PENDING', max_length=20)),
+                ('last_error', models.TextField(blank=True)),
+                ('processor_version', models.PositiveIntegerField(default=1)),
+                ('processed_at', models.DateTimeField(blank=True, null=True)),
+                ('owner_ref', models.CharField(blank=True, db_index=True, max_length=255)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+            ],
+            options={'ordering': ['-created_at']},
+        ),
+        migrations.CreateModel(
+            name='MediaVariant',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('profile', models.CharField(default='default', max_length=50)),
+                ('width', models.PositiveIntegerField()),
+                ('height', models.PositiveIntegerField(default=0)),
+                ('format', models.CharField(max_length=10)),
+                ('file', models.FileField(upload_to='media_engine/derivatives/')),
+                ('file_size', models.BigIntegerField(default=0)),
+                ('quality', models.PositiveSmallIntegerField(default=0)),
+                ('status', models.CharField(choices=[('PENDING', 'Pending'), ('PROCESSING', 'Processing'), ('READY', 'Ready'), ('FAILED', 'Failed')], default='PENDING', max_length=20)),
+                ('processor_version', models.PositiveIntegerField(default=1)),
+                ('last_error', models.TextField(blank=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('asset', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='variants', to='media_engine.mediaasset')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='MediaBinding',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('object_id', models.CharField(max_length=128)),
+                ('field_name', models.CharField(max_length=100)),
+                ('profile', models.CharField(default='default', max_length=50)),
+                ('role', models.CharField(default='content', max_length=50)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('asset', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='bindings', to='media_engine.mediaasset')),
+                ('content_type', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='contenttypes.contenttype')),
+            ],
+        ),
+        migrations.AddConstraint(
+            model_name='mediavariant',
+            constraint=models.UniqueConstraint(fields=('asset', 'profile', 'width', 'format', 'processor_version'), name='uniq_media_variant_version'),
+        ),
+        migrations.AddIndex(
+            model_name='mediavariant',
+            index=models.Index(fields=['asset', 'profile', 'status'], name='media_engin_asset_i_60f63d_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='mediavariant',
+            index=models.Index(fields=['processor_version', 'status'], name='media_engin_process_7c2c36_idx'),
+        ),
+        migrations.AddConstraint(
+            model_name='mediabinding',
+            constraint=models.UniqueConstraint(fields=('content_type', 'object_id', 'field_name'), name='uniq_media_binding_field'),
+        ),
+    ]

media_engine/migrations/0002_panorama_multires.py

@@ -0,0 +1,44 @@
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    dependencies = [('media_engine', '0001_initial')]
+
+    operations = [
+        migrations.AddField(model_name='mediaasset', name='media_kind', field=models.CharField(db_index=True, default='image', max_length=32)),
+        migrations.AddField(model_name='mediaasset', name='projection', field=models.CharField(blank=True, default='', max_length=32)),
+        migrations.AddField(model_name='mediaasset', name='processor', field=models.CharField(blank=True, default='standard_image', max_length=64)),
+        migrations.AddField(model_name='mediaasset', name='metadata_json', field=models.JSONField(blank=True, default=dict)),
+        migrations.AddField(model_name='mediaasset', name='panorama_preview', field=models.FileField(blank=True, upload_to='media_engine/panoramas/previews/')),
+        migrations.CreateModel(
+            name='PanoramaTile',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('profile', models.CharField(default='panorama.multires', max_length=64)),
+                ('processor_version', models.PositiveIntegerField(default=1)),
+                ('level', models.PositiveSmallIntegerField()),
+                ('level_width', models.PositiveIntegerField(default=0)),
+                ('level_height', models.PositiveIntegerField(default=0)),
+                ('col', models.PositiveIntegerField()),
+                ('row', models.PositiveIntegerField()),
+                ('width', models.PositiveIntegerField()),
+                ('height', models.PositiveIntegerField()),
+                ('format', models.CharField(max_length=10)),
+                ('file', models.FileField(upload_to='media_engine/panoramas/')),
+                ('file_size', models.BigIntegerField(default=0)),
+                ('quality', models.PositiveSmallIntegerField(default=0)),
+                ('status', models.CharField(choices=[('PENDING', 'Pending'), ('PROCESSING', 'Processing'), ('READY', 'Ready'), ('FAILED', 'Failed')], default='PENDING', max_length=20)),
+                ('last_error', models.TextField(blank=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('asset', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='panorama_tiles', to='media_engine.mediaasset')),
+            ],
+        ),
+        migrations.AddConstraint(
+            model_name='panoramatile',
+            constraint=models.UniqueConstraint(fields=('asset', 'profile', 'processor_version', 'level', 'col', 'row', 'format'), name='uniq_panorama_tile_version'),
+        ),
+        migrations.AddIndex(model_name='panoramatile', index=models.Index(fields=['asset', 'profile', 'level'], name='media_engin_asset_i_360lvl_idx')),
+        migrations.AddIndex(model_name='panoramatile', index=models.Index(fields=['asset', 'status'], name='media_engin_asset_s_360_idx')),
+    ]

media_engine/migrations/0003_panorama_cube_tiles.py

@@ -0,0 +1,31 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [('media_engine', '0002_panorama_multires')]
+
+    operations = [
+        migrations.RemoveConstraint(
+            model_name='panoramatile',
+            name='uniq_panorama_tile_version',
+        ),
+        migrations.AddField(
+            model_name='panoramatile',
+            name='face',
+            field=models.CharField(blank=True, default='', max_length=1),
+        ),
+        migrations.AddConstraint(
+            model_name='panoramatile',
+            constraint=models.UniqueConstraint(
+                fields=('asset', 'profile', 'processor_version', 'level', 'face', 'col', 'row', 'format'),
+                name='uniq_panorama_tile_version_v2',
+            ),
+        ),
+        migrations.AddIndex(
+            model_name='panoramatile',
+            index=models.Index(
+                fields=['asset', 'profile', 'level', 'face'],
+                name='media_engin_cube_face_idx',
+            ),
+        ),
+    ]

media_engine/models.py

@@ -0,0 +1,145 @@
+import uuid
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+
+
+class MediaAsset(models.Model):
+    class Status(models.TextChoices):
+        PENDING = 'PENDING', 'Pending'
+        PROCESSING = 'PROCESSING', 'Processing'
+        READY = 'READY', 'Ready'
+        PARTIAL = 'PARTIAL', 'Partial'
+        FAILED = 'FAILED', 'Failed'
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    original_sha256 = models.CharField(max_length=64, unique=True, db_index=True)
+    original_file = models.FileField(upload_to='media_engine/originals/')
+    original_name = models.CharField(max_length=255, blank=True)
+    mime_type = models.CharField(max_length=100)
+    width = models.PositiveIntegerField()
+    height = models.PositiveIntegerField()
+    original_size = models.BigIntegerField(default=0)
+    media_kind = models.CharField(max_length=32, default='image', db_index=True)
+    projection = models.CharField(max_length=32, blank=True, default='')
+    processor = models.CharField(max_length=64, blank=True, default='standard_image')
+    metadata_json = models.JSONField(default=dict, blank=True)
+    panorama_preview = models.FileField(upload_to='media_engine/panoramas/previews/', blank=True)
+    dominant_color = models.CharField(max_length=16, blank=True)
+    blurhash = models.CharField(max_length=255, blank=True)
+    placeholder_data_url = models.TextField(blank=True)
+    focal_x = models.FloatField(null=True, blank=True)
+    focal_y = models.FloatField(null=True, blank=True)
+    status = models.CharField(max_length=20, choices=Status.choices, default=Status.PENDING)
+    last_error = models.TextField(blank=True)
+    processor_version = models.PositiveIntegerField(default=1)
+    processed_at = models.DateTimeField(null=True, blank=True)
+    owner_ref = models.CharField(max_length=255, blank=True, db_index=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f'{self.id} {self.original_name or self.original_sha256[:12]}'
+
+
+class MediaVariant(models.Model):
+    class Status(models.TextChoices):
+        PENDING = 'PENDING', 'Pending'
+        PROCESSING = 'PROCESSING', 'Processing'
+        READY = 'READY', 'Ready'
+        FAILED = 'FAILED', 'Failed'
+
+    asset = models.ForeignKey(MediaAsset, related_name='variants', on_delete=models.CASCADE)
+    profile = models.CharField(max_length=50, default='default')
+    width = models.PositiveIntegerField()
+    height = models.PositiveIntegerField(default=0)
+    format = models.CharField(max_length=10)
+    file = models.FileField(upload_to='media_engine/derivatives/')
+    file_size = models.BigIntegerField(default=0)
+    quality = models.PositiveSmallIntegerField(default=0)
+    status = models.CharField(max_length=20, choices=Status.choices, default=Status.PENDING)
+    processor_version = models.PositiveIntegerField(default=1)
+    last_error = models.TextField(blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=['asset', 'profile', 'width', 'format', 'processor_version'],
+                name='uniq_media_variant_version',
+            )
+        ]
+        indexes = [
+            models.Index(fields=['asset', 'profile', 'status']),
+            models.Index(fields=['processor_version', 'status']),
+        ]
+
+    def __str__(self):
+        return f'{self.asset_id} {self.profile} {self.width}.{self.format}'
+
+
+class PanoramaTile(models.Model):
+    class Status(models.TextChoices):
+        PENDING = 'PENDING', 'Pending'
+        PROCESSING = 'PROCESSING', 'Processing'
+        READY = 'READY', 'Ready'
+        FAILED = 'FAILED', 'Failed'
+
+    asset = models.ForeignKey(MediaAsset, related_name='panorama_tiles', on_delete=models.CASCADE)
+    profile = models.CharField(max_length=64, default='panorama.multires')
+    processor_version = models.PositiveIntegerField(default=1)
+    level = models.PositiveSmallIntegerField()
+    face = models.CharField(max_length=1, blank=True, default='')
+    level_width = models.PositiveIntegerField(default=0)
+    level_height = models.PositiveIntegerField(default=0)
+    col = models.PositiveIntegerField()
+    row = models.PositiveIntegerField()
+    width = models.PositiveIntegerField()
+    height = models.PositiveIntegerField()
+    format = models.CharField(max_length=10)
+    file = models.FileField(upload_to='media_engine/panoramas/')
+    file_size = models.BigIntegerField(default=0)
+    quality = models.PositiveSmallIntegerField(default=0)
+    status = models.CharField(max_length=20, choices=Status.choices, default=Status.PENDING)
+    last_error = models.TextField(blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=['asset', 'profile', 'processor_version', 'level', 'face', 'col', 'row', 'format'],
+                name='uniq_panorama_tile_version_v2',
+            )
+        ]
+        indexes = [
+            models.Index(fields=['asset', 'profile', 'level']),
+            models.Index(fields=['asset', 'status']),
+        ]
+
+    def __str__(self):
+        return f"{self.asset_id} L{self.level} {self.face or 'eq'} {self.col},{self.row}.{self.format}"
+
+
+class MediaBinding(models.Model):
+    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
+    object_id = models.CharField(max_length=128)
+    content_object = GenericForeignKey('content_type', 'object_id')
+    field_name = models.CharField(max_length=100)
+    profile = models.CharField(max_length=50, default='default')
+    role = models.CharField(max_length=50, default='content')
+    asset = models.ForeignKey(MediaAsset, related_name='bindings', on_delete=models.CASCADE)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=['content_type', 'object_id', 'field_name'],
+                name='uniq_media_binding_field',
+            )
+        ]

media_engine/node.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass, asdict
+from django.conf import settings
+
+
+@dataclass(frozen=True)
+class NodeIdentity:
+    node_id: str
+    project_slug: str
+    tenant_slug: str
+    deployment_id: str
+
+    def as_dict(self):
+        return asdict(self)
+
+
+def get_node_identity() -> NodeIdentity:
+    return NodeIdentity(
+        node_id=getattr(settings, 'MEDIA_ENGINE_NODE_ID', 'local-node'),
+        project_slug=getattr(settings, 'MEDIA_ENGINE_PROJECT_SLUG', 'local-project'),
+        tenant_slug=getattr(settings, 'MEDIA_ENGINE_TENANT_SLUG', 'default'),
+        deployment_id=getattr(settings, 'MEDIA_ENGINE_DEPLOYMENT_ID', 'standalone'),
+    )
+
+
+def scoped_owner_ref(owner_ref: str) -> str:
+    identity = get_node_identity()
+    clean = (owner_ref or '').strip()
+    prefix = f'{identity.project_slug}:{identity.tenant_slug}'
+    return f'{prefix}:{clean}' if clean else prefix

media_engine/processors/base.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+
+@dataclass(frozen=True)
+class ProcessorResult:
+    asset_id: str
+    processor: str
+    status: str
+
+
+class MediaProcessor(Protocol):
+    name: str
+
+    def supports(self, asset, profile_name: str) -> bool:
+        ...
+
+    def process(self, asset, profile_name: str, force: bool = False) -> ProcessorResult:
+        ...

media_engine/processors/image/standard.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from ..base import ProcessorResult
+
+
+class StandardImageProcessor:
+    name = 'standard_image'
+
+    def supports(self, asset, profile_name: str) -> bool:
+        return getattr(asset, 'media_kind', 'image') == 'image' and not profile_name.startswith('panorama.')
+
+    def process(self, asset, profile_name: str, force: bool = False) -> ProcessorResult:
+        from ...services import generate_standard_variants
+
+        generate_standard_variants(asset, profile_name=profile_name, force=force)
+        return ProcessorResult(str(asset.pk), self.name, asset.status)

media_engine/processors/panorama/__init__.py

@@ -0,0 +1,5 @@
+from .equirectangular import Panorama360Processor
+from .manifest import panorama_manifest
+from .detect import detect_equirectangular
+
+__all__ = ['Panorama360Processor', 'panorama_manifest', 'detect_equirectangular']