callowayproject__bump-my-version-180

{
  "status": "ok",
  "stdout": "bumpversion/versioning/serialization.py:81:def serialize(version: Version, serialize_patterns: List[str], context: MutableMapping) -> str:\nbumpversion/versioning/serialization.py:83:    Attempts to serialize a version with the given serialization format.\nbumpversion/versioning/serialization.py:92:        version: The version to serialize\nbumpversion/versioning/serialization.py:93:        serialize_patterns: The serialization format to use, using Python's format string syntax\nbumpversion/versioning/serialization.py:100:        The serialized version as a string\nbumpversion/versioning/serialization.py:111:    for index, pattern in enumerate(serialize_patterns):\nbumpversion/versioning/serialization.py:130:        raise FormattingError(f\"Could not find a valid serialization format in {serialize_patterns!r} for {version!r}\")\nbumpversion/versioning/serialization.py:134:    serialized = chosen_pattern.format(**local_context)\nbumpversion/versioning/serialization.py:135:    logger.debug(\"Serialized to '%s'\", serialized)\nbumpversion/versioning/serialization.py:138:    return serialized\nbumpversion/version_part.py:11:from bumpversion.versioning.serialization import parse_version, serialize\nbumpversion/version_part.py:24:        serialize: Tuple[str],\nbumpversion/version_part.py:34:        self.serialize_formats = serialize\nbumpversion/version_part.py:42:        return f\"<bumpversion.VersionConfig:{self.parse_regex.pattern}:{self.serialize_formats}>\"\nbumpversion/version_part.py:47:            and self.serialize_formats == other.serialize_formats\nbumpversion/version_part.py:64:        return labels_for_format(self.serialize_formats[0])\nbumpversion/version_part.py:85:    def serialize(self, version: Version, context: MutableMapping) -> str:\nbumpversion/version_part.py:90:            version: The version to serialize\nbumpversion/version_part.py:94:            The serialized version as a string\nbumpversion/version_part.py:96:        return serialize(version, list(self.serialize_formats), context)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "error",
  "error_type": "FileReadError",
  "error_message": "404 Client Error for http+docker://localhost/v1.52/containers/751619edda9a19748cdb0c8d676520e8880297c7d915f26f349c666fab595727/archive?path=%2Fworkspace%2Fbumpversion%2Fversioning%2Fserialization.py%60%2Cstart_line%3A81%2Cend_line%3A140: Not Found (\"Could not find the file /workspace/bumpversion/versioning/serialization.py`,start_line:81,end_line:140 in container 751619edda9a19748cdb0c8d676520e8880297c7d915f26f349c666fab595727\")"
}

