endoreg-db 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

endoreg_db/models/center/center_resource.py

@@ -0,0 +1,19 @@
+from os import name
+from django.db import models
+
+class CenterResource(models.Model):
+    name = models.CharField(max_length=255, null=True)
+    center = models.ForeignKey("Center", on_delete=models.CASCADE)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    quantity = models.FloatField()
+    resource = models.ForeignKey("Resource", on_delete=models.CASCADE)
+    transport_emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True,
+                                                  related_name="center_resource_transport_emission_factor")
+    use_emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True,
+                                            related_name="center_resource_use_emission_factor")
+    year = models.IntegerField()
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+    
+    def __str__(self):
+        return self.center.name + " - " + self.resource.name + " (" + str(self.year) + ")"

endoreg_db/models/center/center_waste.py

@@ -0,0 +1,11 @@
+from django.db import models
+    
+class CenterWaste(models.Model):
+    center = models.ForeignKey("Center", on_delete=models.CASCADE)
+    year = models.IntegerField()
+    waste = models.ForeignKey("Waste", on_delete=models.CASCADE)
+    quantity = models.FloatField()
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+    emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+
+    

endoreg_db/models/data_file/import_classes/raw_pdf.py

@@ -25,11 +25,14 @@ logger = logging.getLogger('pdf_import')
 
 import shutil
 
+# get pdf location from settings, default to ~/erc_data/raw_pdf and create if not exists
+PSEUDO_DIR_RAW_PDF = getattr(settings, 'PSEUDO_DIR_RAW_PDF', settings.BASE_DIR / 'erc_data/raw_pdf')
+
 class RawPdfFile(models.Model):
     file = models.FileField(
         upload_to='raw_pdf/',
         validators=[FileExtensionValidator(allowed_extensions=['pdf'])],
-        storage=FileSystemStorage(location=settings.PSEUDO_DIR_RAW_PDF.resolve().as_posix()),
+        storage=FileSystemStorage(location=PSEUDO_DIR_RAW_PDF.resolve().as_posix()),
     )
 
     pdf_hash = models.CharField(max_length=255, unique=True)

endoreg_db/models/data_file/metadata/video_meta.py

@@ -79,9 +79,10 @@ class FFMpegMeta(models.Model):
     def create_from_file(cls, file_path: Path):
         """Creates an FFMpegMeta instance from a video file using ffmpeg probe."""
         try:
-            probe = ffmpeg.probe(str(file_path))
-        except ffmpeg.Error as e:
-            print(e.stderr)
+            probe = ffmpeg.probe(file_path.resolve().as_posix())
+        except: # ffmpeg.Error as e:
+            # print(e.stderr)
+            print(f"Error while probing {file_path}")
             return None
 
         video_stream = next((stream for stream in probe['streams'] if stream['codec_type'] == 'video'), None)

endoreg_db/models/disease.py

