localcosmos-app-kit 0.9.16__py3-none-any.whl → 0.9.18__py3-none-any.whl

app_kit/features/taxon_profiles/tests/test_zip_import.py

@@ -352,6 +352,10 @@ class TestTaxonProfilesZipImporter(WithMedia, WithTaxonProfiles, WithUser, WithM
                                                                   taxon_latname='Fraxinus excelsior', morphotype='leaf')
         self.assertEqual(fraxinus_excielior_leaf_profile.short_profile,'Fraxinus excelsior morphotype leaf short profile')
         
+        
+        
+    
+        
     @test_settings
     def test_partial_import(self):
         importer = self.get_zip_importer()

app_kit/generic_content_zip_import.py

@@ -570,6 +570,180 @@ class GenericContentZipImporter:
                 'valid_media_types': ', '.join(AVAILABLE_EXTERNAL_MEDIA_TYPES),
             }
             self.add_cell_error(self.workbook_filename, sheet_name, 'B', row_index, message)
+            
+        if external_media_data['media_type']:
+            # call specific validator method for each media type
+            validator_method_name = 'validate_external_media_type_{0}'.format(
+                external_media_data['media_type'].lower()
+            )
+            validator_method = getattr(self, validator_method_name, None)
+            if validator_method:
+                validator_method(external_media_data, sheet_name, row_index)
+            
+    
+    
+    '''
+        image, youTube, vimeo, mp3, wav, pdf, website, file
+    '''
+    def validate_external_media_type_image(self, external_media_data, sheet_name, row_index):
+        # check that the url ends with a valid image extension
+        image_extension = os.path.splitext(external_media_data['url'])[1].lower()
+        if image_extension not in VALID_IMAGE_FORMATS:
+            message = _('Invalid image format in URL: %(cell_value)s. Valid formats are: %(valid_formats)s') % {
+                'cell_value': image_extension,
+                'valid_formats': ', '.join(VALID_IMAGE_FORMATS),
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+        
+        
+    
+    def validate_external_media_type_youtube(self, external_media_data, sheet_name, row_index):
+        url = (external_media_data.get('url') or '').strip()
+        if not url:
+            message = _('Invalid YouTube URL: empty value')
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        try:
+            from urllib.parse import urlparse, parse_qs
+            parsed = urlparse(url)
+            netloc = (parsed.netloc or '').lower()
+            path = parsed.path or ''
+            query = parse_qs(parsed.query or '')
+        except Exception:
+            message = _('Invalid YouTube URL: %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        if parsed.scheme not in ('http', 'https'):
+            message = _('Invalid YouTube URL (scheme must be http/https): %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        video_id = None
+
+        # youtu.be/<id>
+        if netloc.endswith('youtu.be'):
+            candidate = path.lstrip('/')
+            m = re.match(r'^([A-Za-z0-9_-]{11})(?:$|[/?#])', candidate)
+            if m:
+                video_id = m.group(1)
+
+        # *.youtube.com/... variants
+        if not video_id and netloc.endswith('youtube.com'):
+            # watch?v=<id>
+            vvals = query.get('v')
+            if vvals:
+                v = vvals[0]
+                if re.fullmatch(r'[A-Za-z0-9_-]{11}', v or ''):
+                    video_id = v
+            # /embed/<id>, /v/<id>, /shorts/<id>
+            if not video_id:
+                m = re.search(r'/(?:embed|v|shorts)/([A-Za-z0-9_-]{11})(?:$|[/?#])', path)
+                if m:
+                    video_id = m.group(1)
+
+        if not video_id:
+            message = _('Invalid YouTube URL or video id not found: %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        # Optionally: could normalize/store the ID if needed
+        # external_media_data['video_id'] = video_id
+    
+    def validate_external_media_type_vimeo(self, external_media_data, sheet_name, row_index):
+        url = (external_media_data.get('url') or '').strip()
+        if not url:
+            message = _('Invalid Vimeo URL: empty value')
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        try:
+            from urllib.parse import urlparse
+            parsed = urlparse(url)
+            netloc = (parsed.netloc or '').lower()
+            path = parsed.path or ''
+        except Exception:
+            message = _('Invalid Vimeo URL: %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        if parsed.scheme not in ('http', 'https'):
+            message = _('Invalid Vimeo URL (scheme must be http/https): %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        video_id = None
+
+        if netloc.endswith('vimeo.com'):
+            # player.vimeo.com/video/<id>
+            m = re.search(r'/video/(\d+)(?:$|[/?#])', path)
+            if m:
+                video_id = m.group(1)
+            # vimeo.com/<id> or any path ending with /<digits>
+            if not video_id:
+                m = re.search(r'/(\d+)(?:$|[/?#])', path)
+                if m:
+                    video_id = m.group(1)
+
+        if not video_id:
+            message = _('Invalid Vimeo URL or video id not found: %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        # Optionally: could normalize/store the ID if needed
+        # external_media_data['video_id'] = video_id
+    
+    
+    def validate_external_media_type_mp3(self, external_media_data, sheet_name, row_index):
+        # has to end with .mp3
+        if not external_media_data['url'].lower().endswith('.mp3'):
+            message = _('Invalid mp3 format in URL: %(cell_value)s. URL has to end with .mp3') % {
+                'cell_value': external_media_data['url'],
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+    
+    def validate_external_media_type_wav(self, external_media_data, sheet_name, row_index):
+        # has to end with .wav
+        if not external_media_data['url'].lower().endswith('.wav'):
+            message = _('Invalid wav format in URL: %(cell_value)s. URL has to end with .wav') % {
+                'cell_value': external_media_data['url'],
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+    
+    def validate_external_media_type_pdf(self, external_media_data, sheet_name, row_index):
+        # has to end with .pdf
+        if not external_media_data['url'].lower().endswith('.pdf'):
+            message = _('Invalid pdf format in URL: %(cell_value)s. URL has to end with .pdf') % {
+                'cell_value': external_media_data['url'],
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+    
+    
+    def validate_external_media_type_website(self, external_media_data, sheet_name, row_index):
+        # Only flag as invalid if the PATH (not the domain) ends with a file extension
+        try:
+            from urllib.parse import urlparse
+            parsed = urlparse((external_media_data.get('url') or '').strip())
+            path = parsed.path or ''
+        except Exception:
+            path = ''
+
+        # Detect file-like endings in path (e.g., /file.jpg, /index.html)
+        if re.search(r'/[^/]+\.[a-zA-Z0-9]{2,5}$', path):
+            message = _('Invalid website format in URL: %(cell_value)s. URL should not end with a file extension.') % {
+                'cell_value': external_media_data['url'],
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+    
+    
+    def validate_external_media_type_file(self, external_media_data, sheet_name, row_index):
+        # file endings: check if the url has a file extension
+        if not re.search(r'\.[a-zA-Z0-9]{2,5}($|\?)', external_media_data['url']):
+            message = _('Invalid file format in URL: %(cell_value)s. URL has to end with a file extension.') % {
+                'cell_value': external_media_data['url'],
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
     
     
     def add_cell_error(self, filename, sheet_name, column, row, message):

app_kit/taxonomy/sources/custom/forms.py

@@ -13,6 +13,7 @@ TAXON_RANK_CHOICES = (
     ('', '-----'),
     ('kingdom', _('Kingdom')),
     ('phylum', _('Phylum')),
+    ('subphylum', _('Subphylum')),
     ('class', _('Class')),
     ('order', _('Order')),
     ('family', _('Family')),

app_kit/taxonomy/sources/custom/management/commands/import_custom_species_csv.py

@@ -0,0 +1,177 @@
+import csv
+import os
+from typing import Optional, List
+
+from django.core.management.base import BaseCommand, CommandError
+from django.db import transaction
+
+from taxonomy.models import TaxonomyModelRouter
+
+
+class Command(BaseCommand):
+    help = (
+        'Importiert die Arten-/Taxa-CSV (|-getrennt). Erkennt Headerzeile automatisch und überspringt sie.\n'
+        'Unterstütztes Layout (aktuell):\n'
+        '  0: scientific_name | 1: rank | 2: parent_lat | 3: parent_code | 4: de | 5: en | 6: nl | 7: da'
+    )
+
+    def add_arguments(self, parser):
+        parser.add_argument('csv_path', type=str, help='Pfad zur Arten-CSV (|-getrennt).')
+        parser.add_argument('--delimiter', type=str, default='|', help='Trennzeichen (Standard: |).')
+        parser.add_argument('--encoding', type=str, default='utf-8', help='Datei-Kodierung (Standard: utf-8).')
+        parser.add_argument('--dry-run', action='store_true', help='Nur prüfen, am Ende zurückrollen.')
+
+    def handle(self, *args, **options):
+        csv_path = options['csv_path']
+        delimiter = options['delimiter'] or '|'
+        encoding = options['encoding']
+        dry_run = options['dry_run']
+
+        if not os.path.exists(csv_path):
+            raise CommandError(f'Datei nicht gefunden: {csv_path}')
+
+        models = TaxonomyModelRouter('taxonomy.sources.custom')
+        self.stdout.write(self.style.NOTICE('Quelle: taxonomy.sources.custom'))
+        self.stdout.write(self.style.NOTICE(f'Trennzeichen: {repr(delimiter)}'))
+
+        created = 0
+        skipped = 0
+        existing = 0
+        rows = 0
+        self._missing_parents = {}
+        self._header_skipped = False
+        self._existing_names = []
+
+        with open(csv_path, 'r', encoding=encoding, newline='') as f:
+            reader = csv.reader(f, delimiter=delimiter)
+
+            with transaction.atomic():
+                for parts in reader:
+                    rows += 1
+                    if not parts:
+                        continue
+                    # Skip header line if present
+                    if not self._header_skipped and self._looks_like_header(parts):
+                        self._header_skipped = True
+                        continue
+                    c, e, s, existing_name = self._import_species_row(models, parts)
+                    created += c
+                    existing += e
+                    skipped += s
+                    if e and existing_name:
+                        # preserve insertion order, avoid duplicates
+                        if existing_name not in self._existing_names:
+                            self._existing_names.append(existing_name)
+
+                if dry_run:
+                    # Rollback alle DB-Änderungen, aber dennoch Auswertung anzeigen
+                    transaction.set_rollback(True)
+
+        self.stdout.write(self.style.SUCCESS(
+            f'Fertig. Erstellt: {created}, vorhanden: {existing}, übersprungen: {skipped}, Zeilen: {rows}'))
+        if dry_run:
+            self.stdout.write(self.style.WARNING('Dry-Run: Alle Änderungen wurden zurückgerollt.'))
+
+        if existing and self._existing_names:
+            self.stdout.write(self.style.NOTICE('Bereits vorhandene Taxa (exakt):'))
+            for nm in self._existing_names:
+                self.stdout.write(f'- {nm}')
+
+        if skipped and self._missing_parents:
+            self.stdout.write(self.style.WARNING('Übersprungene Zeilen wegen fehlendem Eltern-Taxon (Auszug):'))
+            # Zeige bis zu 25 fehlende Eltern mit Häufigkeit
+            shown = 0
+            for parent_name, count in sorted(self._missing_parents.items(), key=lambda x: -x[1]):
+                self.stdout.write(f'- {parent_name or "<leer>"}: {count}')
+                shown += 1
+                if shown >= 25:
+                    break
+
+    def _looks_like_header(self, parts: List[str]) -> bool:
+        if not parts:
+            return False
+        p0 = (parts[0] or '').strip().lower()
+        p1 = (parts[1] or '').strip().lower() if len(parts) > 1 else ''
+        # Typical header tokens
+        header_tokens = {'scientific name', 'name', 'latname', 'parent taxon', 'rank', 'de', 'en', 'nl', 'dk'}
+        return (p0 in header_tokens) or (p1 in header_tokens)
+
+    def _get_parent(self, models, parent_latname: str):
+        if not parent_latname:
+            return None
+        # exakter Treffer zuerst
+        parent = models.TaxonTreeModel.objects.filter(taxon_latname=parent_latname).first()
+        if parent:
+            return parent
+        # Fallback: case-insensitive Vergleich
+        return models.TaxonTreeModel.objects.filter(taxon_latname__iexact=parent_latname).first()
+
+    def _get_or_create_taxon(self, models, parent, latname: str, rank: str):
+        if not latname:
+            return None, False
+
+        r = (rank or 'species').strip().lower()
+        qs = models.TaxonTreeModel.objects.filter(taxon_latname=latname, rank=r)
+        if parent is None:
+            qs = qs.filter(is_root_taxon=True)
+        else:
+            qs = qs.filter(parent=parent)
+
+        instance = qs.first()
+        created = False
+        if not instance:
+            extra = {'rank': r}
+            if parent is None:
+                extra['is_root_taxon'] = True
+            else:
+                extra['parent'] = parent
+            instance = models.TaxonTreeModel.objects.create(latname, None, **extra)
+            created = True
+        return instance, created
+
+    def _add_locale_if_present(self, models, taxon, name: Optional[str], language: str):
+        if not taxon or not name:
+            return False
+        exists = models.TaxonLocaleModel.objects.filter(taxon=taxon, name=name, language=language).exists()
+        if not exists:
+            models.TaxonLocaleModel.objects.create(taxon, name, language, preferred=True)
+            return True
+        return False
+
+    def _import_species_row(self, models, parts: List[str]):
+        # Unterstütztes Layout (aktuell):
+        # 0: scientific_name | 1: rank | 2: parent_lat | 3: parent_code | 4: de | 5: en | 6: nl | 7: da
+
+        # Normalize parts
+        parts = [(p or '').strip() for p in parts]
+
+        # Minimalprüfung: mindestens 4 Spalten (bis parent_code) erwartet
+        if len(parts) < 4:
+            return 0, 0, 1, None
+
+        name = parts[0]
+        rank = (parts[1] or 'species').strip().lower()
+        parent_latname = parts[2]
+        # parent_code aktuell informativ, optional verwendbar
+        # parent_code = parts[3]
+        locale_start_idx = 4
+
+        parent = self._get_parent(models, parent_latname) if parent_latname else None
+        # If no parent and this should be a root-level taxon, allow creation with no parent
+        if not parent and parent_latname:
+            key = parent_latname
+            self._missing_parents[key] = self._missing_parents.get(key, 0) + 1
+            return 0, 0, 1, None
+
+        taxon, created = self._get_or_create_taxon(models, parent, name, rank)
+        if not taxon:
+            return 0, 0, 1, None
+
+        # Attach vernacular locales if present (de, en, nl, da)
+        locale_langs = ['de', 'en', 'nl', 'da']
+        for offset, lang in enumerate(locale_langs):
+            idx = locale_start_idx + offset
+            val = parts[idx] if idx < len(parts) else ''
+            self._add_locale_if_present(models, taxon, val, lang)
+
+        return (1, 0, 0, None) if created else (0, 1, 0, name)

app_kit/taxonomy/sources/custom/management/commands/import_custom_taxonomy_csv.py

@@ -0,0 +1,177 @@
+# temporary script for a one-time import of BeachExplorer's higher taxonom
+import csv
+import os
+import re
+from typing import List, Optional
+
+from django.core.management.base import BaseCommand, CommandError
+from django.db import transaction
+
+from taxonomy.models import TaxonomyModelRouter
+
+RANK_SET = set([
+    'domain','kingdom','phylum','division','class','order','family','genus','species',
+    'subkingdom','infrakingdom','superphylum','subphylum','infraphylum',
+    'superclass','subclass','infraclass','superorder','suborder',
+    'infraorder','parvorder','superfamily','subfamily','tribe','subtribe',
+    'clade'
+])
+
+
+def is_code_like(val: str) -> bool:
+    return bool(re.fullmatch(r'[a-z]{2,6}', val))
+
+def _non_empty_indices(parts: List[str]) -> List[int]:
+    return [i for i, p in enumerate(parts) if p]
+
+
+class Command(BaseCommand):
+    help = 'Import a custom taxonomy tree from a GROK-Rang CSV (headerlos, |-getrennt).'
+
+    def add_arguments(self, parser):
+        parser.add_argument('csv_path', type=str, help='Pfad zur GROK-Rang CSV-Datei (ohne Header).')
+        parser.add_argument('--language', type=str, default=None,
+                            help='Sprachcode für Bezeichnungen aus dem Pfad (z. B. de, en).')
+        parser.add_argument('--delimiter', type=str, default='|',
+                            help='Trennzeichen (Standard: |).')
+        parser.add_argument('--encoding', type=str, default='utf-8',
+                            help='Datei-Kodierung (Standard: utf-8).')
+        parser.add_argument('--dry-run', action='store_true', help='Nur prüfen, am Ende zurückrollen.')
+        parser.add_argument('--report-limit', type=int, default=10,
+                            help='Maximale Anzahl Beispiel-Einträge in der Dry-Run-Übersicht (Standard: 10).')
+
+    def handle(self, *args, **options):
+        csv_path = options['csv_path']
+        language = options['language']
+        delimiter = options['delimiter'] or '|'
+        encoding = options['encoding']
+        dry_run = options['dry_run']
+
+        if not os.path.exists(csv_path):
+            raise CommandError(f'Datei nicht gefunden: {csv_path}')
+
+        models = TaxonomyModelRouter('taxonomy.sources.custom')
+        self.stdout.write(self.style.NOTICE('Quelle: taxonomy.sources.custom'))
+        self.stdout.write(self.style.NOTICE(f'Trennzeichen: {repr(delimiter)}'))
+
+        # track last Latin parent per depth to build a Latin-only hierarchy
+        self.depth_taxon = {}
+
+        with open(csv_path, 'r', encoding=encoding, newline='') as f:
+            reader = csv.reader(f, delimiter=delimiter)
+            created_count = 0
+            existing_count = 0
+            skipped_count = 0
+            skip_reasons = {}
+            skipped_examples = []
+            row_index = 0
+
+            try:
+                with transaction.atomic():
+                    for parts in reader:
+                        row_index += 1
+                        if not parts:
+                            # Treat truly empty lines as skipped for reporting
+                            skipped_count += 1
+                            skip_reasons['empty line'] = skip_reasons.get('empty line', 0) + 1
+                            if len(skipped_examples) < (options.get('report_limit') or 10):
+                                skipped_examples.append({'row': row_index, 'reason': 'empty line', 'raw': []})
+                            continue
+                        c, e, s, reason = self._import_grok_row(models, parts, language)
+                        created_count += c
+                        existing_count += e
+                        if s:
+                            skipped_count += s
+                            if reason:
+                                skip_reasons[reason] = skip_reasons.get(reason, 0) + 1
+                                if len(skipped_examples) < (options.get('report_limit') or 10):
+                                    skipped_examples.append({'row': row_index, 'reason': reason, 'raw': parts})
+
+                    if dry_run:
+                        # Print a detailed dry-run report before rolling back
+                        self.stdout.write(self.style.WARNING('Dry-Run Bericht:'))
+                        self.stdout.write(f'  Zeilen gelesen: {row_index}')
+                        self.stdout.write(f'  Würde erstellen: {created_count}')
+                        self.stdout.write(f'  Bereits vorhanden: {existing_count}')
+                        self.stdout.write(f'  Übersprungen: {skipped_count}')
+                        if skip_reasons:
+                            self.stdout.write('  Gründe für Überspringen:')
+                            for r, cnt in sorted(skip_reasons.items(), key=lambda x: (-x[1], x[0])):
+                                self.stdout.write(f'    - {r}: {cnt}')
+                        if skipped_examples:
+                            self.stdout.write('  Beispiele übersprungener Einträge:')
+                            for ex in skipped_examples:
+                                preview = '|'.join([str(p) for p in ex.get('raw', [])])
+                                self.stdout.write(f"    - Zeile {ex['row']}: {ex['reason']} -> {preview}")
+                        # Trigger rollback
+                        raise CommandError('Dry-Run abgeschlossen: Änderungen werden zurückgerollt.')
+
+            except CommandError as e:
+                if 'Dry-Run abgeschlossen' in str(e):
+                    self.stdout.write(self.style.WARNING(str(e)))
+                    return
+                raise
+
+        self.stdout.write(self.style.SUCCESS(
+            f'Fertig. Erstellt: {created_count}, vorhanden: {existing_count}, Zeilen: {row_index}'))
+
+    def _get_or_create(self, models, parent, latname, author, rank):
+        existing_qs = models.TaxonTreeModel.objects.filter(taxon_latname=latname, rank=rank)
+        if parent is None:
+            existing_qs = existing_qs.filter(is_root_taxon=True)
+        else:
+            existing_qs = existing_qs.filter(parent=parent)
+
+        instance = existing_qs.first()
+        created = False
+        if not instance:
+            extra = {'rank': rank}
+            if parent is None:
+                extra['is_root_taxon'] = True
+            else:
+                extra['parent'] = parent
+            instance = models.TaxonTreeModel.objects.create(latname, None, **extra)
+            created = True
+        return instance, created
+
+    def _clear_deeper_depth(self, depth: int):
+        # drop any cached parents deeper than current depth
+        for d in list(self.depth_taxon.keys()):
+            if d > depth:
+                del self.depth_taxon[d]
+
+    def _import_grok_row(self, models, parts: List[str], language: Optional[str]):
+        # Normalize tokens but keep positional layout
+        parts = [(p or '').strip() for p in parts]
+        if not parts or len(parts) < 3:
+            return 0, 0, 1, 'empty or too few columns'
+
+        # Fixed GROK layout: [...path..., latin, code, rank]
+        rank = parts[-1]
+        if not rank:
+            return 0, 0, 1, 'missing rank'
+        latin = parts[-3] if len(parts) >= 3 else ''
+        if not latin:
+            return 0, 0, 1, 'missing latin name'
+
+        # Path segments are all tokens before latin
+        path_segments = [p for p in parts[:-3] if p]
+        depth = len(path_segments)
+        parent = self.depth_taxon.get(depth - 1) if depth > 0 else None
+
+        taxon, created = self._get_or_create(models, parent, latin, author=None, rank=rank)
+
+        # Store this taxon as the current parent at its depth and clear deeper cache
+        self.depth_taxon[depth] = taxon
+        self._clear_deeper_depth(depth)
+
+        # Locale: letzter Pfadteil als Bezeichnung (attach vernacular to Latin taxon)
+        if path_segments and language:
+            vernacular = path_segments[-1]
+            exists = models.TaxonLocaleModel.objects.filter(
+                taxon=taxon, name=vernacular, language=language
+            ).exists()
+            if not exists:
+                models.TaxonLocaleModel.objects.create(taxon, vernacular, language, preferred=True)
+
+        return (1, 0, 0, None) if created else (0, 1, 0, None)

app_kit/taxonomy/views.py

@@ -79,7 +79,7 @@ class TaxonTreeView(TemplateView):
         if self.taxon:
             children_nuid_length = len(self.taxon.taxon_nuid) + 3
             taxa = self.models.TaxonTreeModel.objects.annotate(nuid_len=Length('taxon_nuid')).filter(
-                taxon_nuid__startswith=self.taxon.taxon_nuid, nuid_len=children_nuid_length)
+                taxon_nuid__startswith=self.taxon.taxon_nuid, nuid_len=children_nuid_length).order_by('taxon_latname')
             
         else:
             taxa = self.get_root_taxa()

app_kit/tests/test_generic_content_zip_import.py

@@ -320,7 +320,7 @@ class TestGenericContentZipImporter(WithUser, WithMetaApp, TenantTestCase):
         self.assertEqual(licence.licence, 'CC BY-NC')
         self.assertEqual(licence.licence_version, '4.0')
         self.assertEqual(licence.source_link, 'https://imageworld.com/lacerta-agilis.jpg')
-        self.assertEqual(licence.creator_name, 'Art Vandeley')
+        self.assertEqual(licence.creator_name, 'New Author')
         self.assertEqual(content_image.alt_text, 'A new alt text')
         self.assertEqual(content_image.text, 'A new caption')
         self.assertEqual(content_image.title, 'Lizard')
@@ -421,6 +421,146 @@ class TestGenericContentZipImporter(WithUser, WithMetaApp, TenantTestCase):
         # No match for wrong author
         matches = importer.get_taxa_with_taxon_author_tolerance(taxon_source, taxon_latname, 'Smith')
         self.assertEqual(len(matches), 0)
+
+    # External Media URL validation
+    @test_settings
+    def test_validate_external_media_type_youtube_valid_urls(self):
+        importer = self.get_zip_importer()
+        importer.load_workbook()
+        importer.errors = []
+
+        valid_urls = [
+            'https://youtu.be/dQw4w9WgXcQ',
+            'http://youtu.be/dQw4w9WgXcQ',
+            'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
+            'https://youtube.com/watch?v=dQw4w9WgXcQ',
+            'https://www.youtube.com/embed/dQw4w9WgXcQ',
+            'https://www.youtube.com/v/dQw4w9WgXcQ',
+            'https://www.youtube.com/shorts/dQw4w9WgXcQ',
+        ]
+
+        for url in valid_urls:
+            importer.validate_external_media_type_youtube({'url': url}, importer.external_media_sheet_name, 2)
+        self.assertEqual(importer.errors, [])
+
+    @test_settings
+    def test_validate_external_media_type_youtube_invalid_urls(self):
+        importer = self.get_zip_importer()
+        importer.load_workbook()
+        importer.errors = []
+
+        # Empty URL
+        importer.validate_external_media_type_youtube({'url': ''}, importer.external_media_sheet_name, 2)
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid YouTube URL: empty value', importer.errors)
+
+        # Invalid scheme
+        bad_url = 'ftp://youtu.be/dQw4w9WgXcQ'
+        importer.validate_external_media_type_youtube({'url': bad_url}, importer.external_media_sheet_name, 2)
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid YouTube URL (scheme must be http/https): ftp://youtu.be/dQw4w9WgXcQ', importer.errors)
+
+        # No video id
+        bad_url = 'https://www.youtube.com/watch?v='
+        importer.validate_external_media_type_youtube({'url': bad_url}, importer.external_media_sheet_name, 2)
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid YouTube URL or video id not found: https://www.youtube.com/watch?v=', importer.errors)
+
+    @test_settings
+    def test_validate_external_media_type_vimeo_valid_urls(self):
+        importer = self.get_zip_importer()
+        importer.load_workbook()
+        importer.errors = []
+
+        valid_urls = [
+            'https://vimeo.com/123456789',
+            'http://vimeo.com/123456789',
+            'https://player.vimeo.com/video/123456789',
+            'https://www.vimeo.com/123456789',
+        ]
+
+        for url in valid_urls:
+            importer.validate_external_media_type_vimeo({'url': url}, importer.external_media_sheet_name, 2)
+        self.assertEqual(importer.errors, [])
+
+    @test_settings
+    def test_validate_external_media_type_vimeo_invalid_urls(self):
+        importer = self.get_zip_importer()
+        importer.load_workbook()
+        importer.errors = []
+
+        # Empty URL
+        importer.validate_external_media_type_vimeo({'url': ''}, importer.external_media_sheet_name, 2)
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid Vimeo URL: empty value', importer.errors)
+
+        # Invalid scheme
+        bad_url = 'ftp://vimeo.com/123456789'
+        importer.validate_external_media_type_vimeo({'url': bad_url}, importer.external_media_sheet_name, 2)
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid Vimeo URL (scheme must be http/https): ftp://vimeo.com/123456789', importer.errors)
+
+        # No video id
+        bad_url = 'https://vimeo.com/'
+        importer.validate_external_media_type_vimeo({'url': bad_url}, importer.external_media_sheet_name, 2)
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid Vimeo URL or video id not found: https://vimeo.com/', importer.errors)
+
+    @test_settings
+    def test_validate_external_media_type_image_url_extension(self):
+        importer = self.get_zip_importer()
+        importer.load_workbook()
+        importer.errors = []
+
+        # Valid image URL
+        importer.validate_external_media_type_image({'url': 'https://example.com/pic.jpg'}, importer.external_media_sheet_name, 2)
+        # Invalid image URL extension
+        importer.validate_external_media_type_image({'url': 'https://example.com/pic.bmp'}, importer.external_media_sheet_name, 2)
+
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid image format in URL: .bmp. Valid formats are: .jpg, .jpeg, .png, .webp, .gif', importer.errors)
+
+    @test_settings
+    def test_validate_external_media_type_audio_pdf(self):
+        importer = self.get_zip_importer()
+        importer.load_workbook()
+        importer.errors = []
+
+        # mp3
+        importer.validate_external_media_type_mp3({'url': 'https://example.com/audio.txt'}, importer.external_media_sheet_name, 2)
+        importer.validate_external_media_type_mp3({'url': 'https://example.com/audio.mp3'}, importer.external_media_sheet_name, 2)
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid mp3 format in URL: https://example.com/audio.txt. URL has to end with .mp3', importer.errors)
+
+        # wav
+        importer.validate_external_media_type_wav({'url': 'https://example.com/audio.txt'}, importer.external_media_sheet_name, 2)
+        importer.validate_external_media_type_wav({'url': 'https://example.com/audio.wav'}, importer.external_media_sheet_name, 2)
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid wav format in URL: https://example.com/audio.txt. URL has to end with .wav', importer.errors)
+
+        # pdf
+        importer.validate_external_media_type_pdf({'url': 'https://example.com/doc.txt'}, importer.external_media_sheet_name, 2)
+        importer.validate_external_media_type_pdf({'url': 'https://example.com/doc.pdf'}, importer.external_media_sheet_name, 2)
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid pdf format in URL: https://example.com/doc.txt. URL has to end with .pdf', importer.errors)
+
+    @test_settings
+    def test_validate_external_media_type_website(self):
+        importer = self.get_zip_importer()
+        importer.load_workbook()
+        importer.errors = []
+
+        # Invalid: ends with file extension
+        importer.validate_external_media_type_website({'url': 'https://example.com/image.jpg'}, importer.external_media_sheet_name, 2)
+        # Valid: no file extension
+        importer.validate_external_media_type_website({'url': 'https://example.com/some/path?query=x'}, importer.external_media_sheet_name, 2)
+        # Valid: domain-only with TLD
+        importer.validate_external_media_type_website({'url': 'https://example.com'}, importer.external_media_sheet_name, 2)
+
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid website format in URL: https://example.com/image.jpg. URL should not end with a file extension.', importer.errors)
+
+    @test_settings
+    def test_validate_external_media_type_file(self):
+        importer = self.get_zip_importer()
+        importer.load_workbook()
+        importer.errors = []
+
+        # Invalid: no file extension
+        importer.validate_external_media_type_file({'url': 'https://example.com/download/'}, importer.external_media_sheet_name, 2)
+        # Valid: has file extension
+        importer.validate_external_media_type_file({'url': 'https://example.com/download.zip'}, importer.external_media_sheet_name, 2)
+
+        self.assertIn('[Generic Content.xlsx][Sheet:External Media][cell:A3] Invalid file format in URL: https://example.com/download/. URL has to end with a file extension.', importer.errors)
         
         # real world test
         # algaebase entry is : Desmarestia viridis (O.F.Müller) J.V.Lamouroux 1813
@@ -587,4 +727,7 @@ class TestGenericContentZipImporterInvalidData(WithUser, WithMetaApp, TenantTest
         ignorin_importer.load_workbook()
         ignorin_importer.errors = []
         ignorin_importer.validate_listing_in_images_sheet('unlisted.jpg', 'A', 2)
-        self.assertEqual(ignorin_importer.errors, [])
+        self.assertEqual(ignorin_importer.errors, [])
+        
+        
+    

{localcosmos_app_kit-0.9.16.dist-info → localcosmos_app_kit-0.9.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcosmos_app_kit
-Version: 0.9.16
+Version: 0.9.18
 Summary: LocalCosmos App Kit. Web Portal to build Android and iOS apps
 Home-page: https://github.com/localcosmos/app-kit
 Author: Thomas Uher
@@ -14,7 +14,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENCE
-Requires-Dist: localcosmos-server==0.24.10
+Requires-Dist: localcosmos-server==0.24.11
 Requires-Dist: localcosmos-cordova-builder==0.9.6
 Requires-Dist: django-tenants==3.7.0
 Requires-Dist: django-cleanup==9.0.0

{localcosmos_app_kit-0.9.16.dist-info → localcosmos_app_kit-0.9.18.dist-info}/RECORD

@@ -7,7 +7,7 @@ app_kit/definitions.py,sha256=qPfyqMKr71qvBgOj8M7j_7ZbMlFo5sdvfQUUAL0IBBU,82
 app_kit/forms.py,sha256=09xz8t7j7opzAXkBAkSjpjAUFygXHXsSjD62515gRxI,20281
 app_kit/generic.py,sha256=NZDUpyX9Il3NN-kIXwDJGd30s_keRjt2dlAXHEuWfNE,5224
 app_kit/generic_content_validation.py,sha256=d9zM35OaOV382GMRSnIBQXzRcqiPDIaE03OAWtoHgQ4,1146
-app_kit/generic_content_zip_import.py,sha256=LOkLgSNHEZDJHqa2P2ngRVinFefPGQFWKyEZyf4A6uQ,38495
+app_kit/generic_content_zip_import.py,sha256=sVIo5KQeohVTyWMbEyIlr5DDhQ1oXaWiMQycMptJ9vM,46523
 app_kit/global_urls.py,sha256=9y2vQnaD5T4lzma2S0iXWGajZdq5xzq0CsOch7u9SYc,2432
 app_kit/middleware.py,sha256=tav9GDjZlGVsxCsIXUb6Tkibrc1nGnNIK3ScZanDBE8,1278
 app_kit/models.py,sha256=o3JqclCHD64h7Pg3MVX45pZDLYY8EyVT8-83d5FJidE,36764
@@ -464,7 +464,7 @@ app_kit/features/taxon_profiles/tests/common.py,sha256=r27zMWP3LhUCLNv2nSnbLZSb2
 app_kit/features/taxon_profiles/tests/test_forms.py,sha256=tQ4NHGxZz2dzae16tu0JXazTqEskzdv473Ni_ncUaUA,16374
 app_kit/features/taxon_profiles/tests/test_models.py,sha256=-gj-EHBWuFG1mxoOMnwSY2lo0azevO00p0yS-txKcHI,33605
 app_kit/features/taxon_profiles/tests/test_views.py,sha256=8jgvwNe2j79CcoR-FXBI6x9ZnzzxhZLTbX_LGZDgauQ,85993
-app_kit/features/taxon_profiles/tests/test_zip_import.py,sha256=IkW_Of1Dgb3j0aIKoWsUMQajPAX2aQeR31vCUn7N3d4,27185
+app_kit/features/taxon_profiles/tests/test_zip_import.py,sha256=NS5yAOgpedod8qkAMA47NF-Xau_N23kEI5jw88Ee0TE,27217
 app_kit/features/taxon_profiles/tests/__pycache__/common.cpython-311.pyc,sha256=VPg2JQrdcN4hlBj-fGZvvyBb1F79FRk9QI5Wd3HlN04,2573
 app_kit/features/taxon_profiles/tests/__pycache__/common.cpython-313.pyc,sha256=mZa0QDG_CtG8ZTIiQMWSqeBuRzSo8kKqAumsGzZUEus,2397
 app_kit/features/taxon_profiles/tests/__pycache__/test_forms.cpython-311.pyc,sha256=KNorIkGEM4kigyBcxo-1mNhiTVcFMOMA5khcVuTCSuE,16758
@@ -473,7 +473,7 @@ app_kit/features/taxon_profiles/tests/__pycache__/test_models.cpython-311.pyc,sh
 app_kit/features/taxon_profiles/tests/__pycache__/test_models.cpython-313.pyc,sha256=Yh5pGcitUJjxGCfpgLknzn_9pBxK2iBoHXz8jXmtQyY,37911
 app_kit/features/taxon_profiles/tests/__pycache__/test_views.cpython-311.pyc,sha256=LP0Ax_996RBcO7iKOAXLfuPYBkescBUMQage7UNx6eU,94047
 app_kit/features/taxon_profiles/tests/__pycache__/test_views.cpython-313.pyc,sha256=v10_fLVPmVHlQusn-wEobwC5JstZLzfnevMJB7k9VkI,124656
-app_kit/features/taxon_profiles/tests/__pycache__/test_zip_import.cpython-313.pyc,sha256=nfMAbWoVuc43-Gn2dHkmGbvu1J0mppy_9X82vXDUsGw,35276
+app_kit/features/taxon_profiles/tests/__pycache__/test_zip_import.cpython-313.pyc,sha256=wstYyGH-rg8nev8rgokM40R3A4ZgRdxAr_FUACsYTCQ,35276
 app_kit/locale/de/LC_MESSAGES/django.mo,sha256=tSX2dudjFlnL9Vgr8ueLZQ3AxyAzFR6vQtkSRTd3FTs,89194
 app_kit/locale/de/LC_MESSAGES/django.po,sha256=4gLbkP8aCbPWx4stAUFce2OadMQtk_CcNnXdE8MMXnQ,179096
 app_kit/locale/en/LC_MESSAGES/django.mo,sha256=N1pb17IfLd0ASiKO8d68-B4ygSpDkhKOCs8YTzMXQo0,380
@@ -1757,7 +1757,7 @@ app_kit/taxonomy/models.py,sha256=3d5RCnD3OdcnEkGaXhP_HvCBCEz20tq2qWbuBOyYV2M,10
 app_kit/taxonomy/signals.py,sha256=FZHsEUkWN0h7rQN22e8I8MTeP6HfBAzChBTko2PQEHE,1193
 app_kit/taxonomy/urls.py,sha256=q7kE4C7cvgnKH40cUJ1q26MeuAmS7w5fFIJfQiIAgTo,668
 app_kit/taxonomy/utils.py,sha256=Yqu6vuZk3JuUWFKQo9wMS1hhzem5m43SwWKOQmzec64,3181
-app_kit/taxonomy/views.py,sha256=QQtfVkTgskISOh-nad7irG6dP47jG79AufPF_bkepms,6518
+app_kit/taxonomy/views.py,sha256=B--5qstiJcUK2SzVFN6nDX87yLFMqX02God3N-W465I,6544
 app_kit/taxonomy/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 app_kit/taxonomy/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 app_kit/taxonomy/management/commands/taxonomy_recreate_indices.py,sha256=KiK_Wh7lF01Z03jrWz692aTCfDQhEU98CoTDTg-UTjk,7625
@@ -1792,11 +1792,15 @@ app_kit/taxonomy/sources/col/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQe
 app_kit/taxonomy/sources/custom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 app_kit/taxonomy/sources/custom/admin.py,sha256=suMo4x8I3JBxAFBVIdE-5qnqZ6JAZV0FESABHOSc-vg,63
 app_kit/taxonomy/sources/custom/apps.py,sha256=0pJS9BI3enVGwVS-WVMv1LTq5KjOT6QHZ0IaJQVpPw4,104
-app_kit/taxonomy/sources/custom/forms.py,sha256=aPpEIytg4xuIMo0RDUlkCeH2cLE3cayETrmAvB_JW_A,2576
+app_kit/taxonomy/sources/custom/forms.py,sha256=EQW33U3jJjuBN-tSob0Y3heHECPJ-T4critROShFU00,2611
 app_kit/taxonomy/sources/custom/models.py,sha256=4ExGyy2l_mYnGlsBhLndS7lQL5QSFGbE2JSTqx1tPNw,2140
 app_kit/taxonomy/sources/custom/tests.py,sha256=mrbGGRNg5jwbTJtWWa7zSKdDyeB4vmgZCRc2nk6VY-g,60
 app_kit/taxonomy/sources/custom/urls.py,sha256=0P71XKmzS7mLeYIMcn0EE6Vi0pRV1fu-l_d317Kpnug,1032
 app_kit/taxonomy/sources/custom/views.py,sha256=ZFkqba9mGgKdbaZx4GNGI0hKoviyaEOnjf4CGvTTr8E,9780
+app_kit/taxonomy/sources/custom/management/commands/import_custom_species_csv.py,sha256=Ng3-FKfJpxXijxb8EzTEKXgjM8ivJiM92FAIG4ngrug,7434
+app_kit/taxonomy/sources/custom/management/commands/import_custom_taxonomy_csv.py,sha256=Y3QHClrZdvz5Fz-UgyTYhxtcCc6UxBa4BXpyL47PN54,8202
+app_kit/taxonomy/sources/custom/management/commands/__pycache__/import_custom_species_csv.cpython-313.pyc,sha256=AxUh7xot7wo__NBggEI9PEqH9lDX0GHBQ9ZkmTwLjNs,9725
+app_kit/taxonomy/sources/custom/management/commands/__pycache__/import_custom_taxonomy_csv.cpython-313.pyc,sha256=nU0sag8bvHUMSb6KBbs7EF8sZbdp5zwDdSiERW_PAQg,10567
 app_kit/taxonomy/sources/custom/migrations/0001_initial.py,sha256=FLCqXqGQcG0-cMeyxgSt-BuE-5uNq7HfCvYXBDni4wc,4246
 app_kit/taxonomy/sources/custom/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 app_kit/taxonomy/sources/custom/templates/custom_taxonomy/manage_custom_taxon.html,sha256=SSXwvvZflxkKAK1GrkZM15ZD6JUfjEWDmiI78TGhmKg,1348
@@ -1885,7 +1889,7 @@ app_kit/tests/cases.py,sha256=OGjZnENc5aIxPB0T2LxZagCD87om0hImU-aDF5WlBU8,2693
 app_kit/tests/common.py,sha256=KxGYN73HxNPyMrJxelXsN0NA5btQkleWoqTu87jUue8,12293
 app_kit/tests/mixins.py,sha256=K0iR7WSgPOKj3nFRDrm6b61EztaRcdunLlf4pEWshVw,18210
 app_kit/tests/test_forms.py,sha256=5gVJHn6FJrucfq5jitv16TNGjmpkXcAdgfjQ2gdxSok,23822
-app_kit/tests/test_generic_content_zip_import.py,sha256=d309mIKMB1hFtwdPCUWyS6f03PFMY0R78cr_7Z1mJ9w,24313
+app_kit/tests/test_generic_content_zip_import.py,sha256=nmTgtVxtS0PPQbzuWOvup2oLlL-C9DyW3PWKjdb8RfA,31910
 app_kit/tests/test_models.py,sha256=gvTKCpJtNxuOyGgocMIZtLkvO2CnHXJ7jAZgKIcrNNE,48837
 app_kit/tests/test_utils.py,sha256=LQejfDjJw6BRoRUrGjNz0_Ap-1NJhCM6uWyEk8XR9p8,10270
 app_kit/tests/test_views.py,sha256=WKzXwBKlJTtYS2m5oo94DkOUs5cJtwWiJouEM6SkqFQ,85640
@@ -1899,6 +1903,7 @@ app_kit/tests/TESTS_ROOT/images/app-background.jpg,sha256=bmW6cudSfmcRqGSK9P2Sc5
 app_kit/tests/TESTS_ROOT/images/localcosmos-logo.svg,sha256=4-MHj0FjED9eTgmUHnAP-DHCQRqc557HH9akHaoQxs0,409549
 app_kit/tests/TESTS_ROOT/images/test-image-2560-1440.jpg,sha256=BOP-1ZlA9wq-E1sUkOpyqUowpFCdSoF965oKgajjSq0,156278
 app_kit/tests/TESTS_ROOT/ipa_for_tests/TestApp.ipa,sha256=YdGWqMepeBwvpkch3DSVMlnNkf8RuGwENWuwHtoY1Do,78900
+app_kit/tests/TESTS_ROOT/media_for_tests/test/imagestore/31/a6a11b61d65ee19c4c22caa0682288ff.jpg,sha256=dXT6yUqaMJ_91rwQMHT22VjDGb69KRCmm4eboxjtnxM,49349
 app_kit/tests/TESTS_ROOT/templates/neobiota.html,sha256=3ag2VGCuaZ-FoAu25GMUb3s4qMsY7AyhNoDf7CSZJ_w,147
 app_kit/tests/TESTS_ROOT/xlsx_for_testing/BackboneTaxonomy/invalid/Backbone taxonomy.xlsx,sha256=cMkmCtGBR1wwhpDSbjrscNSvLMGnb6YbaliQqws-l7M,8121
 app_kit/tests/TESTS_ROOT/xlsx_for_testing/BackboneTaxonomy/invalid_content_type/Backbone taxonomy.xlsx,sha256=aYRrPI-UABxQUZF-bWvbrD_31ZQgEijdKCzBGOXzGRk,7996
@@ -1928,14 +1933,14 @@ app_kit/tests/__pycache__/common.cpython-313.pyc,sha256=29krHmMxnGBzLReM-dBcU1cR
 app_kit/tests/__pycache__/mixins.cpython-311.pyc,sha256=BpQ9iHqtXMRgIqYh79R-qCPvV7mCxFZD16NTHrkzBLo,30160
 app_kit/tests/__pycache__/mixins.cpython-313.pyc,sha256=4vbTAvCLui4d_00inAU4A01awXhCfVjvXaC4hI6sx9Q,27548
 app_kit/tests/__pycache__/test_forms.cpython-311.pyc,sha256=5EkfnDI_YzuHGlq-Bse7C7XGZi32GgfTzbMg1fY87pI,37496
-app_kit/tests/__pycache__/test_generic_content_zip_import.cpython-313.pyc,sha256=qqzff_gvP29eYod6WNQLyy0g9XjP0Xjo0T61Zn-AV2E,29539
+app_kit/tests/__pycache__/test_generic_content_zip_import.cpython-313.pyc,sha256=G-U45KVf1TwXsMIfzOBntFEJo5QZFvSxpZxaCrZJT0Q,38945
 app_kit/tests/__pycache__/test_models.cpython-311.pyc,sha256=4cb_Zopv6eCuBpVnv-8mIue3uUntAiDxbJZxzFMMDCw,75511
 app_kit/tests/__pycache__/test_models.cpython-313.pyc,sha256=Lmv3BfjLs5Fg-olJeMll5l3f5-hf-X-9fYPhjuXmd-4,82590
 app_kit/tests/__pycache__/test_utils.cpython-313.pyc,sha256=GX3REqZygi2eO_A2F2_KtYi7hg54X5QPtCTCGWuxGpM,14054
 app_kit/tests/__pycache__/test_views.cpython-311.pyc,sha256=NDJR40TcMm-bXXC-wV7OgH1sGR3N7psSWYiUirkkrjU,133242
 app_kit/tests/__pycache__/test_views.cpython-313.pyc,sha256=q851UqIZFCCTfQb1lF4SVxV1j_Vu1hJdOlpckmrGX28,125363
-localcosmos_app_kit-0.9.16.dist-info/licenses/LICENCE,sha256=VnxALPSxXoU59rlNeRdJtwS_nU79IFpVWsZZCQUM4Mw,1086
-localcosmos_app_kit-0.9.16.dist-info/METADATA,sha256=dFda2jrSES7m8CBqR8DaaQnUQIfY-n_-Jseazqzr--Y,1388
-localcosmos_app_kit-0.9.16.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-localcosmos_app_kit-0.9.16.dist-info/top_level.txt,sha256=F6H4pEBkCvUR_iwQHIy4K1iby-jzfWg3CTym5XJKeys,8
-localcosmos_app_kit-0.9.16.dist-info/RECORD,,
+localcosmos_app_kit-0.9.18.dist-info/licenses/LICENCE,sha256=VnxALPSxXoU59rlNeRdJtwS_nU79IFpVWsZZCQUM4Mw,1086
+localcosmos_app_kit-0.9.18.dist-info/METADATA,sha256=wC25Ke7ekb_Rf0l-tcIN2Ih3__GSe64Z0SNNQwGQVSg,1388
+localcosmos_app_kit-0.9.18.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+localcosmos_app_kit-0.9.18.dist-info/top_level.txt,sha256=F6H4pEBkCvUR_iwQHIy4K1iby-jzfWg3CTym5XJKeys,8
+localcosmos_app_kit-0.9.18.dist-info/RECORD,,

{localcosmos_app_kit-0.9.16.dist-info → localcosmos_app_kit-0.9.18.dist-info}/WHEEL

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