{
  "status": "ok",
  "filepath": "bumpversion/versioning/serialization.py",
  "content": "def serialize(version: Version, serialize_patterns: List[str], context: MutableMapping) -> str:\n    \"\"\"\n    Attempts to serialize a version with the given serialization format.\n\n    - valid serialization patterns are those that are renderable with the given context\n    - formats that contain all required components are preferred\n    - the shortest valid serialization pattern is used\n    - if two patterns are equally short, the first one is used\n    - if no valid serialization pattern is found, an error is raised\n\n    Args:\n        version: The version to serialize\n        serialize_patterns: The serialization format to use, using Python's format string syntax\n        context: The context to use when serializing the version\n\n    Raises:\n        FormattingError: if a serialization pattern\n\n    Returns:\n        The serialized version as a string\n    \"\"\"\n    logger.debug(\"Serializing version '%s'\", version)\n    logger.indent()\n\n    local_context = copy(context)\n    local_context.update(version.values())\n    local_context_keys = set(local_context.keys())\n    required_component_labels = set(version.required_components())\n\n    patterns = []\n    for index, pattern in enumerate(serialize_patterns):\n        labels = set(labels_for_format(pattern))\n        patterns.append(\n            {\n                \"pattern\": pattern,\n                \"labels\": labels,\n                \"order\": index,\n                \"num_labels\": len(labels),\n                \"renderable\": local_context_keys >= labels,\n                \"has_required_components\": required_component_labels <= labels,\n            }\n        )\n\n    valid_patterns = filter(itemgetter(\"renderable\"), patterns)\n    sorted_patterns = multisort(\n        list(valid_patterns), ((\"has_required_components\", True), (\"num_labels\", False), (\"order\", False))\n    )\n\n    if not sorted_patterns:\n        raise FormattingError(f\"Could not find a valid serialization format in {serialize_patterns!r} for {version!r}\")\n\n    chosen_pattern = sorted_patterns[0][\"pattern\"]\n    logger.debug(\"Using serialization format '%s'\", chosen_pattern)\n    serialized = chosen_pattern.format(**local_context)\n    logger.debug(\"Serialized to '%s'\", serialized)\n    logger.dedent()\n\n    return serialized",
  "start_line": 81,
  "end_line": 138,
  "total_lines": 138,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "bumpversion/versioning/models.py",
  "content": "\"\"\"Models for managing versioning of software projects.\"\"\"\n\nfrom __future__ import annotations\n\nfrom collections import defaultdict, deque\nfrom itertools import chain\nfrom typing import Any, Dict, List, Optional, Tuple, Union\n\nfrom pydantic import BaseModel, model_validator\n\nfrom bumpversion.exceptions import InvalidVersionPartError\nfrom bumpversion.utils import key_val_string\nfrom bumpversion.versioning.functions import CalVerFunction, NumericFunction, PartFunction, ValuesFunction\n\n\nclass VersionComponent:\n    \"\"\"\n    Represent part of a version number.\n\n    Determines the PartFunction that rules how the part behaves when increased or reset\n    based on the configuration given.\n    \"\"\"\n\n    def __init__(\n        self,\n        values: Optional[list] = None,\n        optional_value: Optional[str] = None,\n        first_value: Union[str, int, None] = None,\n        independent: bool = False,\n        always_increment: bool = False,\n        calver_format: Optional[str] = None,\n        source: Optional[str] = None,\n        value: Union[str, int, None] = None,\n    ):\n        self._value = str(value) if value is not None else None\n        self.func: Optional[PartFunction] = None\n        self.always_increment = always_increment\n        self.independent = True if always_increment else independent\n        self.source = source\n        self.calver_format = calver_format\n        if values:\n            str_values = [str(v) for v in values]\n            str_optional_value = str(optional_value) if optional_value is not None else None\n            str_first_value = str(first_value) if first_value is not None else None\n            self.func = ValuesFunction(str_values, str_optional_value, str_first_value)\n        elif calver_format:\n            self.func = CalVerFunction(calver_format)\n            self._value = self._value or self.func.first_value\n        else:\n            self.func = NumericFunction(optional_value, first_value or \"0\")\n\n    @property\n    def value(self) -> str:\n        \"\"\"Return the value of the part.\"\"\"\n        return self._value or self.func.optional_value\n\n    def copy(self) -> \"VersionComponent\":\n        \"\"\"Return a copy of the part.\"\"\"\n        return VersionComponent(\n            values=getattr(self.func, \"_values\", None),\n            optional_value=self.func.optional_value,\n            first_value=self.func.first_value,\n            independent=self.independent,\n            always_increment=self.always_increment,\n            calver_format=self.calver_format,\n            source=self.source,\n            value=self._value,\n        )\n\n    def bump(self) -> \"VersionComponent\":\n        \"\"\"Return a part with bumped value.\"\"\"\n        new_component = self.copy()\n        new_component._value = self.func.bump(self.value)\n        return new_component\n\n    def null(self) -> \"VersionComponent\":\n        \"\"\"Return a part with first value.\"\"\"\n        new_component = self.copy()\n        new_component._value = self.func.first_value\n        return new_component\n\n    @property\n    def is_optional(self) -> bool:\n        \"\"\"Is the part optional?\"\"\"\n        return self.value == self.func.optional_value\n\n    @property\n    def is_independent(self) -> bool:\n        \"\"\"Is the part independent of the other parts?\"\"\"\n        return self.independent\n\n    def __format__(self, format_spec: str) -> str:\n        try:\n            val = int(self.value)\n        except ValueError:\n            return self.value\n        else:\n            return int.__format__(val, format_spec)\n\n    def __repr__(self) -> str:\n        return f\"<bumpversion.VersionPart:{self.func.__class__.__name__}:{self.value}>\"\n\n    def __eq__(self, other: Any) -> bool:\n        return self.value == other.value if isinstance(other, VersionComponent) else False\n\n\nclass VersionComponentSpec(BaseModel):\n    \"\"\"\n    Configuration of a version component.\n\n    This is used to read in the configuration from the bumpversion config file.\n    \"\"\"\n\n    values: Optional[list] = None\n    \"\"\"The possible values for the component. If it and `calver_format` is None, the component is numeric.\"\"\"\n\n    optional_value: Optional[str] = None  # Optional.\n    \"\"\"The value that is optional to include in the version.\n\n    - Defaults to first value in values or 0 in the case of numeric.\n    - Empty string means nothing is optional.\n    - CalVer components ignore this.\"\"\"\n\n    first_value: Union[str, int, None] = None\n    \"\"\"The first value to increment from.\"\"\"\n\n    independent: bool = False\n    \"\"\"Is the component independent of the other components?\"\"\"\n\n    always_increment: bool = False\n    \"\"\"Should the component always increment, even if it is not necessary?\"\"\"\n\n    calver_format: Optional[str] = None\n    \"\"\"The format string for a CalVer component.\"\"\"\n\n    # source: Optional[str] = None  # Name of environment variable or context variable to use as the source for value\n    depends_on: Optional[str] = None\n    \"\"\"The name of the component this component depends on.\"\"\"\n\n    @model_validator(mode=\"before\")\n    @classmethod\n    def set_always_increment_with_calver(cls, data: Any) -> Any:\n        \"\"\"Set always_increment to True if calver_format is present.\"\"\"\n        if isinstance(data, dict) and data.get(\"calver_format\"):\n            data[\"always_increment\"] = True\n        return data\n\n    def create_component(self, value: Union[str, int, None] = None) -> VersionComponent:\n        \"\"\"Generate a version component from the configuration.\"\"\"\n        return VersionComponent(",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 282,
  "is_truncated": true
}

