@cell_silo_model
class Release(Model):
    """
    A release is generally created when a new version is pushed into a
    production state.

    A commit is generally a git commit. See also releasecommit.py
    """

class Meta:
    app_label = "sentry"
    db_table = "sentry_release"
    unique_together = (("organization", "version"),)

organization = FlexibleForeignKey("sentry.Organization")
projects = models.ManyToManyField(
    "sentry.Project", related_name="releases", through=ReleaseProject
)
version = models.CharField(max_length=DB_VERSION_LENGTH)  # DB_VERSION_LENGTH = 250
ref = models.CharField(max_length=DB_VERSION_LENGTH, null=True, blank=True)  # 分支名
url = models.URLField(null=True, blank=True)  # 发布链接

date_added = models.DateTimeField(default=timezone.now, db_index=True)
date_started = models.DateTimeField(null=True, blank=True)  # 已废弃
date_released = models.DateTimeField(null=True, blank=True)
status = BoundedPositiveIntegerField(
    default=ReleaseStatus.OPEN,  # 0=Open, 1=Archived
    null=True,
)

class ReleaseStatus:
    OPEN = 0      # 活跃状态
    ARCHIVED = 1  # 已归档

commit_count = BoundedPositiveIntegerField(null=True, default=0)
last_commit_id = BoundedBigIntegerField(null=True)
authors = ArrayField(models.TextField(), default=list, null=True)
total_deploys = BoundedPositiveIntegerField(null=True, default=0)
last_deploy_id = BoundedPositiveIntegerField(null=True)

# <package>@<major>.<minor>.<patch>.<revision>-<prerelease>+<build_code>
package = models.TextField(null=True)
major = models.BigIntegerField(null=True)
minor = models.BigIntegerField(null=True)
patch = models.BigIntegerField(null=True)
revision = models.BigIntegerField(null=True)
prerelease = models.TextField(null=True)
build_code = models.TextField(null=True)
build_number = models.BigIntegerField(null=True)

@cached_property
def version_info(self):
    try:
        return parse_release(self.version, json_loads=orjson.loads)
    except RelayError:
        return None

models.Index(
    "organization",
    F("major").desc(),
    F("minor").desc(),
    F("patch").desc(),
    F("revision").desc(),
    Case(When(prerelease="", then=1), default=0).desc(),
    F("prerelease").desc(),
    name="sentry_release_semver_idx",
)

@staticmethod
def is_valid_version(value):
    if value is None:
        return False
    if any(c in value for c in BAD_RELEASE_CHARS):
        return False
    value_stripped = str(value).strip()
    return not (
        not value_stripped
        or value_stripped in (".", "..")
        or value_stripped.lower() == "latest"
    )

import sentry_sdk

sentry_sdk.init(
    dsn="https://examplePublicKey@o0.ingest.sentry.io/0",
    release="myapp@1.2.3",
    environment="production",
)

@classmethod
def _get_or_create_impl(cls, project, version, date_added, metric_tags, create=True):
    cache_key = cls.get_cache_key(project.organization_id, version)
    release = cache.get(cache_key)

    if release in (None, -1):
        project_version = (f"{project.slug}-{version}")[:DB_VERSION_LENGTH]
        releases = list(
            cls.objects.filter(
                organization_id=project.organization_id,
                version__in=[version, project_version],
                projects=project,
            )
        )

        if releases:
            # 已存在：优先匹配 project-version，其次匹配 version
            try:
                release = [r for r in releases if r.version == project_version][0]
            except IndexError:
                release = releases[0]
        elif not create:
            # 自动创建被禁用：仅关联已有的组织级 Release
            release = cls.objects.filter(
                organization_id=project.organization_id,
                version__in=[version, project_version],
            ).first()
            if release is None:
                return None
            release.add_project(project)
        else:
            # 创建新 Release
            try:
                with atomic_transaction(using=router.db_for_write(cls)):
                    release = cls.objects.create(
                        organization_id=project.organization_id,
                        version=version,
                        date_added=date_added,
                        total_deploys=0,
                    )
            except IntegrityError:
                release = cls.objects.get(
                    organization_id=project.organization_id, version=version
                )
            release.add_project(project)

