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

media_engine/tests/test_responsive_media.py

@@ -0,0 +1,153 @@
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from django.test import SimpleTestCase
+
+from media_engine.templatetags.responsive_media import media_image, media_url, responsive_image
+
+
+class ResponsiveImageTagTests(SimpleTestCase):
+    def manifest(self):
+        return {
+            'width': 1600,
+            'height': 900,
+            'dominant_color': '#123456',
+            'original_url': '/media/original.png',
+            'fallback': {'url': '/media/fallback.webp', 'width': 1280, 'height': 720},
+            'variants': {
+                'avif': [
+                    {'url': '/media/480.avif', 'width': 480, 'height': 270},
+                    {'url': '/media/960.avif', 'width': 960, 'height': 540},
+                ],
+                'webp': [
+                    {'url': '/media/480.webp', 'width': 480, 'height': 270},
+                    {'url': '/media/960.webp', 'width': 960, 'height': 540},
+                    {'url': '/media/1280.webp', 'width': 1280, 'height': 720},
+                ],
+            },
+        }
+
+    @patch('media_engine.templatetags.responsive_media.build_manifest')
+    def test_keeps_image_presentation_attributes_on_nested_img(self, build_manifest):
+        build_manifest.return_value = self.manifest()
+
+        html = str(
+            responsive_image(
+                object(),
+                css_class='site-logo rounded',
+                picture_class='media-picture site-logo-wrap',
+                style='object-fit:contain;width:100%',
+                element_id='brand-logo',
+                sizes='(max-width: 600px) 50vw, 240px',
+            )
+        )
+
+        self.assertIn('<picture class="media-picture site-logo-wrap">', html)
+        self.assertIn('class="site-logo rounded"', html)
+        self.assertIn('id="brand-logo"', html)
+        self.assertIn('style="background:#123456;object-fit:contain;width:100%"', html)
+        self.assertIn('srcset="/media/480.avif 480w, /media/960.avif 960w"', html)
+        self.assertIn('srcset="/media/480.webp 480w, /media/960.webp 960w, /media/1280.webp 1280w"', html)
+        self.assertIn('src="/media/fallback.webp"', html)
+
+    @patch('media_engine.templatetags.responsive_media.build_manifest')
+    def test_adaptive_mode_marks_picture_for_runtime_sizing(self, build_manifest):
+        build_manifest.return_value = self.manifest()
+
+        html = str(responsive_image(object(), adaptive=True))
+
+        self.assertIn('data-moe-adaptive="1"', html)
+
+    @patch('media_engine.templatetags.responsive_media.build_manifest')
+    def test_custom_loading_and_dimensions_override_defaults(self, build_manifest):
+        build_manifest.return_value = self.manifest()
+
+        html = str(
+            responsive_image(
+                object(),
+                role='hero',
+                width='320',
+                height='180',
+                loading='lazy',
+                decoding='sync',
+                fetchpriority='low',
+            )
+        )
+
+        self.assertIn('width="320"', html)
+        self.assertIn('height="180"', html)
+        self.assertIn('loading="lazy"', html)
+        self.assertIn('decoding="sync"', html)
+        self.assertIn('fetchpriority="low"', html)
+
+    @patch('media_engine.templatetags.responsive_media.build_manifest')
+    def test_existing_call_signature_remains_compatible(self, build_manifest):
+        build_manifest.return_value = self.manifest()
+
+        html = str(responsive_image(object(), profile='card', role='content', alt='Card'))
+
+        self.assertTrue(html.startswith('<picture>'))
+        self.assertIn('alt="Card"', html)
+        self.assertIn('loading="lazy"', html)
+        self.assertIn('width="1280"', html)
+        self.assertIn('height="720"', html)
+
+    @patch('media_engine.templatetags.responsive_media._binding_for')
+    @patch('media_engine.templatetags.responsive_media.build_manifest')
+    def test_media_image_resolves_model_field_binding(self, build_manifest, binding_for):
+        build_manifest.return_value = self.manifest()
+        binding_for.return_value = SimpleNamespace(
+            asset=object(),
+            profile='hero',
+            role='hero',
+        )
+
+        html = str(
+            media_image(
+                SimpleNamespace(pk=7),
+                'cover_image',
+                alt='Article cover',
+                css_class='article-hero',
+                sizes='(max-width: 768px) 100vw, 1200px',
+            )
+        )
+
+        self.assertIn('<picture', html)
+        self.assertIn('class="article-hero"', html)
+        self.assertIn('loading="eager"', html)
+        self.assertIn('fetchpriority="high"', html)
+        self.assertIn('/media/960.avif 960w', html)
+
+    @patch('media_engine.templatetags.responsive_media._field_url')
+    @patch('media_engine.templatetags.responsive_media._binding_for')
+    def test_media_image_falls_back_to_field_url_without_binding(self, binding_for, field_url):
+        binding_for.return_value = None
+        field_url.return_value = '/uploads/photo.jpg'
+
+        html = str(
+            media_image(
+                SimpleNamespace(pk=9),
+                'photo',
+                alt='Profile',
+                css_class='avatar',
+            )
+        )
+
+        self.assertTrue(html.startswith('<img'))
+        self.assertIn('src="/uploads/photo.jpg"', html)
+        self.assertIn('loading="lazy"', html)
+
+    @patch('media_engine.templatetags.responsive_media._binding_for')
+    @patch('media_engine.templatetags.responsive_media.build_manifest')
+    def test_media_url_selects_smallest_variant_at_or_above_target(self, build_manifest, binding_for):
+        build_manifest.return_value = self.manifest()
+        binding_for.return_value = SimpleNamespace(asset=object(), profile='default')
+
+        url = media_url(
+            SimpleNamespace(pk=3),
+            'logo',
+            preferred_width=700,
+            preferred_format='webp',
+        )
+
+        self.assertEqual(url, '/media/960.webp')

