localcosmos-app-kit 0.9.17__py3-none-any.whl → 0.10.0__py3-none-any.whl

app_kit/features/taxon_profiles/models.py

@@ -87,51 +87,44 @@ class TaxonProfiles(GenericContent):
     def get_primary_localization(self, meta_app=None):
         locale = super().get_primary_localization(meta_app)
 
-        taxon_query = TaxonProfile.objects.filter(taxon_profiles=self)
-        taxa = LazyTaxonList(queryset=taxon_query)
-        for lazy_taxon in taxa:
-
-            taxon_query = {
-                'taxon_source' : lazy_taxon.taxon_source,
-                'taxon_latname' : lazy_taxon.taxon_latname,
-                'taxon_author' : lazy_taxon.taxon_author,
-            }
-
-            taxon_profile = TaxonProfile.objects.filter(taxon_profiles=self, **taxon_query).first()
-
-            if taxon_profile:
+        all_taxon_profiles = TaxonProfile.objects.filter(taxon_profiles=self)
+        for taxon_profile in all_taxon_profiles:
+            
+            if taxon_profile.publication_status == 'draft':
+                continue
                 
-                if taxon_profile.morphotype:
-                    locale[taxon_profile.morphotype] = taxon_profile.morphotype
+            if taxon_profile.morphotype:
+                locale[taxon_profile.morphotype] = taxon_profile.morphotype
 
-                for text in taxon_profile.texts():
+            for text in taxon_profile.texts():
 
-                    # text_type_key = 'taxon_text_{0}'.format(text.taxon_text_type.id)
-                    # short: use name as key (-> no duplicates in translation matrix)
-                    text_type_key = text.taxon_text_type.text_type
-                    locale[text_type_key] = text.taxon_text_type.text_type
-                    
-                    # text.text is a bad key, because if text.text changes, the translation is gone
-                    # text.text are long texts, so use a different key which survives text changes
-                    # locale[text.text] = text.text
+                # text_type_key = 'taxon_text_{0}'.format(text.taxon_text_type.id)
+                # short: use name as key (-> no duplicates in translation matrix)
+                text_type_key = text.taxon_text_type.text_type
+                locale[text_type_key] = text.taxon_text_type.text_type
+                
+                # text.text is a bad key, because if text.text changes, the translation is gone
+                # text.text are long texts, so use a different key which survives text changes
+                # locale[text.text] = text.text
 
-                    short_text_key = self.get_short_text_key(text)
+                short_text_key = self.get_short_text_key(text)
 
-                    if text.text:
-                        locale[short_text_key] = text.text
+                if text.text:
+                    locale[short_text_key] = text.text
 
-                    long_text_key = self.get_long_text_key(text)
+                long_text_key = self.get_long_text_key(text)
 
-                    if text.long_text:
-                        locale[long_text_key] = text.long_text
+                if text.long_text:
+                    locale[long_text_key] = text.long_text
 
-                content_images_primary_localization = taxon_profile.get_content_images_primary_localization()
-                locale.update(content_images_primary_localization)
+            content_images_primary_localization = taxon_profile.get_content_images_primary_localization()
+            locale.update(content_images_primary_localization)
+            
+            short_profile = taxon_profile.short_profile
+            if short_profile:
+                locale[short_profile] = short_profile
                 
-                short_profile = taxon_profile.short_profile
-                if short_profile:
-                    locale[short_profile] = short_profile
-        
+    
         navigation = TaxonProfilesNavigation.objects.filter(taxon_profiles=self).first()
         
         if navigation:

app_kit/features/taxon_profiles/templates/taxon_profiles/ajax/create_taxon_profile.html

@@ -32,7 +32,7 @@
 		<script>
 			var modal = $("#Modal");
 			modal.modal("hide");
-			window.location = "{% url 'manage_taxon_profile' meta_app.id taxon_profiles.id taxon.taxon_source taxon.name_uuid %}";
+			window.location = "{% url 'manage_taxon_profile' meta_app.id taxon_profile.id %}";
 		</script>
 	{% endif %}
 {% endblock %}