# release creation is idempotent to simplify user experiences
created = False
try:
    release, created = Release.objects.get_or_create(
        organization_id=organization.id,
        version=result["version"],
        defaults={
            "ref": result.get("ref"),
            "url": result.get("url"),
            "owner_id": owner_id,
            "date_released": result.get("dateReleased"),
            "status": new_status or ReleaseStatus.OPEN,
            "user_agent": request.META.get("HTTP_USER_AGENT", "")[:256],
        },
    )
except IntegrityError:
    raise ConflictError(
        "Could not create the release it conflicts with existing data",
    )

if not created and not new_releaseprojects:
    status = 208
else:
    status = 201

def should_auto_create_releases(project: Project) -> bool:
    return not features.has("organizations:auto-release-creation", project.organization) or bool(
        project.get_option("sentry:enable_auto_release_creation")
    )

@cell_silo_model
class ReleaseCommit(Model):
    organization_id = BoundedBigIntegerField(db_index=True)
    release = FlexibleForeignKey("sentry.Release")
    commit = FlexibleForeignKey("sentry.Commit", db_constraint=False)
    order = BoundedPositiveIntegerField()

    class Meta:
        db_table = "sentry_releasecommit"
        unique_together = (("release", "commit"), ("release", "order"))

@cell_silo_model
class ReleaseHeadCommit(Model):
    organization_id = BoundedBigIntegerField(db_index=True)
    repository_id = BoundedPositiveIntegerField()
    release = FlexibleForeignKey("sentry.Release")
    commit = FlexibleForeignKey("sentry.Commit", db_constraint=False)

    class Meta:
        db_table = "sentry_releaseheadcommit"
        unique_together = (("repository_id", "release"),)

commit_count = BoundedPositiveIntegerField(null=True, default=0)
last_commit_id = BoundedBigIntegerField(null=True)
authors = ArrayField(models.TextField(), default=list, null=True)

@trace
def set_commits(self, commit_list):
    """
    Bind a list of commits to this release.
    This will clear any existing commit log and replace it with the given commits.
    """
    from sentry.models.releases.set_commits import set_commits
    set_commits(self, commit_list)

def set_refs(self, refs, user_id, fetch=False):
    with start_span(op="set_refs", name="set_refs"):
        from sentry.models.releaseheadcommit import ReleaseHeadCommit
        from sentry.models.repository import Repository
        from sentry.tasks.commits import fetch_commits

        names = {r["repository"] for r in refs}
        repos = list(
            Repository.objects.filter(organization_id=self.organization_id, name__in=names)
        )
        repos_by_name = {r.name: r for r in repos}
        invalid_repos = names - set(repos_by_name.keys())
        if invalid_repos:
            raise InvalidRepository(f"Invalid repository names: {','.join(invalid_repos)}")

        self.handle_commit_ranges(refs)

        for ref in refs:
            repo = repos_by_name[ref["repository"]]
            commit = Commit.objects.get_or_create(
                organization_id=self.organization_id,
                repository_id=repo.id, key=ref["commit"]
            )[0]
            ReleaseHeadCommit.objects.update_or_create(
                organization_id=self.organization_id,
                repository_id=repo.id,
                release=self,
                defaults={"commit": commit},
            )

        if fetch:
            prev_release = get_previous_release(self)
            fetch_commits.apply_async(
                kwargs={
                    "release_id": self.id,
                    "user_id": user_id,
                    "refs": refs,
                    "prev_release_id": prev_release and prev_release.id,
                }
            )

def handle_commit_ranges(self, refs):
    for ref in refs:
        if COMMIT_RANGE_DELIMITER in ref["commit"]:
            ref["previousCommit"], ref["commit"] = ref["commit"].split(COMMIT_RANGE_DELIMITER)

