ctf-attackapi 0.1.1__tar.gz → 0.3.0__tar.gz

{ctf_attackapi-0.1.1 → ctf_attackapi-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctf-attackapi
-Version: 0.1.1
+Version: 0.3.0
 Summary: Get attack infos in attack-defense CTFs quickly to your exploits. CTF-agnostic and cached.
 Keywords: Attack-Defense,CTF,Attack API,Attack Info,Flag IDs,FAUST CTF,ENOWARS,saarCTF
 Author: Markus Bauer
@@ -36,11 +36,11 @@ CTF AttackAPI - Cached and Unified!
 ===================================
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/license/mit)
-![Python](https://img.shields.io/pypi/pyversions/ctf-attackapi?pypiBaseUrl=https://test.pypi.org)
-![Types](https://img.shields.io/pypi/types/ctf-attackapi?pypiBaseUrl=https://test.pypi.org)
+![Python](https://img.shields.io/pypi/pyversions/ctf-attackapi)
+![Types](https://img.shields.io/pypi/types/ctf-attackapi)
 [![Python package tests](https://github.com/Attacking-Lab/ctf-attackapi/actions/workflows/python-package.yml/badge.svg)](https://github.com/Attacking-Lab/ctf-attackapi/actions/workflows/python-package.yml)
-[![PyPI version](https://img.shields.io/pypi/v/ctf-attackapi?pypiBaseUrl=https://test.pypi.org)](https://pypi.org/project/ctf-attackapi)
-![Downloads](https://img.shields.io/pypi/dm/ctf-attackapi?pypiBaseUrl=https://test.pypi.org)
+[![PyPI version](https://img.shields.io/pypi/v/ctf-attackapi)](https://pypi.org/project/ctf-attackapi)
+![Downloads](https://img.shields.io/pypi/dm/ctf-attackapi)
 ![Repo size](https://img.shields.io/github/repo-size/Attacking-Lab/ctf-attackapi)
 
 
@@ -54,6 +54,45 @@ Downloading that file for every exploit you're firing is costing time and bandwi
 
 This package fetches, parses, and caches attack info for you, so you can focus on writing exploits!
 
+Changes in 0.3.0
+----------------
+
+- `flag_id_flat()` is now `flag_ids()`, and `flag_id_raw()` is `flag_ids_raw()`. The list of
+  strings is what an exploit wants essentially every time, so it gets the plain name, and only the
+  one that hands back the game's own structure carries a suffix. The `attack_info_*` aliases are
+  gone with them: flag IDs is what most games call these, so the package calls them that once.
+  The REST API follows -- `/api/v1/flag_ids/...` and `/api/v1/flag_ids_raw/...`, returning a
+  `flag_ids` key.
+- Lookups never raise. `flag_ids()` returns `[]` and `flag_ids_raw()` returns `None` for
+  anything they cannot answer, including a `None` team -- so the common
+  `flag_ids(service, info.team(name))` no longer dies on a name that did not resolve.
+- The mistakes that are wrong on *every* call -- an unknown service or team, a team that never
+  resolved, a team of a type the API never took -- now raise a `UserWarning` pointing at your
+  line, instead of being indistinguishable from a team that simply has no flag IDs yet. The
+  ordinary case stays silent: a known team with nothing published this round is not your mistake.
+  Silence the warnings with `warnings.simplefilter("ignore")` if your exploit prefers it.
+- Both take an optional `round`, counting back from the newest published round when negative
+  (`-1` is the newest). The default is unchanged and still returns every round the game API
+  published -- it only publishes the rounds whose flags are still valid, so narrowing by default
+  would cost you flags. The selector is public as `attackapi.select_round()`, next to
+  `flatten_flag_ids()`.
+- New `has_service()`, for the case-insensitive "does this game have that service?" check that
+  previously meant reaching into the `flag_ids` field. That field is now private.
+
+Changes in 0.2.0
+----------------
+
+- New `atklab` dialect for the ATKLAB gameserver (ECSC 2026): attack info under `attack_info`
+  instead of `flag_ids`, and rounds instead of ticks. The `saarctf`, `faustctf` and `enowars`
+  dialects are unchanged.
+- `AttackInfo` gained `flag_regex` and `current_round`, filled in for the games that report them.
+- The helper behind `flag_id_flat()` (now `flag_ids()`) is public as `attackapi.flatten_flag_ids()`, for callers that
+  flatten a subset of the raw structure themselves.
+- `flag_id_flat()` drops `null` flag IDs instead of returning them as `None` -- a flag store with
+  no ID for a round is a hole, not a value.
+- `GenericAdCtfApiAsync` accepts a plain callable decoder, a `progress` hook, and an injectable
+  `memory_cache`, so it can back a whole game API rather than just `attack.json`.
+
 Features
 --------
 
@@ -63,7 +102,8 @@ Features
 - Unifies team, IP, and flag info lookup between different CTFs:
     - Supports [ENOWARS](https://enowars.com)
     - Supports [FAUST CTF](https://faustctf.net)
-    - Supports [saarCTF](https://ctf.saarland) (including ECSC gameserver)
+    - Supports [saarCTF](https://ctf.saarland)
+    - Supports the [Attacking-Lab](https://attacking-lab.com) gameserver (ECSC 2026)
 
 Quick-Start
 -----------
@@ -83,7 +123,7 @@ from attackapi import *
 # 1. Set the API URL in code (or use CTF_API environment variable)
 configure("https://scoreboard.ctf.saarland/api/attack.json")
 # 2. Get attack infos!
-for username in attack_info().flag_id_flat("no-service", "10.32.1.2"):
+for username in attack_info().flag_ids("servicename", "10.32.1.2"):
   pwn("10.32.1.2", username)
 ```
 
@@ -169,20 +209,32 @@ print(info.teams)  # list of Team objects
 print(info.teams[0].id, info.teams[0].ip, info.teams[0].name)  # Team is ID, IP, and optional name
 print(info.team("10.32.1.2"))  # query Team object by ID, IP, or name
 
-# set of service names
+# set of service names, and a case-insensitive check for one
 print(info.services)
+print(info.has_service("servicename"))
 
-# raw flag IDs for a service and team.
-# team can be ID, IP, or name. 
-# Return data format is determined by game API.
-print(info.flag_id_raw("servicename", "10.32.1.2"))
-# => {"227": "abc", "228": "def", ...}
+# flag format and the round this info was generated for, where the game reports them
+print(info.flag_regex, info.current_round)
 
-# Get flag IDs as string list (independent of game API format, but less precise)
-print(info.flag_id_flat("servicename", "10.32.1.2"))
+# flag IDs for a service and team, as a string list -- the same shape whatever game you play.
+# team can be ID, IP, or name.
+print(info.flag_ids("servicename", "10.32.1.2"))
 # => ["abc", "def"]
+
+# One round only, for the games that report rounds. -1 is the newest published round.
+print(info.flag_ids("servicename", "10.32.1.2", -1))
+# => ["def"]
+
+# the same flag IDs in the game API's own format, when you need the structure it keeps.
+# Return data format is determined by game API.
+print(info.flag_ids_raw("servicename", "10.32.1.2"))
+# => {"227": "abc", "228": "def", ...}
 ```
 
+Nothing above raises. A lookup that cannot be answered gives you `[]` (or `None` for the raw
+form) and warns, so a typo in an exploit costs a line on stderr rather than the round it was in
+the middle of.
+
 Server Documentation
 --------------------
 
@@ -229,3 +281,17 @@ from attackapi.async_api import JsonAdCtfApiAsync
 
 info = await JsonAdCtfApiAsync("https://scoreboard.ctf.saarland/api/scoreboard_current.json").retrieve()
 ```
+
+To get parsed objects instead of raw dicts, `GenericAdCtfApiAsync` takes any `bytes -> object` callable:
+
+```python
+from attackapi.async_api import GenericAdCtfApiAsync
+
+scoreboard = await GenericAdCtfApiAsync(
+    parse_scoreboard, "https://scoreboard.ctf.saarland/api/scoreboard_round_237.json"
+).retrieve()
+```
+
+Both accept `progress=`, a context-manager factory called with the URL around remote fetches (to drive a
+spinner, for example), and `memory_cache=`, an own `GlobalCache` instead of the process-wide one. The
+process-wide cache is keyed by URL alone, so tests that need isolation should inject their own.

{ctf_attackapi-0.1.1 → ctf_attackapi-0.3.0}/README.md

@@ -2,11 +2,11 @@ CTF AttackAPI - Cached and Unified!
 ===================================
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/license/mit)
-![Python](https://img.shields.io/pypi/pyversions/ctf-attackapi?pypiBaseUrl=https://test.pypi.org)
-![Types](https://img.shields.io/pypi/types/ctf-attackapi?pypiBaseUrl=https://test.pypi.org)
+![Python](https://img.shields.io/pypi/pyversions/ctf-attackapi)
+![Types](https://img.shields.io/pypi/types/ctf-attackapi)
 [![Python package tests](https://github.com/Attacking-Lab/ctf-attackapi/actions/workflows/python-package.yml/badge.svg)](https://github.com/Attacking-Lab/ctf-attackapi/actions/workflows/python-package.yml)
-[![PyPI version](https://img.shields.io/pypi/v/ctf-attackapi?pypiBaseUrl=https://test.pypi.org)](https://pypi.org/project/ctf-attackapi)
-![Downloads](https://img.shields.io/pypi/dm/ctf-attackapi?pypiBaseUrl=https://test.pypi.org)
+[![PyPI version](https://img.shields.io/pypi/v/ctf-attackapi)](https://pypi.org/project/ctf-attackapi)
+![Downloads](https://img.shields.io/pypi/dm/ctf-attackapi)
 ![Repo size](https://img.shields.io/github/repo-size/Attacking-Lab/ctf-attackapi)
 
 
@@ -20,6 +20,45 @@ Downloading that file for every exploit you're firing is costing time and bandwi
 
 This package fetches, parses, and caches attack info for you, so you can focus on writing exploits!
 
+Changes in 0.3.0
+----------------
+
+- `flag_id_flat()` is now `flag_ids()`, and `flag_id_raw()` is `flag_ids_raw()`. The list of
+  strings is what an exploit wants essentially every time, so it gets the plain name, and only the
+  one that hands back the game's own structure carries a suffix. The `attack_info_*` aliases are
+  gone with them: flag IDs is what most games call these, so the package calls them that once.
+  The REST API follows -- `/api/v1/flag_ids/...` and `/api/v1/flag_ids_raw/...`, returning a
+  `flag_ids` key.
+- Lookups never raise. `flag_ids()` returns `[]` and `flag_ids_raw()` returns `None` for
+  anything they cannot answer, including a `None` team -- so the common
+  `flag_ids(service, info.team(name))` no longer dies on a name that did not resolve.
+- The mistakes that are wrong on *every* call -- an unknown service or team, a team that never
+  resolved, a team of a type the API never took -- now raise a `UserWarning` pointing at your
+  line, instead of being indistinguishable from a team that simply has no flag IDs yet. The
+  ordinary case stays silent: a known team with nothing published this round is not your mistake.
+  Silence the warnings with `warnings.simplefilter("ignore")` if your exploit prefers it.
+- Both take an optional `round`, counting back from the newest published round when negative
+  (`-1` is the newest). The default is unchanged and still returns every round the game API
+  published -- it only publishes the rounds whose flags are still valid, so narrowing by default
+  would cost you flags. The selector is public as `attackapi.select_round()`, next to
+  `flatten_flag_ids()`.
+- New `has_service()`, for the case-insensitive "does this game have that service?" check that
+  previously meant reaching into the `flag_ids` field. That field is now private.
+
+Changes in 0.2.0
+----------------
+
+- New `atklab` dialect for the ATKLAB gameserver (ECSC 2026): attack info under `attack_info`
+  instead of `flag_ids`, and rounds instead of ticks. The `saarctf`, `faustctf` and `enowars`
+  dialects are unchanged.
+- `AttackInfo` gained `flag_regex` and `current_round`, filled in for the games that report them.
+- The helper behind `flag_id_flat()` (now `flag_ids()`) is public as `attackapi.flatten_flag_ids()`, for callers that
+  flatten a subset of the raw structure themselves.
+- `flag_id_flat()` drops `null` flag IDs instead of returning them as `None` -- a flag store with
+  no ID for a round is a hole, not a value.
+- `GenericAdCtfApiAsync` accepts a plain callable decoder, a `progress` hook, and an injectable
+  `memory_cache`, so it can back a whole game API rather than just `attack.json`.
+
 Features
 --------
 
@@ -29,7 +68,8 @@ Features
 - Unifies team, IP, and flag info lookup between different CTFs:
     - Supports [ENOWARS](https://enowars.com)
     - Supports [FAUST CTF](https://faustctf.net)
-    - Supports [saarCTF](https://ctf.saarland) (including ECSC gameserver)
+    - Supports [saarCTF](https://ctf.saarland)
+    - Supports the [Attacking-Lab](https://attacking-lab.com) gameserver (ECSC 2026)
 
 Quick-Start
 -----------
@@ -49,7 +89,7 @@ from attackapi import *
 # 1. Set the API URL in code (or use CTF_API environment variable)
 configure("https://scoreboard.ctf.saarland/api/attack.json")
 # 2. Get attack infos!
-for username in attack_info().flag_id_flat("no-service", "10.32.1.2"):
+for username in attack_info().flag_ids("servicename", "10.32.1.2"):
   pwn("10.32.1.2", username)
 ```
 
@@ -135,20 +175,32 @@ print(info.teams)  # list of Team objects
 print(info.teams[0].id, info.teams[0].ip, info.teams[0].name)  # Team is ID, IP, and optional name
 print(info.team("10.32.1.2"))  # query Team object by ID, IP, or name
 
-# set of service names
+# set of service names, and a case-insensitive check for one
 print(info.services)
+print(info.has_service("servicename"))
 
-# raw flag IDs for a service and team.
-# team can be ID, IP, or name. 
-# Return data format is determined by game API.
-print(info.flag_id_raw("servicename", "10.32.1.2"))
-# => {"227": "abc", "228": "def", ...}
+# flag format and the round this info was generated for, where the game reports them
+print(info.flag_regex, info.current_round)
 
-# Get flag IDs as string list (independent of game API format, but less precise)
-print(info.flag_id_flat("servicename", "10.32.1.2"))
+# flag IDs for a service and team, as a string list -- the same shape whatever game you play.
+# team can be ID, IP, or name.
+print(info.flag_ids("servicename", "10.32.1.2"))
 # => ["abc", "def"]
+
+# One round only, for the games that report rounds. -1 is the newest published round.
+print(info.flag_ids("servicename", "10.32.1.2", -1))
+# => ["def"]
+
+# the same flag IDs in the game API's own format, when you need the structure it keeps.
+# Return data format is determined by game API.
+print(info.flag_ids_raw("servicename", "10.32.1.2"))
+# => {"227": "abc", "228": "def", ...}
 ```
 
+Nothing above raises. A lookup that cannot be answered gives you `[]` (or `None` for the raw
+form) and warns, so a typo in an exploit costs a line on stderr rather than the round it was in
+the middle of.
+
 Server Documentation
 --------------------
 
@@ -195,3 +247,17 @@ from attackapi.async_api import JsonAdCtfApiAsync
 
 info = await JsonAdCtfApiAsync("https://scoreboard.ctf.saarland/api/scoreboard_current.json").retrieve()
 ```
+
+To get parsed objects instead of raw dicts, `GenericAdCtfApiAsync` takes any `bytes -> object` callable:
+
+```python
+from attackapi.async_api import GenericAdCtfApiAsync
+
+scoreboard = await GenericAdCtfApiAsync(
+    parse_scoreboard, "https://scoreboard.ctf.saarland/api/scoreboard_round_237.json"
+).retrieve()
+```
+
+Both accept `progress=`, a context-manager factory called with the URL around remote fetches (to drive a
+spinner, for example), and `memory_cache=`, an own `GlobalCache` instead of the process-wide one. The
+process-wide cache is keyed by URL alone, so tests that need isolation should inject their own.

ctf_attackapi-0.3.0/pyproject.toml

@@ -0,0 +1,89 @@
+[project]
+name = "ctf-attackapi"
+version = "0.3.0"
+description = "Get attack infos in attack-defense CTFs quickly to your exploits. CTF-agnostic and cached."
+readme = "README.md"
+license = "MIT"
+license_files = ["LICENSE.txt"]
+keywords = [
+    "Attack-Defense",
+    "CTF",
+    "Attack API",
+    "Attack Info",
+    "Flag IDs",
+    "FAUST CTF",
+    "ENOWARS",
+    "saarCTF",
+]
+requires-python = ">=3.9"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Security",
+    "Typing :: Typed",
+]
+dependencies = [
+    "aiohttp>=3.13.3",
+    "aiologic>=0.16.0",
+    "filelock>=3.19.1",
+    "pyyaml>=6.0.3",
+    "typing-extensions>=4.15.0",
+]
+
+[[project.authors]]
+name = "Markus Bauer"
+email = "markus.bauer@cispa.saarland"
+
+[project.optional-dependencies]
+server = ["gunicorn>=23.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/Attacking-Lab/ctf-attackapi"
+Repository = "https://github.com/Attacking-Lab/ctf-attackapi"
+Issues = "https://github.com/Attacking-Lab/ctf-attackapi/issues"
+Background = "https://wiki.attacking-lab.com/attack-defense/"
+
+[project.scripts]
+ctf-attackapi-server = "attackapi.server:main"
+
+[build-system]
+requires = ["uv_build>=0.9.27,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.19.1",
+    "pytest>=8.4.2",
+    "types-pyyaml>=6.0.12.20250915",
+]
+
+[tool.uv.build-backend]
+module-name = "attackapi"
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true
+
+[tool.mypy]
+python_version = "3.9"
+disallow_untyped_defs = true
+packages = [
+    "attackapi",
+    "tests",
+    "examples",
+]
+mypy_path = [
+    "./src",
+    "./tests",
+    "./examples",
+]

ctf_attackapi-0.1.1/pyproject.toml → ctf_attackapi-0.3.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "ctf-attackapi"
-version = "0.1.1"
+version = "0.3.0"
 description = "Get attack infos in attack-defense CTFs quickly to your exploits. CTF-agnostic and cached."
 readme = "README.md"
 license = "MIT"

ctf_attackapi-0.3.0/src/attackapi/__init__.py

@@ -0,0 +1,4 @@
+from .models import Team, AttackInfo, flatten_flag_ids, select_round
+from .functional import configure, attack_info, attack_info_async
+
+__all__ = ["Team", "AttackInfo", "flatten_flag_ids", "select_round", "configure", "attack_info", "attack_info_async"]

ctf_attackapi-0.3.0/src/attackapi/async_api/__init__.py

@@ -0,0 +1,5 @@
+from .api import AdCtfApiAsync, GenericAdCtfApiAsync, GlobalCache, JsonAdCtfApiAsync
+from .decoders import Decoder, Dialect, FunctionDecoder, GenericDecoder
+
+__all__ = ["AdCtfApiAsync", "GenericAdCtfApiAsync", "GlobalCache", "JsonAdCtfApiAsync",
+           "Decoder", "Dialect", "FunctionDecoder", "GenericDecoder"]

{ctf_attackapi-0.1.1 → ctf_attackapi-0.3.0}/src/attackapi/async_api/api.py

@@ -5,13 +5,13 @@ import tempfile
 import time
 from importlib.metadata import version
 from pathlib import Path
-from typing import Optional, Union, Generic, TypeVar, AsyncContextManager, Any
+from contextlib import nullcontext
+from typing import Callable, ContextManager, Optional, Union, Generic, TypeVar, AsyncContextManager, Any
 
 import aiologic
-from aiohttp import ClientSession, ClientTimeout
 from filelock import FileLock
 
-from attackapi.async_api.decoders import Decoder, GenericDecoder, JSONDecoder
+from attackapi.async_api.decoders import Decoder, FunctionDecoder, GenericDecoder, JSONDecoder
 from attackapi.async_api.filelock import acquire_filelock
 from attackapi.models import AttackInfo
 
@@ -38,6 +38,10 @@ class GlobalCache(Generic[T]):
     def set(self, key: str, value: T) -> None:
         self._cache[key] = (time.time(), value)
 
+    def clear(self) -> None:
+        """Drop every cached response. Mostly useful to isolate tests from each other."""
+        self._cache.clear()
+
 
 _api_response_cache: GlobalCache[Any] = GlobalCache()
 
@@ -82,19 +86,23 @@ def _atomic_write(p: Path, raw: bytes) -> None:
 
 
 class GenericAdCtfApiAsync(Generic[T]):
-    def __init__(self, decoder: GenericDecoder[T], url: str = "",
+    def __init__(self, decoder: Union[GenericDecoder[T], Callable[[bytes], T]], url: str = "",
                  tmp_directory: Union[str, Path] = tempfile.gettempdir(), *,
                  lifetime: float = 30.0, timeout: float = 10.0,
-                 aiohttp_arguments: Optional[dict] = None) -> None:
+                 aiohttp_arguments: Optional[dict] = None,
+                 memory_cache: Optional[GlobalCache] = None,
+                 progress: Optional[Callable[[str], ContextManager[None]]] = None) -> None:
         """
         Create a new API client.
 
-        :param decoder: A decoder for API responses
+        :param decoder: A decoder for API responses, or a plain bytes -> object callable
         :param url: URL of your game's API
         :param tmp_directory: where to store cache files
         :param lifetime: How long to cache data for (in seconds)
         :param timeout: How long to wait for API calls (in seconds)
         :param aiohttp_arguments: Optional arguments to pass to aiohttp.ClientSession
+        :param memory_cache: Optional in-memory cache to use instead of the process-wide one
+        :param progress: Optional context-manager factory, called with the URL around remote fetches
         """
         if timeout < 1:
             raise ValueError("Timeout must be at least 1 second")
@@ -104,7 +112,9 @@ class GenericAdCtfApiAsync(Generic[T]):
         self._url = url
         self._lifetime = lifetime
         self._timeout = timeout
-        self._decoder = decoder
+        self._decoder = decoder if isinstance(decoder, GenericDecoder) else FunctionDecoder(decoder)
+        self._memory_cache = memory_cache if memory_cache is not None else _api_response_cache
+        self._progress = progress
         self._aiohttp_arguments = aiohttp_arguments or {
             "headers": {"User-Agent": "python/attackapi " + version("ctf-attackapi")}
         }
@@ -124,19 +134,19 @@ class GenericAdCtfApiAsync(Generic[T]):
         if info is not None:
             return info
         # not found? lock it to avoid concurrent loads
-        async with _api_response_cache.lock:
+        async with self._memory_cache.lock:
             # check again to avoid race conditions
             info = self._check_memory_cache()
             if info is not None:
                 return info
             # not found => load from file or API
-            info = await self._attack_info_from_file()
-            _api_response_cache.set(self._cache_key, info)
+            info = await self._from_file()
+            self._memory_cache.set(self._cache_key, info)
             return info
 
     def _check_memory_cache(self) -> Optional[T]:
-        if (age := _api_response_cache.age(self._cache_key)) is not None and age <= self._lifetime:
-            return _api_response_cache.get(self._cache_key)
+        if (age := self._memory_cache.age(self._cache_key)) is not None and age <= self._lifetime:
+            return self._memory_cache.get(self._cache_key)
         return None
 
     def _check_file_cache(self) -> Optional[T]:
@@ -146,7 +156,7 @@ class GenericAdCtfApiAsync(Generic[T]):
                 return self._decoder.parse(raw)
         return None
 
-    async def _attack_info_from_file(self) -> T:
+    async def _from_file(self) -> T:
         # Step 2: try to load from file
         # this does not work on Windows, because concurrent read + replacing files is not possible.
         # for better performance please use Linux
@@ -161,23 +171,29 @@ class GenericAdCtfApiAsync(Generic[T]):
             if info is not None:
                 return info
             # not found => load from API
-            raw = await self._attack_info_from_remote()
+            raw = await self._from_remote()
             info = self._decoder.parse(raw)
             # and save to file (atomic)
             self._file_cache.set(raw)
             return info
 
-    async def _attack_info_from_remote(self) -> bytes:
-        async with ClientSession(**self._aiohttp_arguments) as session:
-            async with session.get(self._url, timeout=ClientTimeout(total=self._timeout)) as response:
-                response.raise_for_status()
-                return await response.read()
+    async def _from_remote(self) -> bytes:
+        # imported lazily so that cache hits do not pay for importing aiohttp
+        from aiohttp import ClientSession, ClientTimeout
+
+        with self._progress(self._url) if self._progress is not None else nullcontext():
+            async with ClientSession(**self._aiohttp_arguments) as session:
+                async with session.get(self._url, timeout=ClientTimeout(total=self._timeout)) as response:
+                    response.raise_for_status()
+                    return await response.read()
 
 
 class JsonAdCtfApiAsync(GenericAdCtfApiAsync[dict]):
     def __init__(self, url: str, tmp_directory: Union[str, Path] = tempfile.gettempdir(), *,
                  lifetime: float = 30.0, timeout: float = 10.0,
-                 aiohttp_arguments: Optional[dict] = None) -> None:
+                 aiohttp_arguments: Optional[dict] = None,
+                 memory_cache: Optional[GlobalCache] = None,
+                 progress: Optional[Callable[[str], ContextManager[None]]] = None) -> None:
         """
         Create a new API client.
 
@@ -185,11 +201,13 @@ class JsonAdCtfApiAsync(GenericAdCtfApiAsync[dict]):
         :param tmp_directory: where to store cache files
         :param lifetime: How long to cache data for (in seconds)
         :param timeout: How long to wait for API calls (in seconds)
-        :param decoder: A custom decoder for API responses, if the default one doesn't work for your game
         :param aiohttp_arguments: Optional arguments to pass to aiohttp.ClientSession
+        :param memory_cache: Optional in-memory cache to use instead of the process-wide one
+        :param progress: Optional context-manager factory, called with the URL around remote fetches
         """
         super().__init__(decoder=JSONDecoder(), url=url, tmp_directory=tmp_directory, lifetime=lifetime,
-                         timeout=timeout, aiohttp_arguments=aiohttp_arguments)
+                         timeout=timeout, aiohttp_arguments=aiohttp_arguments, memory_cache=memory_cache,
+                         progress=progress)
 
 
 class AdCtfApiAsync(GenericAdCtfApiAsync[AttackInfo]):
@@ -199,7 +217,9 @@ class AdCtfApiAsync(GenericAdCtfApiAsync[AttackInfo]):
 
     def __init__(self, url: str = "", tmp_directory: Union[str, Path] = tempfile.gettempdir(), *,
                  lifetime: float = 30.0, timeout: float = 10.0, decoder: Optional[Decoder] = None,
-                 aiohttp_arguments: Optional[dict] = None) -> None:
+                 aiohttp_arguments: Optional[dict] = None,
+                 memory_cache: Optional[GlobalCache] = None,
+                 progress: Optional[Callable[[str], ContextManager[None]]] = None) -> None:
         """
         Create a new API client.
 
@@ -209,13 +229,16 @@ class AdCtfApiAsync(GenericAdCtfApiAsync[AttackInfo]):
         :param timeout: How long to wait for API calls (in seconds)
         :param decoder: A custom decoder for API responses, if the default one doesn't work for your game
         :param aiohttp_arguments: Optional arguments to pass to aiohttp.ClientSession
+        :param memory_cache: Optional in-memory cache to use instead of the process-wide one
+        :param progress: Optional context-manager factory, called with the URL around remote fetches
         """
         if not url:
             if "CTF_API" not in os.environ:
                 raise Exception("Please call configure() or set CTF_API environment variable!")
             url = os.environ["CTF_API"]
         super().__init__(decoder=decoder or Decoder(), url=url, tmp_directory=tmp_directory, lifetime=lifetime,
-                         timeout=timeout, aiohttp_arguments=aiohttp_arguments)
+                         timeout=timeout, aiohttp_arguments=aiohttp_arguments, memory_cache=memory_cache,
+                         progress=progress)
 
     async def attack_info(self) -> AttackInfo:
         """

{ctf_attackapi-0.1.1 → ctf_attackapi-0.3.0}/src/attackapi/async_api/decoders.py

@@ -1,8 +1,9 @@
 """
 Summary of different API formats:
-saarctf: flag_ids => {service_name => {ip => data}}   {tick: a, tick2: [b, c]}
-faust:   flag_ids => {service_name => {ID => data}}   [a, b]
-enowars: services => {service_name => {ip => data}}   {tick: {X: [a], Y: [b]}}
+saarctf: flag_ids    => {service_name => {ip => data}}   {tick: a, tick2: [b, c]}
+atklab:  attack_info => {service_name => {ip => data}}   {round: {store_index: a}}
+faust:   flag_ids    => {service_name => {ID => data}}   [a, b]
+enowars: services    => {service_name => {ip => data}}   {tick: {X: [a], Y: [b]}}
 
 Additional team list:
 saarctf: teams => [0 => {id: ..., name: ..., logo: ...}]
@@ -12,7 +13,7 @@ enowars: availableTeams: [IP1, IP2, ...]
 import json
 from abc import abstractmethod, ABC
 from dataclasses import dataclass
-from typing import Optional, Generic, TypeVar
+from typing import Callable, Optional, Generic, TypeVar
 
 from attackapi.models import AttackInfo, Team
 
@@ -52,6 +53,17 @@ class SaarctfDialect(Dialect):
         return f"10.{32 + (team_id // 200)}.{team_id % 200}.2"  # actually not needed, saarCTF API exposes full team info
 
 
+class AtklabDialect(Dialect):
+    """
+    ATKLAB gameserver (ECSC 2026). Team entries are shaped like saarCTF's, but the attack info
+    sits under "attack_info" and rounds are called rounds, not ticks.
+    """
+
+    def matches(self, data: dict) -> bool:
+        return "attack_info" in data and "teams" in data \
+            and len(data["teams"]) > 0 and isinstance(data["teams"][0], dict)
+
+
 class FaustDialect(Dialect):
     def matches(self, data: dict) -> bool:
         return "flag_ids" in data and "teams" in data and len(data["teams"]) > 0 and isinstance(data["teams"][0], int)
@@ -70,6 +82,7 @@ class EnowarsDialect(Dialect):
 
 
 DIALECTS = [
+    AtklabDialect("atklab"),
     SaarctfDialect("saarctf"),
     FaustDialect("faustctf", "fd66:666:{:d}::2"),
     EnowarsDialect("enowars", "10.1.{:d}.1"),
@@ -90,6 +103,16 @@ class JSONDecoder(GenericDecoder[dict]):
         return json.loads(raw)
 
 
+class FunctionDecoder(GenericDecoder[T]):
+    """Adapts a plain ``bytes -> T`` callable to the decoder interface."""
+
+    def __init__(self, parse: Callable[[bytes], T]) -> None:
+        self._parse = parse
+
+    def parse(self, raw: bytes) -> T:
+        return self._parse(raw)
+
+
 class Decoder(GenericDecoder[AttackInfo]):
     """
     A decoder converts the game APIs response (in bytes) into teams, services, and attack information.
@@ -108,16 +131,23 @@ class Decoder(GenericDecoder[AttackInfo]):
         :raises ValueError: If data is invalid
         :return:
         """
-        info = AttackInfo(raw=raw)
         data = json.loads(raw)
         dialect = self._get_dialect(data)
+        info = AttackInfo(
+            flag_regex=data.get("flag_regex"),
+            # saarCTF counts ticks, the ATKLAB gameserver counts rounds; same number
+            current_round=data.get("current_round", data.get("current_tick")),
+            raw=raw
+        )
 
         if "flag_ids" in data:
             self._parse_services(info, data["flag_ids"])
+        elif "attack_info" in data:
+            self._parse_services(info, data["attack_info"])
         elif "services" in data:
             self._parse_services(info, data["services"])
         else:
-            raise ValueError("Unknown format - no flag_ids or services key found")
+            raise ValueError("Unknown format - no flag_ids, attack_info or services key found")
 
         if "teams" in data:
             self._parse_teams(dialect, info, data["teams"])
@@ -141,7 +171,7 @@ class Decoder(GenericDecoder[AttackInfo]):
             if not isinstance(flag_ids, dict):
                 raise ValueError(f"Invalid flag_ids format for service {service_name!r}: {type(flag_ids)}")
             info.services.add(service_name)
-            info.flag_ids[service_name.lower()] = flag_ids
+            info._flag_ids[service_name.lower()] = flag_ids
 
     def _parse_teams(self, dialect: Dialect, info: AttackInfo, teams: list) -> None:
         for team in teams:

ctf_attackapi-0.3.0/src/attackapi/models.py

@@ -0,0 +1,189 @@
+import warnings
+from dataclasses import dataclass, field, asdict
+from typing import Optional, Union, Any
+from typing_extensions import TypeAlias
+
+RawFlagIds: TypeAlias = Union[list, dict[str, Union[str, list, dict]]]
+
+
+def flatten_flag_ids(flag_ids: Any) -> list[str]:
+    """
+    Collect every non-null scalar flag ID out of an arbitrarily nested flag-ID structure.
+    Independent of the game API's exact nesting, but loses the round / flag-store structure.
+    """
+    if flag_ids is None:  # a flag store with no ID for this round/team
+        return []
+    if isinstance(flag_ids, str):
+        return [flag_ids]
+    if isinstance(flag_ids, list):
+        result = []
+        for value in flag_ids:
+            result += flatten_flag_ids(value)
+        return result
+    if isinstance(flag_ids, dict):
+        result = []
+        for value in flag_ids.values():
+            result += flatten_flag_ids(value)
+        return result
+    return [str(flag_ids)]
+
+
+def select_round(flag_ids: Any, round: int) -> Any:
+    """
+    Restrict flag IDs to a single round. Every game that reports a round keys its per-team attack
+    info by it; FAUST CTF does not have the dimension at all, and its plain list is returned
+    unchanged rather than sliced into something that only looks like a round.
+
+    :param flag_ids: raw flag IDs for one service and team, as returned by flag_ids_raw()
+    :param round: a round number, or an offset from the newest published round (-1 = newest)
+    :return: the same structure, holding at most the requested round
+    """
+    if not isinstance(flag_ids, dict):
+        return flag_ids
+    keys = list(flag_ids.keys())
+    if round < 0:
+        # the game API publishes a window of recent rounds, in no guaranteed order
+        if all(isinstance(key, str) and key.lstrip("-").isdigit() for key in keys):
+            keys.sort(key=int)
+        if -round > len(keys):
+            return {}
+        key = keys[round]
+    else:
+        key = str(round)
+    return {key: flag_ids[key]} if key in flag_ids else {}
+
+
+@dataclass(frozen=True)
+class Team:
+    """
+    An attackable team.
+    IP is given for every game, ID is given or inferred for all known CTFs.
+    Name is not present everywhere.
+    """
+    id: int
+    ip: str
+    name: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class AttackInfo:
+    """
+    Container for all attack info parsed from the game API.
+    Use methods team(), flag_ids(), and flag_ids_raw() to look up data.
+    Fields teams and services can be iterated.
+    """
+
+    teams: list[Team] = field(default_factory=list)
+    team_lookup: dict[str, Team] = field(default_factory=dict)
+    services: set[str] = field(default_factory=set)
+    _flag_ids: dict[str, dict[str, RawFlagIds]] = field(default_factory=dict)
+    flag_regex: Optional[str] = None
+    current_round: Optional[int] = None
+    raw: bytes = b""  # everything, as given by the game API
+
+    def team(self, name: Union[str, int]) -> Optional[Team]:
+        """
+        Find a team.
+
+        :param name: Team ID, IP, or name (as far as supported by the API)
+        :return:
+        """
+        return self.team_lookup.get(str(name).lower())
+
+    def has_service(self, service: str) -> bool:
+        """
+        Whether this game has a service by that name (case insensitive).
+
+        :param service: Name of a service
+        :return:
+        """
+        return service.lower() in self._flag_ids
+
+    def flag_ids(self, service: str, team: Union[str, int, Team, None],
+                 round: Optional[int] = None) -> list[str]:
+        """
+        Find flag IDs for a service and team, as a simple string list -- the same list whatever
+        game you are playing, and what an exploit almost always wants.
+
+        Never raises: a lookup that cannot be answered warns and returns [], so a typo in an
+        exploit costs a warning on stderr rather than the round it was in the middle of.
+
+        :param service: Name of a service (case insensitive, see field "services" for a list of valid names)
+        :param team: Team ID, IP, name, or instance (from .team(...))
+        :param round: Restrict the result to one round, or to an offset from the newest published
+            round (-1 = newest). Defaults to every round the game API published.
+        :return:
+        """
+        flag_ids = self._lookup(service, team, round)
+        return flatten_flag_ids(flag_ids) if flag_ids is not None else []
+
+    def flag_ids_raw(self, service: str, team: Union[str, int, Team, None],
+                     round: Optional[int] = None) -> Optional[RawFlagIds]:
+        """
+        Find flag IDs for a service and team, in the game API's own format -- for callers that
+        need the structure flag_ids() flattens away. That format differs per game.
+
+        Never raises, and returns None for anything it cannot answer -- see flag_ids().
+
+        :param service: Name of a service (case insensitive, see field "services" for a list of valid names)
+        :param team: Team ID, IP, name, or instance (from .team(...))
+        :param round: Restrict the result to one round, or to an offset from the newest published
+            round (-1 = newest). Defaults to every round the game API published.
+        :return:
+        """
+        return self._lookup(service, team, round)
+
+    def _lookup(self, service: str, team: Union[str, int, Team, None],
+                round: Optional[int], stacklevel: int = 3) -> Optional[RawFlagIds]:
+        """
+        The lookup behind both accessors. Warns rather than raises on the mistakes that are wrong
+        on every call -- an unknown service or team, a team that never resolved -- and stays quiet
+        about the ones that are a normal part of a running game.
+
+        :param stacklevel: frames between this method and the caller to blame in a warning
+        """
+        if team is None:
+            warnings.warn(f"No team given for service {service!r} - did an earlier team() lookup fail?",
+                          stacklevel=stacklevel)
+            return None
+        flag_ids = self._flag_ids.get(service.lower())
+        if flag_ids is None:
+            warnings.warn(f"Unknown service {service!r}, this game has: {', '.join(sorted(self.services))}",
+                          stacklevel=stacklevel)
+            return None
+        raw = self._team_flag_ids(service, flag_ids, team, stacklevel + 1)
+        if raw is None or round is None:
+            return raw
+        return select_round(raw, round)
+
+    def _team_flag_ids(self, service: str, flag_ids: dict, team: Union[str, int, Team],
+                       stacklevel: int) -> Optional[RawFlagIds]:
+        """Pick one team out of a service's flag IDs, which the game API keys by ID, IP, or name."""
+        if isinstance(team, Team):
+            for key in (str(team.id), team.ip, team.name):
+                if key is not None and key.lower() in flag_ids:
+                    return flag_ids[key.lower()]
+            # a team the game knows about but has no flag IDs for: the service may be down, or the
+            # round's info may not be out yet. Both are ordinary, and neither is worth a warning.
+            return None
+        if isinstance(team, (str, int)):
+            key = str(team).lower()
+            if key in flag_ids:
+                return flag_ids[key]
+            if key in self.team_lookup:
+                return self._team_flag_ids(service, flag_ids, self.team_lookup[key], stacklevel)
+            warnings.warn(f"Unknown team {team!r} for service {service!r} - not in this attack info "
+                          f"(a typo, or a team that is offline or banned)", stacklevel=stacklevel)
+            return None
+        warnings.warn(f"Invalid team type for service {service!r}: {type(team).__name__}: {team!r}",
+                      stacklevel=stacklevel)
+        return None
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self) -> str:
+        return f"AttackInfo(services={self.services!r}, {len(self.teams)} teams)"

{ctf_attackapi-0.1.1 → ctf_attackapi-0.3.0}/src/attackapi/server/server.py

@@ -21,8 +21,8 @@ class AttackApiViews:
             web.get("/api/v1/raw", self.get_raw),
             web.get("/api/v1/services", self.get_services),
             web.get("/api/v1/teams", self.get_teams),
-            web.get("/api/v1/attack_info/{service}/{team}", self.get_attack_info),
-            web.get("/api/v1/attack_info_raw/{service}/{team}", self.get_attack_info_raw),
+            web.get("/api/v1/flag_ids/{service}/{team}", self.get_flag_ids),
+            web.get("/api/v1/flag_ids_raw/{service}/{team}", self.get_flag_ids_raw),
         ]
 
     async def docs(self, request: web.Request) -> web.Response:
@@ -38,8 +38,8 @@ class AttackApiViews:
                 docs = docs.replace('"NOP"', json.dumps(info.teams[0].name))
                 if len(info.services) > 0:
                     s = list(info.services)[0]
-                    raw = info.flag_id_raw(s, info.teams[0])
-                    flat = info.flag_id_flat(s, info.teams[0])
+                    raw = info.flag_ids_raw(s, info.teams[0])
+                    flat = info.flag_ids(s, info.teams[0])
                     if raw:
                         docs = docs.replace(
                             json.dumps({"227": "username1", "228": "username2", "229": "username3"}),
@@ -68,31 +68,31 @@ class AttackApiViews:
         info = await self._api.attack_info()
         return web.json_response({"services": list(info.services)})
 
-    async def _attack_info_common(self, request: web.Request,
-                                  cb: Callable[[AttackInfo, str, str], Any]) -> web.Response:
+    async def _flag_ids_common(self, request: web.Request,
+                               cb: Callable[[AttackInfo, str, str], Any]) -> web.Response:
         service = request.match_info["service"]
         team = request.match_info["team"]
         if not service or not team:
             raise web.HTTPBadRequest(reason="Invalid team or service")
         info = await self._api.attack_info()
-        if service.lower() not in info.flag_ids:
+        if not info.has_service(service):
             raise web.HTTPBadRequest(reason=f"Unknown service, or service has no attack info: {service}")
         flag_ids = cb(info, service, team)
         return web.json_response(
-            {"attack_info": flag_ids}
+            {"flag_ids": flag_ids}
         )
 
-    async def get_attack_info(self, request: web.Request) -> web.Response:
+    async def get_flag_ids(self, request: web.Request) -> web.Response:
         def _cb(info: AttackInfo, service: str, team: str) -> Any:
-            return info.flag_id_flat(service, team)
+            return info.flag_ids(service, team)
 
-        return await self._attack_info_common(request, _cb)
+        return await self._flag_ids_common(request, _cb)
 
-    async def get_attack_info_raw(self, request: web.Request) -> web.Response:
+    async def get_flag_ids_raw(self, request: web.Request) -> web.Response:
         def _cb(info: AttackInfo, service: str, team: str) -> Any:
-            return info.flag_id_raw(service, team)
+            return info.flag_ids_raw(service, team)
 
-        return await self._attack_info_common(request, _cb)
+        return await self._flag_ids_common(request, _cb)
 
 
 async def create_app() -> web.Application:

ctf_attackapi-0.1.1/src/attackapi/__init__.py

@@ -1,4 +0,0 @@
-from .models import Team, AttackInfo
-from .functional import configure, attack_info, attack_info_async
-
-__all__ = ["Team", "AttackInfo", "configure", "attack_info", "attack_info_async"]

ctf_attackapi-0.1.1/src/attackapi/async_api/__init__.py

@@ -1,4 +0,0 @@
-from .api import AdCtfApiAsync, JsonAdCtfApiAsync
-from .decoders import Decoder, Dialect
-
-__all__ = ["AdCtfApiAsync", "JsonAdCtfApiAsync", "Decoder", "Dialect"]

ctf_attackapi-0.1.1/src/attackapi/models.py

@@ -1,134 +0,0 @@
-from dataclasses import dataclass, field, asdict
-from typing import Optional, Union, Any, cast
-from typing_extensions import TypeAlias
-
-RawFlagIds: TypeAlias = Union[list, dict[str, Union[str, list, dict]]]
-
-
-def _flat(flag_ids: Any) -> list[str]:
-    if isinstance(flag_ids, list):
-        result = []
-        for value in flag_ids:
-            result += _flat(value)
-        return result
-    if isinstance(flag_ids, dict):
-        result = []
-        for value in flag_ids.values():
-            result += _flat(value)
-        return result
-    return [cast(str, flag_ids)]
-
-
-@dataclass(frozen=True)
-class Team:
-    """
-    An attackable team.
-    IP is given for every game, ID is given or inferred for all known CTFs.
-    Name is not present everywhere.
-    """
-    id: int
-    ip: str
-    name: Optional[str] = None
-
-    def to_dict(self) -> dict:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class AttackInfo:
-    """
-    Container for all attack info parsed from the game API.
-    Use methods team(), flag_id_raw(), and flag_id_flat() to look up data.
-    Fields teams and services can be iterated.
-    """
-
-    teams: list[Team] = field(default_factory=list)
-    team_lookup: dict[str, Team] = field(default_factory=dict)
-    services: set[str] = field(default_factory=set)
-    flag_ids: dict[str, dict[str, RawFlagIds]] = field(default_factory=dict)
-    raw: bytes = b""  # everything, as given by the game API
-
-    def team(self, name: Union[str, int]) -> Optional[Team]:
-        """
-        Find a team.
-
-        :param name: Team ID, IP, or name (as far as supported by the API)
-        :return:
-        """
-        return self.team_lookup.get(str(name).lower())
-
-    def flag_id_raw(self, service: str, team: Union[str, int, Team]) -> Optional[RawFlagIds]:
-        """
-        Find flag IDs for a service and team. Flag IDs are returned in the APIs raw format.
-
-        :param service: Name of a service (case insensitive, see field "services" for a list of valid names)
-        :param team: Team ID, IP, name, or instance (from .team(...))
-        :return:
-        """
-        flag_ids = self.flag_ids.get(service.lower(), {})
-        if isinstance(team, Team):
-            if str(team.id) in flag_ids:
-                return flag_ids[str(team.id)]
-            if team.ip is not None and team.ip.lower() in flag_ids:
-                return flag_ids[team.ip.lower()]
-            if team.name is not None and team.name.lower() in flag_ids:
-                return flag_ids[team.name.lower()]
-            return None
-        elif isinstance(team, str):
-            team = team.lower()
-            if team in flag_ids:
-                return flag_ids.get(team.lower())
-            elif team in self.team_lookup:
-                return self.flag_id_raw(service, self.team_lookup[team])
-            return None
-        elif isinstance(team, int):
-            if str(team) in flag_ids:
-                return flag_ids.get(str(team))
-            elif str(team) in self.team_lookup:
-                return self.flag_id_raw(service, self.team_lookup[str(team)])
-            return None
-
-        raise ValueError(f"Invalid team type: {type(team)}: {team!r}")
-
-    def flag_id_flat(self, service: str, team: Union[str, int, Team]) -> list[str]:
-        """
-        Find flag IDs for a service and team.
-        Flag IDs are returned as a simple string list, containing all attack info for all flag stores.
-
-        :param service: Name of a service (case insensitive, see field "services" for a list of valid names)
-        :param team: Team ID, IP, name, or instance (from .team(...))
-        :return:
-        """
-        flag_ids = self.flag_id_raw(service, team)
-        return _flat(flag_ids) if flag_ids is not None else []
-
-    def attack_info_raw(self, service: str, team: Union[str, int, Team]) -> Optional[RawFlagIds]:
-        """
-        Find attack info for a service and team. Attack info is returned in the APIs raw format.
-
-        This is an alias for flag_id_raw(...).
-
-        :param service: Name of a service (case insensitive, see field "services" for a list of valid names)
-        :param team: Team ID, IP, name, or instance (from .team(...))
-        :return:
-        """
-        return self.flag_id_raw(service, team)
-
-    def attack_info_flat(self, service: str, team: Union[str, int, Team]) -> list[str]:
-        """
-        Find attack info for a service and team.
-        Attack info is returned as a simple string list, containing all attack info for all flag stores.
-
-        This is an alias for flag_id_flat(...).
-
-        :param service: Name of a service (case insensitive, see field "services" for a list of valid names)
-        :param team: Team ID, IP, name, or instance (from .team(...))
-        :return:
-        """
-        return self.flag_id_flat(service, team)
-
-    def __str__(self) -> str:
-        return repr(self)
-
-    def __repr__(self) -> str:
-        return f"AttackInfo(services={self.services!r}, {len(self.teams)} teams)"