Enforcing Unique Together Constraint with ManyToMany Fields

The issue you're facing is that group_of_participants__id__in doesn't enforce an exact match for ManyToMany relationships. Instead, it returns any Workshop that has any of the specified groups, not necessarily the exact same set.

Solution

You need to:

1. First filter by the lecturer and area
2. Then check if the set of groups matches exactly

Here's how you can implement this in your form's clean() method:

PYTHONCopied
def clean(self):
    cleaned_data = super().clean()
    
    # Get the input values
    lecturer = cleaned_data.get('lecturer')
    area = cleaned_data.get('area')
    groups = cleaned_data.get('group_of_participants')
    
    if lecturer and area and groups:
        # First filter by lecturer and area
        workshops = Workshop.objects.filter(
            lecturer=lecturer,
            area=area
        )
        
        # Convert input groups to a set of IDs
        input_group_ids = set(group.id for group in groups)
        
        # Check each workshop for exact group match
        for workshop in workshops:
            workshop_group_ids = set(workshop.group_of_participants.values_list('id', flat=True))
            
            # If we find an exact match (same number of groups and same IDs)
            if workshop_group_ids == input_group_ids:
                raise ValidationError("A workshop with this lecturer, area, and exact set of groups already exists.")
    
    return cleaned_data

This approach:

1. Filters workshops by lecturer and area first
2. For each matching workshop, compares the set of group IDs with your input set
3. Raises a validation error if an exact match is found

Alternative Approach

If you're creating many workshops and need better performance, you could also add a custom save method to your form that creates a unique identifier for the group combination:

PYTHONCopied
def save(self, commit=True):
    instance = super().save(commit=False)
    
    # If this is a new workshop being created
    if not instance.pk:
        # Create a unique hash for the groups
        groups = self.cleaned_data['group_of_participants']
        group_ids = sorted([g.id for g in groups])
        instance.group_hash = hash(tuple(group_ids))
        
    if commit:
        instance.save()
        self.save_m2m()
    
    return instance

This would require adding a group_hash field to your Workshop model and creating a unique constraint on lecturer, area, and group_hash.