@cell_silo_model
class Deploy(Model):
    organization_id = BoundedBigIntegerField(db_index=True)
    release = FlexibleForeignKey("sentry.Release")
    environment_id = BoundedPositiveIntegerField(db_index=True)
    date_finished = models.DateTimeField(default=timezone.now, db_index=True)
    date_started = models.DateTimeField(null=True, blank=True)
    name = models.CharField(max_length=64, null=True, blank=True)
    url = models.URLField(null=True, blank=True)
    notified = models.BooleanField(null=True, db_index=True, default=False)

    class Meta:
        app_label = "sentry"
        db_table = "sentry_deploy"

Release.objects.filter(id=release.id).update(
    total_deploys=F("total_deploys") + 1, last_deploy_id=deploy.id
)

def create_deploy(organization, release, serializer):
    result = serializer.validated_data
    release_projects = list(release.projects.all())
    projects = result.get("projects", release_projects)

    # 验证项目有效性
    invalid_projects = {project.slug for project in projects} - {
        project.slug for project in release_projects
    }
    if len(invalid_projects) > 0:
        raise ParameterValidationError(
            f"Invalid projects ({', '.join(invalid_projects)}) for release {release.version}"
        )

    # 获取或创建环境
    env = Environment.objects.get_or_create(
        name=result["environment"], organization_id=organization.id
    )[0]
    for project in projects:
        env.add_project(project)

    # 创建 Deploy 记录
    deploy = Deploy.objects.create(
        organization_id=organization.id,
        release=release,
        environment_id=env.id,
        date_finished=result.get("dateFinished", timezone.now()),
        date_started=result.get("dateStarted"),
        name=result.get("name"),
        url=result.get("url"),
    )
    deploy_created.send_robust(deploy=deploy, sender=create_deploy)

    # 更新 Release 统计
    Release.objects.filter(id=release.id).update(
        total_deploys=F("total_deploys") + 1, last_deploy_id=deploy.id
    )

    # 更新 ReleaseProjectEnvironment
    for project in projects:
        ReleaseProjectEnvironment.objects.update_or_create(
            release=release,
            environment=env,
            project=project,
            defaults={"last_deploy_id": deploy.id},
        )

    # 触发通知
    Deploy.notify_if_ready(deploy.id)

    return deploy

@classmethod
def notify_if_ready(cls, deploy_id, fetch_complete=False):
    lock_key = cls.get_lock_key(deploy_id)
    lock = locks.get(lock_key, duration=30, name="deploy_notify")
    with TimedRetryPolicy(10)(lock.acquire):
        deploy = cls.objects.filter(id=deploy_id).select_related("release").get()
        if deploy.notified:
            return

        release = deploy.release
        environment = Environment.objects.get(
            organization_id=deploy.organization_id, id=deploy.environment_id
        )

        if not fetch_complete:
            release_has_commits = ReleaseCommit.objects.filter(
                organization_id=release.organization_id, release=release
            ).exists()

            if not release_has_commits:
                if ReleaseHeadCommit.objects.filter(
                    organization_id=release.organization_id, release=release
                ).exists():
                    return  # 等待 fetch_commits 完成

        # 为每个项目创建 Activity 并发送通知
        activity = None
        for project in deploy.release.projects.all():
            activity = Activity.objects.create(
                type=ActivityType.DEPLOY.value,
                project=project,
                ident=Activity.get_version_ident(release.version),
                data={
                    "version": release.version,
                    "deploy_id": deploy.id,
                    "environment": environment.name,
                },
                datetime=deploy.date_finished,
            )
        if activity is not None:
            activity.send_notification()
            deploy.update(notified=True)

@cell_silo_model
class ReleaseEnvironment(Model):
    organization = FlexibleForeignKey("sentry.Organization")
    release = FlexibleForeignKey("sentry.Release")
    environment = FlexibleForeignKey("sentry.Environment")
    first_seen = models.DateTimeField(default=timezone.now)
    last_seen = models.DateTimeField(default=timezone.now, db_index=True)

    class Meta:
        db_table = "sentry_environmentrelease"
        unique_together = (("organization", "release", "environment"),)