{
  "status": "error",
  "error_type": "FileReadError",
  "error_message": "404 Client Error for http+docker://localhost/v1.52/containers/751619edda9a19748cdb0c8d676520e8880297c7d915f26f349c666fab595727/archive?path=%2Fworkspace%2Fbumpversion%2Fversioning%2Fmodels.py%60%2Cstart_line%3A151: Not Found (\"Could not find the file /workspace/bumpversion/versioning/models.py`,start_line:151 in container 751619edda9a19748cdb0c8d676520e8880297c7d915f26f349c666fab595727\")"
}

{
  "status": "ok",
  "filepath": "bumpversion/versioning/models.py",
  "content": "            values=self.values,\n            optional_value=self.optional_value,\n            first_value=self.first_value,\n            independent=self.independent,\n            always_increment=self.always_increment,\n            calver_format=self.calver_format,\n            # source=self.source,\n            value=value,\n        )\n\n\nclass VersionSpec:\n    \"\"\"The specification of a version's components and their relationships.\"\"\"\n\n    def __init__(self, components: Dict[str, VersionComponentSpec], order: Optional[List[str]] = None):\n        if not components:\n            raise ValueError(\"A VersionSpec must have at least one component.\")\n        if not order:\n            order = list(components.keys())\n        if len(set(order) - set(components.keys())) > 0:\n            raise ValueError(\"The order of components refers to items that are not in your components.\")\n\n        self.component_configs = components\n        self.order = order\n        self.dependency_map = defaultdict(list)\n        previous_component = self.order[0]\n        self.always_increment = [name for name, config in self.component_configs.items() if config.always_increment]\n        for component in self.order[1:]:\n            if self.component_configs[component].independent:\n                continue\n            elif self.component_configs[component].depends_on:\n                self.dependency_map[self.component_configs[component].depends_on].append(component)\n            else:\n                self.dependency_map[previous_component].append(component)\n            previous_component = component\n\n    def create_version(self, values: Dict[str, str]) -> \"Version\":\n        \"\"\"Generate a version from the given values.\"\"\"\n        components = {\n            key: comp_config.create_component(value=values.get(key))\n            for key, comp_config in self.component_configs.items()\n        }\n        return Version(version_spec=self, components=components)\n\n    def get_dependents(self, component_name: str) -> List[str]:\n        \"\"\"Return the parts that depend on the given part.\"\"\"\n        stack = deque(self.dependency_map.get(component_name, []), maxlen=len(self.order))\n        visited = []\n\n        while stack:\n            e = stack.pop()\n            if e not in visited:\n                visited.append(e)\n                stack.extendleft(self.dependency_map[e])\n\n        return visited\n\n\nclass Version:\n    \"\"\"The specification of a version and its parts.\"\"\"\n\n    def __init__(\n        self, version_spec: VersionSpec, components: Dict[str, VersionComponent], original: Optional[str] = None\n    ):\n        self.version_spec = version_spec\n        self.components = components\n        self.original = original\n\n    def values(self) -> Dict[str, str]:\n        \"\"\"Return the values of the parts.\"\"\"\n        return {key: value.value for key, value in self.components.items()}\n\n    def __getitem__(self, key: str) -> VersionComponent:\n        return self.components[key]\n\n    def __len__(self) -> int:\n        return len(self.components)\n\n    def __iter__(self):\n        return iter(self.components)\n\n    def __repr__(self):\n        return f\"<bumpversion.Version:{key_val_string(self.components)}>\"\n\n    def __eq__(self, other: Any) -> bool:\n        return (\n            all(value == other.components[key] for key, value in self.components.items())\n            if isinstance(other, Version)\n            else False\n        )\n\n    def required_components(self) -> List[str]:\n        \"\"\"Return the names of the parts that are required.\"\"\"\n        return [key for key, value in self.components.items() if value.value != value.func.optional_value]\n\n    def bump(self, component_name: str) -> \"Version\":\n        \"\"\"Increase the value of the specified component, reset its dependents, and return a new Version.\"\"\"\n        if component_name not in self.components:\n            raise InvalidVersionPartError(f\"No part named {component_name!r}\")\n\n        new_values = dict(self.components.items())\n        always_incr_values, components_to_reset = self._always_increment()\n        new_values.update(always_incr_values)\n\n        if component_name not in components_to_reset:\n            new_values[component_name] = self.components[component_name].bump()\n            components_to_reset |= set(self.version_spec.get_dependents(component_name))\n\n        for component in components_to_reset:\n            if not self.components[component].is_independent:\n                new_values[component] = self.components[component].null()\n\n        return Version(self.version_spec, new_values, self.original)\n\n    def _always_incr_dependencies(self) -> dict:\n        \"\"\"Return the components that always increment and depend on the given component.\"\"\"\n        return {name: self.version_spec.get_dependents(name) for name in self.version_spec.always_increment}\n\n    def _increment_always_incr(self) -> dict:\n        \"\"\"Increase the values of the components that always increment.\"\"\"\n        components = self.version_spec.always_increment\n        return {name: self.components[name].bump() for name in components}\n\n    def _always_increment(self) -> Tuple[dict, set]:\n        \"\"\"Return the components that always increment and their dependents.\"\"\"\n        values = self._increment_always_incr()\n        dependents = self._always_incr_dependencies()\n        for component_name, value in values.items():\n            if value == self.components[component_name]:\n                dependents.pop(component_name, None)\n        unique_dependents = set(chain.from_iterable(dependents.values()))\n        return values, unique_dependents",
  "start_line": 151,
  "end_line": 282,
  "total_lines": 282,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "bumpversion/versioning/serialization.py:106:    local_context.update(version.values())\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "bumpversion/versioning/serialization.py:106:    local_context.update(version.values())\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Current: 5.06.0\nBumped: 5.70.0\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "59:class NumericFunction(PartFunction):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "error",
  "error_type": "FileReadError",
  "error_message": "404 Client Error for http+docker://localhost/v1.52/containers/751619edda9a19748cdb0c8d676520e8880297c7d915f26f349c666fab595727/archive?path=%2Fworkspace%2Fbumpversion%2Fversioning%2Ffunctions.py%60%2Cstart_line%3D59: Not Found (\"Could not find the file /workspace/bumpversion/versioning/functions.py`,start_line=59 in container 751619edda9a19748cdb0c8d676520e8880297c7d915f26f349c666fab595727\")"
}

