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/cli.py:48:                \"--serialize\",\nbumpversion/cli.py:124:    \"--serialize\",\nbumpversion/cli.py:235:    serialize: Optional[List[str]],\nbumpversion/cli.py:257:    Valid values include those given in the `--serialize` / `--parse` option.\nbumpversion/cli.py:271:        serialize=serialize or None,\nbumpversion/cli.py:398:    \"--serialize\",\nbumpversion/cli.py:461:    serialize: Optional[List[str]],\nbumpversion/cli.py:486:        serialize=serialize or None,\nbumpversion/utils.py:37:def labels_for_format(serialize_format: str) -> List[str]:\nbumpversion/utils.py:38:    \"\"\"Return a list of labels for the given serialize_format.\"\"\"\nbumpversion/utils.py:39:    return [item[1] for item in string.Formatter().parse(serialize_format) if item[1]]\nbumpversion/config/files_legacy.py:52:            serialize = bumpversion_options.get(\"serialize\", [])\nbumpversion/config/files_legacy.py:55:            if not isinstance(serialize, list):\nbumpversion/config/files_legacy.py:56:                bumpversion_options[\"serialize\"] = [serialize]\nbumpversion/config/files_legacy.py:96:        current_version: The serialized current version.\nbumpversion/config/files_legacy.py:97:        new_version: The serialized new version.\nbumpversion/config/models.py:28:    serialize: tuple\nbumpversion/config/models.py:83:    serialize: tuple = Field(min_length=1)\nbumpversion/config/models.py:116:                    serialize=self.serialize,\nbumpversion/config/models.py:167:        return VersionConfig(self.parse, self.serialize, self.search, self.replace, self.parts)\nbumpversion/config/utils.py:17:        \"serialize\": config_dict[\"serialize\"],\nbumpversion/config/__init__.py:20:    \"serialize\": (\"{major}.{minor}.{patch}\",),\nbumpversion/config/files.py:145:        serialize=config.serialize,\nbumpversion/bump.py:83:    next_version_str = config.version_config.serialize(next_version, ctx)\nbumpversion/show.py:120:        next_version_str = config.version_config.serialize(next_version, ctx)\nbumpversion/visualize.py:129:            next_version_str = config.version_config.serialize(next_version, get_context(config))\nbumpversion/files.py:84:            serialize=file_change.serialize or version_config.serialize_formats,\nbumpversion/files.py:96:            self.file_change.serialize,\nbumpversion/files.py:188:        context[\"current_version\"] = self.version_config.serialize(current_version, context)\nbumpversion/files.py:193:            context[\"new_version\"] = self.version_config.serialize(new_version, context)\nbumpversion/files.py:279:            serialize=file_change.serialize or version_config.serialize_formats,\nbumpversion/files.py:291:            self.file_change.serialize,\nbumpversion/files.py:317:            self.file_change.serialize,\nbumpversion/files.py:330:        new_context[\"current_version\"] = self.version_config.serialize(current_version, context)\nbumpversion/files.py:331:        new_context[\"new_version\"] = self.version_config.serialize(new_version, context)\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),",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "bumpversion/versioning/serialization.py",
  "content": "\"\"\"Functions for serializing and deserializing version objects.\"\"\"\n\nimport re\nfrom copy import copy\nfrom operator import itemgetter\nfrom typing import Dict, List, MutableMapping\n\nfrom bumpversion.exceptions import BumpVersionError, FormattingError\nfrom bumpversion.ui import get_indented_logger\nfrom bumpversion.utils import key_val_string, labels_for_format\nfrom bumpversion.versioning.models import Version\n\nlogger = get_indented_logger(__name__)\n\n\ndef parse_version(version_string: str, parse_pattern: str) -> Dict[str, str]:\n    \"\"\"\n    Parse a version string into a dictionary of the parts and values using a regular expression.\n\n    Args:\n        version_string: Version string to parse\n        parse_pattern: The regular expression pattern to use for parsing\n\n    Returns:\n        A dictionary of version part labels and their values, or an empty dictionary\n        if the version string doesn't match.\n\n    Raises:\n        BumpVersionError: If the parse_pattern is not a valid regular expression\n    \"\"\"\n    if not version_string:\n        logger.debug(\"Version string is empty, returning empty dict\")\n        return {}\n    elif not parse_pattern:\n        logger.debug(\"Parse pattern is empty, returning empty dict\")\n        return {}\n\n    logger.debug(\"Parsing version '%s' using regexp '%s'\", version_string, parse_pattern)\n    logger.indent()\n\n    try:\n        pattern = re.compile(parse_pattern, re.VERBOSE)\n    except re.error as e:\n        raise BumpVersionError(f\"'{parse_pattern}' is not a valid regular expression.\") from e\n\n    match = re.search(pattern, version_string)\n\n    if not match:\n        logger.debug(\n            \"'%s' does not parse current version '%s'\",\n            parse_pattern,\n            version_string,\n        )\n        return {}\n\n    parsed = match.groupdict(default=\"\")\n    logger.debug(\"Parsed the following values: %s\", key_val_string(parsed))\n    logger.dedent()\n\n    return parsed\n\n\ndef multisort(xs: list, specs: tuple) -> list:\n    \"\"\"\n    Sort a list of dictionaries by multiple keys.\n\n    From https://docs.python.org/3/howto/sorting.html#sort-stability-and-complex-sorts\n\n    Args:\n        xs: The list of dictionaries to sort\n        specs: A tuple of (key, reverse) pairs\n\n    Returns:\n        The sorted list\n    \"\"\"\n    for key, reverse in reversed(specs):\n        xs.sort(key=itemgetter(key), reverse=reverse)\n    return xs\n\n\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": 1,
  "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": "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",
  "filepath": "bumpversion/versioning/functions.py",
  "content": "\"\"\"Generators for version parts.\"\"\"\n\nimport datetime\nimport re\nfrom typing import List, Optional, Union\n\nfrom bumpversion.context import get_datetime_info\n\n\nclass PartFunction:\n    \"\"\"Base class for a version part function.\"\"\"\n\n    first_value: str\n    optional_value: str\n    independent: bool\n    always_increment: bool\n\n    def bump(self, value: str) -> str:\n        \"\"\"Increase the value.\"\"\"\n        raise NotImplementedError\n\n\nclass IndependentFunction(PartFunction):\n    \"\"\"\n    This is a class that provides an independent function for version parts.\n\n    It simply returns the optional value, which is equal to the first value.\n    \"\"\"\n\n    def __init__(self, value: Union[str, int, None] = None):\n        if value is None:\n            value = \"\"\n        self.first_value = str(value)\n        self.optional_value = str(value)\n        self.independent = True\n        self.always_increment = False\n\n    def bump(self, value: Optional[str] = None) -> str:\n        \"\"\"Return the optional value.\"\"\"\n        return value or self.optional_value\n\n\nclass CalVerFunction(PartFunction):\n    \"\"\"This is a class that provides a CalVer function for version parts.\"\"\"\n\n    def __init__(self, calver_format: str):\n        self.independent = False\n        self.calver_format = calver_format\n        self.first_value = self.bump()\n        self.optional_value = \"There isn't an optional value for CalVer.\"\n        self.independent = False\n        self.always_increment = True\n\n    def bump(self, value: Optional[str] = None) -> str:\n        \"\"\"Return the optional value.\"\"\"\n        return self.calver_format.format(**get_datetime_info(datetime.datetime.now()))\n\n\nclass 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\n\nclass ValuesFunction(PartFunction):\n    \"\"\"\n    This is a class that provides a values list based function for version parts.\n\n    It is initialized with a list of values and iterates through them when\n    bumping the part.\n\n    The default optional value of this function is equal to the first value,\n    but may be otherwise specified.\n\n    When trying to bump a part which has already the maximum value in the list\n    you get a ValueError exception.\n    \"\"\"\n\n    def __init__(\n        self,\n        values: List[str],\n        optional_value: Optional[str] = None,\n        first_value: Optional[str] = None,\n    ):\n        if not values:\n            raise ValueError(\"Version part values cannot be empty\")\n\n        self._values = values\n        self.independent = False\n\n        if optional_value is None:\n            optional_value = values[0]\n\n        if optional_value not in values:\n            raise ValueError(f\"Optional value {optional_value} must be included in values {values}\")\n\n        self.optional_value = optional_value\n\n        if not first_value:\n            first_value = values[0]\n\n        if first_value not in values:\n            raise ValueError(f\"First value {first_value} must be included in values {values}\")\n\n        self.first_value = first_value\n\n    def bump(self, value: str) -> str:\n        \"\"\"Return the item after ``value`` in the list.\"\"\"\n        try:\n            return self._values[self._values.index(value) + 1]\n        except IndexError as e:\n            raise ValueError(\n                f\"The part has already the maximum value among {self._values} and cannot be bumped.\"",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 151,
  "is_truncated": true
}