@cell_silo_model
class ReleaseProjectEnvironment(Model):
    release = FlexibleForeignKey("sentry.Release")
    project = FlexibleForeignKey("sentry.Project")
    environment = FlexibleForeignKey("sentry.Environment")
    new_issues_count = BoundedPositiveIntegerField(default=0)
    first_seen = models.DateTimeField(default=timezone.now)
    last_seen = models.DateTimeField(default=timezone.now, db_index=True)
    last_deploy_id = BoundedPositiveIntegerField(null=True, db_index=True)
    adopted = models.DateTimeField(null=True, blank=True)
    unadopted = models.DateTimeField(null=True, blank=True)

    class Meta:
        db_table = "sentry_releaseprojectenvironment"
        unique_together = (("project", "release", "environment"),)

class SourceFileType(Enum):
    SOURCE = 1              # 原始源文件
    MINIFIED_SOURCE = 2     # 压缩后的源文件（bundle.min.js）
    SOURCE_MAP = 3          # Source Map 映射文件（bundle.min.js.map）
    INDEXED_RAM_BUNDLE = 4  # React Native 的 RAM Bundle 格式

@cell_silo_model
class ArtifactBundle(Model):
    organization_id = BoundedBigIntegerField(db_index=True)
    bundle_id = models.UUIDField(default=NULL_UUID, db_index=True)
    file = FlexibleForeignKey("sentry.File")
    artifact_count = BoundedPositiveIntegerField()
    indexing_state = models.IntegerField(
        default=None, null=True,
        choices=ArtifactBundleIndexingState.choices()
    )
    date_added = models.DateTimeField(default=timezone.now, db_index=True)
    date_uploaded = models.DateTimeField(default=timezone.now)
    date_last_modified = models.DateTimeField(null=True)

    class Meta:
        app_label = "sentry"
        db_table = "sentry_artifactbundle"

@cell_silo_model
class ArtifactBundleIndex(Model):
    organization_id = BoundedBigIntegerField(db_index=True)
    artifact_bundle = FlexibleForeignKey("sentry.ArtifactBundle")
    url = models.TextField()
    date_added = models.DateTimeField(default=timezone.now)

    class Meta:
        db_table = "sentry_artifactbundleindex"
        indexes = (models.Index(fields=("url", "artifact_bundle")),)

@cell_silo_model
class ReleaseArtifactBundle(Model):
    organization_id = BoundedBigIntegerField(db_index=True)
    release_name = models.CharField(max_length=250)
    dist_name = models.CharField(max_length=250)  # NULL 用空字符串表示
    artifact_bundle = FlexibleForeignKey("sentry.ArtifactBundle")
    date_added = models.DateTimeField(default=timezone.now)

@classmethod
def get_release_associations(cls, organization_id, artifact_bundle):
    release_artifact_bundles = ReleaseArtifactBundle.objects.filter(
        organization_id=organization_id, artifact_bundle=artifact_bundle
    ).order_by("-id")

    return [
        {
            "release": release_artifact_bundle.release_name,
            "dist": release_artifact_bundle.dist_name or None,
        }
        for release_artifact_bundle in release_artifact_bundles
    ]

def count_artifacts_in_artifact_bundles(self, project_ids):
    qs = (
        ArtifactBundle.objects.filter(
            organization_id=self.organization_id,
            releaseartifactbundle__organization_id=self.organization_id,
            releaseartifactbundle__release_name=self.version,
            projectartifactbundle__organization_id=self.organization_id,
            projectartifactbundle__project_id__in=project_ids,
        )
        .annotate(count=Sum(Func(F("artifact_count"), 1, function="COALESCE")))
        .values_list("releaseartifactbundle__release_name", "count")
    )
    qs.query.group_by = ["releaseartifactbundle__release_name"]
    if len(qs) == 0:
        return None
    return qs[0]

