callowayproject__bump-my-version-180

{
  "status": "ok",
  "stdout": "bumpversion/versioning/serialization.py:10:from bumpversion.utils import key_val_string, labels_for_format\nbumpversion/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:86:    - formats that contain all required components are preferred\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:112:        labels = set(labels_for_format(pattern))\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:133:    logger.debug(\"Using serialization format '%s'\", chosen_pattern)\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:9:from bumpversion.utils import labels_for_format\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:56:        Return the order of the labels in a serialization format.\nbumpversion/version_part.py:58:        Currently, order depends on the first given serialization format.\nbumpversion/version_part.py:59:        This seems like a good idea because this should be the most complete format.\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)\nbumpversion/versioning/models.py:31:        calver_format: Optional[str] = None,\nbumpversion/versioning/models.py:40:        self.calver_format = calver_format\nbumpversion/versioning/models.py:46:        elif calver_format:\nbumpversion/versioning/models.py:47:            self.func = CalVerFunction(calver_format)\nbumpversion/versioning/models.py:65:            calver_format=self.calver_format,\nbumpversion/versioning/models.py:92:    def __format__(self, format_spec: str) -> str:\nbumpversion/versioning/models.py:98:            return int.__format__(val, format_spec)\nbumpversion/versioning/models.py:115:    \"\"\"The possible values for the component. If it and `calver_format` is None, the component is numeric.\"\"\"\nbumpversion/versioning/models.py:133:    calver_format: Optional[str] = None\nbumpversion/versioning/models.py:134:    \"\"\"The format string for a CalVer component.\"\"\"\nbumpversion/versioning/models.py:143:        \"\"\"Set always_increment to True if calver_format is present.\"\"\"\nbumpversion/versioning/models.py:144:        if isinstance(data, dict) and data.get(\"calver_format\"):\nbumpversion/versioning/models.py:156:            calver_format=self.calver_format,\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "bumpversion/versioning/models.py",
  "content": "    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.",
  "start_line": 70,
  "end_line": 120,
  "total_lines": 282,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "bumpversion/versioning/serialization.py",
  "content": "\ndef 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": 80,
  "end_line": 138,
  "total_lines": 138,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "",
  "exit_code": 0
}

{
  "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\":",
  "start_line": 1,
  "end_line": 70,
  "total_lines": 282,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "bumpversion/versioning/models.py",
  "content": "    - 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(\n            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:",
  "start_line": 120,
  "end_line": 269,
  "total_lines": 282,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "Initial version: <bumpversion.Version:major=5, minor=6, patch=0>\nBumped version: <bumpversion.Version:major=5, minor=7, patch=0>\nSerialized: 5.70.0\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Local context: {'major': '5', 'minor': '7', 'patch': '0'}\nSerialized: 5.70.0\n",
  "stderr": "",
  "exit_code": 0
}

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

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

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

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

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

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

{
  "status": "ok",
  "stdout": "'1' -> '10'\n'2' -> '20'\n'3' -> '30'\n'4' -> '40'\n'5' -> '50'\n'6' -> '60'\n'7' -> '70'\n'8' -> '80'\n'9' -> '90'\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Local context (now using components): {'major': <bumpversion.VersionPart:NumericFunction:5>, 'minor': <bumpversion.VersionPart:NumericFunction:7>, 'patch': <bumpversion.VersionPart:NumericFunction:0>}\nSerialized: 5.07.0\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": "bumpversion/versioning/models.py:281:        unique_dependents = set(chain.from_iterable(dependents.values()))\nbumpversion/versioning/serialization.py:106:    local_context.update(version.values())\nbumpversion/show.py:19:        print_info(next(iter(value.values())))\n",
  "stderr": "",
  "exit_code": 0
}