endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/models/rule/rule_applicator.py

@@ -1,224 +0,0 @@
-from .rule import Rule
-import random
-from django.core.exceptions import ValidationError
-
-class RuleApplicator:
-    """
-    A class to apply different types of rules to a Django model instance based on the Rule configuration.
-    """
-
-    def get_rule_by_name(self, rule_name):
-        """
-        A helper method to fetch a rule by name. This can be further customized.
-        """
-        # get rule by name which is natural key
-        rule = Rule.objects.get_by_natural_key(rule_name)
-        return rule
-
-
-    def apply(self, obj, rule):
-        """
-        Applies a specified rule to an object based on the rule type and attributes.
-
-        Parameters:
-        obj (Django model instance): The object to which the rule is applied.
-        rule (Rule): The rule instance containing the rule_type and attribute details.
-        """
-        rule_type_method = self.get_rule_type_method(rule.rule_type.name)
-        if rule_type_method:
-            rule_type_method(obj, rule)
-
-        else:
-            raise ValueError(f"Unsupported rule type: {rule.rule_type.name}")
-        
-    def apply_rule_by_name(self, obj, rule_name):
-        """
-        A helper method to apply a rule and get a value. This can be further customized.
-        """
-        rule = self.get_rule_by_name(rule_name)
-        self.apply(obj, rule)
-
-    def apply_rules_by_name(self, obj, rule_names):
-        """
-        A helper method to apply multiple rules and get values. This can be further customized.
-        """
-        rules = [self.get_rule_by_name(rule_name) for rule_name in rule_names]
-        for rule in rules:
-            self.apply(obj, rule)
-            
-
-    def get_rule_type_method(self, rule_type_name):
-        """
-        Maps rule type name to the corresponding method.
-        """
-        return getattr(self, f"handle_{rule_type_name}", None)
-
-    def parse_attribute_path(self, obj, attribute_key):
-        """
-        Parses the attribute path and applies the value to the correct attribute of a nested object.
-        """
-        parts = attribute_key.split('.')
-        model_name = parts[0]
-        if model_name.lower() != obj.__class__.__name__.lower():
-            raise ValidationError(f"Model type mismatch: expected {model_name}, got {obj.__class__.__name__}")
-
-        # Navigate through the nested attributes
-        target = obj
-        for part in parts[1:-1]:
-            target = getattr(target, part)
-
-        return target, parts[-1]
-
-    def set_attribute_value(self, obj, rule):
-        """
-        Generic method to set attribute value considering nested paths.
-        """
-        target, attribute = self.parse_attribute_path(obj, rule.attribute_key)
-        setattr(target, attribute, rule.attribute_dict['value'])
-        target.save()
-
-    #####
-
-    def handle_case_attribute_set_value(self, obj, rule):
-        """
-        Sets a specific attribute to a given value.
-        """
-        self.set_attribute_value(obj, rule.attribute_key, rule.attribute_dict["value"])
-
-    def handle_case_attribute_set_value_range_uniform(self, obj, rule):
-        """
-        Sets an attribute to a value within a specified range, selected uniformly.
-        """
-        if not hasattr(rule, 'attribute_dtype') or rule.attribute_dtype.name not in ['numeric', 'ordered_categorical']:
-            raise ValidationError("Attribute dtype must be numeric or ordered_categorical")
-        min_val = rule.attribute_dict["value_min"]
-        max_val = rule.attribute_dict["value_max"]
-        value = random.uniform(min_val, max_val)
-        self.set_attribute_value(obj, rule.attribute_key, value)
-
-    def handle_case_attribute_set_value_range_norm_dist(self, obj, rule):
-        """
-        Sets an attribute to a value within a specified range, based on a normal distribution.
-        """
-        if rule.attribute_dtype.name in ['float', "integer"]:
-            raise ValidationError("Attribute dtype must be float or integer")
-        mean = rule.attribute_dict["value_mean"]
-        std_dev = rule.attribute_dict["value_sd"]
-        value = random.normalvariate(mean, std_dev)
-        self.set_attribute_value(obj, rule.attribute_key, value)
-        
-
-    def handle_case_attribute_set_from_list_uniform(self, obj, rule):
-        """
-        Selects an attribute value uniformly from a list of choices.
-        """
-        choices = rule.attribute_dict["value_choices"]
-        value = random.choice(choices)
-        self.set_attribute_value(obj, rule.attribute_key, value)
-
-    def handle_case_attribute_set_from_prop_tuple_list(self, obj, rule):
-        """
-        Selects an attribute value based on a list of value-probability tuples.
-        """
-        prop_list = rule.attribute_dict["value_prop_tuple_list"]
-        total = sum(prop for _, prop in prop_list)
-        pick = random.uniform(0, total)
-        current = 0
-        for value, prop in prop_list:
-            current += prop
-            if current > pick:
-                self.set_attribute_value(obj, rule.attribute_key, value)
-                break
-
-
-    #####
-
-    def handle_case_add_patient(self, obj, rule):
-        """Function to add a patient to a case. If the patient already exists, raise an error. Requires the following
-        rules in the rule_dict:
-        - gender_rule
-        - dob_rule
-        - event_rules
-        - disease_rules
-        """
-        from endoreg_db.models import Patient, PatientEvent, PatientDisease, Case
-
-        # Check if the 
-        obj:Case = obj
-        if obj.patient:
-            raise ValueError("Patient already exists in the case")
-        
-        patient = Patient()
-        self.apply_rule_by_name(patient, rule.attribute_dict["patient_gender_rule"])
-        self.apply_rule_by_name(patient, rule.attribute_dict["patient_dob_rule"])
-        self.apply_rules_by_name(patient, rule.attribute_dict["patient_event_rules"])
-        self.apply_rules_by_name(patient, rule.attribute_dict["patient_disease_rules"])
-
-    def handle_case_add_polyp(self, obj, rule):
-        """
-        Adds a polyp to the case, processing various polyp characteristics. Requires Rules for each attribute:
-        - polyp_location_organ_rule (single rule)
-        - polyp_location_organ_part_rule (single rule)
-        - polyp_morphology_classification_shape_choices_rule (list of rules)
-        - polyp_morphology_classification_chromo_choices_rule (list of rules)
-        - polyp_intervention_type_rule (single rule)
-        - polyp_intervention_instrument_rule (single rule)
-        - polyp_size_mm_rule (single rule)
-
-        """
-        # Example: create and add a polyp instance based on the rules
-        from endoreg_db.models import Polyp  # Ensure you have a Polyp model and adjust the import
-        from endoreg_db.models import Location
-        from endoreg_db.models import EndoscopicIntervention
-        from endoreg_db.models import PolypMorphology
-
-        assert obj.examination.type != None, "Examination type is required"
-
-        location = Location()
-        location.organ = self.apply_rule_by_name(location, rule.attribute_dict["polyp_location_organ_rule"])
-        location.organ_part = self.apply_rule_by_name(location, rule.attribute_dict["polyp_location_organ_part_rule"])
-        location.save()
-
-        morphology = PolypMorphology()
-        # M2M to ClassificationChoice (linked to Classification which has name as natural key)
-        morphology.shape_classification_choices = self.apply_rules_by_name(morphology, rule.attribute_dict["polyp_morphology_classification_shape_choices_rules"])
-        # M2M to ClassificationChoice (linked to Classification which has name as natural key)
-        morphology.chromo_classification_choices = self.apply_rules_by_name(morphology, rule.attribute_dict["polyp_morphology_classification_chromo_choices_rules"])
-        morphology.save()
-
-        intervention = EndoscopicIntervention()
-        intervention.type = self.apply_rule_by_name(intervention, rule.attribute_dict["polyp_intervention_type_rule"])
-        intervention.instrument = self.apply_rule_by_name(intervention, rule.attribute_dict["polyp_intervention_instrument_rule"])
-        intervention.save()
-
-        polyp = Polyp()
-        polyp.size_mm = self.apply_rule_by_name(polyp, rule.attribute_dict["polyp_size_mm_rule"])
-        polyp.location = location
-        polyp.morphology = morphology
-        polyp.intervention = intervention
-        
-        polyp.save()
-
-        obj.polyps.add(polyp)
-        obj.save()
-
-
-    # def handle_case_add_esophageal_varices(self, obj, rule):
-    #     """
-    #     Handles adding esophageal varices to a case based on the rule.
-    #     """
-    #     # Similar to the polyp case, create and add esophageal varices based on the attributes
-    #     from endoreg_db.models import EsophagealVarices  # Ensure this model exists
-    #     varices = EsophagealVarices()
-    #     varices.origin = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_origin_rule"])
-    #     varices.classification = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_classification_rule"])
-    #     varices.location_extent = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_location_extent_rule"])
-    #     varices.save()
-    #     # Assuming a relationship setup
-    #     obj.esophageal_varices.add(varices)
-    #     obj.save()
-
-
-    
-    
-        

