Make release_type package field instead of release field

Author: Peter-Sh

src/redis_release/bht/behaviours.py

@@ -731,8 +731,8 @@ def __init__(
         super().__init__(name=f"{name} - debian", log_prefix=log_prefix)
 
     def update(self) -> Status:
-        if self.release_meta.release_type is not None:
-            self.workflow.inputs["release_type"] = self.release_meta.release_type.value
+        if self.package_meta.release_type is not None:
+            self.workflow.inputs["release_type"] = self.package_meta.release_type.value
         if self.release_meta.tag is not None:
             self.workflow.inputs["release_tag"] = self.release_meta.tag
         return Status.SUCCESS
@@ -765,6 +765,8 @@ def update(self) -> Status:
             return Status.FAILURE
 
         msg = ""
+        if self.release_version.is_internal:
+            msg = "Hombebrew internal release detected"
         if self.release_version.is_rc:
             self.package_meta.homebrew_channel = HomebrewChannel.RC
             msg = "Homebrew channel detected: rc"
@@ -1061,7 +1063,7 @@ def __init__(
         super().__init__(name=name, log_prefix=log_prefix)
 
     def update(self) -> Status:
-        if self.release_meta.release_type == ReleaseType.INTERNAL:
+        if self.package_meta.release_type == ReleaseType.INTERNAL:
             if self.package_meta.publish_internal_release:
                 self.logger.debug(
                     f"Internal release requires publishing: {self.release_meta.tag}"
@@ -1077,28 +1079,33 @@ def update(self) -> Status:
 
 class DetectReleaseType(LoggingAction):
     def __init__(
-        self, name: str, release_meta: ReleaseMeta, log_prefix: str = ""
+        self,
+        name: str,
+        package_meta: PackageMeta,
+        release_meta: ReleaseMeta,
+        log_prefix: str = "",
     ) -> None:
         self.release_meta = release_meta
+        self.package_meta = package_meta
         super().__init__(name=name, log_prefix=log_prefix)
 
     def update(self) -> Status:
-        if self.release_meta.release_type is not None:
+        if self.package_meta.release_type is not None:
             if self.log_once(
-                "release_type_detected", self.release_meta.ephemeral.log_once_flags
+                "release_type_detected", self.package_meta.ephemeral.log_once_flags
             ):
                 self.logger.info(
-                    f"Detected release type: {self.release_meta.release_type}"
+                    f"Detected release type: {self.package_meta.release_type}"
                 )
             return Status.SUCCESS
         if self.release_meta.tag and re.search(r"-int\d*$", self.release_meta.tag):
-            self.release_meta.release_type = ReleaseType.INTERNAL
+            self.package_meta.release_type = ReleaseType.INTERNAL
         else:
-            self.release_meta.release_type = ReleaseType.PUBLIC
+            self.package_meta.release_type = ReleaseType.PUBLIC
         self.log_once(
             "release_type_detected", self.release_meta.ephemeral.log_once_flags
         )
-        self.logger.info(f"Detected release type: {self.release_meta.release_type}")
+        self.logger.info(f"Detected release type: {self.package_meta.release_type}")
         return Status.SUCCESS
 
 

src/redis_release/bht/ppas.py

@@ -137,12 +137,15 @@ def create_identify_target_ref_ppa(
 
 
 def create_detect_release_type_ppa(
+    package_meta: PackageMeta,
     release_meta: ReleaseMeta,
     log_prefix: str,
 ) -> Union[Selector, Sequence]:
     return create_PPA(
         "Detect Release Type",
-        DetectReleaseType("Detect Release Type", release_meta, log_prefix=log_prefix),
+        DetectReleaseType(
+            "Detect Release Type", package_meta, release_meta, log_prefix=log_prefix
+        ),
     )
 
 

src/redis_release/bht/state.py

@@ -143,6 +143,7 @@ class PackageMeta(BaseModel):
 
     serialization_hint: Literal["generic"] = "generic"
     package_type: Optional[PackageType] = None
+    release_type: Optional[ReleaseType] = None
     repo: str = ""
     ref: Optional[str] = None
     publish_internal_release: bool = False
@@ -195,7 +196,6 @@ class ReleaseMeta(BaseModel):
     """Metadata for the release."""
 
     tag: Optional[str] = None
-    release_type: Optional[ReleaseType] = None
     last_started_at: Optional[datetime] = None
     ephemeral: ReleaseMetaEphemeral = Field(default_factory=ReleaseMetaEphemeral)
 

src/redis_release/bht/tree_factory.py

@@ -133,6 +133,7 @@ def create_workflow_complete_tree_branch(
             log_prefix,
         )
         detect_release_type = create_detect_release_type_ppa(
+            package_meta,
             release_meta,
             log_prefix,
         )

src/redis_release/cli.py

@@ -2,7 +2,7 @@
 
 import asyncio
 import logging
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 import typer
 from py_trees.display import render_dot_tree, unicode_tree
@@ -30,6 +30,47 @@
 logger = logging.getLogger(__name__)
 
 
+def parse_force_release_type(
+    force_release_type_list: Optional[List[str]],
+) -> Dict[str, ReleaseType]:
+    """Parse force_release_type arguments from 'package_name:release_type' format.
+
+    Args:
+        force_release_type_list: List of strings in format 'package_name:release_type'
+
+    Returns:
+        Dictionary mapping package names to ReleaseType
+
+    Raises:
+        typer.BadParameter: If format is invalid or release type is unknown
+    """
+    if not force_release_type_list:
+        return {}
+
+    result = {}
+    for item in force_release_type_list:
+        if ":" not in item:
+            raise typer.BadParameter(
+                f"Invalid format '{item}'. Expected 'package_name:release_type' (e.g., 'docker:internal')"
+            )
+
+        package_name, release_type_str = item.split(":", 1)
+        package_name = package_name.strip()
+        release_type_str = release_type_str.strip().lower()
+
+        try:
+            release_type = ReleaseType(release_type_str)
+        except ValueError:
+            valid_types = ", ".join([rt.value for rt in ReleaseType])
+            raise typer.BadParameter(
+                f"Invalid release type '{release_type_str}'. Valid types: {valid_types}"
+            )
+
+        result[package_name] = release_type
+
+    return result
+
+
 @app.command()
 def release_print(
     release_tag: str = typer.Argument(..., help="Release tag (e.g., 8.4-m01-int1)"),
@@ -108,10 +149,10 @@ def release(
     tree_cutoff: int = typer.Option(
         2000, "--tree-cutoff", "-m", help="Max number of ticks to run the tree for"
     ),
-    force_release_type: Optional[ReleaseType] = typer.Option(
+    force_release_type: Optional[List[str]] = typer.Option(
         None,
         "--force-release-type",
-        help="Force release type (public or internal)",
+        help="Force release type per package in format 'package_name:release_type' (e.g., 'docker:internal' or 'all:public'). Can be specified multiple times.",
     ),
     override_state_name: Optional[str] = typer.Option(
         None,
@@ -139,7 +180,7 @@ def release(
         release_tag=release_tag,
         force_rebuild=force_rebuild or [],
         only_packages=only_packages or [],
-        force_release_type=force_release_type,
+        force_release_type=parse_force_release_type(force_release_type),
         override_state_name=override_state_name,
         slack_token=slack_token,
         slack_channel_id=slack_channel_id,

src/redis_release/models.py

@@ -3,7 +3,7 @@
 import functools
 import re
 from enum import Enum
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from pydantic import BaseModel, Field
 
@@ -235,7 +235,7 @@ class ReleaseArgs(BaseModel):
     release_tag: str
     force_rebuild: List[str] = Field(default_factory=list)
     only_packages: List[str] = Field(default_factory=list)
-    force_release_type: Optional[ReleaseType] = None
+    force_release_type: Dict[str, ReleaseType] = Field(default_factory=dict)
     override_state_name: Optional[str] = None
     slack_token: Optional[str] = None
     slack_channel_id: Optional[str] = None

src/redis_release/state_manager.py

@@ -50,9 +50,6 @@ def __init__(
         self.aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY")
         self.aws_session_token = os.getenv("AWS_SESSION_TOKEN")
 
-        # local state cache for dry run mode
-        self._local_state_cache = {}
-
     @property
     def s3_client(self) -> Optional[boto3.client]:
         """Lazy initialization of S3 client."""
@@ -245,7 +242,31 @@ def apply_args(self, state: ReleaseState) -> None:
 
             if self.args.force_release_type:
                 logger.info(f"Force release type: {self.args.force_release_type}")
-                state.meta.release_type = self.args.force_release_type
+                # Handle "all" keyword to apply to all packages
+                if "all" in self.args.force_release_type:
+                    release_type = self.args.force_release_type["all"]
+                    for package_name in state.packages:
+                        state.packages[package_name].meta.release_type = release_type
+                        logger.info(
+                            f"Set release type for package '{package_name}': {release_type}"
+                        )
+                else:
+                    # Set release type for specific packages
+                    for (
+                        package_name,
+                        release_type,
+                    ) in self.args.force_release_type.items():
+                        if package_name in state.packages:
+                            state.packages[package_name].meta.release_type = (
+                                release_type
+                            )
+                            logger.info(
+                                f"Set release type for package '{package_name}': {release_type}"
+                            )
+                        else:
+                            logger.warning(
+                                f"Package '{package_name}' not found in state, skipping release type override"
+                            )
 
     def load(self) -> Optional[ReleaseState]:
         """Load state from storage backend."""

src/redis_release/state_slack.py

@@ -83,19 +83,19 @@ def __init__(
             reply_broadcast: If True and thread_ts is set, also show in main channel
         """
         self.client = WebClient(token=slack_token)
-        self.channel_id = slack_channel_id
+        self.channel_id: str = slack_channel_id
         self.thread_ts = thread_ts
         self.reply_broadcast = reply_broadcast
         self.message_ts: Optional[str] = None
         self.last_blocks_json: Optional[str] = None
         self.started_at = datetime.now(timezone.utc)
 
-    def format_package_name(self, package_name: str, state: ReleaseState) -> str:
+    def format_package_name(self, package_name: str, package: Package) -> str:
         """Format package name with capital letter and release type.
 
         Args:
             package_name: The raw package name
-            state: The ReleaseState to get release type from
+            package: The Package to get release type from
 
         Returns:
             Formatted package name with capital letter and release type in parentheses
@@ -104,8 +104,8 @@ def format_package_name(self, package_name: str, state: ReleaseState) -> str:
         formatted = package_name.capitalize()
 
         # Add release type if available
-        if state.meta.release_type:
-            release_type_str = state.meta.release_type.value
+        if package.meta.release_type:
+            release_type_str = package.meta.release_type.value
             formatted = f"{formatted} ({release_type_str})"
 
         return formatted
@@ -149,7 +149,9 @@ def update_message(self, state: ReleaseState) -> bool:
                 response = self.client.chat_postMessage(**kwargs)
                 self.message_ts = response["ts"]
                 # Update channel_id from response (authoritative)
-                self.channel_id = response["channel"]
+                channel = response.get("channel")
+                if isinstance(channel, str):
+                    self.channel_id = channel
                 logger.info(
                     f"Posted Slack message ts={self.message_ts}"
                     + (f" in thread {self.thread_ts}" if self.thread_ts else "")
@@ -231,7 +233,7 @@ def _make_blocks(self, state: ReleaseState) -> List[Dict[str, Any]]:
         # Process each package
         for package_name, package in sorted(state.packages.items()):
             # Format package name with capital letter and release type
-            formatted_name = self.format_package_name(package_name, state)
+            formatted_name = self.format_package_name(package_name, package)
 
             # Get workflow statuses
             build_status_emoji = self._get_status_emoji(package, package.build)