media_engine/urls.py

@@ -0,0 +1,14 @@
+from django.urls import path
+from rest_framework.routers import DefaultRouter
+from .views import MediaViewSet
+from . import system_views
+
+router = DefaultRouter()
+router.register('images', MediaViewSet, basename='media-image')
+
+urlpatterns = [
+    path('system/capabilities/', system_views.capabilities, name='media-engine-capabilities'),
+    path('system/health/', system_views.health, name='media-engine-health'),
+    path('system/version/', system_views.version, name='media-engine-version'),
+    path('system/openapi.yaml', system_views.openapi_yaml, name='media-engine-openapi'),
+] + router.urls

media_engine/validators.py

@@ -0,0 +1,42 @@
+import io
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from PIL import Image
+try:
+    import pillow_avif  # noqa: F401
+except Exception:
+    pillow_avif = None
+
+ALLOWED_FORMATS = {'JPEG', 'PNG', 'WEBP', 'AVIF'}
+MIME_BY_FORMAT = {
+    'JPEG': 'image/jpeg',
+    'PNG': 'image/png',
+    'WEBP': 'image/webp',
+    'AVIF': 'image/avif',
+}
+
+
+def inspect_upload(uploaded_file):
+    max_bytes = getattr(settings, 'MEDIA_ENGINE_MAX_UPLOAD_BYTES', 25 * 1024 * 1024)
+    if uploaded_file.size > max_bytes:
+        raise ValidationError(f'Image exceeds maximum upload size of {max_bytes} bytes.')
+
+    uploaded_file.seek(0)
+    raw = uploaded_file.read()
+    uploaded_file.seek(0)
+    try:
+        image = Image.open(io.BytesIO(raw))
+        image.verify()
+        image = Image.open(io.BytesIO(raw))
+        fmt = (image.format or '').upper()
+        if fmt not in ALLOWED_FORMATS:
+            raise ValidationError(f'Unsupported image format: {fmt or "unknown"}')
+        width, height = image.size
+        max_pixels = getattr(settings, 'MEDIA_ENGINE_MAX_PIXELS', 50_000_000)
+        if width * height > max_pixels:
+            raise ValidationError(f'Image exceeds maximum pixel count of {max_pixels}.')
+    except ValidationError:
+        raise
+    except Exception as exc:
+        raise ValidationError('Invalid or corrupted image.') from exc
+    return raw, fmt, MIME_BY_FORMAT[fmt], width, height

media_engine/views.py