app_kit/features/taxon_profiles/templates/taxon_profiles/ajax/manage_taxon_profile_form.html

@@ -1,70 +1,51 @@
 {% load i18n static localcosmos_tags %}
 {% if text_types %}
-<form id="taxon-text-types-form" method="POST" action="{% url 'manage_taxon_profile' meta_app.id taxon_profiles.id taxon.taxon_source taxon.name_uuid %}">{% csrf_token %}
+<form id="taxon-text-types-form" method="POST" action="{% url 'manage_taxon_profile' meta_app.id taxon_profile.id %}"
+>{% csrf_token %}
 	<div id="text-types-form-fields">
 		{% for field in form %}
-			{% if field.field.is_category_field %}
-				{% if field.field.is_first_category %}
-					<div id="order-ctype-{{ field.field.category|ctype_id }}-container" class="object-order-flex mb-3">
-				{% endif %}
-				<div id="order-ctype-{{ text_type_content_type.id }}{% if field.field.category %}-{{ field.field.category.id }}{% endif %}-container" {% if field.field.category %}data-object-id="{{ field.field.category.id }}"{% endif %} class="text-type-category-container">
+			{% if field.field.category %}
+				<h2>
+					{{ field.field.category }}
+				</h2>
 			{% endif %}
-					<div {% if field.name in form.text_type_map %}id="ctype-{{ field.field.taxon_text_type|ctype_id }}-{{ field.field.taxon_text_type.id }}" data-object-id="{{ field.field.taxon_text_type.id }}" {% endif %} class="row">
-						<div class="col-12">
-							{% if field.is_hidden %}
-								{% if field.field.category %}
-									<h2>
-										{{ field.field.category }}
-									</h2>
+			<div class="row">
+				<div class="col-12">
 
-									{% if not field.field.text_type_count %}
-										{% if taxon_profile.taxon_text_set %}
-											<div class="alert alert-info">{% trans 'The selected Text Set does not include any text types for this category.' %}</div>
-										{% else %}
-											<div class="alert alert-info">{% trans 'No text types for this this category yet.' %}</div>
-										{% endif %}
-									{% endif %}
-								{% else %}
+					{% if field.is_hidden %}
+						{{ field }}
+					{% else %}
+						<div class="form-group {% if field.errors %}has-error{% endif %}">
+
+							<h4>
+								{{ field.label }}
+								{% if field.field.taxon_text_type %}
+									{% if show_text_length_badges %}{% if field.field.is_short_version %}<span class="badge badge-info">{% trans 'short version' %}</span>{% else %}<span class="badge badge-primary">{% trans 'long version' %}</span>{% endif %} {% endif %}
 								{% endif %}
-								{{ field }}
-							{% else %}
-								<div class="form-group {% if field.errors %}has-error{% endif %}">
+							</h4>
 
-									<h4>
-										{{ field.label }}
-										{% if field.field.taxon_text_type %}
-											{% if show_text_length_badges %}{% if field.field.is_short_version %}<span class="badge badge-info">{% trans 'short version' %}</span>{% else %}<span class="badge badge-primary">{% trans 'long version' %}</span>{% endif %} {% endif %}
-										{% endif %}
-									</h4>
+							{% if field.field.language %}
+								<img src="{% static 'localcosmos_server/images/countries/' %}{{ field.field.language }}.gif" /> {{ field.field.language }}
+							{% endif %}
 
-									{% if field.field.language %}
-										<img src="{% static 'localcosmos_server/images/countries/' %}{{ field.field.language }}.gif" /> {{ field.field.language }}
-									{% endif %}
+							{{ field }}
+							{% if field.help_text %}
+								<small class="form-text text-muted">{{ field.help_text }}</small>
+							{% endif %}
+						</div>
 
