{"record":{"id":"9d899391465be060","repo":"deepset-ai/haystack","slug":"oversized-factor-must-be-at-least-1","errorCode":null,"errorMessage":"oversized_factor must be at least 1.","messagePattern":"oversized_factor must be at least 1\\.","errorType":"validation","errorClass":"ValueError","httpStatus":null,"severity":"error","filePath":"haystack/components/preprocessors/python_code_splitter.py","lineNumber":132,"sourceCode":"            members but not the class header are prefixed with the bare class signature\n            (decorators plus the ``class Foo(...):`` lines) in source order.\n        :param secondary_split_overlap: Line overlap for the secondary splitter; only used\n            in the oversized fallback. The primary AST split never adds overlap.\n        :param secondary_split_length: Lines per chunk for the secondary splitter.\n            Defaults to ``max_effective_lines`` when ``None``.\n        :raises ValueError: If any parameter is invalid (negative, zero where positive is\n            required, or ``min_effective_lines > max_effective_lines``).\n        \"\"\"\n        if min_effective_lines < 1:\n            raise ValueError(\"min_effective_lines must be at least 1.\")\n        if max_effective_lines < 1:\n            raise ValueError(\"max_effective_lines must be at least 1.\")\n        if min_effective_lines > max_effective_lines:\n            raise ValueError(\"min_effective_lines must not be greater than max_effective_lines.\")\n        if expected_chars_per_line < 1:\n            raise ValueError(\"expected_chars_per_line must be at least 1.\")\n        if oversized_factor < 1:\n            raise ValueError(\"oversized_factor must be at least 1.\")\n        if secondary_split_overlap < 0:\n            raise ValueError(\"secondary_split_overlap must be non-negative.\")\n        if secondary_split_length is not None and secondary_split_length < 1:\n            raise ValueError(\"secondary_split_length must be at least 1.\")\n\n        self.min_effective_lines = min_effective_lines\n        self.max_effective_lines = max_effective_lines\n        self.expected_chars_per_line = expected_chars_per_line\n        self.oversized_factor = oversized_factor\n        self.strip_docstrings = strip_docstrings\n        self.preserve_class_definition = preserve_class_definition\n        self.secondary_split_overlap = secondary_split_overlap\n        self.secondary_split_length = secondary_split_length\n\n    def _effective_lines(self, text: str) -> int:\n        \"\"\"Return the number of *effective lines* for ``text`` (see class docstring).\"\"\"\n        if not text:\n            return 0","sourceCodeStart":114,"sourceCodeEnd":150,"githubUrl":"https://github.com/deepset-ai/haystack/blob/e318778c9bf60a1963e3b5f451359655dd696c30/haystack/components/preprocessors/python_code_splitter.py#L114-L150","documentation":"PythonCodeSplitter's __init__ requires oversized_factor >= 1. This factor decides when a chunk counts as oversized (relative to the target size); a value below 1 would mark normal chunks oversized, so ValueError is raised.","triggerScenarios":"Calling PythonCodeSplitter(oversized_factor=0.5) or 0, e.g. from a fractional multiplier intended to shrink chunks or a config value expressed as a percentage (50 instead of 1.5... but <1 percentages like 0.5 fail).","commonSituations":"Confusing the factor with a percentage (0.5 for 50%), setting it to 1.0-expecting shrink behavior, or copying defaults from a different splitter whose parameter semantics differ.","solutions":["Use a factor >= 1, e.g. oversized_factor=1.5 (chunks 50% over target are oversized).","Omit the parameter to use the default.","Convert percentage configs correctly: factor = 1 + pct/100.","Validate the config value before construction: assert oversized_factor >= 1."],"exampleFix":"// before\nPythonCodeSplitter(oversized_factor=0.5)  # meant 50%\n// after\nPythonCodeSplitter(oversized_factor=1.5)  # 50% over target = oversized","handlingStrategy":"validation","validationCode":"if oversized_factor < 1:\n    oversized_factor = 1 + oversized_factor  # interpret 0.5 as 50% over\ncode_splitter = PythonCodeSplitter(oversized_factor=max(1.0, oversized_factor))","typeGuard":"def is_valid_oversized_factor(v) -> bool:\n    return isinstance(v, (int, float)) and v >= 1","tryCatchPattern":"try:\n    splitter = PythonCodeSplitter(oversized_factor=factor)\nexcept ValueError as e:\n    logging.warning(\"Invalid oversized_factor (%s), using default\", e)\n    splitter = PythonCodeSplitter()","preventionTips":["Remember the factor is a multiplier >= 1, not a percentage.","Convert percentages with factor = 1 + pct / 100.","Document the parameter semantics in your config schema and validate it."],"tags":["python","validation","constructor-argument","haystack"],"backgroundTag":"invalid-constructor-argument","analyzedSha":"e318778c9bf60a1963e3b5f451359655dd696c30","analyzedAt":"2026-08-30T11:45:20.711Z","schemaVersion":2},"datasetVersion":"2026-08-30T13:17:10.514Z"}