elif sort in self.SESSION_SORTS:
    if not flatten:
        return Response(
            {"detail": "sorting by crash statistics requires flattening (flatten=1)"},
            status=400,
        )
    paginator_cls = ReleasesMergingOffsetPaginator
    paginator_kwargs.update(
        data_load_func=lambda offset, limit: (
            release_health.backend.get_project_releases_by_stability(
                project_ids=filter_params["project_id"],
                environments=filter_params.get("environment"),
                scope=sort,
                offset=offset,
                stats_period=summary_stats_period,
                limit=limit,
            )
        ),
        ...
    )

class ReleaseStages(str, Enum):
    ADOPTED = "adopted"
    LOW_ADOPTION = "low_adoption"
    REPLACED = "replaced"

def adoption_stage(adopted, unadopted) -> AdoptionStage:
    if adopted is not None and unadopted is None:
        stage = ReleaseStages.ADOPTED      # 已采纳（正在使用）
    elif adopted is not None and unadopted is not None:
        stage = ReleaseStages.REPLACED      # 已被新版本替代
    else:
        stage = ReleaseStages.LOW_ADOPTION  # 低采纳率
    return {"stage": stage, "adopted": adopted, "unadopted": unadopted}

@cell_silo_model
class ReleaseThreshold(Model):
    threshold_type = BoundedPositiveIntegerField(choices=ReleaseThresholdType.as_choices())
    trigger_type = BoundedPositiveIntegerField(choices=ReleaseThresholdTriggerType.as_choices())
    value = models.IntegerField()
    window_in_seconds = models.PositiveIntegerField()
    project = FlexibleForeignKey("sentry.Project", related_name="release_thresholds")
    environment = FlexibleForeignKey("sentry.Environment", null=True)
    date_added = models.DateTimeField(default=timezone.now)

def get_previous_release(release: Release) -> Release | None:
    return (
        Release.objects.filter(organization_id=release.organization_id)
        .filter(
            Exists(
                ReleaseProject.objects.filter(
                    release=OuterRef("pk"),
                    project_id__in=ReleaseProject.objects.filter(
                        release=release
                    ).values_list("project_id", flat=True),
                )
            )
        )
        .extra(select={"sort": "COALESCE(date_released, date_added)"})
        .exclude(version=release.version)
        .order_by("-sort")
        .first()
    )

def _get_group_release_version(self, group_id, environment_names, orderby):
    from sentry.models.grouprelease import GroupRelease
    group_releases = GroupRelease.objects.filter(group_id=group_id)
    if environment_names:
        group_releases = group_releases.filter(environment__in=environment_names)
    return self.get(
        id__in=group_releases.order_by(orderby).values("release_id")[:1]
    ).version

@staticmethod
def is_release_newer_or_equal(org_id, release, other_release):
    if release is None:
        return False
    if other_release is None:
        return True
    if release == other_release:
        return True

    releases = {
        release.version: float(release.date_added.timestamp())
        for release in Release.objects.filter(
            organization_id=org_id, version__in=[release, other_release]
        )
    }
    release_date = releases.get(release)
    other_release_date = releases.get(other_release)

    if release_date is not None and other_release_date is not None:
        return release_date > other_release_date
    return False

def follows_semver_versioning_scheme(org_id, project_id, release_version=None):
    cache_key = "follows_semver:1:%s" % hash_values([org_id, project_id])
    follows_semver = cache.get(cache_key)

    if follows_semver is None:
        releases_list = list(
            Release.objects.filter(
                organization_id=org_id,
                projects__id__in=[project_id],
                status=ReleaseStatus.OPEN
            )
            .using_replica()
            .order_by("-date_added")[:10]
        )

        if len(releases_list) <= 2:
            follows_semver = releases_list[0].is_semver_release
        elif len(releases_list) < 10:
            follows_semver = any(
                release.is_semver_release for release in releases_list[0:3]
            )
        else:
            semver_matches = sum(
                map(lambda release: release.is_semver_release, releases_list)
            )
            at_least_three_in_last_ten = semver_matches >= 3
            at_least_one_in_last_three = any(
                release.is_semver_release for release in releases_list[0:3]
            )
            follows_semver = at_least_one_in_last_three and at_least_three_in_last_ten
        cache.set(cache_key, follows_semver, 3600)
    ...