-									{{ field }}
-									{% if field.help_text %}
-										<small class="form-text text-muted">{{ field.help_text }}</small>
-									{% endif %}
+						{% if field.field.taxon_text and field.field.is_short_version %}
+							{% with content_instance=field.field.taxon_text %}
+								<div id="content-images-list-{{ content_instance|ctype_id }}-{{ content_instance.id }}" class="taxon-text-images-container">
+									{% include 'app_kit/ajax/content_images_list.html' %}
 								</div>
-
-								{% if field.field.taxon_text and field.field.is_short_version %}
-									{% with content_instance=field.field.taxon_text %}
-										<div id="content-images-list-{{ content_instance|ctype_id }}-{{ content_instance.id }}" class="taxon-text-images-container">
-											{% include 'app_kit/ajax/content_images_list.html' %}
-										</div>
-									{% endwith %}
-								{% endif %}
-								<br><br>
-							{% endif %}	
-						</div>
-					</div>
-			{% if field.field.is_last %}
+							{% endwith %}
+						{% endif %}
+						<br><br>
+					{% endif %}
 				</div>
-			{% endif %}
+			</div>
 		{% endfor %}
-		{% if form.has_categories %}
-			<!--</div>-->
-		{% endif %}
 	</div>
 
 	<div class="row">

app_kit/features/taxon_profiles/templates/taxon_profiles/ajax/manage_taxon_profile_morphotype.html

@@ -23,7 +23,8 @@
 	{% if success %}
         <script>
             {% if created %}
-                window.location.href = "{% url 'manage_taxon_profile' meta_app.id taxon_profiles.id taxon_profile.taxon.taxon_source taxon_profile.taxon.name_uuid taxon_profile.morphotype %}";
+                // taxon_profile is the created morphotype profile
+                window.location.href = "{% url 'manage_taxon_profile' meta_app.id taxon_profile.id %}";
             {% else %}
                 // Reload the page to show the updated morphotype
                 $('#Modal').modal('hide');

app_kit/features/taxon_profiles/templates/taxon_profiles/ajax/nature_guide_taxonlist.html

@@ -7,7 +7,7 @@
 				{% if meta_node.taxon %}
 					{% get_taxon_profile meta_app meta_node.taxon as profile %}
 					{% if profile %}
-						<a href="{% url 'manage_taxon_profile' meta_app.id generic_content.id profile.taxon_source profile.name_uuid %}">
+						<a href="{% url 'manage_taxon_profile' meta_app.id profile.id %}">
 							{{ meta_node.name }} <i>{{ meta_node.taxon_latname }} {{ meta_node.taxon_author }}</i>
 						</a>
 						{% if profile.publication_status == 'draft' %}
@@ -23,7 +23,7 @@
 					{% get_nature_guide_taxon meta_node nature_guide as taxon %}
 					{% get_taxon_profile meta_app taxon as non_taxon_profile %}
 					{% if non_taxon_profile %}
-						<a href="{% url 'manage_taxon_profile' meta_app.id generic_content.id non_taxon_profile.taxon_source non_taxon_profile.name_uuid %}">
+						<a href="{% url 'manage_taxon_profile' meta_app.id non_taxon_profile.id %}">
 							{{ meta_node.name }}
 						</a>
 						{% if non_taxon_profile.publication_status == 'draft' %}

app_kit/features/taxon_profiles/templates/taxon_profiles/ajax/non_nature_guide_taxonlist.html

@@ -3,7 +3,7 @@
 <ul>
     {% for profile in non_nature_guide_taxon_profiles %}
         <li>
-            <a href="{% url 'manage_taxon_profile' meta_app.id generic_content.id profile.taxon_source profile.name_uuid %}">
+            <a href="{% url 'manage_taxon_profile' meta_app.id profile.id %}">
                 <i>{{ profile.taxon_latname }} {{ profile.taxon_author }}</i>
             </a>
             {% if profile.publication_status == 'draft' %}

app_kit/features/taxon_profiles/templates/taxon_profiles/manage_taxon_profile.html

@@ -92,7 +92,7 @@
 							</div>
 							{% for duplicate in possible_duplicates %}
 								<i>