endoreg_db/models/rule/rule_attribute_dtype.py

@@ -1,17 +0,0 @@
-from django.db import models
-
-
-class RuleAttributeDtypeManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class RuleAttributeDType(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-
-    objects = RuleAttributeDtypeManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name

endoreg_db/models/rule/rule_type.py

@@ -1,20 +0,0 @@
-from django.db import models
-
-class RuleTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class RuleType(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-
-    objects = RuleTypeManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name
-
-    class Meta:
-        verbose_name = 'Rule Type'
-        verbose_name_plural = 'Rule Types'

endoreg_db/models/rule/ruleset.py

@@ -1,17 +0,0 @@
-from django.db import models
-
-class RulesetManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class Ruleset(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    rules = models.ManyToManyField('Rule')
-
-    objects = RulesetManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name

endoreg_db/renames.yml

@@ -1,8 +0,0 @@
-date_created: created_at
-date_modified: updated_at
-last_update: updated_at
-date_updated: updated_at
-createdOn: created_at
-updatedOn: updated_at
-modified_at: updated_at
-lastModified: updated_at

endoreg_db/serializers/_old/raw_pdf_meta_validation.py

@@ -1,223 +0,0 @@
-from pathlib import Path
-from rest_framework import serializers
-from django.conf import settings
-#from ...models import RawPdfFile, SensitiveMeta
-from endoreg_db.models import RawPdfFile, SensitiveMeta
-
-class PDFFileForMetaSerializer(serializers.ModelSerializer):
-    """
-    Serializer to fetch PDF metadata along with linked `SensitiveMeta` details.
-    Implements validation and ensures Vue.js can process errors easily.
-    """
-
-    # Fetch patient details from `SensitiveMeta`
-    patient_first_name = serializers.CharField(source="sensitive_meta.patient_first_name", read_only=True)
-    patient_last_name = serializers.CharField(source="sensitive_meta.patient_last_name", read_only=True)
-    patient_dob = serializers.CharField(source="sensitive_meta.patient_dob", read_only=True)
-    examination_date = serializers.CharField(source="sensitive_meta.examination_date", read_only=True)
-
-    # PDF file URL where Vue.js can fetch the document
-    pdf_url = serializers.SerializerMethodField()
-
-    # Full absolute path of the PDF file
-    full_pdf_path = serializers.SerializerMethodField()
-
-    # Direct file path from the database
-    file = serializers.SerializerMethodField()
-
-    class Meta:
-        model = RawPdfFile
-        fields = ['id', 'file', 'pdf_url', 'full_pdf_path', 
-                  'sensitive_meta_id', 'patient_first_name', 
-                  'patient_last_name', 'patient_dob', 'examination_date']
-
-    @staticmethod
-    def get_next_pdf(last_id=None):
-        """
-        Retrieves the first available PDF if `last_id` is NOT provided.
-        Otherwise, fetches the next available PDF where `id > last_id`.
-        """
-        query_filter = {} if last_id is None else {"id__gt": int(last_id)}
-
-        # Get the next available PDF
-        pdf_entry = RawPdfFile.objects.select_related("sensitive_meta").filter(**query_filter).order_by('id').first()
-
-        return pdf_entry  # Returns a model instance or None
-
-    def get_pdf_url(self, obj):
-        """
-        Generates the full URL for Vue.js to fetch and display the PDF.
-        """
-        request = self.context.get('request')
-        print("---------------------here :",obj.file)
-        if request and obj.file:
-            return request.build_absolute_uri(f"/api/pdf/sensitivemeta/?id={obj.id}")  # Constructs full API endpoint
-        return None  # Return None if file is missing
-
-    def get_file(self, obj):
-        """
-        Returns the relative file path stored in the database.
-        """
-        if not obj.file:
-            return None  # No file linked
-        return str(obj.file.name).strip()  # Ensures clean output
-
-    def get_full_pdf_path(self, obj):
-        """
-        Constructs the full absolute file path using `settings.MEDIA_ROOT`.
-        """
-        if not obj.file:
-            return None  # No file linked
-
-        pdf_relative_path = str(obj.file.name)
-
-        full_path = Path(settings.MEDIA_ROOT) / pdf_relative_path
-
-        return str(full_path) if full_path.exists() else None  # Returns path or None if file is missing
-
-    def validate(self, data):
-        """
-        Ensures that the PDF file is valid and has required fields.
-        """
-        errors = {}
-
-        if 'file' in data and not data['file']:
-            errors['file'] = "A valid PDF file is required."
-
-        if 'sensitive_meta_id' in data and not SensitiveMeta.objects.filter(id=data['sensitive_meta_id']).exists():
-            errors['sensitive_meta_id'] = "The provided sensitive_meta_id does not exist."
-
-        if errors:
-            raise serializers.ValidationError(errors)  # Returns structured error response
-
-        return data  # Returns validated data
-
-
-from rest_framework import serializers
-#from ..models import SensitiveMeta
-
-class SensitiveMetaUpdateSerializer(serializers.ModelSerializer):
-    """
-    Serializer for updating patient details in the `SensitiveMeta` table.
-    Allows partial updates.
-    """
-
-    sensitive_meta_id = serializers.IntegerField(write_only=True)  # Needed for lookup, not included in response
-
-    class Meta:
-        model = SensitiveMeta
-        fields = ['sensitive_meta_id', 'patient_first_name', 'patient_last_name', 'patient_dob', 'examination_date']
-
-    def validate(self, data):
-        """
-        Ensures valid input before updating.
-        """
-        errors = {}
-
-        if 'patient_first_name' in data and (not data['patient_first_name'].strip()):
-            errors['patient_first_name'] = "First name cannot be empty."
-
-        if 'patient_last_name' in data and (not data['patient_last_name'].strip()):
-            errors['patient_last_name'] = "Last name cannot be empty."
-
-        if 'patient_dob' in data and not data['patient_dob']:
-            errors['patient_dob'] = "Date of birth is required."
-
-        if 'examination_date' in data and not data['examination_date']:
-            errors['examination_date'] = "Examination date is required."
-
-        if errors:
-            raise serializers.ValidationError(errors)
-
-        return data
-
-    def update(self, instance, validated_data):
-        """
-        Updates only the provided fields dynamically.
-        """
-        validated_data.pop("sensitive_meta_id", None)  # Remove ID before updating
-
-        for attr, value in validated_data.items():
-            setattr(instance, attr, value)  # Dynamically update fields
-
-        instance.save()
-        return instance
-
-
-
-"""
-await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
-const fetchPdfMeta = async (lastId = 1) => {
-    const url = lastId 
-        ? `http://localhost:8000/api/pdf/sensitivemeta/?last_id=${lastId}` 
-        : "http://localhost:8000/api/pdf/sensitivemeta/";
-
-    try {
-        const response = await axios.get(url);
-        console.log("PDF Metadata:", response.data);
-    } catch (error) {
-        console.error("Error fetching PDFs:", error.response?.data || error);
-    }
-};
-
-fetchPdfMeta(); // Fetch the first available PDF
-
-"""
-
-"""with header response"""
-"""
-await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
-
-const fetchPdfMeta = async (lastId = 1) => {
-    const url = lastId 
-        ? `http://localhost:8000/api/pdf/sensitivemeta/?last_id=${lastId}` 
-        : "http://localhost:8000/api/pdf/sensitivemeta/";
-
-    try {
-        const response = await axios.get(url, {
-            headers: {
-                "Accept": "application/json"  
-            }
-        });
-
-        console.log("PDF Metadata (JSON Expected):", response.data);
-    } catch (error) {
-        console.error("Error fetching PDFs:", error.response?.data || error);
-    }
-};
-
-fetchPdfMeta(); 
-"""
-
-
-"""
-await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
-
-const updatePatientInfo = async () => {
-    const updatedData = {
-        sensitive_meta_id: 1,
-        patient_first_name: "dummy value",
-        patient_last_name: "dummy value",
-        patient_dob: "1994-06-15",
-        examination_date: "2024-06-15"
-    };
-
-    try {
-        const response = await axios.patch("http://localhost:8000/api/pdf/update_sensitivemeta/", updatedData, {
-            headers: { "Content-Type": "application/json" }
-        });
-
-        console.log("Update Success:", response.data);
-        alert("Patient information updated successfully!");
-
-        return response.data;
-    } catch (error) {
-        console.error("Update Error:", error.response?.data || error);
-        alert("Failed to update patient information.");
-        return error.response?.data || { error: "Unknown error" };
-    }
-};
-
-updatePatientInfo().then(response => console.log("Final Response:", response));
-
-"""