@@ -0,0 +1,111 @@
+from django.conf import settings
+from django.http import HttpResponseRedirect
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.viewsets import ViewSet
+from .manifest import build_manifest
+from .models import MediaAsset, MediaVariant
+from .profiles import get_profile
+from .serializers import MediaUploadSerializer, MediaAssetSerializer
+from .services import ingest_uploaded_file, generate_variant
+from .queueing import enqueue_asset
+from .auth import MediaEngineApiKeyPermission
+from .node import scoped_owner_ref
+
+
+class MediaViewSet(ViewSet):
+    permission_classes = [MediaEngineApiKeyPermission]
+
+    def create(self, request):
+        serializer = MediaUploadSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        data = serializer.validated_data
+        asset, created = ingest_uploaded_file(
+            data['file'],
+            owner_ref=scoped_owner_ref(data.get('owner_ref', '')),
+            focal_x=data.get('focal_x'),
+            focal_y=data.get('focal_y'),
+            profile=data.get('profile', 'default'),
+            media_kind=data.get('media_kind', ''),
+            projection=data.get('projection', ''),
+            enqueue=True,
+        )
+        output = MediaAssetSerializer(asset, context={'profile': data.get('profile', 'default')}).data
+        return Response(output, status=status.HTTP_201_CREATED if created else status.HTTP_200_OK)
+
+    def retrieve(self, request, pk=None):
+        asset = get_object_or_404(MediaAsset, pk=pk)
+        profile = request.query_params.get('profile', 'default')
+        return Response(MediaAssetSerializer(asset, context={'profile': profile}).data)
+
+    def partial_update(self, request, pk=None):
+        asset = get_object_or_404(MediaAsset, pk=pk)
+        changed = False
+        for field in ('focal_x', 'focal_y'):
+            if field in request.data:
+                value = float(request.data[field])
+                if not 0 <= value <= 1:
+                    return Response({field: 'Must be between 0 and 1.'}, status=400)
+                setattr(asset, field, value)
+                changed = True
+        if changed:
+            asset.save(update_fields=['focal_x', 'focal_y', 'updated_at'])
+        return Response(MediaAssetSerializer(asset).data)
+
+    @action(detail=True, methods=['post'])
+    def regenerate(self, request, pk=None):
+        asset = get_object_or_404(MediaAsset, pk=pk)
+        profile = request.data.get('profile', 'default')
+        enqueue_asset(asset.id, profile=profile, force=True)
+        return Response({'id': str(asset.id), 'status': 'queued', 'profile': profile}, status=202)
+
+    @action(detail=True, methods=['get'])
+    def manifest(self, request, pk=None):
+        asset = get_object_or_404(MediaAsset, pk=pk)
+        profile = request.query_params.get('profile', 'default')
+        return Response(build_manifest(asset, profile=profile))
+
+    @action(detail=True, methods=['get'])
+    def panorama(self, request, pk=None):
+        asset = get_object_or_404(MediaAsset, pk=pk)
+        profile = request.query_params.get('profile', 'panorama.multires')
+        manifest = build_manifest(asset, profile=profile)
+        adapter = request.query_params.get('adapter', 'generic').lower()
+        if adapter == 'pannellum':
+            from .adapters.pannellum import to_pannellum
+            manifest = to_pannellum(manifest)
+        elif adapter == 'marzipano':
+            from .adapters.marzipano import to_marzipano
+            manifest = to_marzipano(manifest)
+        elif adapter == 'threejs':
+            from .adapters.threejs import to_threejs
+            manifest = to_threejs(manifest)
+        elif adapter != 'generic':
+            return Response({'adapter': 'Unsupported adapter.'}, status=400)
+        return Response(manifest)
+
+    @action(detail=True, methods=['get'])
+    def render(self, request, pk=None):
+        asset = get_object_or_404(MediaAsset, pk=pk)
+        profile_name = request.query_params.get('profile', 'default')
+        profile = get_profile(profile_name)
+        fmt = request.query_params.get('format', 'avif').lower()
+        width = int(request.query_params.get('width', 640))
+        if fmt not in set(profile.get('formats', [])) | {profile.get('fallback_format', 'jpeg')}:
+            return Response({'format': 'Unsupported format.'}, status=400)
+        width = min(width, asset.width)
+        variant = MediaVariant.objects.filter(
+            asset=asset,
+            profile=profile_name,
+            width=width,
+            format=fmt,
+            processor_version=getattr(settings, 'MEDIA_ENGINE_PIPELINE_VERSION', 1),
+            status=MediaVariant.Status.READY,
+        ).first()
+        if variant is None:
+            variant = generate_variant(asset, profile_name=profile_name, width=width, fmt=fmt)
+        if variant is None:
+            return Response({'status': 'processing', 'retry_after': 1}, status=202)
+        return HttpResponseRedirect(variant.file.url)

