error · langchain-ai/langchain — 7,521 matches

.github/ISSUE_TEMPLATE/bug-report.yml YAML 4 matches view file →

        def bad_code(inputs) -> int:
          raise NotImplementedError('For demo purpose')
          chain = RunnableLambda(bad_code)

· · ·

  - type: textarea
    attributes:
      label: Error Message and Stack Trace (if applicable)
      description: |
        If you are reporting an error, please copy and paste the full error message and

· · ·

        If you are reporting an error, please copy and paste the full error message and
        stack trace.
        (This will be automatically formatted into code, so no need for backticks.)

· · ·

      label: Description
      description: |
        What is the problem, question, or error?
        Write a short description telling what you are doing, what you expect to happen, and what is currently happening.

.github/PULL_REQUEST_TEMPLATE.md MARKDOWN 1 matches view file →

  - Examples:
    - fix(anthropic): resolve flag parsing error
    - feat(core): add multi-tenant support
    - test(openai): update API usage tests

.github/scripts/check_diff.py PYTHON 6 matches · showing 5 view file →

        dirs = [d for d in VCR_PACKAGES if d in all_affected]
    else:
        raise ValueError(f"Unknown job: {job}")
    return [

· · ·

    Raises:
        ValueError: If a single argument looks like JSON but is not a string array.
    """
    if len(args) != 1:

· · ·

    try:
        parsed = json.loads(value)
    except json.JSONDecodeError as e:
        msg = "Expected changed files JSON to be a list of strings."
        raise ValueError(msg) from e

· · ·

        raise ValueError(msg) from e
    if not isinstance(parsed, list) or not all(

· · ·

    ):
        msg = "Expected changed files JSON to be a list of strings."
        raise ValueError(msg)
    return parsed

+ 1 more matches in this file

.github/scripts/check_extras_sync.py PYTHON 8 matches · showing 5 view file →

    Raises:
        ValueError: If the dependency string cannot be parsed.
    """
    match = _NAME_RE.match(dep)

· · ·

    if not match:
        msg = f"Cannot parse dependency: {dep!r}"
        raise ValueError(msg)
    name = match.group(1)
    rest = dep[match.end() :].strip()

· · ·

        if close == -1:
            msg = f"Unclosed extras bracket in dependency: {dep!r}"
            raise ValueError(msg)
        rest = rest[close + 1 :].strip()

· · ·

def main(pyproject_path: Path) -> int:
    """Check extras sync and return `0` on pass, `1` on mismatch or parse error."""
    with pyproject_path.open("rb") as f:
        data = tomllib.load(f)

· · ·

        try:
            name, spec = _parse_dep(dep)
        except ValueError as e:
            print(f"::error file={pyproject_path}::{e}")
            return 1

+ 3 more matches in this file

.github/scripts/check_prerelease_dependencies.py PYTHON 2 matches view file →

            if "rc" in dep_version_string:
                raise ValueError(
                    f"Dependency {dep_version} has a prerelease version. Please remove this."
                )

· · ·

                "allow-prereleases", False
            ):
                raise ValueError(
                    f"Dependency {dep_version} has allow-prereleases set to true. Please remove this."
                )

