ctf-attackapi 0.1.0__tar.gz → 0.2.2__tar.gz

{ctf_attackapi-0.1.0 → ctf_attackapi-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctf-attackapi
-Version: 0.1.0
+Version: 0.2.2
 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,20 @@ 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.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()` 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 +77,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
 -----------
@@ -172,6 +187,9 @@ print(info.team("10.32.1.2"))  # query Team object by ID, IP, or name
 # set of service names
 print(info.services)
 
+# flag format and the round this info was generated for, where the game reports them
+print(info.flag_regex, info.current_round)
+
 # raw flag IDs for a service and team.
 # team can be ID, IP, or name. 
 # Return data format is determined by game API.
@@ -229,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.1.0 → ctf_attackapi-0.2.2}/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,20 @@ 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.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()` 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 +43,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
 -----------
@@ -138,6 +153,9 @@ print(info.team("10.32.1.2"))  # query Team object by ID, IP, or name
 # set of service names
 print(info.services)
 
+# flag format and the round this info was generated for, where the game reports them
+print(info.flag_regex, info.current_round)
+
 # raw flag IDs for a service and team.
 # team can be ID, IP, or name. 
 # Return data format is determined by game API.
@@ -195,3 +213,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.2.2/pyproject.toml

@@ -0,0 +1,89 @@
+[project]
+name = "ctf-attackapi"
+version = "0.2.2"
+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.0/pyproject.toml → ctf_attackapi-0.2.2/pyproject.toml.orig

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

ctf_attackapi-0.2.2/src/attackapi/__init__.py

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

ctf_attackapi-0.2.2/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.0 → ctf_attackapi-0.2.2}/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.0 → ctf_attackapi-0.2.2}/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"])

{ctf_attackapi-0.1.0 → ctf_attackapi-0.2.2}/src/attackapi/models.py

@@ -1,22 +1,30 @@
 from dataclasses import dataclass, field, asdict
-from typing import Optional, Union, Any, cast
+from typing import Optional, Union, Any
 from typing_extensions import TypeAlias
 
 RawFlagIds: TypeAlias = Union[list, dict[str, Union[str, list, dict]]]
 
 
-def _flat(flag_ids: Any) -> list[str]:
+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 += _flat(value)
+            result += flatten_flag_ids(value)
         return result
     if isinstance(flag_ids, dict):
         result = []
         for value in flag_ids.values():
-            result += _flat(value)
+            result += flatten_flag_ids(value)
         return result
-    return [cast(str, flag_ids)]
+    return [str(flag_ids)]
 
 
 @dataclass(frozen=True)
@@ -46,6 +54,8 @@ class AttackInfo:
     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]:
@@ -100,7 +110,7 @@ class AttackInfo:
         :return:
         """
         flag_ids = self.flag_id_raw(service, team)
-        return _flat(flag_ids) if flag_ids is not None else []
+        return flatten_flag_ids(flag_ids) if flag_ids is not None else []
 
     def attack_info_raw(self, service: str, team: Union[str, int, Team]) -> Optional[RawFlagIds]:
         """

ctf_attackapi-0.1.0/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.0/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"]