@classmethod
def merge(cls, to_release, from_releases):
    from sentry.models.group import Group
    from sentry.models.grouprelease import GroupRelease
    from sentry.models.groupresolution import GroupResolution
    from sentry.models.releasecommit import ReleaseCommit
    from sentry.models.releaseenvironment import ReleaseEnvironment
    from sentry.models.releasefile import ReleaseFile
    from sentry.models.releaseprojectenvironment import ReleaseProjectEnvironment
    from sentry.models.releases.release_project import ReleaseProject

    model_list = (
        ReleaseCommit, ReleaseEnvironment, ReleaseFile, ReleaseProject,
        ReleaseProjectEnvironment, GroupRelease, GroupResolution,
    )
    for release in from_releases:
        for model in model_list:
            if hasattr(model, "release"):
                update_kwargs = {"release": to_release}
            else:
                update_kwargs = {"release_id": to_release.id}
            try:
                with atomic_transaction(using=router.db_for_write(model)):
                    model.objects.filter(release_id=release.id).update(**update_kwargs)
            except IntegrityError:
                for item in model.objects.filter(release_id=release.id):
                    try:
                        with atomic_transaction(using=router.db_for_write(model)):
                            model.objects.filter(id=item.id).update(**update_kwargs)
                    except IntegrityError:
                        item.delete()

        Group.objects.filter(first_release=release).update(first_release=to_release)
        release.delete()

def safe_delete(self):
    from sentry import release_health
    from sentry.models.group import Group
    from sentry.models.releasefile import ReleaseFile

    # 保护 1：不能删除被 Group.first_release 引用的 Release
    if Group.objects.filter(first_release=self).exists():
        raise UnsafeReleaseDeletion(ERR_RELEASE_REFERENCED)

    # 保护 2：不能删除有健康度数据的 Release
    project_ids = list(self.projects.values_list("id").all())
    if release_health.backend.check_has_health_data(
        [(p[0], self.version) for p in project_ids]
    ):
        raise UnsafeReleaseDeletion(ERR_RELEASE_HEALTH_DATA)

    # 删除关联文件和 Release 自身
    file_list = ReleaseFile.objects.filter(
        release_id=self.id
    ).select_related("file")
    for releasefile in file_list:
        releasefile.file.delete()
        releasefile.delete()
    self.delete()

@classmethod
def get_unused_filter(cls, cutoff_date: datetime) -> Q:
    from django.db.models import Exists, OuterRef
    from sentry.models.deploy import Deploy
    from sentry.models.distribution import Distribution
    from sentry.models.group import Group
    # ... 其他 imports

    # 子查询：检查各种"仍在使用"的条件
    group_first_release_exists = Exists(
        Group.objects.filter(first_release=OuterRef("id"))
    )
    recent_activity_exists = Exists(
        ReleaseProjectEnvironment.objects.filter(
            release_id=OuterRef("id"), last_seen__gte=cutoff_date
        )
    )
    recent_deploys_exist = Exists(
        Deploy.objects.filter(
            release_id=OuterRef("id"), date_finished__gte=cutoff_date
        )
    )
    group_resolutions_exist = Exists(
        GroupResolution.objects.filter(release_id=OuterRef("id"))
    )
    # ... 更多子查询

    # 定义"必须保留"的条件
    keep_conditions = (
        Q(date_added__gte=cutoff_date)
        | group_first_release_exists
        | group_resolutions_exist
        | recent_deploys_exist
        | recent_activity_exists
        # ... 更多条件
    )

    # 返回逆条件（可以删除的 Release）
    return cast(Q, ~keep_conditions)