@@ -0,0 +1,56 @@
+from django.db import models
+
+class DiseaseManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Disease(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    objects = DiseaseManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+class DiseaseClassificationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class DiseaseClassification(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    disease = models.ForeignKey(Disease, on_delete=models.CASCADE)
+
+    objects = DiseaseClassificationManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+class DiseaseClassificationChoiceManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class DiseaseClassificationChoice(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    disease_classification = models.ForeignKey(DiseaseClassification, on_delete=models.CASCADE)
+
+    objects = DiseaseClassificationChoiceManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/emission/__init__.py

@@ -0,0 +1 @@
+from .emission_factor import EmissionFactor

endoreg_db/models/emission/emission_factor.py

@@ -0,0 +1,20 @@
+from django.db import models
+
+class EmissionFactorManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class EmissionFactor(models.Model):
+    objects = EmissionFactorManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+    value = models.FloatField()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name

endoreg_db/models/event.py

@@ -0,0 +1,22 @@
+from django.db import models
+
+class Event(models.Model):
+    """
+    A class representing an event.
+
+    Attributes:
+        name (str): The name of the event.
+        name_de (str): The German name of the event.
+        name_en (str): The English name of the event.
+        description (str): A description of the event.
+    """
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/information_source.py

@@ -18,5 +18,12 @@ class InformationSource(models.Model):
     name_de = models.CharField(max_length=100, blank=True, null=True)
     name_en = models.CharField(max_length=100, blank=True, null=True)
 
+    url = models.URLField(blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    date = models.DateField(blank=True, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+
     def __str__(self):
         return self.name

endoreg_db/models/laboratory/__init__.py

@@ -0,0 +1 @@
+from .lab_value import LabValue

endoreg_db/models/laboratory/lab_value.py

@@ -0,0 +1,102 @@
+from django.db import models
+import warnings
+
+LANG = "de"
+
+class LabValueManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class LabValue(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    abbreviation = models.CharField(max_length=10, blank=True, null=True)
+    default_unit = models.ForeignKey('Unit', on_delete=models.CASCADE, blank=True, null=True)
+    numeric_precision = models.IntegerField(default=3)
+    default_single_categorical_value_distribution = models.ForeignKey(
+        'SingleCategoricalValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_single_categorical_value_distribution'
+    )
+    default_numerical_value_distribution = models.ForeignKey(
+        'NumericValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_numerical_value_distribution'
+    )
+    default_multiple_categorical_value_distribution = models.ForeignKey(
+        'MultipleCategoricalValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_multiple_categorical_value_distribution'
+    )
+    default_date_value_distribution = models.ForeignKey(
+        'DateValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_date_value_distribution'
+    )
+    default_normal_range = models.JSONField(blank=True, null=True)
+    normal_range_age_dependent = models.BooleanField(default=False)
+    normal_range_gender_dependent = models.BooleanField(default=False)
+    normal_range_special_case = models.BooleanField(default=False)
+    objects = LabValueManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+    def get_default_default_distribution(self):
+        if self.default_single_categorical_value_distribution:
+            return self.default_single_categorical_value_distribution
+        elif self.default_numerical_value_distribution:
+            return self.default_numerical_value_distribution
+        elif self.default_multiple_categorical_value_distribution:
+            return self.default_multiple_categorical_value_distribution
+        elif self.default_date_value_distribution:
+            return self.default_date_value_distribution
+        else:
+            warnings.warn("No default distribution set for lab value")
+            return None
+    
+    def get_normal_range(self, age=None, gender=None):
+        age_dependent = self.normal_range_age_dependent
+        gender_dependent = self.normal_range_gender_dependent
+        special_case = self.normal_range_special_case
+
+        min_value = None
+        max_value = None
+
+        if not age_dependent and \
+        not gender_dependent and \
+        not special_case:
+            min_value = self.default_normal_range.get('min', None)
+            max_value = self.default_normal_range.get('max', None)
+
+        if age_dependent: 
+            # get normal range for age)
+            warnings.warn("Age dependent normal range not implemented yet")
+            pass
+        
+        if gender_dependent:
+            if not gender:
+                warnings.warn("Calling get_normal_range with gender_dependent=True requires gender to be set, choosing by random")
+                # set gender to either "male" or "female"
+                from random import choice
+                choices = ["male", "female"]
+                gender = choice(choices)
+
+            default_range_dict = self.default_normal_range.get(gender, {})
+            min_value = default_range_dict.get('min', None)
+            max_value = default_range_dict.get('max', None)
+
+        if special_case:
+            # get normal range for special case
+            warnings.warn("Special case normal range not implemented yet")
+
+        return min_value, max_value
+

endoreg_db/models/medication/__init__.py

@@ -0,0 +1 @@
+from .medication import *

endoreg_db/models/medication/medication.py

@@ -0,0 +1,148 @@
+from django.db import models
+
+class MedicationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Medication(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    adapt_to_renal_function = models.BooleanField(default = False)
+    adapt_to_hepatic_function = models.BooleanField(default=False)
+    adapt_to_indication = models.BooleanField(default=False)
+    adapt_to_age = models.BooleanField(default=False)
+    adapt_to_weight = models.BooleanField(default=False)
+    adapt_to_risk = models.BooleanField(default=False)
+    default_unit = models.ForeignKey('Unit', on_delete=models.CASCADE)
+
+
+    objects = MedicationManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+class MedicationScheduleManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class MedicationSchedule(models.Model):
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    medication = models.ForeignKey("Medication", on_delete=models.CASCADE)
+    unit = models.ForeignKey("Unit", on_delete=models.CASCADE)
+    therapy_duration_d = models.FloatField(blank=True, null=True)
+    dose = models.FloatField()
+    intake_times = models.ManyToManyField(
+        "MedicationIntakeTime", 
+    )
+
+    objects = MedicationScheduleManager()
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    
+class MedicationIntakeTimeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class MedicationIntakeTime(models.Model):
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    repeats = models.CharField(max_length=20, default = "daily")
+    time = models.TimeField()
+
+    objects = MedicationIntakeTimeManager()
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+
+# IMPLEMENT MEDICATION INDICATION TYPE
+class MedicationIndicationTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class MedicationIndicationType(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    objects = MedicationIndicationTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+    @classmethod
+    def get_random_indication_by_type(cls, name) -> "MedicationIndication":
+        return cls.objects.get(name=name).medication_indications.order_by('?').first()
+    
+
+    def get_random_medication_indication(self):
+        from endoreg_db.models import MedicationIndication
+        return MedicationIndication.objects.filter(indication_type=self).order_by('?').first()
+
+
+class MedicationIndicationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class MedicationIndication(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    indication_type = models.ForeignKey(
+        "MedicationIndicationType", on_delete=models.CASCADE, related_name="medication_indications"
+    )
+    medication_schedules = models.ManyToManyField(
+        "MedicationSchedule"
+    )
+    diseases = models.ManyToManyField(
+        "Disease"
+    )
+    events = models.ManyToManyField(
+        "Event"
+    )
+    classification_choices = models.ManyToManyField(
+        "DiseaseClassificationChoice"
+    )
+    sources = models.ManyToManyField(
+        "InformationSource"
+    )
+
+    def get_indication_links(self):
+        links = {
+            "medication_schedules": self.medication_schedules,
+            "diseases": self.diseases,
+            "events": self.events,
+            "classification_choices": self.classification_choices
+        }
+
+    objects = MedicationIndicationManager()
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def create_patient_medication_schedules(self, patient):
+        from endoreg_db.models import PatientMedicationSchedule
+        for medication_schedule in self.medication_schedules.all():
+            PatientMedicationSchedule.objects.create(
+                patient=patient,
+                medication_schedule=medication_schedule
+            )

endoreg_db/models/other/__init__.py

@@ -0,0 +1,5 @@
+from .material import Material
+from .resource import Resource
+from .transport_route import TransportRoute
+from .waste import Waste
+from .distribution import *

endoreg_db/models/other/distribution.py

@@ -0,0 +1,215 @@
+from django.db import models
+import numpy as np
+from scipy.stats import skewnorm
+
+class BaseValueDistribution(models.Model):
+    """
+    Abstract base class for value distributions.
+    """
+    name = models.CharField(max_length=100)
+
+    class Meta:
+        abstract = True
+
+    def generate_value(self):
+        """
+        Generate a value based on the distribution rules.
+        Must be implemented by subclasses.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+    
+    def natural_key(self):
+        return (self.name,)
+
+class NumericValueDistributionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class NumericValueDistribution(BaseValueDistribution):
+    """
+    Numeric value distribution model.
+    Supports uniform, normal, and skewed normal distributions with hard limits.
+    """
+    objects = NumericValueDistributionManager()
+    DISTRIBUTION_CHOICES = [
+        ('uniform', 'Uniform'),
+        ('normal', 'Normal'),
+        ('skewed_normal', 'Skewed Normal'),
+    ]
+
+    distribution_type = models.CharField(max_length=20, choices=DISTRIBUTION_CHOICES)
+    min_value = models.FloatField()
+    max_value = models.FloatField()
+    mean = models.FloatField(null=True, blank=True)
+    std_dev = models.FloatField(null=True, blank=True)
+    skewness = models.FloatField(null=True, blank=True)
+
+    def generate_value(self):
+        if self.distribution_type == 'uniform':
+            return np.random.uniform(self.min_value, self.max_value)
+        elif self.distribution_type == 'normal':
+            value = np.random.normal(self.mean, self.std_dev)
+            return np.clip(value, self.min_value, self.max_value)
+        elif self.distribution_type == 'skewed_normal':
+            value = skewnorm.rvs(a=self.skewness, loc=self.mean, scale=self.std_dev)
+            return np.clip(value, self.min_value, self.max_value)
+        else:
+            raise ValueError("Unsupported distribution type")
+        
+    
+class SingleCategoricalValueDistributionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class SingleCategoricalValueDistribution(BaseValueDistribution):
+    """
+    Single categorical value distribution model.
+    Assigns a single value based on specified probabilities.
+    """
+    objects = SingleCategoricalValueDistributionManager()
+    categories = models.JSONField()  # { "category": "probability", ... }
+
+    def generate_value(self):
+        categories, probabilities = zip(*self.categories.items())
+        return np.random.choice(categories, p=probabilities)
+    
+
+class MultipleCategoricalValueDistributionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class MultipleCategoricalValueDistribution(BaseValueDistribution):
+    """
+    Multiple categorical value distribution model.
+    Assigns a specific number or varying number of values based on probabilities.
+    """
+    objects = MultipleCategoricalValueDistributionManager()
+    categories = models.JSONField()  # { "category": "probability", ... }
+    min_count = models.IntegerField()
+    max_count = models.IntegerField()
+    count_distribution_type = models.CharField(max_length=20, choices=[('uniform', 'Uniform'), ('normal', 'Normal')])
+    count_mean = models.FloatField(null=True, blank=True)
+    count_std_dev = models.FloatField(null=True, blank=True)
+
+    def generate_value(self):
+        if self.count_distribution_type == 'uniform':
+            count = np.random.randint(self.min_count, self.max_count + 1)
+        elif self.count_distribution_type == 'normal':
+            count = int(np.random.normal(self.count_mean, self.count_std_dev))
+            count = np.clip(count, self.min_count, self.max_count)
+        else:
+            raise ValueError("Unsupported count distribution type")
+
+        categories, probabilities = zip(*self.categories.items())
+        return list(np.random.choice(categories, size=count, p=probabilities))
+
+
+class DateValueDistributionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+from datetime import date, timedelta
+class DateValueDistribution(BaseValueDistribution):
+    """
+    Assign date values based on specified distribution.
+    Expects distribution_type (uniform, normal) and mode (date, timedelta) and based on this either
+    date_min, date_max, date_mean, date_std_dev or
+    timedelta_days_min, timedelta_days_max, timedelta_days_mean, timedelta_days_std_dev
+    """
+    objects = DateValueDistributionManager()
+    name = models.CharField(max_length=100)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    DISTRIBUTION_CHOICES = [
+        ('uniform', 'Uniform'),
+        ('normal', 'Normal'),
+    ]
+    MODE_CHOICES = [
+        ('date', 'Date'),
+        ('timedelta', 'Timedelta'),
+    ]
+
+    distribution_type = models.CharField(max_length=20, choices=DISTRIBUTION_CHOICES)
+    mode = models.CharField(max_length=20, choices=MODE_CHOICES)
+
+    # Date-related fields
+    date_min = models.DateField(blank=True, null=True)
+    date_max = models.DateField(blank=True, null=True)
+    date_mean = models.DateField(blank=True, null=True)
+    date_std_dev = models.IntegerField(blank=True, null=True)  # Standard deviation in days
+
+    # Timedelta-related fields
+    timedelta_days_min = models.IntegerField(blank=True, null=True)
+    timedelta_days_max = models.IntegerField(blank=True, null=True)
+    timedelta_days_mean = models.IntegerField(blank=True, null=True)
+    timedelta_days_std_dev = models.IntegerField(blank=True, null=True)
+
+    def generate_value(self):
+        if self.mode == 'date':
+            return self._generate_date_value()
+        elif self.mode == 'timedelta':
+            return self._generate_timedelta_value()
+        else:
+            raise ValueError("Unsupported mode")
+
+    def _generate_date_value(self):
+        #UNTESTED
+        if self.distribution_type == 'uniform':
+            start_date = self.date_min.toordinal()
+            end_date = self.date_max.toordinal()
+            random_ordinal = np.random.randint(start_date, end_date)
+            return date.fromordinal(random_ordinal)
+        elif self.distribution_type == 'normal':
+            mean_ordinal = self.date_mean.toordinal()
+            std_dev_days = self.date_std_dev
+            random_ordinal = int(np.random.normal(mean_ordinal, std_dev_days))
+            random_ordinal = np.clip(random_ordinal, self.date_min.toordinal(), self.date_max.toordinal())
+            return date.fromordinal(random_ordinal)
+        else:
+            raise ValueError("Unsupported distribution type")
+
+    def _generate_timedelta_value(self):
+        if self.distribution_type == 'uniform':
+            random_days = np.random.randint(self.timedelta_days_min, self.timedelta_days_max + 1)
+            
+            
+        elif self.distribution_type == 'normal':
+            random_days = int(np.random.normal(self.timedelta_days_mean, self.timedelta_days_std_dev))
+            random_days = np.clip(random_days, self.timedelta_days_min, self.timedelta_days_max)
+            
+        else:
+            raise ValueError("Unsupported distribution type")
+        
+        current_date = date.today()
+        generated_date = current_date - timedelta(days=random_days)
+        print(generated_date)
+        return(generated_date)
+        
+# Example Usage
+# Numeric distribution for age
+# age_distribution = NumericValueDistribution.objects.create(
+#     name='Age Distribution',
+#     distribution_type='normal',
+#     min_value=0,
+#     max_value=100,
+#     mean=50,
+#     std_dev=15
+# )
+
+# # Single categorical distribution for gender
+# gender_distribution = SingleCategoricalValueDistribution.objects.create(
+#     name='Gender Distribution',
+#     categories={'male': 0.5, 'female': 0.5}
+# )
+
+# # Multiple categorical distribution for symptoms
+# symptoms_distribution = MultipleCategoricalValueDistribution.objects.create(
+#     name='Symptoms Distribution',
+#     categories={'fever': 0.3, 'cough': 0.4, 'fatigue': 0.2, 'nausea': 0.1},
+#     min_count=1,
+#     max_count=3,
+#     count_distribution_type='normal',
+#     count_mean=2,
+#     count_std_dev=0.5
+# )

endoreg_db/models/other/material.py

@@ -0,0 +1,16 @@
+from django.db import models
+
+class MaterialManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Material(models.Model):
+    objects = MaterialManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+
+    def natural_key(self):
+        return (self.name,)