-									<a href="{% url 'manage_taxon_profile' meta_app.id taxon_profiles.id duplicate.taxon_source duplicate.name_uuid %}">{{ duplicate.taxon_latname }} {{ duplicate.taxon_author }}</a>
+									<a href="{% url 'manage_taxon_profile' meta_app.id duplicate.id %}">{{ duplicate.taxon_latname }} {{ duplicate.taxon_author }}</a>
 								</i>
 							{% endfor %}
 						</div>
@@ -111,10 +111,10 @@
 				</div>
 			</div>
 		{% endif %}
-		{% if taxon_profile.morphotype %}
+		{% if taxon_profile.morphotype and taxon_profile.parent_profile %}
 			<div class="row">
 				<div class="col-12">
-					{% trans 'This is a morphotype of:' %} <a href="{% url 'manage_taxon_profile' meta_app.id taxon_profiles.id taxon.taxon_source taxon.name_uuid %}">
+					{% trans 'This is a morphotype of:' %} <a href="{% url 'manage_taxon_profile' meta_app.id taxon_profile.parent_profile.id %}">
 						{{ taxon }}
 					</a>
 				</div>
@@ -131,7 +131,7 @@
 								{% if taxon_profile.morphotype_profiles %}
 									{% for morphotype in taxon_profile.morphotype_profiles %}
 										<div>
-											<a href="{% url 'manage_taxon_profile' meta_app.id taxon_profiles.id taxon_profile.taxon.taxon_source taxon_profile.taxon.name_uuid morphotype.morphotype %}">
+											<a href="{% url 'manage_taxon_profile' meta_app.id morphotype.id %}">
 												{{ morphotype.morphotype }}
 											</a>
 										</div>

app_kit/features/taxon_profiles/urls.py

@@ -10,6 +10,9 @@ urlpatterns = [
          views.CreateTaxonProfile.as_view(), name='create_taxon_profile'),
     path('manage-taxon-profile/<int:meta_app_id>/<int:taxon_profiles_id>/<str:taxon_source>/<uuid:name_uuid>/',
          views.ManageTaxonProfile.as_view(), name='manage_taxon_profile'),
+    # this should be the future wherever possible, as it is more robust (does not rely on taxon_source and name_uuid to be unchanged)
+    path('manage-taxon-profile/<int:meta_app_id>/<int:taxon_profile_id>/',
+         views.ManageTaxonProfile.as_view(), name='manage_taxon_profile'),
     path('delete-taxon-profile/<int:meta_app_id>/<int:pk>/',
         views.DeleteTaxonProfile.as_view(), name='delete_taxon_profile'),
     # morphotypes

app_kit/features/taxon_profiles/views.py