.github/scripts/get_min_versions.py PYTHON 4 matches view file →

    Raises:
        requests.exceptions.RequestException: If PyPI API request fails
        KeyError: If package not found or response format unexpected
    """
    pypi_url = f"https://pypi.org/pypi/{package_name}/json"

· · ·

            if spec_set.contains(version):
                valid_versions.append(version)
        except ValueError:
            continue

· · ·

        return version in constraints
    except Exception as e:
        print(f"Error: {e}")
        return False

· · ·

    if unresolved:
        print(
            "ERROR: no published version on PyPI satisfies the declared constraint "
            f"for: {', '.join(sorted(unresolved))}. A release likely pinned a "
            "dependency to a version that is not yet published. Release the "

.github/scripts/pr-labeler.js JAVASCRIPT 9 matches · showing 5 view file →

    raw = fs.readFileSync(configPath, 'utf8');
  } catch (e) {
    throw new Error(`Failed to read ${configPath}: ${e.message}`);
  }
  let config;

· · ·

    config = JSON.parse(raw);
  } catch (e) {
    throw new Error(`Failed to parse pr-labeler-config.json: ${e.message}`);
  }
  const required = [

· · ·

  const missing = required.filter(k => !(k in config));
  if (missing.length > 0) {
    throw new Error(`pr-labeler-config.json missing required keys: ${missing.join(', ')}`);
  }
  return config;

· · ·

function init(github, owner, repo, config, core) {
  if (!core) {
    throw new Error('init() requires a `core` parameter (e.g., from actions/github-script)');
  }
  const {

· · ·

        test = p => re.test(p);
      } else {
        throw new Error(
          `fileRules[${i}] (label: "${rule.label}") has no recognized matcher ` +
          `(expected one of: prefix, suffix, exact, pattern)`

+ 4 more matches in this file

.github/scripts/test_release_options.py PYTHON 2 matches view file →

        # PyYAML (YAML 1.1) parses the bare key `on` as boolean True
        return data[True]["workflow_dispatch"]["inputs"]["working-directory"]["options"]
    except (KeyError, TypeError) as e:
        msg = f"Could not find workflow_dispatch options in {workflow}: {e}"
        raise AssertionError(msg) from e

· · ·

        raise AssertionError(msg) from e

.github/tools/git-restore-mtime #! 25 matches · showing 5 view file →

if __name__ != "__main__":
    raise ImportError("{} should not be used as a module.".format(__name__))
import argparse

· · ·

    try:
        cwd = os.path.dirname(os.path.realpath(__file__))
        return Git(cwd=cwd, errors=False).describe().lstrip("v")
    except Git.Error:
        return "-".join((version, "unknown"))

· · ·

    except Git.Error:
        return "-".join((version, "unknown"))

· · ·

class Git:
    def __init__(self, workdir=None, gitdir=None, cwd=None, errors=True):
        self.gitcmd = ["git"]
        self.errors = errors

· · ·

        self.errors = errors
        self._proc = None
        if workdir:

+ 20 more matches in this file

.github/workflows/_compile_integration_test.yml YAML 1 matches view file →

# Validates that a package's integration tests compile without syntax or import errors.
#
# (If an integration test fails to compile, it won't run.)

.github/workflows/_refresh_model_profiles.yml YAML 5 matches view file →

            resolved="${GITHUB_WORKSPACE}/${CLI_PATH}"
            if [ ! -d "${resolved}" ]; then
              echo "::error::cli-path '${CLI_PATH}' does not exist at ${resolved}"
              exit 1
            fi

· · ·

        run: |
          echo "${PROVIDERS_JSON}" | jq -e 'type == "array" and length > 0' > /dev/null || {
            echo "::error::providers input must be a non-empty JSON array"
            exit 1
          }

· · ·

          echo "${PROVIDERS_JSON}" | jq -e 'all(has("provider") and has("data_dir"))' > /dev/null || {
            echo "::error::every entry in providers must have 'provider' and 'data_dir' keys"
            exit 1
          }

· · ·

              --provider "${provider}" \
              --data-dir "${GITHUB_WORKSPACE}/${data_dir}"; then
              echo "::error::Failed to refresh provider: ${provider}"
              failed="${failed} ${provider}"
            fi

· · ·

          done
          if [ -n "${failed}" ]; then
            echo "::error::The following providers failed:${failed}"
            exit 1
          fi

.github/workflows/_release.yml YAML 14 matches · showing 5 view file →

          import sys
          import tomllib
          import urllib.error
          import urllib.request

· · ·

          if requested_version and normalize(requested_version) != normalize(version):
              print(
                  f"::error::Requested release version {requested_version!r} does "
                  f"not match {pkg_name} pyproject.toml version {version!r}."
              )

· · ·

              with urllib.request.urlopen(url, timeout=10):
                  already_published = True
          except urllib.error.HTTPError as err:
              if err.code == 404:
                  already_published = False

· · ·

                  # Fail closed: an unexpected status means we can't verify.
                  print(
                      f"::error::PyPI returned HTTP {err.code} checking whether "
                      f"{pkg_name}=={version} exists; cannot verify, aborting."
                  )

· · ·

                  sys.exit(1)
          except urllib.error.URLError as err:
              # Fail closed: if PyPI is unreachable we must not assume the version
              # is free, or we risk re-publishing an existing release.

+ 9 more matches in this file

.github/workflows/block_fork_main_prs.yml YAML 3 matches view file →

            } catch (e) {
              if (e.status !== 404) {
                throw new Error(`getLabel(${labelName}) failed: ${e.message}`);
              }
              try {

· · ·

                const alreadyExists =
                  createErr.status === 422 &&
                  Array.isArray(createErr.errors) &&
                  createErr.errors.some(e => e.code === 'already_exists');
                if (!alreadyExists) throw createErr;

· · ·

                  createErr.errors.some(e => e.code === 'already_exists');
                if (!alreadyExists) throw createErr;
              }

.github/workflows/bump_uv_pin.yml YAML 8 matches · showing 5 view file →

          semver='^[0-9]+\.[0-9]+\.[0-9]+$'
          if [[ ! "$current" =~ $semver ]]; then
            echo "::error::Could not parse current uv pin from $action_file (got '$current')"
            exit 1
          fi

· · ·

          if [[ ! "$latest" =~ $semver ]]; then
            echo "::error::Unexpected uv tag from GitHub API (got '$latest')"
            exit 1
          fi

· · ·

          action_file=".github/actions/uv_setup/action.yml"
          # `grep -c` returns 1 on no-match and 2 on read errors. We want
          # "no match" surfaced as the explicit count-of-zero check below;
          # read errors must abort. Capture the exit code separately so

· · ·

          # read errors must abort. Capture the exit code separately so
          # `set -e` doesn't swallow either case.
          set +e

· · ·

          set -e
          if [ "$before_rc" -gt 1 ]; then
            echo "::error::grep read error on $action_file (exit=$before_rc)"
            exit 1
          fi

+ 3 more matches in this file

.github/workflows/check_extras_sync.yml YAML 3 matches view file →

          )
          if [ ${#files[@]} -eq 0 ]; then
            echo "::error::No pyproject.toml files found under libs/"
            exit 1
          fi

· · ·

          done
          if [ ${#failed[@]} -gt 0 ]; then
            echo "::error::Extras-sync check failed for ${#failed[@]} package(s):"
            printf '::error::  %s\n' "${failed[@]}"
            exit 1

· · ·

            printf '::error::  %s\n' "${failed[@]}"
            exit 1
          fi

.github/workflows/check_release_deps.yml YAML 7 matches · showing 5 view file →

                      # New manifest: absent at the base ref, so not a version bump.
                      continue
                  print(f"::error file={manifest}::failed to read base manifest: {stderr}")
                  sys.exit(1)
              base = project_table(shown.stdout)

· · ·

          project = data.get("project")
          if project is None:
              print(f"::error file={manifest_path}::no [project] table to resolve")
              sys.exit(1)

· · ·

            else
              # Surface the resolver's reason (stdout+stderr were captured) and tell a
              # likely-transient index/network error apart from a genuinely bad pin.
              cat "$filtered_dir/compile.log"
              if grep -qiE 'error sending request|failed to fetch|error trying to connect|connection|timed out|temporarily unavailable|status code (429|50[0-9])' "$filtered_dir/compile.log"; then

· · ·

              if grep -qiE 'error sending request|failed to fetch|error trying to connect|connection|timed out|temporarily unavailable|status code (429|50[0-9])' "$filtered_dir/compile.log"; then
                echo "❌ ${pkg_dir}: resolver hit a possible transient PyPI/index error"
                transient=1

· · ·

                echo "❌ ${pkg_dir}: resolver hit a possible transient PyPI/index error"
                transient=1
              else

+ 2 more matches in this file

.github/workflows/check_versions.yml YAML 1 matches view file →

              # in sync with pyproject.toml. Don't let it pass unchecked.
              echo "--- $dir ---"
              echo "Error: $dir has a _version.py but no 'check_version' Makefile target"
              FAILED=1
            fi

.github/workflows/pr_labeler.yml YAML 1 matches view file →

        run: |
          if [ -z "${{ steps.app-token.outputs.token }}" ]; then
            echo "::error::GitHub App token generation failed — cannot classify contributor"
            exit 1
          fi

.github/workflows/pr_lint.yml YAML 2 matches view file →

# Examples:
#     feat(core): add multi‐tenant support
#     fix(langchain): resolve error
#     docs: update API usage examples
#     docs(openai): update API usage examples

· · ·

        run: |
          if [[ "$PR_TITLE" =~ ^[a-z]+\(\)[!]?: ]]; then
            echo "::error::PR title has empty scope parentheses: '$PR_TITLE'"
            echo "Either remove the parentheses or provide a scope (e.g., 'fix(core): ...')."
            exit 1

.github/workflows/pr_lint_trailer.yml YAML 2 matches view file →

            // Comment write paths can fail for several reasons that should not
            // turn this advisory job red on its own: fork PRs run with
            // restricted tokens, secondary rate limits, transient API errors.
            // Fall back to `core.summary` so a maintainer can paste the
            // remediation manually. The check still fails — `setFailed` is

· · ·

                }
              } catch (commentErr) {
                core.warning(`Could not post sticky comment (fork PR token, rate limit, or transient API error): ${commentErr.message}`);
                await core.summary
                  .addHeading(summaryHeading)

.github/workflows/reopen_on_assignment.yml YAML 2 matches view file →

              }));
            } catch (e) {
              throw new Error(
                `Failed to search for closed PRs to reopen after assigning ${assignee} ` +
                `to #${issueNumber} (HTTP ${e.status ?? 'unknown'}): ${e.message}`,

· · ·

                  continue;
                }
                // Transient errors (rate limit, 5xx) should fail the job so
                // the label is NOT removed and the run can be retried.
                throw e;

.github/workflows/require_issue_link.yml YAML 9 matches · showing 5 view file →

              const sender = context.payload.sender?.login;
              if (!sender) {
                throw new Error('Event has no sender — cannot check permissions');
              }
              try {

· · ·

                }
                const status = e.status ?? 'unknown';
                throw new Error(
                  `Permission check failed for ${sender} (HTTP ${status}): ${e.message}`,
                );

· · ·

                  console.log(`PR author "${prAuthor}" is NOT assigned to #${num} (assignees: ${assignees.join(', ') || 'none'})`);
                }
              } catch (error) {
                if (error.status === 404) {
                  console.log(`Issue #${num} not found — skipping`);

· · ·

                if (error.status === 404) {
                  console.log(`Issue #${num} not found — skipping`);
                } else {

· · ·

                  // Non-404 errors (rate limit, server error) must not be
                  // silently skipped — they could cause false enforcement
                  // (closing a legitimate PR whose assignment can't be verified).

+ 4 more matches in this file

AGENTS.md MARKDOWN 4 matches view file →

- [ ] Tests fail when your new logic is broken
- [ ] Happy path is covered
- [ ] Edge cases and error conditions are tested
- [ ] Use fixtures/mocks for external dependencies
- [ ] Tests are deterministic (no flaky tests)

· · ·

- No `eval()`, `exec()`, or `pickle` on user-controlled input
- Proper exception handling (no bare `except:`) and use a `msg` variable for error messages
- Remove unreachable/commented code before committing
- Race conditions or resource leaks (file handles, sockets, threads).

· · ·

    Raises:
        InvalidEmailError: If the email address format is invalid.
        SMTPConnectionError: If unable to connect to email server.
    """

