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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctf-attackapi
-Version: 0.2.2
+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
@@ -54,6 +54,31 @@ 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
 ----------------
 
@@ -61,7 +86,7 @@ Changes in 0.2.0
   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
+- 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.
@@ -98,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)
 ```
 
@@ -184,23 +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"))
 
 # 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. 
+# 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_id_raw("servicename", "10.32.1.2"))
+print(info.flag_ids_raw("servicename", "10.32.1.2"))
 # => {"227": "abc", "228": "def", ...}
-
-# Get flag IDs as string list (independent of game API format, but less precise)
-print(info.flag_id_flat("servicename", "10.32.1.2"))
-# => ["abc", "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
 --------------------
 

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

@@ -20,6 +20,31 @@ 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
 ----------------
 
@@ -27,7 +52,7 @@ Changes in 0.2.0
   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
+- 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.
@@ -64,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)
 ```
 
@@ -150,23 +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"))
 
 # 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. 
+# 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_id_raw("servicename", "10.32.1.2"))
+print(info.flag_ids_raw("servicename", "10.32.1.2"))
 # => {"227": "abc", "228": "def", ...}
-
-# Get flag IDs as string list (independent of game API format, but less precise)
-print(info.flag_id_flat("servicename", "10.32.1.2"))
-# => ["abc", "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
 --------------------
 

{ctf_attackapi-0.2.2 → ctf_attackapi-0.3.0}/pyproject.toml

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

@@ -1,6 +1,6 @@
 [project]
 name = "ctf-attackapi"
-version = "0.2.2"
+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.2.2 → ctf_attackapi-0.3.0}/src/attackapi/async_api/decoders.py

@@ -171,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.2.2 → 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.2.2/src/attackapi/__init__.py

@@ -1,4 +0,0 @@
-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/models.py

@@ -1,144 +0,0 @@
-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)]
-
-
-@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)
-    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 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 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]:
-        """
-        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)"