@@ -298,16 +298,22 @@ class ManageTaxonProfile(CreateTaxonProfileMixin, MetaAppFormLanguageMixin, Form
 
     def set_taxon(self, request, **kwargs):
         
-        self.taxon_profiles =  TaxonProfiles.objects.get(pk=kwargs['taxon_profiles_id'])
-
-        taxon_source = kwargs['taxon_source']
-        name_uuid = kwargs['name_uuid']
+        if 'taxon_profile_id' in kwargs:
+            self.taxon_profile = TaxonProfile.objects.get(pk=kwargs['taxon_profile_id'])
+            self.taxon_profiles = self.taxon_profile.taxon_profiles
+            
+        else:
         
-        morphotype = kwargs.get('morphotype', None)
+            self.taxon_profiles =  TaxonProfiles.objects.get(pk=kwargs['taxon_profiles_id'])
 
-        self.taxon_profile = TaxonProfile.objects.get(taxon_profiles=self.taxon_profiles,
-                                                taxon_source=taxon_source, name_uuid=name_uuid,
-                                                morphotype=morphotype)
+            taxon_source = kwargs['taxon_source']
+            name_uuid = kwargs['name_uuid']
+            
+            morphotype = kwargs.get('morphotype', None)
+
+            self.taxon_profile = TaxonProfile.objects.get(taxon_profiles=self.taxon_profiles,
+                                                    taxon_source=taxon_source, name_uuid=name_uuid,
+                                                    morphotype=morphotype)
 
         self.taxon = LazyTaxon(instance=self.taxon_profile)
 
@@ -744,44 +750,50 @@ class CollectTaxonImages(MetaAppFormLanguageMixin, TemplateView):
         return images
 
     def get_taxon_images(self, exclude=[]):
-        images = ContentImage.objects.filter(image_store__taxon_source=self.taxon.taxon_source,
-                            image_store__taxon_latname=self.taxon.taxon_latname).exclude(pk__in=exclude)
+        
+        images = []
+        
+        if not self.taxon_profile.morphotype:
+            images = ContentImage.objects.filter(image_store__taxon_source=self.taxon.taxon_source,
+                                image_store__taxon_latname=self.taxon.taxon_latname).exclude(pk__in=exclude)
 
         return images
     
     # images can be on MetNode or NatureGuidesTaxonTree
     def get_nature_guide_images(self, exclude=[]):
         
-        meta_nodes = MetaNode.objects.filter(taxon_source=self.taxon.taxon_source, 
-            taxon_latname=self.taxon.taxon_latname, taxon_author=self.taxon.taxon_author, morphotype=self.morphotype)
-
         nature_guide_images = []
+        
+        if not self.taxon_profile.morphotype:
+        
+            meta_nodes = MetaNode.objects.filter(taxon_source=self.taxon.taxon_source, 
+                taxon_latname=self.taxon.taxon_latname, taxon_author=self.taxon.taxon_author, morphotype=self.morphotype)
 
-        if meta_nodes:
+            if meta_nodes:
 
-            meta_node_ids = meta_nodes.values_list('id', flat=True)
+                meta_node_ids = meta_nodes.values_list('id', flat=True)
 
-            meta_node_content_type = ContentType.objects.get_for_model(MetaNode)
-            meta_node_images = ContentImage.objects.filter(content_type=meta_node_content_type,
-                                            object_id__in=meta_node_ids).exclude(pk__in=exclude)
-            
-            exclude += list(meta_node_images.values_list('id', flat=True))
-            nature_guide_images += list(meta_node_images)
+                meta_node_content_type = ContentType.objects.get_for_model(MetaNode)
+                meta_node_images = ContentImage.objects.filter(content_type=meta_node_content_type,
+                                                object_id__in=meta_node_ids).exclude(pk__in=exclude)
+                
+                exclude += list(meta_node_images.values_list('id', flat=True))
+                nature_guide_images += list(meta_node_images)
 
-        
-        nodes = NatureGuidesTaxonTree.objects.filter(meta_node__taxon_source=self.taxon.taxon_source,
-            meta_node__taxon_latname=self.taxon.taxon_latname,
-            meta_node__taxon_author=self.taxon.taxon_author)
+            
+            nodes = NatureGuidesTaxonTree.objects.filter(meta_node__taxon_source=self.taxon.taxon_source,
+                meta_node__taxon_latname=self.taxon.taxon_latname,
+                meta_node__taxon_author=self.taxon.taxon_author)
 
-        if nodes:
+            if nodes:
 
-            node_ids = nodes.values_list('id', flat=True)
+                node_ids = nodes.values_list('id', flat=True)
 
-            node_content_type = ContentType.objects.get_for_model(NatureGuidesTaxonTree)
-            node_images = ContentImage.objects.filter(content_type=node_content_type,
-                                            object_id__in=node_ids).exclude(pk__in=exclude)
-            
-            nature_guide_images += list(node_images)
+                node_content_type = ContentType.objects.get_for_model(NatureGuidesTaxonTree)
+                node_images = ContentImage.objects.filter(content_type=node_content_type,
+                                                object_id__in=node_ids).exclude(pk__in=exclude)
+                
+                nature_guide_images += list(node_images)
             
 
         return nature_guide_images

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)