Reference🔗

def __iter__(self) -> Iterator[CTIEntry]:
    """Prepare interator."""
    return iter(self.__entries)

@staticmethod
def fix_author(author: str) -> tuple[str, ...]:
    """Fix author information.

    Args:
        author: list of authors

    Returns:
        list of autors
    """
    if author.count(",") > 0 and author.count(",") == author.count(" "):
        res = [
            " ".join(j.strip() for j in i.split(",")[::-1])
            for i in author.split("/")
        ]
        author = ",".join(res)
    author = author.replace(" und ", ", ")
    author = author.replace("Von ", "")
    author = "Dušan".join(CTI.dusan_replace_re.split(author))
    author = "Živadinović".join(CTI.zivadinovic_replace_re.split(author))
    author = author.replace('M"cker', "Möcker")

    return tuple([i.strip() for i in author.split(",")])

@staticmethod
def fix_chars(inp: bytes) -> bytes:
    """Fix characters in input string.

    Args:
        inp: input string

    Returns:
        string with characters fixed
    """
    table = bytes.maketrans(
        b"\334\344\374\366\337\351",
        b"\232\204\201\224\341\202",
    )
    return inp.translate(table).replace(b"\307\317", b"\204")

@staticmethod
def from_match(match: re.Match | None) -> PaperInfo:
    """Get PaperInfo from match object."""
    if False:
        _info = {"paper": Papers.NONE, "year": "-1"}
        if match is not None:
            groups = match.groupdict()
            year = groups["year"]
            if not isinstance(year, str):
                raise TypeError
            _info = {
                "paper": Papers.ct if groups["paper"] == "i" else Papers.iX,
                "year": int(year),
            }
    if match is None:
        return PaperInfo()

    return PaperInfo(
        Papers.from_char(match.groupdict()["paper"]), int(match.groupdict()["year"])
    )

@staticmethod
def from_char(c: str) -> Papers:
    """Create Papers instance from character."""
    return {"c": Papers.ct, "i": Papers.iX}.get(c, Papers.NONE)

def __call__(self) -> CTIEntry:
    """Return `CTIEntry` for content.

    Returns:
        `CTIEntry` instance
    """
    return CTIEntry(
        self.shorttitle,
        self.title,
        self.author,
        self.pages,
        self.full_issue,
        self.info,
        "c't magazin für computertechnik",
        self.date.strftime("%Y-%m-%d"),
        self.references,
        self.keywords,
    )

@staticmethod
def year_issue2full_issue(year: int, issue: int) -> str:
    """Retrieve full issue for c't from year and issue number.

    Args:
        year: issue year
        issue: issue number in year

    Returns:
        correctly formatted issue number string
    """
    tmp_issue: int | str = issue
    if tmp_issue == IssueMap.SPECIAL_ISSUE:
        if year in {2022}:
            tmp_issue = "c't Jahresrückblick"
        elif year in {2023, 2024}:
            pass
        elif year >= IssueMap.YEAR_FOR_RETRO_STARTING_AS_SPECIAL_ISSUE:
            tmp_issue = "retro"
    if year < IssueMap.YEAR_FOR_MONTLY_TO_2WEEK_FREQUENCY or (
        year == IssueMap.YEAR_FOR_MONTLY_TO_2WEEK_FREQUENCY
        and issue < IssueMap.LAST_MONTHLY_ISSUE_IN_1997
    ):
        return f"{year:04d} / {Ct.month_issue_map[issue]}"
    if year == 2024 and issue == 25:  # noqa: PLR2004
        return f"{year:04d} / {issue}: Das c't-Bastel-Kompendium"
    return f"{year:04d} / {tmp_issue}"

def __add_issues_up(self, diff: timedelta, key: tuple[int, int]) -> tuple[int, int]:
    """Add issues later then last known issue.

    Args:
        diff: difference between issues
        key: requested issue

    Raises:
        AssertionError: if inconsisten data detected
    """
    step_year, step_issue = self._issue_max
    step_issue += 1
    self._issue_max = (step_year, step_issue)
    if self._issue_max not in self._cache:
        if step_issue >= IssueMap.SPECIAL_ISSUE:
            step_issue = 1
            step_year += 1
            self._issue_max = (step_year, step_issue)
        self._date_max += diff
        self._cache[self._issue_max] = self._date_max
    elif self._date_max < self._cache[self._issue_max]:
        self._date_max = self._cache[self._issue_max]
    if self._date_max >= datetime.now(tz=UTC) + timedelta(
        days=16,
    ):
        msg = (
            f"{self._date_max=} < "
            f"{datetime.now(tz=UTC) + timedelta(days=14)=}, "
            f"{key=}\n{self._cache=}"
        )
        raise AssertionError(msg)
    return (step_year, step_issue)

def __call__(self, year: int, issue: int) -> datetime:
    """Generate release dates for c't."""
    key = (year, issue)
    diff = timedelta(days=14)
    if key in self._cache:
        return self._cache[key]
    while key > self._issue_max:
        _step_year, _step_issue = self.__add_issues_up(diff, key)
    while key < self._issue_min:
        self.__add_issues_down(diff, key)

    return self._cache[key]

def __call__(self) -> CTIEntry:
    """Return CTIEntry from data.

    Returns:
        CTIEntry
    """
    return CTIEntry(
        self.shorttitle,
        self.title,
        self.author,
        self.pages,
        self.full_issue,
        self.info,
        "iX",
        self.date.strftime("%Y-%m-%d"),
        self.references,
        self.keywords,
    )

def __hash__(self) -> int:
    """Calculate hash value for instance.

    Returns:
      hash value
    """
    return hash(
        (
            self.shorttitle,
            self.title,
            self.author,
            self.pages,
            self.issue,
            self.info,
            self.journaltitle,
            self.date,
            self.references,
            self.keywords,
        ),
    )

    def __str__(self) -> str:
        """Return string for entry."""
        if self.entry.author is None:
            authors = ""
        else:
            authors = " and ".join(
                ", ".join(j[::-1] for j in i[::-1].split(maxsplit=1))
                for ii in self.entry.author
                if (i := (ii if ii is not None else " "))
            )
        papershort = {"c't magazin für computertechnik": "c't"}.get(
            self.entry.journaltitle,
            self.entry.journaltitle,
        )
        keywords = ",".join(
            s for i in self.entry.keywords.split(",") if (s := i.strip())
        )
        res = f"""\
@article{{{self.entry.pages}:{papershort}_{self.entry.issue.replace(" ", "_")},
  title = {{{self.fix_title(self.entry.title)}}},"""
        if self.entry.shorttitle is not None:
            res = f"""{res}
  shorttitle = {{{self.fix_title(self.entry.shorttitle)}}},"""
        return f"""{res}
  author = {{{authors}}},
  date = {{{self.entry.date}}},
  journaltitle = {{{self.entry.journaltitle}}},
  pages = {{{self.entry.pages}}},
  issue = {{{self.entry.issue}}},
  keywords = {{{keywords}}},
}}
"""

@staticmethod
def fix_title(inp: str) -> str:
    """Prepare string for BiBTeX file.

    Args:
        inp: BiBTeX entry sting to modify.

    Returns:
        BiBTeX entry string wich escaped upper characters
    """
    upper = re.compile(r"([A-Z])")
    return upper.sub(r"{\1}", inp)