bluebird-api 0.1.0__py3-none-any.whl

bluebird_api/__init__.py

@@ -0,0 +1,77 @@
+import logging
+import os
+import re
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+from bluebird_dt import logger
+from fastapi import FastAPI, Request, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.gzip import GZipMiddleware
+from fastapi.routing import APIRoute
+from fastapi.staticfiles import StaticFiles
+
+from .route_tags import tags_metadata
+from .routes import router
+
+bluebird_logger = logging.getLogger("bluebird_dt")
+bluebird_logger.setLevel(logging.DEBUG)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(logger.CustomFormatter())
+bluebird_logger.addHandler(stream_handler)
+
+app = FastAPI(
+    title="BluebirdATC: AI for air traffic control",
+    description="FastAPI interface to control the simulation framework BluebirdATC.",
+    license_info={
+        "name": "License",
+        "url": "https://github.com/project-bluebird/BluebirdATC/blob/dev/LICENSE",
+    },
+    openapi_tags=tags_metadata,
+    strict_content_type=False,
+)
+app.include_router(router)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+app.add_middleware(GZipMiddleware, minimum_size=500)
+
+# serve the frontend
+repo_root = Path(__file__).resolve().parents[2]
+dist_path = repo_root / "bluebird-hmi" / "dist"
+
+if dist_path.is_dir():
+    app.mount("/hmi", StaticFiles(directory=str(dist_path), html=True), name="frontend")
+    app.mount("/hmi/assets", StaticFiles(directory=os.path.join(dist_path, "assets")), name="assets")
+
+
+# For webapp, requests will be prepended with "/api" - strip that out here
+@app.middleware("http")
+async def strip_api_prefix(request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+    path = request.url.path
+    if path.startswith("/api"):
+        newpath = re.sub("/api", "", path)
+        request.scope["path"] = newpath
+    return await call_next(request)
+
+
+def use_route_names_as_operation_ids(app: FastAPI) -> None:
+    """
+    Simplify operation IDs so that generated API clients have simpler function
+    names.
+
+    Must be called after all routes have been added.
+    """
+    for route in app.routes:
+        if isinstance(route, APIRoute):
+            route.operation_id = route.name
+
+
+use_route_names_as_operation_ids(app)
+
+# keep track of current simulation instance
+# app.state.current_runner = None

bluebird_api/models.py

@@ -0,0 +1,39 @@
+import typing
+
+from bluebird_dt.utility.supported_actions import SUPPORTED_ACTIONS
+from pydantic import BaseModel, Field
+
+from bluebird_api.runnerabc import RunnerABC
+
+SUPPORTED_ACTIONS_LIST = [action for actions in SUPPORTED_ACTIONS.values() for action in actions]
+
+
+class RunnerStore:
+    current_runner: RunnerABC = None
+
+
+class ActionInput(BaseModel):
+    """An action to be sent to the simulator."""
+
+    agent: str = Field(
+        description="The agent performing the action.",
+        json_schema_extra={"example": "atc_1"},
+    )
+    callsign: str = Field(
+        description="The callsign of the flight being acted on.",
+        json_schema_extra={"example": "AIR123"},
+    )
+    kind: typing.Literal[tuple(SUPPORTED_ACTIONS_LIST)] = Field(
+        description="The kind of action to perform. Must be a string that is one of the supported actions.",
+        json_schema_extra={"example": "change_heading_to"},
+    )
+    value: typing.Any = Field(
+        description=(
+            "The value associated with the action. The type of this value depends on the action being performed."
+        ),
+        json_schema_extra={"example": 90},
+    )
+    sector: str = Field(
+        description="The sector that the action is being performed in.",
+        json_schema_extra={"example": "sector_1"},
+    )

bluebird_api/route_tags.py

@@ -0,0 +1,23 @@
+# FastAPI metadata tags for use in Swagger autodocs.
+tags_metadata = [
+    {
+        "name": "Control",
+        "description": "High level control of BluebirdATC.",
+    },
+    {
+        "name": "Scenarios",
+        "description": "Routes to get information about scenarios.",
+    },
+    {
+        "name": "Evolve",
+        "description": "Routes to start, stop and evolve the simulation.",
+    },
+    {
+        "name": "State",
+        "description": "Routes to get the state of the simulation.",
+    },
+    {
+        "name": "Submit",
+        "description": "Routes to submit actions, plans and more to the simulation.",
+    },
+]

bluebird_api/routers/__init__.py

@@ -0,0 +1,19 @@
+"""
+This module contains all the routers for the different features available in BluebirdATC. Note that, unlike in compiled
+programming languages where disabled features are not included in the machine code, not including certain routers just
+means that the endpoint is not available but the logic will continue to be available in BluebirdATC,
+and therefore logged.
+
+All the following routers are independent on the implementation of the storage of the runners and get this through the
+fastapi dependency. See the respective documentation in ../runnerabc.py.
+
+Note the endpoint for loading a run, that the HMI and most clients expect, is not included here as they are dependent on
+the implementation of the store, which is dependent on the use case. An example of this endpoint, and any other
+endpoints not included within the groups defined here are available in ../routes.py
+"""
+
+from .core import core_router
+
+__all__ = [
+    "core_router",
+]

bluebird_api/routers/core.py

@@ -0,0 +1,295 @@
+import typing
+from datetime import datetime, timezone
+
+import pandas as pd
+from bluebird_dt.events.event_logger import SimStartStop
+from bluebird_dt.simulator.common import list_sim_scenario_categories, list_sim_scenarios
+from fastapi import APIRouter
+
+from bluebird_api.models import ActionInput, RunnerStore
+
+from ..runnerabc import RunnerDep
+
+core_router = APIRouter()
+
+
+# explicitly store background tasks
+background_tasks = set()
+
+
+@core_router.get("/", tags=["Control"])
+async def index() -> str:
+    """
+    Verify that the API is running.
+    """
+
+    return "Hello, BluebirdATC!"
+
+
+@core_router.get("/list_scenario_categories", tags=["Scenarios"])
+async def list_scenario_categories():  # noqa: ANN201
+    """
+    List the scenario categories.
+    """
+
+    return list_sim_scenario_categories()
+
+
+@core_router.get("/list_scenarios/{category}", tags=["Scenarios"])
+async def list_scenarios(category: str):  # noqa: ANN201
+    """
+    List the scenarios in a given category.
+    """
+
+    return list_sim_scenarios(category)
+
+
+@core_router.post("/close", tags=["Control"])
+async def close(runner: RunnerDep) -> bool:
+    """
+    Unload a given simulator scenario.
+    """
+
+    await runner.delete()
+    RunnerStore.current_runner = None
+    return True
+
+
+@core_router.post("/evolve/{time_delta}", tags=["Evolve"])
+async def evolve(runner: RunnerDep, time_delta: float) -> bool:
+    """
+    Evolve the simulation by a given time delta (in seconds).
+    Note that this steps through the sim in steps of sim.evolve_period.
+    """
+    if time_delta <= 0.0:
+        raise Exception("Time delta must be positive.")
+
+    # evolve the sim in steps of self.evolve_period until time_delta is reached
+    update_amount = runner.evolve_period
+
+    while time_delta > 0.0:
+        runner.sim.evolve(update_amount)
+        time_delta -= update_amount
+
+    return True
+
+
+@core_router.post("/start/{tick_frequency_period}", tags=["Evolve"])
+async def start(runner: RunnerDep, tick_frequency_period: float) -> bool:
+    """
+    Start the simulation running with a given tick_frequency_period (in seconds).
+    """
+
+    if tick_frequency_period <= 0.0:
+        raise Exception("tick_frequency_period must be positive.")
+
+    runner.tick_frequency_period = tick_frequency_period
+    runner.sim.manager.event_logger.log_sim_event(
+        SimStartStop(event="clocks on", simulation_datetime=runner.sim.manager.environment.datetime)
+    )
+    runner.log_simrate()
+    runner.running = True
+
+    return True
+
+
+@core_router.get("/environment", tags=["State"])
+async def complete_environment(  # noqa: ANN201
+    runner: RunnerDep, no_airspace: bool = False, last_n_observations: int = 0
+):
+    """
+    Get the all of the environment data.
+    """
+    if RunnerStore.current_runner is None or runner.sim is None:
+        return {"exists": False}
+    # HMI doesn't need to reload the environment again
+    runner.sim.manager.reload_environment = False
+
+    return runner.sim.environment(
+        sim_time=runner.sim.manager.environment.time,
+        sector_id=None,
+        no_airspace=no_airspace,
+        last_n_observations=last_n_observations,
+    )
+
+
+@core_router.get("/environment/{sector_id}", tags=["State"])
+async def environment(  # noqa: ANN201
+    runner: RunnerDep, sector_id: str | None = None, no_airspace: bool = False, last_n_observations: int = 0
+):
+    """
+    Get the environment data for a given sector.
+    """
+    if RunnerStore.current_runner is None or runner.sim is None:
+        return {"exists": False}
+    # HMI doesn't need to reload the environment again
+    runner.sim.manager.reload_environment = False
+
+    return runner.sim.environment(
+        sim_time=runner.sim.manager.environment.time,
+        sector_id=sector_id,
+        no_airspace=no_airspace,
+        last_n_observations=last_n_observations,
+    )
+
+
+@core_router.get("/static_data", tags=["State"])
+async def static_data(  # noqa: ANN201
+    runner: RunnerDep,
+):
+    """
+    Get the static data for the scenario.
+    """
+    if RunnerStore.current_runner is None or runner.sim is None:
+        return {"exists": False}
+    return {"exists": True} | runner.sim.static_data(
+        sim_time=runner.sim.manager.environment.time,
+    )
+
+
+@core_router.get("/dynamic_data/{sector_id}", tags=["State"])
+async def dynamic_data(  # noqa: ANN201
+    runner: RunnerDep, sector_id: str | None = None
+):
+    """
+    Get the dynamic data for the scenario.
+    """
+    if RunnerStore.current_runner is None or runner.sim is None:
+        return {"exists": False}
+    sim_time = runner.sim.manager.environment.time
+    if sector_id.lower() == "none" or sector_id.lower() == "all":
+        return {"exists": True} | runner.sim.dynamic_data(sim_time)
+
+    return {"exists": True} | runner.sim.dynamic_data(sim_time=sim_time, sector_id=sector_id)
+
+
+@core_router.post("/actions", tags=["Submit"])
+async def actions(runner: RunnerDep, action_input: list[ActionInput]) -> bool:
+    """
+    Send actions to the simulator. The POST body should be a JSON list of
+    actions.
+    """
+
+    timed_actions = []
+
+    for act in action_input:
+        agent = act.agent
+        callsign = act.callsign
+        kind = act.kind
+        value = act.value
+        sector = act.sector
+
+        action_time = (
+            datetime.fromtimestamp(
+                runner.sim.manager.environment.time,
+                tz=timezone.utc,
+            ).isoformat(timespec="microseconds")[:-6]
+        ).replace("T", " ")
+
+        print(f"{action_time} : {agent} : {callsign} -> {kind} = {value}")
+
+        action: dict[str, typing.Any] = {
+            "agent": agent,
+            "callsign": callsign,
+            "kind": kind,
+            "value": value,
+            "time": action_time,
+            "sector": sector,
+        }
+
+        timed_actions.append(action)
+
+    runner.sim.action(timed_actions)
+
+    return True
+
+
+@core_router.get("/status", tags=["Control"])
+async def runner_status(runner: RunnerDep):  # noqa: ANN201
+    """
+    Get the current state of the current run.
+    """
+    if RunnerStore.current_runner is None:
+        return {"exists": False}
+    return {
+        "exists": runner.scenario_name is not None,
+        "iterations": runner.tick,
+        "category": runner.category,
+        "scenario": runner.scenario_name,
+        "running": runner.running,
+        "evolve_period": runner.evolve_period,
+        "tick_frequency_period": runner.tick_frequency_period,
+        "kill": runner.kill,
+        "reload": runner.sim.manager.reload_environment if runner.sim is not None else False,
+        "time_of_next_tick": runner.time_of_next_tick.isoformat(),
+    }
+
+
+@core_router.post("/save", tags=["Control"])
+async def save(runner: RunnerDep) -> bool:
+    """
+    Save sim state to JSON file.
+    """
+    runner.sim.save()
+
+    return True
+
+
+@core_router.post("/evolve_period/{evolve_period}", tags=["Evolve"])
+async def set_evolve_period(runner: RunnerDep, evolve_period: float) -> bool:
+    """
+    Change the update period.
+    """
+
+    if evolve_period <= 0.0:
+        raise Exception("Evolve period must be positive.")
+
+    runner.evolve_period = evolve_period
+
+    return True
+
+
+@core_router.post("/tick_frequency/{tick_frequency}", tags=["Evolve"])
+async def set_tick_frequency(runner: RunnerDep, tick_frequency: float) -> bool:
+    """
+    Change the update tick frequency.
+    """
+
+    if tick_frequency <= 0.0:
+        raise Exception("Tick frequency must be positive.")
+
+    runner.tick_frequency_period = tick_frequency
+
+    return True
+
+
+@core_router.post("/pause", tags=["Evolve"])
+async def pause(runner: RunnerDep) -> bool:
+    """
+    Pause the simulation.
+    """
+    runner.running = False
+
+    return True
+
+
+@core_router.post("/rewind/{new_time}", tags=["Control"])
+async def rewind(runner: RunnerDep, new_time: str) -> bool:
+    """
+    Rewind sim to a previous time
+    """
+
+    date_format = "%Y-%m-%d %H:%M:%S"
+    rewind_to_time = pd.to_datetime(new_time, format=date_format)
+    runner.sim.manager.rewind_to_time(rewind_to_time)
+
+    return True
+
+
+@core_router.get("/selected_aircraft/{sector_id}", tags=["State"])
+async def get_selected_aircraft(sector_id: str, runner: RunnerDep) -> dict:
+    """
+    Get the currently selected aircraft for a given sector.
+    """
+
+    return runner.hmi.get(sector_id, {"selected_aircraft": ""})

bluebird_api/routes.py

@@ -0,0 +1,50 @@
+"""
+The routes module builds the router for the proided endpoint and adds any endpoints only available for
+BluebirdATC, including loading which is implementation dependent.
+"""
+
+import asyncio
+
+from fastapi import APIRouter, Depends, Request
+
+from bluebird_api.models import RunnerStore
+from bluebird_api.routers.core import background_tasks
+from bluebird_api.runner import Runner
+
+from .routers import (
+    core_router,
+)
+
+
+async def simulator(request: Request):
+    """
+    The simulator dependency, available to endpoints using the RunnerDep dependency, provides access to the runner.
+    """
+
+    request.state.runner = RunnerStore.current_runner
+
+
+router = APIRouter(dependencies=[Depends(simulator)])
+
+router.include_router(core_router)
+
+
+@router.post("/load/{category}/{scenario_name}", tags=["Control"])
+async def load(category: str, scenario_name: str) -> bool:  # noqa: ARG001
+    """
+    End any existing run, then create a new Runner and load a given simulator scenario.
+    """
+
+    if RunnerStore.current_runner is not None:
+        await RunnerStore.current_runner.delete()
+
+    RunnerStore.current_runner = Runner(category, scenario_name)
+
+    # start the task
+    task = asyncio.create_task(RunnerStore.current_runner.run_main())
+
+    # add the task to the background tasks set and have it auto-remove its reference from the set when done
+    background_tasks.add(task)
+    task.add_done_callback(background_tasks.remove)
+
+    return True

bluebird_api/runner.py

@@ -0,0 +1,27 @@
+"""
+The runner implementation for the general BluebirdATC API. This runner is responsible for the initialisation of the
+simulator class.
+"""
+
+import asyncio
+
+from bluebird_dt.simulator import Simulator
+from typing_extensions import override
+
+from bluebird_api.runnerabc import RunnerABC
+
+
+class Runner(RunnerABC):
+    def __init__(self, category: str, scenario_name: str):
+        super().__init__(category, scenario_name)
+
+    @override
+    def initialise_simulator(self, *args, **kwargs) -> Simulator:  # noqa: ANN002, ANN003
+        return Simulator.from_category(*args, **kwargs)
+
+    @override
+    async def delete(self):
+        self.kill = True
+        self.sim.save()
+        self.sim = None
+        await asyncio.sleep(3)

bluebird_api/runnerabc.py

@@ -0,0 +1,148 @@
+"""
+This module provides the interfaces used in all endpoints to obtain data from the runner and simulator that is being
+requested.
+
+The first thing available is the RunnerABC class, which is implemented for BluebirdATC in ./runner.py.
+
+Secondly, and most importantly, this module provides the FastAPI dependency for the runner, used to access the simulator
+instance, RunnerDep.
+To use this dependency, create an endpoint as would be done normally.
+As one of the arguments to the function, include the RunnerDep type alias as shown in the example below and
+it will be available to interact with.
+
+>>> from ..runnerabc import RunnerDep
+>>> @core_router.post("/close", tags=["Control"])
+>>> async def close(runner: RunnerDep) -> bool:
+>>>    await runner.delete()
+>>> return True
+
+If during resolution of the runner, for example trying to find the runner, the runner is not available,
+a HTTP error 404 (Not found) will be returned before even running the function above.
+"""
+
+import asyncio
+import typing
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from datetime import datetime, timedelta
+
+from bluebird_dt.events.event_logger import SimRateUpdate
+from bluebird_dt.logger import logger
+from bluebird_dt.simulator.simulator import Simulator
+from fastapi import Depends, HTTPException, Request
+
+
+class RunnerABC(ABC):
+    kill: bool
+    category: str
+    scenario_name: str
+    sim: Simulator
+    running: bool
+    evolve_period: float
+    tick_frequency_period: float
+    tick: int
+    hmi: dict
+
+    @abstractmethod
+    def initialise_simulator(self, *args, **kwargs) -> Simulator:  # noqa: ANN002, ANN003
+        """
+        Function to instantiate the simulator class, or variations of it for each use case.
+
+        This function is designed to be a transparent function taking all the arguments passed into the constructor of
+        the runner class from the load endpoint.
+        """
+        pass
+
+    @abstractmethod
+    async def delete(self):
+        pass
+
+    def log_simrate(self):
+        """
+        Creates an entry in the file logs with the current tick frequency and evolve period of the runner.
+
+        See documentation for the event_logger.log_sim_event for more information.
+        """
+        self.sim.manager.event_logger.log_sim_event(
+            SimRateUpdate(
+                simulation_datetime=self.sim.manager.environment.datetime,
+                tick_frequency=self.tick_frequency_period,
+                evolve_period=self.evolve_period,
+            )
+        )
+
+    def __init__(self, category: str, scenario_name: str, log_name: str | None = None):
+        """
+        Constructor of the Runner classes.
+
+        Although the argumets of this function are currently hardcoded, if a usecase requires different ones they will
+        be replaced by args and kwargs placeholders.
+
+        Arguments
+        ---------
+        category: str
+            The category of scenario to load
+        scenario_name: str
+            The specific scenario of the category to load
+        log_name: str
+            The name to store the logs for the run.
+        """
+        self.category = category
+        self.scenario_name = scenario_name
+        self.sim = self.initialise_simulator(self.category, self.scenario_name, log_filename=log_name)
+        self.running = False
+        self.evolve_period = 6.0
+        self.tick_frequency_period = 6.0
+        self.kill = False
+        self.time_of_next_tick = datetime.min
+        self.tick = 0
+        self.hmi = defaultdict(lambda: {"selected_aircraft": ""})
+
+        # allow 'None' and 'ALL' sectors to also select aircraft
+        self.hmi["None"] = {"selected_aircraft": ""}
+        self.hmi["ALL"] = {"selected_aircraft": ""}
+        # try a lock to avoid concurrency bugs
+        self._sim_lock = asyncio.Lock()
+
+    async def run_main(self):
+        self.time_of_next_tick = datetime.now()
+
+        while True:
+            if self.running and datetime.now() >= self.time_of_next_tick:
+                async with self._sim_lock:
+                    start_time = datetime.now()
+                    self.time_of_next_tick = start_time + timedelta(seconds=self.tick_frequency_period)
+
+                    self.sim.evolve(self.evolve_period)
+                    self.tick += 1
+                    logger.info(f"evolve time: {datetime.now() - start_time}")
+
+            if self.kill:
+                self.category = None
+                self.scenario_name = None
+                break
+
+            await asyncio.sleep(0.1)
+
+
+async def runner(request: Request) -> RunnerABC:  # noqa: ARG001
+    """
+    Function taking the runner information from the state, and making it available for the endpoint that uses it. See
+    module documentation for more details on usage, and an example.
+
+    This FastAPI dependency will throw a HTTP exception if the runner isinstance is not found, therefore this does not
+    need to be handled by the individual endpoint.
+    """
+    runner = request.state.runner
+
+    if runner is None:
+        raise HTTPException(404, "Runner instance not found")
+
+    if not isinstance(runner, RunnerABC):
+        raise HTTPException(500, "The runner passed is not a valid type.")
+
+    request.state.runner = None
+    return runner
+
+
+RunnerDep = typing.Annotated[RunnerABC, Depends(runner)]

bluebird_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: bluebird-api
+Version: 0.1.0
+Summary: A REST API for the Project Bluebird Digital Twin
+Author: Project Bluebird
+License-Expression: AGPL-3.0-or-later
+Requires-Python: <3.15,>=3.10
+Requires-Dist: bluebird-dt
+Requires-Dist: fastapi<0.137,>=0.136.1
+Requires-Dist: lxml-html-clean>=0.4.4
+Requires-Dist: uvicorn<0.47,>=0.46.0
+Description-Content-Type: text/markdown
+
+## The REST API for BluebirdATC
+
+It is possible to run the BluebirdATC digital twin in a server process, such that the simulation will evolve at regular time intervals, and Agents and/or frontend visualization software can interact with it via HTTP requests.
+In particular, users can:
+* Query available scenario categories and scenarios.
+* Load a selected scenario.
+* Evolve the simulation by a specified time interval.
+* Obtain the current state of the `Environment`.
+* Submit `Actions` to individual aircraft.
+* Save logfiles with data on all steps of the simulation.
+
+In order to run the app, with all the correct dependencies for this feature, from the `BluebirdATC/bluebird-api` directory, run the command:
+
+```shell
+uv run uvicorn bluebird_api:app --port 8000
+```
+
+You should then be able to go to [http://localhost:8000](http://localhost:8000) in a web browser, and see the message "Hello, BluebirdATC!".
+
+To see the full list and description of API endpoints, with the application running, go to [http://localhost:8000/docs](http://localhost:8000/docs).
+
+## Frontend visualisation
+
+The app also serves the frontend visualization (more details on that can be found [here](../bluebird-hmi/README.md)), at the URL [http://localhost:8000/hmi](http://localhost:8000/hmi).

bluebird_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+bluebird_api/__init__.py,sha256=MknZUHlacEtAxkoDnRM3seRpPc-NoU3ZBrXWhq51GUU,2425
+bluebird_api/models.py,sha256=WDn5DY3e9-vkEYiJUMcXLFTPfXm9GMaErgCFLcBV0y0,1310
+bluebird_api/route_tags.py,sha256=O7lt8V_lICSDaiv_bCBtloZyIkuFtrSIoP7rVzAl3Ko,631
+bluebird_api/routes.py,sha256=Ta-olnEcMiDVrIgSWBDs7StLbzXJ_CCI0NXQIUoIkNM,1457
+bluebird_api/runner.py,sha256=0S2IdAcOzbROARSx1OySp6xBM2qwM3VEmoo3fQw34v8,731
+bluebird_api/runnerabc.py,sha256=BV9Z2hPYrE3-ay0TDZtqlOPHIduuDKqqQ9ApOHvIpEk,5310
+bluebird_api/routers/__init__.py,sha256=1ta7f7k3a6GaAKIYniQs4xquL7OwXJtAsipaWfS7POs,946
+bluebird_api/routers/core.py,sha256=k2RIdhLVzF5mjs-iuLlsidtYXDj_d_tSD_P09QT8--4,8320
+bluebird_api-0.1.0.dist-info/METADATA,sha256=kd1F1ZW5AcL1T6J-ysWUW5clAT4tGRyn16E-EIFr4RA,1664
+bluebird_api-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+bluebird_api-0.1.0.dist-info/RECORD,,

bluebird_api-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any