feat: generate requirements.txt from dependencies

[jordanrfrazier]

Adds functionality to generate a requirements.txt file containing all necessary dependencies to execute a flow using LFX.

Summary by CodeRabbit

Release Notes

• New Features

  • Added requirements CLI command to generate a requirements.txt file from Langflow flow JSON, with options to include/exclude the LFX package and control version pinning.

• Improvements

  • Enhanced model and embedding class loading with lazy initialization for improved startup performance.
  • Updated starter projects with refined dependency management.

[coderabbitai]

Important

Review skipped

Auto incremental reviews are disabled on this repository.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

Walkthrough

This pull request refactors model and embedding class retrieval from plural bulk-loading functions to singular on-demand loaders with lazy imports and caching, plus introduces a new requirements generation feature for Langflow flows. Multiple starter projects, components, and tests are updated to align with the API changes.

Changes

Cohort / File(s)	Summary
API Refactoring Core src/lfx/src/lfx/base/models/unified_models.py	Introduces lazy runtime imports for model/embedding classes via new mappings and caches. Adds singular getters get_model_class() and get_embedding_class() alongside deprecated plural wrappers. Replaces hard-coded class imports with on-demand loading and updates metadata resolution to source from provider metadata.
Starter Project Updates src/backend/base/langflow/initial_setup/starter_projects/*.json	Updates two starter project JSONs (Nvidia Remix, Youtube Analysis) to use new singular API (get_model_class, get_embedding_class) instead of plural variants and updates code_hash values.
Component API Updates src/lfx/src/lfx/components/llm_operations/batch_run.py, src/lfx/src/lfx/components/models_and_agents/embedding_model.py	Updates imports and usage to call get_model_class() and get_embedding_class() directly instead of dictionary lookups; adds validation for missing model class names.
Test Mock Refactoring src/backend/tests/unit/components/llm_operations/test_lambda_filter.py, src/backend/tests/unit/components/llm_operations/test_structured_output_component.py, src/backend/tests/unit/components/models_and_agents/test_embedding_model_component.py, src/backend/tests/unit/components/models_and_agents/test_language_model_component.py	Updates patch targets and mock parameters from plural to singular getters across multiple test classes. Adjusts mock return values to return classes directly instead of dictionaries.
Requirements Generation Feature src/lfx/src/lfx/utils/flow_requirements.py, src/lfx/src/lfx/__main__.py, src/lfx/src/lfx/utils/__init__.py	Adds new module for generating requirements.txt from Langflow flows with AST-based import extraction, dynamic provider detection, and transitive dependency resolution. Adds CLI command requirements with support for version pinning and LFX inclusion options.
Requirements Generation Tests src/lfx/tests/unit/test_flow_requirements.py	Comprehensive unit and integration tests for requirements generation utilities covering import extraction, provider detection, version pinning, and real-world starter project scenarios.
Metadata & Index Updates src/lfx/src/lfx/_assets/component_index.json, src/lfx/src/lfx/_assets/stable_hash_history.json	Updates component index with new API calls and dependency versions; updates stable hash entries for BatchRunComponent and EmbeddingModel to reflect code changes.

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~75 minutes

🚥 Pre-merge checks | ✅ 5 | ❌ 2

❌ Failed checks (2 warnings)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 45.65% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.
Test Quality And Coverage	⚠️ Warning	Pull request has significant test coverage gaps for critical new functionality including CLI command wrapper and dynamic import functions.	Create CLI test file for requirements_command_wrapper and add unit tests for get_model_class() and get_embedding_class() functions with comprehensive coverage.

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The pull request title 'feat: generate requirements.txt from dependencies' clearly and concisely summarizes the main feature addition: generating a requirements.txt file from flow dependencies, which aligns with the substantial changes across multiple files for this functionality.
Test Coverage For New Implementations	✅ Passed	The PR includes comprehensive test coverage with 92 new test methods across 13 test classes and updates to 4 existing test files with 40 patches.
Test File Naming And Structure	✅ Passed	Test files follow correct naming convention (test_*.py) with proper pytest structure, descriptive function names, and comprehensive coverage of positive, negative, and edge case scenarios.
Excessive Mock Usage Warning	✅ Passed	Test modifications show appropriate mock usage targeting external dependencies rather than core logic, with good balance of unit and integration tests.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch generate-reqs-from-flow

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

Actionable comments posted: 3

🧹 Nitpick comments (10)

src/backend/tests/unit/components/llm_operations/test_structured_output_component.py (1)

54-62: Fixture name mock_model_classes not renamed to match the singular API change.

The fixture's docstring and inner function were updated to singular (_create_mock_model_class), but the fixture itself is still named mock_model_classes. This is inconsistent with the broader rename from get_model_classes → get_model_class and makes it confusing when read alongside the mock_get_model_class parameter names used throughout the tests.

Rename the fixture

     `@pytest.fixture`
-    def mock_model_classes(self):
+    def mock_model_class(self):
         """Helper fixture to create a mock model class factory for MockLanguageModel."""

         def _create_mock_model_class(mock_llm_instance):
             """Create a mock model class that returns the provided mock LLM."""
             return MagicMock(return_value=mock_llm_instance)

         return _create_mock_model_class

This would also require updating all test method signatures that reference mock_model_classes to mock_model_class (approximately 20 occurrences in this file).

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/backend/tests/unit/components/llm_operations/test_structured_output_component.py`
around lines 54 - 62, Rename the pytest fixture mock_model_classes to
mock_model_class (and update its docstring to singular) so it matches the inner
factory function _create_mock_model_class and the new singular API naming; then
update all test function parameters in this file that currently accept
mock_model_classes to use mock_model_class instead (roughly 20 occurrences) so
usages align with the renamed fixture and existing mock_get_model_class naming.

src/lfx/src/lfx/utils/flow_requirements.py (3)

108-155: lru_cache(maxsize=1) on functions with parameters will cache only the last call.

_get_lfx_transitive_dists and _get_lfx_provided_imports accept an lfx_dist_name parameter but use maxsize=1. If these are ever called with different dist names (e.g., "lfx" then "lfx-nightly"), the cache will evict and recompute each time. Currently this isn't an issue because callers always use the default "lfx", but the parameter+cache combination is misleading. Consider either removing the parameter (hardcoding "lfx") or using maxsize=None if multi-dist-name support is intended.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/src/lfx/utils/flow_requirements.py` around lines 108 - 155, The
functions _get_lfx_transitive_dists and _get_lfx_provided_imports declare an
lfx_dist_name parameter but are decorated with `@lru_cache`(maxsize=1), which will
only cache a single call and is misleading if different dist names are ever
used; fix by either removing the lfx_dist_name parameter and hardcoding "lfx"
inside both functions (update any internal references to lfx_dist_name) so the
single-entry cache makes sense, or change the decorator to
`@lru_cache`(maxsize=None) to allow caching of multiple dist names if you intend
to support calls like "lfx-nightly"; apply the same choice consistently to both
functions.

---

260-306: _PROVIDER_EMBEDDING_CLASS dict is recreated on every call.

The _PROVIDER_EMBEDDING_CLASS dictionary on lines 280–287 is a static mapping but is rebuilt each time _resolve_embedding_provider_packages is called. Moving it to module level would avoid the repeated allocation and make it easier to discover/maintain alongside IMPORT_NAME_OVERRIDES and MODULE_EXTRA_DEPS.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/src/lfx/utils/flow_requirements.py` around lines 260 - 306, The
_PROVIDER_EMBEDDING_CLASS dict is a static mapping recreated on each call to
_resolve_embedding_provider_packages; move that mapping out of the function to
module scope (e.g., PROVIDER_EMBEDDING_CLASS) near IMPORT_NAME_OVERRIDES and
MODULE_EXTRA_DEPS, then have _resolve_embedding_provider_packages reference the
module-level PROVIDER_EMBEDDING_CLASS instead of declaring it inline; keep the
same keys/values and ensure no other semantics
change—_resolve_embedding_provider_packages, _get_lfx_provided_imports,
STDLIB_MODULES, and _import_to_package should continue to be used as before.

---

126-131: Consider regex-based check for more robust extra-dependency filtering.

Line 127 uses if "extra ==" in req to skip optional/extra dependencies. While PEP 508 technically allows variable whitespace around markers (e.g., extra==, extra ==), importlib.metadata.requires() consistently normalizes to extra == with single spacing. The current string match works reliably in practice. If you want to be more defensive against potential edge cases or future variations, a regex check would be safer:

Suggested fix

-            if "extra ==" in req:
-                continue  # skip optional/extra dependencies
+            if re.search(r'\bextra\s*==', req):
+                continue  # skip optional/extra dependencies

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/src/lfx/utils/flow_requirements.py` around lines 126 - 131, Replace
the brittle substring check if "extra ==" in req with a regex-based test to
robustly detect PEP 508 extra markers (e.g. use re.search to match word boundary
"extra" followed by optional whitespace and "=="); update the loop that iterates
over reqs and inspects req (the block that currently skips optional/extra
dependencies before calling _collect) to use this regex check so variants like
"extra==", "extra  ==", or similar spacing still get skipped.

src/lfx/tests/unit/test_flow_requirements.py (2)

28-38: Module-level _find_starter_projects_dir with sentinel fallback is pragmatic but could produce confusing failures.

If the starter projects directory is never found, STARTER_PROJECTS_DIR will be Path("STARTER_PROJECTS_NOT_FOUND"). The individual test fixtures correctly pytest.skip when specific files don't exist, so this won't cause false failures. Just noting the sentinel approach is unconventional — a None with a skip at fixture level would be slightly clearer.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/tests/unit/test_flow_requirements.py` around lines 28 - 38, The
module-level function _find_starter_projects_dir currently returns a sentinel
Path("STARTER_PROJECTS_NOT_FOUND") which is unconventional; change
_find_starter_projects_dir to return None when the starter_projects directory
isn't found and set STARTER_PROJECTS_DIR = None accordingly, then ensure any
tests/fixtures that check STARTER_PROJECTS_DIR handle None (they already skip
when files are missing) so replace sentinel comparisons with explicit None
checks; update references to STARTER_PROJECTS_DIR and _find_starter_projects_dir
to use the new None semantics.

---

633-633: Avoid bare l as a variable name — easily confused with 1.

-        lines = [l for l in txt.strip().split("\n") if l and not l.startswith("#")]
+        lines = [line for line in txt.strip().split("\n") if line and not line.startswith("#")]

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/tests/unit/test_flow_requirements.py` at line 633, The comprehension
uses a bare variable name `l` which is easy to confuse with `1`; rename that
iterator to a clear identifier like `line` (e.g., change "lines = [l for l in
txt.strip().split('\n') if l and not l.startswith('#')]" to use `line`) so the
intent is obvious and readability improves—update any related references in the
same expression or nearby assertions in test_flow_requirements.py.

src/lfx/src/lfx/_assets/component_index.json (2)

89866-89869: Eager instantiation of all provider embedding models may be expensive.

_build_available_models instantiates an embedding class for every available model of the selected provider. Depending on the provider, this could involve many instantiation calls (some providers have dozens of embedding models). If these constructors perform network calls or validation, this could significantly slow down build_embeddings().

Consider lazy instantiation (e.g., a factory dict or __getattr__ proxy) so models are only created when actually accessed.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/src/lfx/_assets/component_index.json` around lines 89866 - 89869, The
_build_available_models function eagerly instantiates every embedding (causing
expensive work); change it to return a lazy factory/proxy mapping instead: in
_build_available_models, keep the same keys (model_name) but store a
lambda/factory that calls embedding_class(**self._build_kwargs_for_model(...))
(or a lightweight proxy object implementing __call__ or __getattr__ to
instantiate on first access), and adjust build_embeddings/EmbeddingsWithModels
usage so available_models contains these factories/proxies (or update
EmbeddingsWithModels to accept callables and instantiate when needed); reference
_build_available_models, _build_kwargs_for_model, embedding_class,
EmbeddingsWithModels, and build_embeddings when making the change.

---

89866-89869: Extract common kwargs-building logic into a shared helper method to eliminate duplication.

_build_kwargs and _build_kwargs_for_model contain ~40 lines of nearly identical logic for optional parameters, Watson-specific handling, Ollama-specific handling, and request_timeout special cases. The methods differ only in how the API key is obtained. Refactor by extracting lines 321–361 from _build_kwargs_for_model (or lines 388–428 from _build_kwargs) into a _build_optional_kwargs_dict() helper that both methods call, with api_key as a parameter.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/src/lfx/_assets/component_index.json` around lines 89866 - 89869, The
_build_kwargs and _build_kwargs_for_model methods duplicate optional-parameter,
Watson/Ollama, and request_timeout logic; extract that shared logic into a new
helper method named _build_optional_kwargs_dict(self, model_provider: str,
param_mapping: dict[str, str], api_key: str | None) that returns the kwargs for
optional params (including mapping
api_base/dimensions/chunk_size/request_timeout/max_retries/show_progress_bar/model_kwargs),
handles IBM watsonx url/project_id defaults, Ollama base_url default, and the
Google request_timeout special-case; then have _build_kwargs and
_build_kwargs_for_model call this helper (pass provider/model.get("provider")
and api_key appropriately) and only keep the API-key-specific lines
(get_api_key_for_provider call) in _build_kwargs while _build_kwargs_for_model
uses the provided api_key parameter.

src/lfx/src/lfx/base/models/unified_models.py (2)

103-118: Deprecation notices are docstring-only — consider emitting a runtime warning.

These functions are marked as deprecated via docstrings, but callers won't see any signal at runtime. A warnings.warn(..., DeprecationWarning, stacklevel=2) would surface the deprecation during development/testing.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/src/lfx/base/models/unified_models.py` around lines 103 - 118, Add
runtime deprecation warnings to get_model_classes and get_embedding_classes:
import the warnings module and call warnings.warn with an explanatory message,
category=DeprecationWarning, and stacklevel=2 at the start of each function
(get_model_classes and get_embedding_classes) so callers receive a visible
deprecation signal during development; keep the existing docstrings intact.

---

47-100: get_model_class and get_embedding_class are nearly identical — DRY opportunity.

Both functions share the same cache-check → lookup → import → cache-store logic. A single private helper parameterized on the mapping dict, cache dict, and label string would eliminate the duplication.

Sketch

+def _get_class(
+    class_name: str,
+    import_map: dict[str, tuple[str, str]],
+    cache: dict[str, type],
+    kind: str,   # "model" or "embedding"
+) -> type:
+    if class_name in cache:
+        return cache[class_name]
+    import_info = import_map.get(class_name)
+    if import_info is None:
+        msg = f"Unknown {kind} class: {class_name}"
+        raise ValueError(msg)
+    module_path, attr_name = import_info
+    try:
+        module = importlib.import_module(module_path)
+    except ImportError as exc:
+        pkg_hint = module_path.split(".")[0].replace("_", "-")
+        msg = (
+            f"Could not import '{module_path}' for {kind} class '{class_name}'. "
+            f"Install the missing package (e.g. uv pip install {pkg_hint})."
+        )
+        raise ImportError(msg) from exc
+    cls = getattr(module, attr_name)
+    cache[class_name] = cls
+    return cls
+
+
 def get_model_class(class_name: str) -> type:
-    ...
+    return _get_class(class_name, _MODEL_CLASS_IMPORTS, _model_class_cache, "model")
+
 def get_embedding_class(class_name: str) -> type:
-    ...
+    return _get_class(class_name, _EMBEDDING_CLASS_IMPORTS, _embedding_class_cache, "embedding")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lfx/src/lfx/base/models/unified_models.py` around lines 47 - 100,
get_model_class and get_embedding_class duplicate the same import/caching logic;
extract a single private helper (e.g. _import_class(class_name: str, mapping:
dict, cache: dict, label: str) -> type) that does cache lookup, mapping lookup,
importlib.import_module, constructs the same pkg_hint/ImportError message,
getattr to fetch attr_name, stores the class in cache and returns it; then
rewrite get_model_class to call _import_class(class_name, _MODEL_CLASS_IMPORTS,
_model_class_cache, "model") and get_embedding_class to call
_import_class(class_name, _EMBEDDING_CLASS_IMPORTS, _embedding_class_cache,
"embedding") so behavior and error messages remain identical.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/lfx/src/lfx/__main__.py`:
- Around line 150-205: The CLI currently assumes flow_path is a file and that
disk IO always succeeds; update requirements_command_wrapper to validate
Path(flow_path).is_file() and if not print a user-friendly error via typer.echo
and raise typer.Exit(1), and wrap file reads and writes in try/except OSError
blocks (around Path.read_text and Path(output).write_text) to catch IO errors,
logging the exception message with typer.echo and exiting cleanly; keep the
existing JSONDecodeError handling and still call generate_requirements_txt as
before.

In `@src/lfx/src/lfx/_assets/component_index.json`:
- Around line 72394-72395: The project bumped the "google" package in
src/lfx/src/lfx/_assets/component_index.json to version 2.5.0 which requires
Python >=3.6 and specific ranges for google-auth and google-api-core and changes
discovery caching; update and verify compatibility by ensuring CI and runtime
Python versions (e.g., .github/workflows, tox/pyproject) meet >=3.6, add or
tighten pins in requirements.txt or pyproject.toml for google-auth
(>=1.16.0,<2dev) and google-api-core (>=1.21.0,<2dev), run dependency resolution
and tests, and audit any code that relies on dynamic discovery fetching (search
for usages of googleapiclient.discovery.build and related discovery caching
logic) to handle the new behavior or vendor bundled discovery docs.

In `@src/lfx/src/lfx/base/models/unified_models.py`:
- Around line 60-69: The ImportError message currently builds pkg_hint from
module_path (import_info -> module_path) which yields misleading hints for
internal modules (e.g. "lfx"); update the logic in get_model_class (where
import_info, module_path, attr_name and class_name are used) to prefer an
explicit install hint: extend the mapping that provides import_info to allow an
optional third element like install_hint and, if present, use that for the error
message; additionally, treat internal module paths (e.g.
module_path.startswith("lfx.")) as not eligible for automatic pip hints and fall
back to the explicit install_hint or a generic message suggesting checking
dependencies.

---

Nitpick comments:
In
`@src/backend/tests/unit/components/llm_operations/test_structured_output_component.py`:
- Around line 54-62: Rename the pytest fixture mock_model_classes to
mock_model_class (and update its docstring to singular) so it matches the inner
factory function _create_mock_model_class and the new singular API naming; then
update all test function parameters in this file that currently accept
mock_model_classes to use mock_model_class instead (roughly 20 occurrences) so
usages align with the renamed fixture and existing mock_get_model_class naming.

In `@src/lfx/src/lfx/_assets/component_index.json`:
- Around line 89866-89869: The _build_available_models function eagerly
instantiates every embedding (causing expensive work); change it to return a
lazy factory/proxy mapping instead: in _build_available_models, keep the same
keys (model_name) but store a lambda/factory that calls
embedding_class(**self._build_kwargs_for_model(...)) (or a lightweight proxy
object implementing __call__ or __getattr__ to instantiate on first access), and
adjust build_embeddings/EmbeddingsWithModels usage so available_models contains
these factories/proxies (or update EmbeddingsWithModels to accept callables and
instantiate when needed); reference _build_available_models,
_build_kwargs_for_model, embedding_class, EmbeddingsWithModels, and
build_embeddings when making the change.
- Around line 89866-89869: The _build_kwargs and _build_kwargs_for_model methods
duplicate optional-parameter, Watson/Ollama, and request_timeout logic; extract
that shared logic into a new helper method named
_build_optional_kwargs_dict(self, model_provider: str, param_mapping: dict[str,
str], api_key: str | None) that returns the kwargs for optional params
(including mapping
api_base/dimensions/chunk_size/request_timeout/max_retries/show_progress_bar/model_kwargs),
handles IBM watsonx url/project_id defaults, Ollama base_url default, and the
Google request_timeout special-case; then have _build_kwargs and
_build_kwargs_for_model call this helper (pass provider/model.get("provider")
and api_key appropriately) and only keep the API-key-specific lines
(get_api_key_for_provider call) in _build_kwargs while _build_kwargs_for_model
uses the provided api_key parameter.

In `@src/lfx/src/lfx/base/models/unified_models.py`:
- Around line 103-118: Add runtime deprecation warnings to get_model_classes and
get_embedding_classes: import the warnings module and call warnings.warn with an
explanatory message, category=DeprecationWarning, and stacklevel=2 at the start
of each function (get_model_classes and get_embedding_classes) so callers
receive a visible deprecation signal during development; keep the existing
docstrings intact.
- Around line 47-100: get_model_class and get_embedding_class duplicate the same
import/caching logic; extract a single private helper (e.g.
_import_class(class_name: str, mapping: dict, cache: dict, label: str) -> type)
that does cache lookup, mapping lookup, importlib.import_module, constructs the
same pkg_hint/ImportError message, getattr to fetch attr_name, stores the class
in cache and returns it; then rewrite get_model_class to call
_import_class(class_name, _MODEL_CLASS_IMPORTS, _model_class_cache, "model") and
get_embedding_class to call _import_class(class_name, _EMBEDDING_CLASS_IMPORTS,
_embedding_class_cache, "embedding") so behavior and error messages remain
identical.

In `@src/lfx/src/lfx/utils/flow_requirements.py`:
- Around line 108-155: The functions _get_lfx_transitive_dists and
_get_lfx_provided_imports declare an lfx_dist_name parameter but are decorated
with `@lru_cache`(maxsize=1), which will only cache a single call and is
misleading if different dist names are ever used; fix by either removing the
lfx_dist_name parameter and hardcoding "lfx" inside both functions (update any
internal references to lfx_dist_name) so the single-entry cache makes sense, or
change the decorator to `@lru_cache`(maxsize=None) to allow caching of multiple
dist names if you intend to support calls like "lfx-nightly"; apply the same
choice consistently to both functions.
- Around line 260-306: The _PROVIDER_EMBEDDING_CLASS dict is a static mapping
recreated on each call to _resolve_embedding_provider_packages; move that
mapping out of the function to module scope (e.g., PROVIDER_EMBEDDING_CLASS)
near IMPORT_NAME_OVERRIDES and MODULE_EXTRA_DEPS, then have
_resolve_embedding_provider_packages reference the module-level
PROVIDER_EMBEDDING_CLASS instead of declaring it inline; keep the same
keys/values and ensure no other semantics
change—_resolve_embedding_provider_packages, _get_lfx_provided_imports,
STDLIB_MODULES, and _import_to_package should continue to be used as before.
- Around line 126-131: Replace the brittle substring check if "extra ==" in req
with a regex-based test to robustly detect PEP 508 extra markers (e.g. use
re.search to match word boundary "extra" followed by optional whitespace and
"=="); update the loop that iterates over reqs and inspects req (the block that
currently skips optional/extra dependencies before calling _collect) to use this
regex check so variants like "extra==", "extra  ==", or similar spacing still
get skipped.

In `@src/lfx/tests/unit/test_flow_requirements.py`:
- Around line 28-38: The module-level function _find_starter_projects_dir
currently returns a sentinel Path("STARTER_PROJECTS_NOT_FOUND") which is
unconventional; change _find_starter_projects_dir to return None when the
starter_projects directory isn't found and set STARTER_PROJECTS_DIR = None
accordingly, then ensure any tests/fixtures that check STARTER_PROJECTS_DIR
handle None (they already skip when files are missing) so replace sentinel
comparisons with explicit None checks; update references to STARTER_PROJECTS_DIR
and _find_starter_projects_dir to use the new None semantics.
- Line 633: The comprehension uses a bare variable name `l` which is easy to
confuse with `1`; rename that iterator to a clear identifier like `line` (e.g.,
change "lines = [l for l in txt.strip().split('\n') if l and not
l.startswith('#')]" to use `line`) so the intent is obvious and readability
improves—update any related references in the same expression or nearby
assertions in test_flow_requirements.py.