{
  "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
}

{
  "status": "ok",
  "filepath": "bumpversion/show.py",
  "content": "\"\"\"Functions for displaying information about the version.\"\"\"\n\nimport dataclasses\nfrom io import StringIO\nfrom pprint import pprint\nfrom typing import Any, Optional\n\nfrom bumpversion.bump import get_next_version\nfrom bumpversion.config import Config\nfrom bumpversion.context import get_context\nfrom bumpversion.exceptions import BadInputError\nfrom bumpversion.ui import print_error, print_info\nfrom bumpversion.utils import recursive_sort_dict\n\n\ndef output_default(value: dict) -> None:\n    \"\"\"Output the value with key=value or just value if there is only one item.\"\"\"\n    if len(value) == 1:\n        print_info(next(iter(value.values())))\n    else:\n        buffer = StringIO()\n        pprint(value, stream=buffer, sort_dicts=True)  # noqa: T203\n        print_info(buffer.getvalue())\n\n\ndef output_yaml(value: dict) -> None:\n    \"\"\"Output the value as yaml.\"\"\"\n    from bumpversion.yaml_dump import dump\n\n    print_info(dump(recursive_sort_dict(value)))\n\n\ndef output_json(value: dict) -> None:\n    \"\"\"Output the value as json.\"\"\"\n    import json\n\n    def default_encoder(obj: Any) -> str:\n        if dataclasses.is_dataclass(obj):\n            return str(obj)\n        elif isinstance(obj, type):\n            return obj.__name__\n        raise TypeError(f\"Object of type {type(obj), str(obj)} is not JSON serializable\")\n\n    print_info(json.dumps(value, sort_keys=True, indent=2, default=default_encoder))\n\n\nOUTPUTTERS = {\n    \"yaml\": output_yaml,\n    \"json\": output_json,\n    \"default\": output_default,\n}\n\n\ndef resolve_name(obj: Any, name: str, default: Any = None, err_on_missing: bool = False) -> Any:\n    \"\"\"\n    Get a key or attr ``name`` from obj or default value.\n\n    Copied and modified from Django Template variable resolutions\n\n    Resolution methods:\n\n    - Mapping key lookup\n    - Attribute lookup\n    - Sequence index\n\n    Args:\n        obj: The object to access\n        name: A dotted name to the value, such as ``mykey.0.name``\n        default: If the name cannot be resolved from the object, return this value\n        err_on_missing: Raise a `BadInputError` if the name cannot be resolved\n\n    Returns:\n        The value at the resolved name or the default value.\n\n    Raises:\n        BadInputError: If we cannot resolve the name and `err_on_missing` is `True`\n\n    # noqa: DAR401\n    \"\"\"\n    lookups = name.split(\".\")\n    current = obj\n    try:  # catch-all for unexpected failures\n        for bit in lookups:\n            try:  # dictionary lookup\n                current = current[bit]\n                # ValueError/IndexError are for numpy.array lookup on\n                # numpy < 1.9 and 1.9+ respectively\n            except (TypeError, AttributeError, KeyError, ValueError, IndexError):\n                try:  # attribute lookup\n                    current = getattr(current, bit)\n                except (TypeError, AttributeError):\n                    # Reraise if the exception was raised by a @property\n                    if bit in dir(current):\n                        raise\n                    try:  # list-index lookup\n                        current = current[int(bit)]\n                    except (\n                        IndexError,  # list index out of range\n                        ValueError,  # invalid literal for int()\n                        KeyError,  # current is a dict without `int(bit)` key\n                        TypeError,\n                    ):  # un-subscript-able object\n                        return default\n        return current\n    except Exception as e:  # noqa: BLE001 # pragma: no cover\n        if err_on_missing:\n            raise BadInputError(f\"Could not resolve '{name}'\") from e\n        else:\n            return default\n\n\ndef do_show(*args, config: Config, format_: str = \"default\", increment: Optional[str] = None) -> None:\n    \"\"\"Show current version or configuration information.\"\"\"\n    config_dict = config.model_dump()\n    ctx = get_context(config)\n\n    if increment:\n        version = config.version_config.parse(config.current_version)\n        next_version = get_next_version(version, config, increment, None)\n        next_version_str = config.version_config.serialize(next_version, ctx)\n        config_dict[\"new_version\"] = next_version_str\n\n    try:\n        if \"all\" in args or not args:\n            show_items = config_dict\n        else:\n            show_items = {key: resolve_name(config_dict, key) for key in args}\n\n        OUTPUTTERS.get(format_, OUTPUTTERS[\"default\"])(show_items)\n    except BadInputError as e:\n        print_error(e.message)",
  "start_line": 1,
  "end_line": 131,
  "total_lines": 131,
  "is_truncated": false
}

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

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "  File \"<stdin>\", line 1\n    print(f\"'{:02}'.format('7')\")\n                                ^\nSyntaxError: f-string: empty expression not allowed\n",
  "details": {
    "stdout": "",
    "stderr": "  File \"<stdin>\", line 1\n    print(f\"'{:02}'.format('7')\")\n                                ^\nSyntaxError: f-string: empty expression not allowed\n",
    "exit_code": 1
  }
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "  File \"<string>\", line 1\n    print(f\"{:02}\".format(\"7\"))\n                  ^\nSyntaxError: f-string: empty expression not allowed\n",
  "details": {
    "stdout": "",
    "stderr": "  File \"<string>\", line 1\n    print(f\"{:02}\".format(\"7\"))\n                  ^\nSyntaxError: f-string: empty expression not allowed\n",
    "exit_code": 1
  }
}

{
  "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": "'70'\n",
  "stderr": "",
  "exit_code": 0
}

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

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

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