fix: skip CronWorkflow creation when @schedule resolves to no schedule (#3122)

## PR Type

- [x] Bug fix

## Summary

When `@schedule` is present but all scheduling flags are falsy (e.g.
`@schedule(daily=False)`), deploying to Argo Workflows crashes with
`AttributeError: 'NoneType' object has no attribute 'split'` and no
WorkflowTemplate is created. This fix makes the deploy succeed and skip
CronWorkflow creation, which is the expected behaviour when no schedule
is configured.

## Issue

Fixes #3121

## Reproduction

**Runtime:** argo

**Commands to run:**
```bash
python myflow.py argo-workflows create
```

Where `myflow.py` contains:

```python
from metaflow import FlowSpec, step, schedule

@schedule(daily=False)
class MyFlow(FlowSpec):
    @step
    def start(self):
        self.next(self.end)

    @step
    def end(self):
        pass

if __name__ == "__main__":
    MyFlow()
```

**Where evidence shows up:** parent console / `argo-workflows create`
output

<details>
<summary>Before (error / log snippet)</summary>

```
AttributeError: 'NoneType' object has no attribute 'split'
  File ".../metaflow/plugins/argo/argo_workflows.py", line 463, in _get_schedule
    return " ".join(schedule.schedule.split()[:5]), schedule.timezone
```

</details>

<details>
<summary>After (evidence that fix works)</summary>

```
Workflow template 'MyFlow' created successfully.
No CronWorkflow created (no schedule configured).
```

</details>

## Root Cause

`ScheduleDecorator.flow_init` sets `self.schedule = None` when all
scheduling flags are falsy (`schedule_decorator.py:49`).
`_get_schedule()` in `argo_workflows.py` guarded against the decorator
being absent (`if schedule:`), but not against `schedule.schedule` being
`None`. Calling `.split()` on `None` raises `AttributeError`.
Separately, `trigger_explanation()` checked decorator presence rather
than `self._schedule`, so it would incorrectly report CronWorkflow-based
triggering even when no schedule was resolved.

## Why This Fix Is Correct

`_get_schedule()` now returns `(None, None)` when `schedule.schedule is
None`, treating it identically to the decorator being absent. The rest
of the deploy path already handles `self._schedule is None` correctly —
no CronWorkflow is created. `trigger_explanation()` now checks
`self._schedule is not None`, which is the actual resolved value, rather
than decorator presence.

## Failure Modes Considered

1. **Flows with a real schedule are unaffected** — the
`schedule.schedule is None` guard is only entered when all flags are
falsy; any valid cron string, `daily=True`, `hourly=True`, or
`weekly=True` sets a non-None value and takes the existing return path.
2. **Backward compatibility** — the previous behaviour for the
`@schedule(daily=False)` case was a crash, so changing it to a clean
no-op is strictly an improvement with no risk of regression.

## Tests

- [x] Unit tests added/updated
- [x] Reproduction script provided (required for Core Runtime)
- [ ] CI passes
- [ ] If tests are impractical: explain why below and provide manual
evidence above

The bug is straightforward to reproduce with the script above. Unit test
coverage for `_get_schedule()` with a `None` schedule value would be a
good addition.

## Non-Goals

This fix does not address the Step Functions path (which returns
`schedule.schedule` directly and handles `None` safely already), does
not implement an `--no-enable-schedule` flag (see PR #3102), and does
not change any scheduling behaviour for flows where a schedule is
actually configured.

## AI Tool Usage

- [x] AI tools were used (describe below)

OpenCode (Claude Sonnet) was used to identify the bug, draft the issue,
and generate the fix. All generated code was reviewed and understood
before committing.

---------

Co-authored-by: Shashank Srikanth <ssrikanth@netflix.com>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 3 people

metaflow/plugins/argo/argo_workflows.py

@@ -460,6 +460,11 @@ def _get_schedule(self):
         if schedule:
             # Remove the field "Year" if it exists
             schedule = schedule[0]
+            if schedule.schedule is None:
+                # @schedule decorator is present but all scheduling flags are
+                # falsy (e.g. @schedule(daily=False)). Treat this the same as
+                # no decorator — do not create a CronWorkflow.
+                return None, None
             return " ".join(schedule.schedule.split()[:5]), schedule.timezone
         return None, None
 
@@ -482,7 +487,7 @@ def schedule(self):
 
     def trigger_explanation(self):
         # Trigger explanation for cron workflows
-        if self.flow._flow_decorators.get("schedule"):
+        if self._schedule is not None:
             return (
                 "This workflow triggers automatically via the CronWorkflow *%s*."
                 % self.name

test/unit/test_argo_workflows_cli.py

@@ -1,6 +1,9 @@
+import types
+
 import pytest
 
 from metaflow.plugins.argo.argo_workflows_cli import sanitize_for_argo
+from metaflow.plugins.argo.argo_workflows import ArgoWorkflows
 
 
 @pytest.mark.parametrize(
@@ -27,3 +30,105 @@
 def test_sanitize_for_argo(name, expected):
     sanitized = sanitize_for_argo(name)
     assert sanitized == expected
+
+
+@pytest.fixture
+def make_argo_with_schedule():
+    """
+    Factory fixture: returns a callable that builds a minimal ArgoWorkflows-like
+    object whose _get_schedule() can be called without instantiating the full
+    class (which requires a live graph, environment, datastore, etc.).
+
+    The method only accesses self.flow._flow_decorators, so we build the
+    smallest possible stand-in for each layer.
+    """
+
+    def _make(schedule_value, timezone_value=None):
+        decorator = types.SimpleNamespace(
+            schedule=schedule_value, timezone=timezone_value
+        )
+        flow = types.SimpleNamespace(_flow_decorators={"schedule": [decorator]})
+        instance = object.__new__(ArgoWorkflows)
+        instance.flow = flow
+        return instance
+
+    return _make
+
+
+@pytest.fixture
+def argo_without_schedule():
+    """ArgoWorkflows stand-in with no @schedule decorator at all."""
+    flow = types.SimpleNamespace(_flow_decorators={})
+    instance = object.__new__(ArgoWorkflows)
+    instance.flow = flow
+    return instance
+
+
+def test_get_schedule_no_decorator_returns_none(argo_without_schedule):
+    """No @schedule decorator → (None, None)."""
+    assert argo_without_schedule._get_schedule() == (None, None)
+
+
+@pytest.mark.parametrize(
+    "schedule_value, timezone_value, expected",
+    [
+        # schedule resolved to None → (None, None) regardless of timezone.
+        # The schedule_none case is the regression test for the AttributeError
+        # bug where None.split() was called when all scheduling flags were falsy.
+        (None, None, (None, None)),
+        (None, "America/Los_Angeles", (None, None)),
+        # 6-field quartz cron → trimmed to 5 fields, timezone passed through.
+        ("0 0 * * ? *", None, ("0 0 * * ?", None)),
+        ("0 0 * * ? *", "Europe/Berlin", ("0 0 * * ?", "Europe/Berlin")),
+    ],
+    ids=[
+        "schedule_none",
+        "schedule_none_with_timezone",
+        "cron_expression",
+        "cron_expression_with_timezone",
+    ],
+)
+def test_get_schedule(
+    make_argo_with_schedule, schedule_value, timezone_value, expected
+):
+    argo = make_argo_with_schedule(
+        schedule_value=schedule_value, timezone_value=timezone_value
+    )
+    assert argo._get_schedule() == expected
+
+
+def test_trigger_explanation_no_schedule_does_not_claim_cronworkflow(
+    argo_without_schedule,
+):
+    """With no schedule, trigger_explanation() must not mention CronWorkflow."""
+    argo_without_schedule._schedule = None
+    argo_without_schedule.triggers = []
+    result = argo_without_schedule.trigger_explanation()
+    assert "CronWorkflow" not in result
+
+
+def test_trigger_explanation_schedule_none_does_not_claim_cronworkflow(
+    make_argo_with_schedule,
+):
+    """
+    When @schedule is present but resolved to None, trigger_explanation()
+    must not claim the workflow triggers via a CronWorkflow.
+    """
+    argo = make_argo_with_schedule(schedule_value=None)
+    argo._schedule = None  # mirrors what _get_schedule() would set
+    argo.triggers = []
+    result = argo.trigger_explanation()
+    assert "CronWorkflow" not in result
+
+
+def test_trigger_explanation_active_schedule_claims_cronworkflow(
+    make_argo_with_schedule,
+):
+    """When a real schedule is set, trigger_explanation() names the CronWorkflow."""
+    argo = make_argo_with_schedule(schedule_value="0 0 * * ? *")
+    argo._schedule = "0 0 * * ?"
+    argo.name = "myflow"
+    result = argo.trigger_explanation()
+    assert result is not None
+    assert "CronWorkflow" in result
+    assert "myflow" in result