· · ·

        SMTPConnectionError: If unable to connect to email server.
    """
```

CLAUDE.md MARKDOWN 4 matches view file →

- [ ] Tests fail when your new logic is broken
- [ ] Happy path is covered
- [ ] Edge cases and error conditions are tested
- [ ] Use fixtures/mocks for external dependencies
- [ ] Tests are deterministic (no flaky tests)

· · ·

- No `eval()`, `exec()`, or `pickle` on user-controlled input
- Proper exception handling (no bare `except:`) and use a `msg` variable for error messages
- Remove unreachable/commented code before committing
- Race conditions or resource leaks (file handles, sockets, threads).

· · ·

    Raises:
        InvalidEmailError: If the email address format is invalid.
        SMTPConnectionError: If unable to connect to email server.
    """

· · ·

        SMTPConnectionError: If unable to connect to email server.
    """
```

libs/core/langchain_core/_api/__init__.py PYTHON 1 matches view file →

    Raises:
        AttributeError: If the attribute is not a valid dynamic import.
    """
    module_name = _dynamic_imports.get(attr_name)

`auth login`	both terms (AND is implicit)
`auth OR login`	either term
`NOT path:vendor`	exclude matches
`"exact phrase"`	quoted exact match
`/func\s+Test/`	regex
`handler~1`	fuzzy (Levenshtein 1)
`file:*_test.go`	filename glob
`path:pkg/auth/**`	full path glob
`lang:go`	language filter

Search any public repo from your terminal