feat: traces v0 (#11689)

[Adam-Aghili]

• feat: traces v0

v0 for traces includes:

• filters: status, token usage range and datatime
• accordian rows per trace

Could add:

• more filter options. Ecamples: session_id, trace_id and latency range

• fix: token range

• feat: create sidebar buttons for logs and trace

add sidebar buttons for logs and trace
remove lods canvas control

• fix: fix duplicate trace ID insertion

hopefully fix duplicate trace ID insertion on windows

• fix: update tests and alembic tables for uts

update tests and alembic tables for uts

• chore: add session_id

• chore: allo grouping by session_id and flow_id

• chore: update race input output

• chore: change run name to flow_name - flow_id was flow_name - trace_id
  now flow_name - flow_id

• facelift

• clean up and add testcases

• clean up and add testcases

• merge Alembic detected multiple heads

• [autofix.ci] apply automated fixes

• improve testcases

• remodel files

• chore: address gabriel simple changes

address gabriel simple changes in traces.py and native.py

• clean up and testcases

• chore: address OTel and PG status comments

#11689 (comment) #11689 (comment)

• chore: OTel span naming convention

model name is now set using name = f"{operation} {model_name}" if model_name else operation

• add traces

• feat: use uv sources for CPU-only PyTorch (feat: use uv sources for CPU-only PyTorch #11884)

• feat: use uv sources for CPU-only PyTorch

Configure [tool.uv.sources] with pytorch-cpu index to avoid ~6GB CUDA dependencies in Docker images. This replaces hardcoded wheel URLs with a cleaner index-based approach.

• Add pytorch-cpu index with explicit = true
• Add torch/torchvision to [tool.uv.sources]
• Add explicit torch/torchvision deps to trigger source override
• Regenerate lockfile without nvidia/cuda/triton packages
• Add required-environments for multi-platform support

• fix: update regex to only replace name in [project] section

The previous regex matched all lines starting with name = "...", which incorrectly renamed the UV index pytorch-cpu to langflow-nightly during nightly builds. This caused uv lock to fail with: "Package torch references an undeclared index: pytorch-cpu"

The new regex specifically targets the name field within the [project] section only, avoiding unintended replacements in other sections like [[tool.uv.index]].

• style: fix ruff quote style

• fix: remove required-environments to fix Python 3.13 macOS x86_64 CI

The required-environments setting was causing hard failures when packages like torch didn't have wheels for specific platform/Python combinations. Without this setting, uv resolves optimistically and handles missing wheels gracefully at runtime instead of failing during resolution.

---

• LE-270: Hydration and Console Log error (LE-270: Hydration and Console Log error #11628)

• LE-270: add fix hydration issues

• LE-270: fix disable field on max token on language model

---

• test: add wait for selector in mcp server tests (test: add wait for selector in mcp server tests #11883)

• Add wait for selector in mcp server tests

• [autofix.ci] apply automated fixes

• Add more awit for selectors

• [autofix.ci] apply automated fixes

---

• fix: reduce visual lag in frontend (fix: reduce visual lag in frontend  #11686)

• Reduce lag in frontend by batching react events and reducing minimval visual build time

• Cleanup

• [autofix.ci] apply automated fixes

• add tests and improve code read

• [autofix.ci] apply automated fixes

• Remove debug log

---

• feat: lazy load imports for language model component (feat: lazy load imports for language model component #11737)

• Lazy load imports for language model component

Ensures that only the necessary dependencies are required. For example, if OpenAI provider is used, it will now only import langchain_openai, rather than requiring langchain_anthropic, langchain_ibm, etc.

• Add backwards-compat functions

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes (attempt 2/3)

• Add exception handling

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes (attempt 2/3)

• comp index

• docs: azure default temperature (docs: azure default temperature #11829)

• change-azure-openai-default-temperature-to-1.0

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes (attempt 2/3)

• [autofix.ci] apply automated fixes (attempt 3/3)

• [autofix.ci] apply automated fixes

---

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes (attempt 2/3)

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes (attempt 2/3)

• fix unit test?

• add no-group dev to docker builds

• [autofix.ci] apply automated fixes

---

• feat: generate requirements.txt from dependencies (feat: generate requirements.txt from dependencies  #11810)

• Base script to generate requirements

Dymanically picks dependency for LanguageM Comp.
Requires separate change to remove eager loading.

• Lazy load imports for language model component

Ensures that only the necessary dependencies are required. For example, if OpenAI provider is used, it will now only import langchain_openai, rather than requiring langchain_anthropic, langchain_ibm, etc.

• Add backwards-compat functions

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes (attempt 2/3)

• Add exception handling

• Add CLI command to create reqs

• correctly exclude langchain imports

• Add versions to reqs

• dynamically resolve provider imports for language model comp

• Lazy load imports for reqs, some ruff fixes

• Add dynamic resolves for embedding model comp

• Add install hints

• Add missing provider tests; add warnings in reqs script

• Add a few warnings and fix install hint

• update comments add logging

• Package hints, warnings, comments, tests

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes (attempt 2/3)

• [autofix.ci] apply automated fixes (attempt 3/3)

• Add alias for watsonx

• Fix anthropic for basic prompt, azure mapping

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes (attempt 2/3)

• ruff

• [autofix.ci] apply automated fixes

• test formatting

• ruff

• [autofix.ci] apply automated fixes

---

• fix: add handle to file input to be able to receive text (fix: add handle to file input to be able to receive text #11825)

• changed base file and file components to support muitiple files and files from messages

• update component index

• update input file component to clear value and show placeholder

• updated starter projects

• [autofix.ci] apply automated fixes

• updated base file, file and video file to share robust file verification method

• updated component index

• updated templates

• fix whitespaces

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes (attempt 2/3)

• add file upload test for files fed through the handle

• [autofix.ci] apply automated fixes

• added tests and fixed things pointed out by revies

• update component index

• fixed test

• ruff fixes

• Update component_index.json

• [autofix.ci] apply automated fixes

• [autofix.ci] apply automated fixes (attempt 2/3)

• [autofix.ci] apply automated fixes (attempt 3/3)

• updated component index

• updated component index

• removed handle from file input

• Added functionality to use multiple files on the File Path, and to allow files on the langflow file system.

• [autofix.ci] apply automated fixes

• fixed lfx test

• build component index

---

• docs: Add AGENTS.md development guide (docs: Add AGENTS.md development guide #11922)

• add AGENTS.md rule to project

• change to agents-example

• remove agents.md

• add example description

• chore: address cris I1 comment

address cris I1 comment

• chore: address cris I5

address cris I5

• chore: address cris I6

address cris I6

• chore: address cris R7

address cris R7

• fix testcase

• chore: address cris R2

address cris R2

• restructure insight page into sidenav

• added header and total run node

• restructing branch

• chore: address gab otel model changes

address gab otel model changes will need no migration tables

• chore: update alembic migration tables

update alembic migration tables after model changes

• add empty state for gropu sessions

• remove invalid mock

• test: update and add backend tests

update and add backend tests

• chore: address backend code rabbit comments

address backend code rabbit comments

• chore: address code rabbit frontend comments

address code rabbit frontend comments

• chore: test_native_tracer minor fix address c1

test_native_tracer minor fix address c1

• chore: address C2 + C3

address C2 + C3

• chore: address H1-H5

address H1-H5

• test: update test_native_tracer

update test_native_tracer

• fixes

• chore: address M2

address m2

• chore: address M1

address M1

• dry changes, factorization

• chore: fix 422 spam and clean comments

fix 422 spam and clean comments

• chore: address M12

address M12

• chore: address M3 address M3

• chore: address M4

address M4

• chore: address M5

address M5

• chore: clean up for M7, M9, M11

clean up for M7, M9, M11

• chore: address L2,L4,L5,L6 + any test

address L2,L4,L5 and L6 + any test

• chore: alembic + comment clean up

alembic + comment clean up

• chore: remove depricated test_traces file

remove depricated test_traces file. test have all been moved to test_traces_api.py

• fix datetime

• chore: fix test_trace_api ge=0 is allowed now

fix test_trace_api ge=0 is allowed now

• chore: remove unused traces cost flow

remove unused traces cost flow

• fix traces test

• fix traces test

• fix traces test

• fix traces test

• fix traces test

• chore: address gabriels otel coment

address gabriels otel coment latest

---

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on base/target branches other than the default branch.

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

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch rc/traces-v0

---

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.}

[github-actions]

✅ Migration Validation Passed

All migrations follow the Expand-Contract pattern correctly.

[github-actions]

Frontend Unit Test Coverage Report

Coverage Summary

Lines	Statements	Branches	Functions
	22.87% (7981/34890)	15.45% (4224/27334)	15.6% (1147/7348)

Unit Test Results

Tests	Skipped	Failures	Errors	Time
2611	0 💤	0 ❌	0 🔥	41.559s ⏱️

[codecov]

Codecov Report

❌ Patch coverage is 71.97999% with 392 lines in your changes missing coverage. Please review.
⚠️ Please upload report for BASE (release-1.8.0@93323ed). Learn more about missing BASE report.

Files with missing lines	Patch %	Lines
.../components/TraceComponent/FlowInsightsContent.tsx	0.00%	109 Missing ⚠️
...ckend/base/langflow/services/tracing/repository.py	36.36%	56 Missing ⚠️
...e/components/TraceComponent/TraceAccordionItem.tsx	0.00%	54 Missing ⚠️
...FlowPage/components/flowSidebarComponent/index.tsx	0.00%	37 Missing ⚠️
...ponents/TraceComponent/config/flowTraceColumns.tsx	0.00%	24 Missing ⚠️
...Page/components/TraceComponent/TraceDetailView.tsx	52.38%	5 Missing and 15 partials ⚠️
.../langflow/services/database/models/traces/model.py	90.06%	15 Missing ⚠️
.../base/langflow/services/tracing/native_callback.py	91.12%	15 Missing ⚠️
...Page/components/TraceComponent/traceViewHelpers.ts	87.27%	3 Missing and 11 partials ⚠️
...c/backend/base/langflow/services/tracing/native.py	93.02%	12 Missing ⚠️
... and 12 more

Additional details and impacted files

@@               Coverage Diff                @@
##             release-1.8.0   #11983   +/-   ##
================================================
  Coverage                 ?   37.06%           
================================================
  Files                    ?     1588           
  Lines                    ?    77960           
  Branches                 ?    11800           
================================================
  Hits                     ?    28895           
  Misses                   ?    47446           
  Partials                 ?     1619           

Flag	Coverage Δ
backend	57.36% <86.30%> (?)
frontend	20.49% <54.24%> (?)
lfx	41.49% <ø> (?)

Flags with carried forward coverage won't be shown. Click here to find out more.

Files with missing lines	Coverage Δ
src/backend/base/langflow/api/router.py	100.00% <100.00%> (ø)
src/backend/base/langflow/api/v1/traces.py	100.00% <100.00%> (ø)
...ckend/base/langflow/services/tracing/validation.py	100.00% <100.00%> (ø)
src/frontend/src/components/ui/sidebar.tsx	51.63% <ø> (ø)
...rc/controllers/API/queries/traces/use-get-trace.ts	100.00% <100.00%> (ø)
...ge/components/PageComponent/MemoizedComponents.tsx	58.97% <ø> (ø)
.../pages/FlowPage/components/PageComponent/index.tsx	0.00% <ø> (ø)
...es/FlowPage/components/TraceComponent/SpanTree.tsx	100.00% <100.00%> (ø)
...ts/flowSidebarComponent/components/searchInput.tsx	0.00% <ø> (ø)
...idebarComponent/components/sidebarSegmentedNav.tsx	98.03% <100.00%> (ø)
... and 25 more

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[codeflash-ai]

⚡️Codeflash found 41% (0.41x) speedup for safe_int_tokens in src/backend/base/langflow/services/tracing/formatting.py

⏱️ Runtime : 3.03 milliseconds → 2.15 milliseconds (best of 69 runs)

📝 Explanation and details

The optimization adds a fast path for pure-integer strings by stripping whitespace and checking isdigit() (after removing an optional sign), allowing the hot-path int(value) call to succeed without first catching a ValueError and then falling back to float(value). This avoids the exception-raising overhead that the original code incurred on ~4700 integer-string inputs, reducing per-call cost from ~1260 ns to ~713 ns for those cases. Additionally, float parsing is now guarded by a check for ., e, or E in the string, preventing needless float() attempts on non-numeric strings and cutting exception traffic by ~1200 occurrences. The profiler confirms the new fast-path lines (strip, isdigit, and int) collectively take less time than the original try/except cascade, yielding a 41% overall speedup with no behavioral regressions.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 48 Passed
🌀 Generated Regression Tests	✅ 5097 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

⚙️ Click to see Existing Unit Tests

🌀 Click to see Generated Regression Tests

import math  # used to construct NaN/inf values for tests

# imports
import pytest  # used for our unit tests
from langflow.services.tracing.formatting import safe_int_tokens


def test_integer_inputs_basic():
    # Integers should be returned unchanged (including negatives, per current implementation).
    codeflash_output = safe_int_tokens(0)  # zero remains zero
    codeflash_output = safe_int_tokens(7)  # positive integer preserved
    codeflash_output = safe_int_tokens(-3)  # negative integer preserved (behavior of current code)


def test_float_inputs_and_truncation():
    # Finite floats are truncated toward zero by int()
    codeflash_output = safe_int_tokens(12.9)  # float truncated down
    codeflash_output = safe_int_tokens(12.0)  # exact float -> exact int
    codeflash_output = safe_int_tokens(-0.9)  # negative fractional truncated toward zero yields 0

    # Non-finite floats produce 0
    codeflash_output = safe_int_tokens(math.nan)  # NaN -> treated as failure -> 0
    codeflash_output = safe_int_tokens(math.inf)  # +inf -> 0
    codeflash_output = safe_int_tokens(-math.inf)  # -inf -> 0


def test_string_numeric_variants():
    # Integer and float strings are parsed and coerced to int
    codeflash_output = safe_int_tokens("42")  # plain integer string
    codeflash_output = safe_int_tokens("42.9")  # float string truncated
    codeflash_output = safe_int_tokens("  -8  ")  # whitespace is allowed by int()/float() parsing
    codeflash_output = safe_int_tokens("-2.7")  # negative float string truncated toward zero

    # Scientific notation handled via float parsing
    codeflash_output = safe_int_tokens("1e3")  # "1e3" -> 1000
    codeflash_output = safe_int_tokens("1E2")  # uppercase E also works

    # Non-numeric and special floating strings -> 0
    codeflash_output = safe_int_tokens("NaN")  # textual NaN -> parsed to nan -> 0
    codeflash_output = safe_int_tokens("inf")  # textual infinity -> parsed to inf -> 0
    codeflash_output = safe_int_tokens("")  # empty string -> invalid -> 0
    codeflash_output = safe_int_tokens("true")  # boolean-as-string is not numeric -> 0
    codeflash_output = safe_int_tokens("False")  # same for "False"


def test_boolean_none_and_other_types():
    # Booleans must be treated specially and return 0 (even though bool is a subclass of int)
    codeflash_output = safe_int_tokens(True)
    codeflash_output = safe_int_tokens(False)

    # None and other non-numeric types return 0
    codeflash_output = safe_int_tokens(None)
    codeflash_output = safe_int_tokens([])  # lists are not numbers
    codeflash_output = safe_int_tokens({})  # dicts are not numbers
    codeflash_output = safe_int_tokens((1, 2, 3))  # tuples -> 0
    codeflash_output = safe_int_tokens(b"123")  # bytes are not str/int/float in this function -> 0


def test_overflow_and_extremely_large_values_in_strings():
    # Very large scientific notation overflows float to inf -> should return 0
    codeflash_output = safe_int_tokens("1e1000")  # parsed float becomes inf -> 0

    # Extremely large integer string (but not parsed as float) will raise ValueError on int(...) if too big?
    # Python's int can handle arbitrary precision, so large integer strings should parse.
    huge_int_str = "9" * 200  # very large integer string
    codeflash_output = safe_int_tokens(huge_int_str)


def test_edge_negative_fraction_string_behavior():
    # Negative fractional strings are parsed as float then truncated toward zero
    codeflash_output = safe_int_tokens("-0.9999")  # truncated toward zero


def test_large_scale_list_of_string_integers():
    # Create 1000 numeric string tokens and ensure mapping yields the expected ints
    inputs = [str(i) for i in range(1000)]  # 0..999 as strings
    outputs = [safe_int_tokens(v) for v in inputs]  # call the function for each element


def test_large_scale_repeated_calls_with_mixed_types():
    # Build 1000 mixed inputs alternating numeric strings, floats, booleans, None, and garbage strings.
    mixed = []
    expected = []
    for i in range(1000):
        if i % 5 == 0:
            mixed.append(str(i))  # numeric string
            expected.append(i)
        elif i % 5 == 1:
            mixed.append(float(i) + 0.9)  # float -> truncated
            expected.append(int(float(i) + 0.9))
        elif i % 5 == 2:
            mixed.append(True if (i % 2 == 0) else False)  # booleans -> 0
            expected.append(0)
        elif i % 5 == 3:
            mixed.append(None)  # None -> 0
            expected.append(0)
        else:
            mixed.append("not-a-number")  # non-numeric string -> 0
            expected.append(0)

    # Run the function across the mixed list and confirm expected results
    results = [safe_int_tokens(x) for x in mixed]


def test_stability_under_repeated_invocations():
    # Repeatedly call safe_int_tokens on the same set of values to ensure deterministic behavior
    values = ["10", 10, 10.9, "10.9", "NaN", True, None, "1e2", "1e1000"]
    expected_once = [safe_int_tokens(v) for v in values]  # baseline
    # Repeat 1000 times and verify no change
    for _ in range(1000):
        codeflash_output = [safe_int_tokens(v) for v in values]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import math
from typing import Any

# imports
import pytest
from langflow.services.tracing.formatting import safe_int_tokens


def test_plain_integer_positive():
    """Test that positive integers are returned as-is."""
    codeflash_output = safe_int_tokens(42)


def test_plain_integer_zero():
    """Test that zero is returned as-is."""
    codeflash_output = safe_int_tokens(0)


def test_plain_integer_negative():
    """Test that negative integers are returned as-is (no bounds checking)."""
    codeflash_output = safe_int_tokens(-100)


def test_plain_float_whole_number():
    """Test that floats representing whole numbers are truncated to int."""
    codeflash_output = safe_int_tokens(12.0)


def test_plain_float_fractional_part():
    """Test that floats with fractional parts are truncated (not rounded)."""
    codeflash_output = safe_int_tokens(12.9)
    codeflash_output = safe_int_tokens(12.1)


def test_string_integer():
    """Test that numeric strings are parsed as integers."""
    codeflash_output = safe_int_tokens("42")
    codeflash_output = safe_int_tokens("0")


def test_string_float_notation():
    """Test that string representations of floats are parsed correctly."""
    codeflash_output = safe_int_tokens("12.0")
    codeflash_output = safe_int_tokens("12.5")


def test_string_scientific_notation():
    """Test that scientific notation strings are parsed correctly."""
    codeflash_output = safe_int_tokens("1e3")
    codeflash_output = safe_int_tokens("1.5e2")


def test_none_value():
    """Test that None returns 0."""
    codeflash_output = safe_int_tokens(None)


def test_bool_true():
    """Test that True (bool) returns 0, not 1."""
    codeflash_output = safe_int_tokens(True)


def test_bool_false():
    """Test that False (bool) returns 0."""
    codeflash_output = safe_int_tokens(False)


def test_empty_string():
    """Test that empty string returns 0."""
    codeflash_output = safe_int_tokens("")


def test_string_nan():
    """Test that the string 'NaN' returns 0."""
    codeflash_output = safe_int_tokens("NaN")


def test_string_inf():
    """Test that the string 'inf' returns 0."""
    codeflash_output = safe_int_tokens("inf")


def test_float_nan():
    """Test that math.nan (float NaN) returns 0."""
    codeflash_output = safe_int_tokens(float("nan"))


def test_float_inf():
    """Test that float infinity returns 0."""
    codeflash_output = safe_int_tokens(float("inf"))


def test_float_negative_inf():
    """Test that negative infinity returns 0."""
    codeflash_output = safe_int_tokens(float("-inf"))


def test_string_whitespace_only():
    """Test that whitespace-only strings return 0."""
    codeflash_output = safe_int_tokens("   ")
    codeflash_output = safe_int_tokens("\t")
    codeflash_output = safe_int_tokens("\n")


def test_string_leading_trailing_whitespace():
    """Test that strings with leading/trailing whitespace are handled."""
    # int() and float() in Python handle leading/trailing whitespace
    codeflash_output = safe_int_tokens("  42  ")
    codeflash_output = safe_int_tokens("  12.5  ")


def test_string_negative_number():
    """Test that negative numbers in strings are parsed correctly."""
    codeflash_output = safe_int_tokens("-100")
    codeflash_output = safe_int_tokens("-12.5")


def test_string_plus_sign():
    """Test that strings with explicit + sign are parsed."""
    codeflash_output = safe_int_tokens("+42")


def test_string_invalid_text():
    """Test that non-numeric strings return 0."""
    codeflash_output = safe_int_tokens("hello")
    codeflash_output = safe_int_tokens("12abc")
    codeflash_output = safe_int_tokens("abc12")


def test_string_mixed_separators():
    """Test that strings with invalid number formats return 0."""
    codeflash_output = safe_int_tokens("12.34.56")
    codeflash_output = safe_int_tokens("1,000")


def test_list_input():
    """Test that list inputs return 0 (not a recognized type)."""
    codeflash_output = safe_int_tokens([1, 2, 3])


def test_dict_input():
    """Test that dict inputs return 0 (not a recognized type)."""
    codeflash_output = safe_int_tokens({"key": "value"})


def test_complex_number():
    """Test that complex numbers return 0 (not a recognized type)."""
    codeflash_output = safe_int_tokens(1 + 2j)


def test_custom_object():
    """Test that custom objects return 0 (not a recognized type)."""
    class CustomClass:
        pass
    codeflash_output = safe_int_tokens(CustomClass())


def test_float_very_small():
    """Test that very small floats are truncated to 0."""
    codeflash_output = safe_int_tokens(0.001)
    codeflash_output = safe_int_tokens(0.999)


def test_float_large_number():
    """Test that large finite floats are handled correctly."""
    codeflash_output = safe_int_tokens(1e10)


def test_string_leading_zeros():
    """Test that strings with leading zeros are parsed correctly."""
    codeflash_output = safe_int_tokens("0042")
    codeflash_output = safe_int_tokens("00")


def test_string_scientific_negative_exponent():
    """Test that scientific notation with negative exponent works."""
    codeflash_output = safe_int_tokens("1e-1")  # 0.1 truncated to 0
    codeflash_output = safe_int_tokens("1e-2")  # 0.01 truncated to 0


def test_string_uppercase_scientific():
    """Test that uppercase 'E' in scientific notation works."""
    codeflash_output = safe_int_tokens("1E3")
    codeflash_output = safe_int_tokens("1.5E2")


def test_float_negative_zero():
    """Test that -0.0 is handled correctly."""
    codeflash_output = safe_int_tokens(-0.0)


def test_string_inf_case_variations():
    """Test that case variations of inf return 0."""
    codeflash_output = safe_int_tokens("INF")
    codeflash_output = safe_int_tokens("Inf")


def test_string_nan_case_variations():
    """Test that case variations of NaN return 0."""
    codeflash_output = safe_int_tokens("nan")
    codeflash_output = safe_int_tokens("NAN")


def test_string_negative_inf():
    """Test that negative infinity string returns 0."""
    codeflash_output = safe_int_tokens("-inf")


def test_bytes_input():
    """Test that bytes input returns 0 (not a recognized type)."""
    codeflash_output = safe_int_tokens(b"42")


def test_tuple_input():
    """Test that tuple input returns 0 (not a recognized type)."""
    codeflash_output = safe_int_tokens((1, 2))


def test_set_input():
    """Test that set input returns 0 (not a recognized type)."""
    codeflash_output = safe_int_tokens({1, 2, 3})


def test_large_integer_value():
    """Test that very large integers are handled correctly."""
    large_int = 10**18
    codeflash_output = safe_int_tokens(large_int)


def test_large_float_value():
    """Test that very large floats are truncated to int correctly."""
    large_float = 1.234e15
    codeflash_output = safe_int_tokens(large_float)


def test_large_integer_string():
    """Test that very large integer strings are parsed."""
    large_int_str = "999999999999999999999"
    codeflash_output = safe_int_tokens(large_int_str); result = codeflash_output


def test_many_calls_with_integers():
    """Test performance with 1000 calls using integer inputs."""
    results = []
    for i in range(1000):
        results.append(safe_int_tokens(i))


def test_many_calls_with_strings():
    """Test performance with 1000 calls using string inputs."""
    results = []
    for i in range(1000):
        results.append(safe_int_tokens(str(i)))


def test_many_calls_with_floats():
    """Test performance with 1000 calls using float inputs."""
    results = []
    for i in range(1000):
        results.append(safe_int_tokens(float(i) + 0.5))


def test_many_calls_with_mixed_types():
    """Test performance with 1000 calls using mixed input types."""
    results = []
    for i in range(1000):
        if i % 3 == 0:
            results.append(safe_int_tokens(i))
        elif i % 3 == 1:
            results.append(safe_int_tokens(str(i)))
        else:
            results.append(safe_int_tokens(float(i)))


def test_large_list_of_valid_strings():
    """Test processing a list of 1000 valid numeric strings."""
    test_strings = [str(i * 10) for i in range(1000)]
    results = [safe_int_tokens(s) for s in test_strings]


def test_large_list_of_invalid_strings():
    """Test processing a list of 1000 invalid strings (all return 0)."""
    test_strings = ["invalid_" + str(i) for i in range(1000)]
    results = [safe_int_tokens(s) for s in test_strings]


def test_large_list_of_float_strings():
    """Test processing a list of 1000 float strings."""
    test_strings = [str(i * 10) + ".5" for i in range(1000)]
    results = [safe_int_tokens(s) for s in test_strings]


def test_large_list_of_scientific_notation():
    """Test processing a list of 1000 scientific notation strings."""
    test_strings = []
    results = []
    for i in range(1, 1001):
        test_strings.append(f"{i}e1")
        results.append(safe_int_tokens(f"{i}e1"))


def test_large_list_of_negative_integers():
    """Test processing a list of 1000 negative integers."""
    results = [safe_int_tokens(-i) for i in range(1000)]


def test_stress_test_mixed_valid_invalid():
    """Stress test with 1000 mixed valid and invalid inputs."""
    test_data = []
    for i in range(1000):
        if i % 5 == 0:
            test_data.append(i)  # int
        elif i % 5 == 1:
            test_data.append(str(i))  # string int
        elif i % 5 == 2:
            test_data.append(float(i) + 0.3)  # float
        elif i % 5 == 3:
            test_data.append("invalid_" + str(i))  # invalid string
        else:
            test_data.append(None)  # None
    
    results = [safe_int_tokens(v) for v in test_data]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To test or edit this optimization locally git merge codeflash/optimize-pr11983-2026-03-02T21.12.39

Click to see suggested changes

Suggested change

	try:
	return int(value)
	except ValueError:
	try:
	parsed = float(value)
	return int(parsed) if math.isfinite(parsed) else 0
	except (ValueError, TypeError, OverflowError):
	return 0
	s = value.strip()
	if not s:
	return 0
	# Fast path for plain integer strings: avoids try/except overhead.
	s2 = s
	if s2[0] in "+-" and len(s2) > 1:
	s2 = s2[1:]
	if s2.isdigit():
	try:
	return int(s)
	except (ValueError, OverflowError):
	# Extremely rare; fall through to return 0
	return 0
	# Only attempt float parsing if the string looks like a float/scientific form.
	if ("." in s) or ("e" in s) or ("E" in s):
	try:
	parsed = float(s)
	return int(parsed) if math.isfinite(parsed) else 0
	except (ValueError, TypeError, OverflowError):
	return 0
	return 0