{
  "status": "ok",
  "filepath": "bumpversion/versioning/functions.py",
  "content": "class NumericFunction(PartFunction):\n    \"\"\"\n    This is a class that provides a numeric function for version parts.\n\n    It simply starts with the provided first_value (0 by default) and\n    increases it following the sequence of integer numbers.\n\n    The optional value of this function is equal to the first value.\n\n    This function also supports alphanumeric parts, altering just the numeric\n    part (e.g. 'r3' --> 'r4'). Only the first numeric group found in the part is\n    considered (e.g. 'r3-001' --> 'r4-001').\n    \"\"\"\n\n    FIRST_NUMERIC = re.compile(r\"(?P<prefix>[^-0-9]*)(?P<number>-?\\d+)(?P<suffix>.*)\")\n\n    def __init__(self, optional_value: Union[str, int, None] = None, first_value: Union[str, int, None] = None):\n        if first_value is not None and not self.FIRST_NUMERIC.search(str(first_value)):\n            raise ValueError(f\"The given first value {first_value} does not contain any digit\")\n\n        self.first_value = str(first_value or 0)\n        self.optional_value = str(optional_value or self.first_value)\n        self.independent = False\n        self.always_increment = False\n\n    def bump(self, value: Union[str, int]) -> str:\n        \"\"\"Increase the first numerical value by one.\"\"\"\n        match = self.FIRST_NUMERIC.search(str(value))\n        if not match:\n            raise ValueError(f\"The given value {value} does not contain any digit\")\n\n        part_prefix, part_numeric, part_suffix = match.groups()\n\n        if int(part_numeric) < int(self.first_value):\n            raise ValueError(\n                f\"The given value {value} is lower than the first value {self.first_value} and cannot be bumped.\"\n            )\n\n        bumped_numeric = int(part_numeric) + 1\n\n        return \"\".join([part_prefix, str(bumped_numeric), part_suffix])\n",
  "start_line": 59,
  "end_line": 100,
  "total_lines": 151,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "70\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Python 3.10.19\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "70\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "700\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "7 \n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "10\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "  File \"<stdin>\", line 22\n    from collections importnamedtuple\n                     ^^^^^^^^^^^^^^^^\nSyntaxError: invalid syntax\n",
  "details": {
    "stdout": "",
    "stderr": "  File \"<stdin>\", line 22\n    from collections importnamedtuple\n                     ^^^^^^^^^^^^^^^^\nSyntaxError: invalid syntax\n",
    "exit_code": 1
  }
}