feat: concurrency decorator

[anish-sahoo]

Summary

• add @cog.concurrent for configuring async runner concurrency
• statically extract decorator concurrency and bake it through COG_MAX_CONCURRENCY with existing precedence
• enforce async requirements at decorator, build, and runtime; deprecate cog.yaml concurrency
• update concurrency docs, llms.txt, examples, and integration fixtures

Example

import cog

class Runner(cog.BaseRunner):
    @cog.concurrent(max=4)
    async def run(self, prompt: str = cog.Input()) -> str:
        return await generate(prompt)

Testing

• go test ./pkg/schema/python ./pkg/config ./pkg/image
• golangci-lint run ./pkg/schema/python ./pkg/config ./pkg/image
• uv run --with pytest pytest python/tests/test_concurrent.py
• uv run --with ruff ruff check python/cog/init.py python/tests/test_concurrent.py
• PYO3_PYTHON="$(uv run python -c 'import sys; print(sys.executable)')" cargo test -p coglet-python parse_max_concurrency
• PYO3_PYTHON="$(uv run python -c 'import sys; print(sys.executable)')" cargo clippy --manifest-path crates/Cargo.toml -p coglet-python -- -D warnings
• prettier --check docs/deploy.md docs/environment.md docs/python.md docs/yaml.md examples/hello-concurrency/README.md
• git diff --check

Fixes #2811

[ask-bonk]

I'm Bonk, and I've done a quick review of your PR.

This PR adds the @cog.concurrent decorator for configuring async predictor concurrency, with static extraction at build time and runtime enforcement. The decorator integrates cleanly with the existing precedence chain (runtime env > YAML > decorator > default) and properly deprecates the concurrency.max YAML field.

Issues found:

1. Missing parser test for qualified alias import pattern — The tree-sitter parser tests cover direct import, qualified import (import cog), and imported alias (from cog import concurrent as foo), but lack coverage for the qualified alias pattern (import cog as c + @c.concurrent). The streaming decorator has this test (TestStreamingDecoratorQualifiedAliasOptIn) and the concurrent implementation uses the same attributeIsCogConcurrent helper, so it likely works — but explicit coverage prevents regressions.

[ask-bonk]

I reviewed PR #3089 (add @cog.concurrent decorator) and posted a review with one suggestion:

Finding: Missing parser test for import cog as c + @c.concurrent(max=...) pattern in pkg/schema/python/parser_test.go. The streaming decorator has this coverage, but concurrent doesn't. I provided a suggestion comment adding TestConcurrentDecoratorQualifiedAliasMax to fill the gap.

Everything else looked solid — the decorator implementation, build-time static extraction, precedence handling, runtime enforcement in Coglet, and deprecation of YAML concurrency are all correctly implemented.

github run

[ask-bonk]

I'm Bonk, and I've done a quick review of your PR.

This PR adds the @cog.concurrent decorator for configuring async predictor concurrency, with static extraction at build time and runtime enforcement. Overall the implementation is solid — the decorator, precedence handling, runtime checks in Coglet, and deprecation of YAML concurrency are all correctly implemented.

Issues found:

1. Missing parser test for qualified alias import pattern — The previous review already flagged this, but the test still hasn't been added. The tree-sitter parser tests cover direct import, qualified import (import cog), and imported alias (from cog import concurrent as foo), but lack coverage for the qualified alias pattern (import cog as c + @c.concurrent). The streaming decorator has this test (TestStreamingDecoratorQualifiedAliasOptIn) and the concurrent implementation uses the same attributeIsCogConcurrent helper, so it likely works — but explicit coverage prevents regressions.
2. CodeQL integer conversion warning — The int64 → int conversion at pkg/schema/python/annotations.go:309 triggered a CodeQL alert. The code does have an upper bound check at line 306, but int64(math.MaxInt) may not be recognized as a proper bound by static analysis. Extracting the bound to a named constant silences the warning without changing behavior.

[ask-bonk]

Posted a batch review to PR #3089 with two suggestions:

1. Missing parser test — pkg/schema/python/parser_test.go needs a test for the import cog as c + @c.concurrent(max=...) import pattern (same as what exists for @cog.streaming).
2. CodeQL integer conversion — pkg/schema/python/annotations.go:306 should extract int64(math.MaxInt) to a named variable so CodeQL recognizes the bound check.

github run

[ask-bonk]

I'm Bonk, and I've done a quick review of your PR.

This PR adds the @cog.concurrent decorator for configuring async predictor concurrency, with static extraction at build time and runtime enforcement. Overall the implementation is solid — the decorator, precedence handling, runtime checks in Coglet, and deprecation of YAML concurrency are all correctly implemented.

Issues found:

1. Go syntax error in parser tests — There's a duplicate empty function definition at line 1053 that will cause a compilation error.
2. CodeQL integer conversion warning — The int64 → int conversion at pkg/schema/python/annotations.go:306 still triggers a CodeQL alert. Extracting the bound to a named constant silences the warning without changing behavior.

[ask-bonk]

Posted a batch review to PR #3089 with two issues:

1. Go syntax error — pkg/schema/python/parser_test.go:1053 has a duplicate empty TestConcurrentDecoratorIgnoredWhenNotFromCog function definition that will fail compilation.
2. CodeQL integer conversion — pkg/schema/python/annotations.go:306 still needs the int64(math.MaxInt) bound extracted to a named variable for CodeQL to recognize the check.

github run

[ask-bonk]

LGTM

github run