def targeting()

in experimenter/experimenter/experiments/models.py [0:0]

• 74 lines of code
• 25 McCabe index (conditional complexity)

    def targeting(self):
        if self.published_dto:
            return self.published_dto.get("targeting", self.PUBLISHED_TARGETING_MISSING)

        sticky_expressions = []
        expressions = []

        if self.targeting_config and self.targeting_config.targeting:
            sticky_expressions.append(self.targeting_config.targeting)

        if self.is_desktop and self.channel:
            expressions.append(f'browserSettings.update.channel == "{self.channel}"')

        sticky_expressions.extend(self._get_targeting_min_version())
        expressions.extend(self._get_targeting_max_version())

        if locales := self.locales.all():
            locales = [locale.code for locale in sorted(locales, key=lambda l: l.code)]

            sticky_expressions.append(f"locale in {locales}")

        if languages := self.languages.all():
            languages = [
                language.code for language in sorted(languages, key=lambda l: l.code)
            ]

            sticky_expressions.append(f"language in {languages}")

        if countries := self.countries.all():
            countries = [
                country.code for country in sorted(countries, key=lambda c: c.code)
            ]
            sticky_expressions.append(f"region in {countries}")

        enrollments_map_key = "enrollments_map"
        if self.is_desktop:
            enrollments_map_key = "enrollmentsMap"

        if excluded_experiments := NimbusExperimentBranchThroughExcluded.objects.filter(
            parent_experiment=self
        ).order_by("id"):
            for excluded in excluded_experiments:
                if excluded.branch_slug:
                    sticky_expressions.append(
                        f"({enrollments_map_key}['{excluded.child_experiment.slug}'] "
                        f"== '{excluded.branch_slug}') == false"
                    )
                else:
                    sticky_expressions.append(
                        f"('{excluded.child_experiment.slug}' in enrollments) == false"
                    )

        if required_experiments := NimbusExperimentBranchThroughRequired.objects.filter(
            parent_experiment=self
        ).order_by("id"):
            for required in required_experiments:
                if required.branch_slug:
                    sticky_expressions.append(
                        f"{enrollments_map_key}['{required.child_experiment.slug}'] "
                        f"== '{required.branch_slug}'"
                    )
                else:
                    sticky_expressions.append(
                        f"'{required.child_experiment.slug}' in enrollments"
                    )

        if self.is_sticky and sticky_expressions:
            expressions.append(
                make_sticky_targeting_expression(
                    self.is_desktop, self.is_rollout, sticky_expressions
                )
            )
        else:
            expressions.extend(sticky_expressions)

        if prefs := self._get_targeting_pref_conflicts():
            expressions.append(
                make_sticky_targeting_expression(
                    self.is_desktop,
                    self.is_rollout,
                    (f"!('{pref}'|preferenceIsUserSet)" for pref in sorted(prefs)),
                )
            )

        #  If there is no targeting defined all clients should match, so we return "true"
        return (
            " && ".join(f"({expression})" for expression in expressions)
            if expressions
            else "true"
        )