media_optimization_engine-1.4.0.dist-info/METADATA

@@ -0,0 +1,253 @@
+Metadata-Version: 2.4
+Name: media-optimization-engine
+Version: 1.4.0
+Summary: Media Optimization Engineer for Django/Python: automatic model-field optimization, responsive picture/srcset rendering, AVIF/WebP derivatives, 360 media, autonomous nodes, and CDN-ready storage.
+Author-email: Achille Kabasele <pepexykabasele@gmail.com>
+Maintainer-email: Achille Kabasele <pepexykabasele@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Kabasele754/media-optimization-engine
+Project-URL: Repository, https://github.com/Kabasele754/media-optimization-engine
+Project-URL: Issues, https://github.com/Kabasele754/media-optimization-engine/issues
+Project-URL: Documentation, https://github.com/Kabasele754/media-optimization-engine/tree/master/docs
+Keywords: django,media,image-optimization,avif,webp,panorama,360,marzipano,cdn,cloudflare-r2
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django<6.1,>=4.2.30
+Requires-Dist: djangorestframework<4,>=3.14
+Requires-Dist: Pillow<13,>=10.3
+Requires-Dist: pillow-avif-plugin<2,>=1.5
+Requires-Dist: numpy<3,>=1.26
+Requires-Dist: blurhash<2,>=1.1
+Provides-Extra: celery
+Requires-Dist: celery<6,>=5.4; extra == "celery"
+Requires-Dist: redis<7,>=5; extra == "celery"
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]<4,>=3.2; extra == "postgres"
+Provides-Extra: s3
+Requires-Dist: boto3<2,>=1.35; extra == "s3"
+Requires-Dist: django-storages[s3]<2,>=1.14; extra == "s3"
+Provides-Extra: r2
+Requires-Dist: boto3<2,>=1.35; extra == "r2"
+Requires-Dist: django-storages[s3]<2,>=1.14; extra == "r2"
+Provides-Extra: observability
+Requires-Dist: prometheus-client<1,>=0.21; extra == "observability"
+Provides-Extra: all
+Requires-Dist: celery<6,>=5.4; extra == "all"
+Requires-Dist: redis<7,>=5; extra == "all"
+Requires-Dist: psycopg[binary]<4,>=3.2; extra == "all"
+Requires-Dist: boto3<2,>=1.35; extra == "all"
+Requires-Dist: django-storages[s3]<2,>=1.14; extra == "all"
+Requires-Dist: prometheus-client<1,>=0.21; extra == "all"
+Dynamic: license-file
+
+# Media Optimization Engineer 1.4
+
+Media Optimization Engineer (MOE) is a reusable Django/Python package for image optimization, responsive delivery, and 360-degree media processing.
+
+The public package is intentionally application-agnostic. It does not depend on any consuming project's themes, tenants, brands, business models, or private infrastructure.
+
+## Core capabilities
+
+### Standard images
+
+- automatic ImageField / FileField integration;
+- immutable originals;
+- AVIF, WebP and JPEG derivatives;
+- responsive width sets;
+- semantic profiles such as avatar, card, hero, and default;
+- focal-point aware crops;
+- dominant color, BlurHash and lightweight placeholders;
+- SHA-256 deduplication;
+- local, S3-compatible and Cloudflare R2 storage;
+- Redis/Celery processing when enabled;
+- CDN-ready derivative URLs;
+- Django template tags for responsive rendering.
+
+### 360 panoramas
+
+- equirectangular panorama support;
+- progressive preview;
+- multiresolution pyramids;
+- tiled AVIF/WebP delivery;
+- generic manifests;
+- Pannellum, Marzipano and Three.js adapters;
+- optional cubemap generation.
+
+## Install
+
+~~~bash
+pip install media-optimization-engine
+~~~
+
+Optional infrastructure extras:
+
+~~~bash
+pip install "media-optimization-engine[all]"
+~~~
+
+## Django setup
+
+~~~python
+# settings.py
+INSTALLED_APPS = [
+    # ...
+    "rest_framework",
+    "media_engine",
+]
+
+MEDIA_ENGINE_TASK_MODE = "auto"
+
+MEDIA_ENGINE_AUTO_FIELDS = {
+    "articles.Article": {
+        "cover_image": {
+            "profile": "hero",
+            "role": "hero",
+        },
+    },
+    "accounts.Profile": {
+        "photo": {
+            "profile": "avatar",
+            "role": "content",
+        },
+    },
+    "organizations.Organization": {
+        "logo": {
+            "profile": "default",
+            "role": "content",
+        },
+    },
+}
+~~~
+
+~~~python
+# urls.py
+from django.urls import include, path
+
+urlpatterns = [
+    path("api/v1/", include("media_engine.urls")),
+]
+~~~
+
+Then:
+
+~~~bash
+python manage.py migrate
+python manage.py media_engine_doctor
+~~~
+
+## Django template rendering
+
+For normal model fields, use the high-level media_image tag:
+
+~~~django
+{% load responsive_media %}
+
+{% media_image article "cover_image"
+    alt=article.title
+    css_class="article-hero"
+    sizes="(max-width: 768px) 100vw, 1200px"
+%}
+~~~
+
+MOE resolves the field's MediaBinding, generates a responsive picture with available AVIF/WebP sources, preserves the image's CSS classes, and falls back to the original field URL only when no processed binding is available.
+
+### Logo or footer image
+
+~~~django
+{% load responsive_media %}
+
+{% media_image organization "logo"
+    alt=organization.name
+    css_class="site-logo"
+    sizes="240px"
+%}
+~~~
+
+### Card grid
+
+~~~django
+{% load responsive_media %}
+
+{% for article in articles %}
+  <article class="article-card">
+    {% media_image article "cover_image"
+        alt=article.title
+        css_class="article-card__image"
+        sizes="(max-width: 640px) 92vw, (max-width: 1100px) 45vw, 360px"
+    %}
+    <h2>{{ article.title }}</h2>
+  </article>
+{% endfor %}
+~~~
+
+### Direct binding rendering
+
+Advanced integrations can render a known asset directly:
+
+~~~django
+{% load responsive_media %}
+
+{% responsive_image binding.asset
+    profile=binding.profile
+    role=binding.role
+    alt=object.title
+    css_class="media-object"
+    picture_class="media-object-picture"
+    sizes="100vw"
+%}
+~~~
+
+### One optimized URL
+
+For Open Graph metadata, CSS backgrounds, emails, or APIs where picture is not possible:
+
+~~~django
+{% load responsive_media %}
+
+{% media_url organization "logo" preferred_width=512 preferred_format="webp" as optimized_logo %}
+
+<meta property="og:image" content="{{ optimized_logo }}">
+~~~
+
+For normal page images, prefer media_image over media_url; the browser can make a better final choice from srcset and sizes.
+
+## Responsive selection
+
+MOE provides width descriptors and sizes. The browser chooses the final resource using layout width, viewport, DPR, supported formats, and its own network heuristics.
+
+JavaScript is not required for normal responsive images.
+
+Runtime measurement is appropriate only for highly dynamic components whose rendered width cannot be described reliably with sizes, such as resizable editors, canvas-like builders, or asynchronously mounted panels.
+
+## Backfill
+
+Historical media can be ingested with maintenance commands:
+
+~~~bash
+python manage.py backfill_registered_media
+python manage.py audit_media_engine --fail-on-incomplete
+~~~
+
+New uploads registered in MEDIA_ENGINE_AUTO_FIELDS are handled automatically.
+
+## Runtime independence
+
+Embedded Django mode and standalone-node mode are autonomous. Optional control-plane synchronization must never be required for upload, processing, rendering, or derivative delivery.
+
+## License
+
+MIT License. Copyright (c) 2026 Achille Kabasele.

media_optimization_engine-1.4.0.dist-info/RECORD

@@ -0,0 +1,85 @@
+media_engine/__init__.py,sha256=HfAxEc4JmiSOgrNiFiJht-4V2AUW8vplhQrM6QgcvUI,227
+media_engine/admin.py,sha256=X-vE76CV_Ow6ylObT-mm-wD7O-Tl1iw1QhwWtVVIFtU,1588
+media_engine/apps.py,sha256=Dh4H86cECcBR5kLkqZnXcU7xWEPXQnCz4iH0KpmRe6g,319
+media_engine/auth.py,sha256=nd3enjjvKNd788czIqmm7WTXqrPk01OHxb4KduYHGPc,1119
+media_engine/autoregister.py,sha256=WNWDcT2sFUAjuMKavgB84txOQjE8XHWDaLTMJqD3aQc,3731
+media_engine/control_plane.py,sha256=g2xCx7-wgP6KjNQbIe6petfQ4PvAMHcRkAWwIEqDdDI,10094
+media_engine/doctor.py,sha256=o2sn5gW-Pf7wttukRQ3EM3D5Gol-5WZz9tF8_S1AbNk,6122
+media_engine/focal_detectors.py,sha256=qRX6QWC7lYRpsbIjdIHtYAMCymmxDBKJhxazai6E4CA,997
+media_engine/health.py,sha256=DjNxIe8_5gmPjzjhMka7MD_XMyMBAVIEB_edRwm4ttw,2716
+media_engine/image_ops.py,sha256=GgVUVsKMlKd6gPsE9IhfTPC-p9FPVg8pXjuGm9NKPMo,4574
+media_engine/integration.py,sha256=JVZLtet9lmNb0tQ5z2bBVhQJhM4tHkZaaEHiBbgS1YY,1519
+media_engine/locks.py,sha256=kJfPamg26jXTC7O904DnBXMefWwOtEC82rVrAZd0Hig,506
+media_engine/manifest.py,sha256=95LkdM7UEt9Za6oaj5fFO9i2RJYG8G-AJlj-F7mc3v0,3566
+media_engine/metrics.py,sha256=CvYPUt3RTM0AdSk32i9jxp2JDGDDgOr0aPvGll2b_Mc,1648
+media_engine/models.py,sha256=uAUc9lN8pzPiRyAs2TPstPJUzQ--hhJwh7CFpibkinU,6428
+media_engine/node.py,sha256=5lIusUkZ-ALb9c4qGrnP4PsZG8jGM7wmsd09HSMfaxo,887
+media_engine/profiles.py,sha256=4_akGg8J5IQ0Q57kqpbwgHKva-_-DjuJIfXCDrXI2IU,2478
+media_engine/queueing.py,sha256=eqxLlnUIevN6_Pw3temJSsbhFxGYKPQMt9ufA1Wj0OQ,1336
+media_engine/registry.py,sha256=lNqz8AzcpoJglc-yphcfgYiucfjLuU8vSUPqBcSX9I8,1371
+media_engine/runtime_config.py,sha256=4ImMovJGe2vDQnRKDwSC1Ag2dkfjqIyrJmmeN-pNZ6A,1267
+media_engine/serializers.py,sha256=saq7y8tR6gsWsavueX5nbMF_6KeVQLUdchs4Str0Yvw,1308
+media_engine/services.py,sha256=aFtehPz9dyvjW15r2N4T2XqW4KWKQfXSOhOAk1_pD4A,8380
+media_engine/signals.py,sha256=GSUedn5Oe5wT9nVF5vOt-YvBpgtqYkRAFDMjaq5ZoOo,248
+media_engine/storage_paths.py,sha256=wGjWWOH6uPk5kviERlUlBidmyAFJA37g1CIB5Tt0hqM,500
+media_engine/system_views.py,sha256=ik1VGOgprvLA5HMmmkZFff5ONMKKNqaLuVyRoq_acEY,3508
+media_engine/tasks.py,sha256=DY4d2qzTLJRBGg86mDseS8_ty4XSCspj9YnpdMFdgYE,1514
+media_engine/urls.py,sha256=_XVaI5DYdFjJg0UYceRBSndIy5yrms2-GOe0n_gSES0,601
+media_engine/validators.py,sha256=G1IKFh34lHGTftfhJNEXui1orspBVglJEgEHI2K0Iec,1432
+media_engine/views.py,sha256=22T7WMmCCMfbnYwqd9HnbUICEG6FCFI7xQj6uVpNI7w,5110
+media_engine/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+media_engine/adapters/flutter/README.md,sha256=j0r7Mecx6OMBM1RXh-7uR6PJjqvpkUoI8BDnG6b_EM4,495
+media_engine/adapters/flutter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+media_engine/adapters/flutter/models.dart,sha256=wvnfERfMgtrZAKBzYJPo8ntDrVmn9geC35KVGU-9CnM,2349
+media_engine/adapters/marzipano/__init__.py,sha256=FZiH8ei3WWwnFZXunyFM5uNwznI4HTddTwz1XzWho_E,62
+media_engine/adapters/marzipano/manifest.py,sha256=eXLTAKM_qG0C44AliXGDCIgWvLsBYYhzlOqeVUE6W6Q,1917
+media_engine/adapters/pannellum/__init__.py,sha256=GR2Mhcsj0rf5uLSXTpPTentrUxdrxNA4arafn2a-_qY,62
+media_engine/adapters/pannellum/manifest.py,sha256=RY9DnwvQAPKiEhmRTeXftq5xzL1HvF_qrFsX-aZx00E,753
+media_engine/adapters/threejs/__init__.py,sha256=1DUIYZrcFRHKqBtXTUO2oGhqsh7C-EJI6Uy-3QzzyQk,58
+media_engine/adapters/threejs/manifest.py,sha256=qhYZYKHCl_xyBOJITKqhtgx-CuyQYCV9utWbGQDXN1c,303
+media_engine/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+media_engine/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+media_engine/management/commands/audit_media_engine.py,sha256=91VNMOahisVMp5tTHNzZCzuFSLl8nxGGEAW_jc-Lm5g,2620
+media_engine/management/commands/audit_panorama_media.py,sha256=k-j0ic-RlEO9LVYd5ZX_ThTFNlxI_2llfl5P_DPPktw,998
+media_engine/management/commands/backfill_panorama_media.py,sha256=tw5aOPqZYBEGOqjFzvVTZpSRmsUxYSwDXZ4YODNWEYI,1512
+media_engine/management/commands/backfill_registered_media.py,sha256=jTWb9tWQJL4PfJm80z3C6i8JQ7_9LDlwdR5Q0dc6MfE,840
+media_engine/management/commands/backfill_responsive_images.py,sha256=vfkvDIIQ8-8hEBY6umFKQRTRXDli2BZCfOj_F7q9djA,1157
+media_engine/management/commands/cleanup_image_derivatives.py,sha256=5e3IHQVboI40C8_DwyyhP7xjjhx42NbUbjrSGGWEwZQ,1300
+media_engine/management/commands/media_engine_doctor.py,sha256=TTSan-nOVBhZ6yC7c4lH85fxUwsz5FrnJfKGrxDfniU,510
+media_engine/management/commands/media_engine_node_report.py,sha256=kOOhTRAsyhpY5Rv5ZQo6RIEbmz12R7aSoYhy1M1mzzc,1163
+media_engine/management/commands/rollback_media_engine_config.py,sha256=0T0I7lvALdhHMNk5RP_3UrjSpaRL-fE5Nyy4r6BL9kM,515
+media_engine/management/commands/sync_media_engine_hub.py,sha256=5g91YJsx8feh86yZ5OY7yFdCZbfUzHszxWjsJFYIeAE,787
+media_engine/migrations/0001_initial.py,sha256=lY20ercltw3f_DJmltDIrpnHVUM4X0amvoznNpXj63Y,5226
+media_engine/migrations/0002_panorama_multires.py,sha256=dpKzGuHKJ6CtqJO-xgH56MIrKtnhJ-Jlvk731GmYsKo,3117
+media_engine/migrations/0003_panorama_cube_tiles.py,sha256=lJLQx3k0myJoHcucojtBZWGL6srUcRYQVv7XzMPTZZI,1030
+media_engine/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+media_engine/processors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+media_engine/processors/base.py,sha256=tXWzY2m-gYq9qCx9zUrlmJaK6qrmGhgB4bKcilk5cK4,421
+media_engine/processors/registry.py,sha256=Uf-5UvRSm3gyIq6tbU3EKYuwBR2Gk3TUxLpNETc9RN4,546
+media_engine/processors/image/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+media_engine/processors/image/standard.py,sha256=t_uAX8ftaTmR35XBFCi87sG7LACC8Qi5hKeAvOfXL3A,602
+media_engine/processors/panorama/__init__.py,sha256=x8U9y8fzCXPZVrXew_swVXqdF6ITgnNc0RRkvKNJsiY,216
+media_engine/processors/panorama/cube_tiles.py,sha256=ITKi1ZfiQmlI5RfqDAXF3X44VWcz7rcF45baQ4lLg0g,3969
+media_engine/processors/panorama/cubemap.py,sha256=dwWftLKCWOYh5u4wP3guCReAbDotJy5FO8XQsN-TdCc,1423
+media_engine/processors/panorama/detect.py,sha256=nG4mT4syeAUVo441tt95xHLIwrmX-ys7kq8XJEqZ6pQ,898
+media_engine/processors/panorama/equirectangular.py,sha256=CL9HTRb6KwIqFOGO2CLqz7CIWK4x547DTFgnzRCKNdU,7267
+media_engine/processors/panorama/manifest.py,sha256=F7jz9bQnJ8mGJyT90zm7CVFbtnGuBgWgq7eM7EZdBwY,4037
+media_engine/processors/panorama/tiles.py,sha256=IW1WFan8e0Yfmwskmxdwax1A3yEyVF0R45JXn2QrusQ,2956
+media_engine/spec/openapi.yaml,sha256=CD7zoD9ltUFKzITqm9jrNCrBYzlr1EdDB6YiozCDILs,5738
+media_engine/static/media_engine/adaptive-media.js,sha256=ggoeknJBevT3A8T57HRzPunCPyAD8e_P2Gow8_WcY3g,2129
+media_engine/static/media_engine/media-cache-sw.js,sha256=pBMJfCspN0SA1MPU0YNTySYYf3m9BTmANjjhh_CL45U,549
+media_engine/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+media_engine/templatetags/responsive_media.py,sha256=meEdGn5IhGIPvWuktM5RSoQwQxwKUl57CJN-A21bKuE,7341
+media_engine/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+media_engine/tests/test_distributed_node.py,sha256=Ev8TSuZk-te5aGIS9rTq1z8GDzZVCJk0iagFFMro14s,3142
+media_engine/tests/test_image_ops.py,sha256=CG0VRh85I_y7Mv1vBs4Mu61szc0FoOgBLWhc5U-ejCk,494
+media_engine/tests/test_panorama.py,sha256=XHz7hmja3LBX37oALkCl-X1Eg1sofdHcvRoQZ-ljVNY,1332
+media_engine/tests/test_paths.py,sha256=GKdVZQfGEnffxTD4AIWMHZ0qtE-K5AVm1P9nur7QOig,404
+media_engine/tests/test_profiles.py,sha256=oOhdvyRbZGW-TI-TI0BMIoPNSAALhmBnKlzBMQ8SOh4,300
+media_engine/tests/test_responsive_media.py,sha256=zv50HVVIZA6cjLFvrimE9wgKrxwz-YCmhfixNijSVeA,5968
+media_optimization_engine-1.4.0.dist-info/licenses/LICENSE,sha256=1opBmAobedP1rC2gF7n_zFbvJ7tXT6McLaJzLBEmJEE,1073
+media_optimization_engine-1.4.0.dist-info/METADATA,sha256=4RX_SSqTnY7d2ci8Lslubo8ByY7D8VbE3QgqX6ZrC1E,7535
+media_optimization_engine-1.4.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+media_optimization_engine-1.4.0.dist-info/entry_points.txt,sha256=yqnRhbItLlCUBvkLAH-Waq4Rlz2RXiH5dXzi3VEymjE,65
+media_optimization_engine-1.4.0.dist-info/top_level.txt,sha256=T31aKQHDr9u7GPiEULX4KCNwjssi5x2jsCqZ0EVCscA,13
+media_optimization_engine-1.4.0.dist-info/RECORD,,

media_optimization_engine-1.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

media_optimization_engine-1.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+media-engine-doctor = media_engine.doctor:main