mirror of
https://github.com/kuhyx/WUT_Computer_Science.git
synced 2026-11-10 18:47:11 +01:00
Krzysztof kuhy Rudnicki
74fb46b4ab
152 ruff findings to 0 across twelve files, and mypy --strict is clean on all of them but one -- see the end. The course is marked unrunnable because it wants Kafka and Flink, so the verification is what can be run without them. Ten of the twelve modules now import cleanly against a venv with confluent-kafka, kafka-python and flask; the two pyflink ones are skipped. That check did not exist before, because four of these files WERE their own side effect: - `kafka/generate_and_send.py` and `kafka/kafka_consumer.py` ran their `while True:` loop at module level. Importing either never returns; I gave up after twelve seconds of rdkafka connection failures. - `zin1/producent.py` built a KafkaProducer at module level and raised NoBrokersAvailable on import. - `flink/anomaly_detector.py` called `env.execute()` at module level. Each is a `main()` behind a `__main__` guard now, so importing one is free and running it is unchanged. `webinterface.py` called `json.loads` and never imported json, so the first message on the topic would have raised NameError. mypy then found three more of the same shape: confluent-kafka's `msg.error()` and `msg.value()` both return Optional, and the code dereferenced them straight away. They are narrowed to locals now, which also stops `msg.error()` being called twice per message. A malformed alarm with no timestamp is skipped with a warning instead of dividing None by 1000. Two SLF001 findings were reads of `KafkaError._PARTITION_EOF`. That leading underscore is confluent-kafka's own naming and there is no public alias, but `KafkaError.name()` is public and returns exactly that string -- checked against the installed library, where code() is -191 and name() is "_PARTITION_EOF". Flask's `debug=True` is now opt-in via FLASK_DEBUG, because the debug console executes arbitrary code. The ten `random` calls are simulation, not crypto, so S311 is not a real vulnerability -- but `secrets.SystemRandom()` is a drop-in with the same methods and no rule to argue with, so that is what they use. Behaviour is checked, not assumed: the sensor still returns a location in 1..10 and a temperature in -20..40, the thresholds still classify -15 as too cold, 40 as too hot and 20 as normal, transactions still carry a four-digit card id, and TemperatureReading survives a to_dict/from_dict round trip. **Two mypy errors remain and are deliberate.** `--strict` implies `disallow_subclassing_any`, and the Flink job must subclass pyflink's MapFunction and KeyedProcessFunction, which ship no types. Fixing it means weakening strict globally or writing an override for our own module. Neither is worth it, so the two are reported in TODO-refactor-remaining.md rather than hidden. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
60 lines
1.6 KiB
Python
Executable File
60 lines
1.6 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""A one-route Flask app that drains the `alarms` topic and returns it as JSON."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
from typing import TYPE_CHECKING
|
|
|
|
from confluent_kafka import Consumer
|
|
from flask import Flask, jsonify
|
|
|
|
if TYPE_CHECKING:
|
|
from flask.typing import ResponseReturnValue
|
|
|
|
app = Flask(__name__)
|
|
|
|
# confluent-kafka names this error _PARTITION_EOF, leading underscore and all.
|
|
# `KafkaError.name()` is the public way to ask for it without reaching into a
|
|
# private attribute; it returns exactly this string.
|
|
PARTITION_EOF = "_PARTITION_EOF"
|
|
|
|
HTTP_INTERNAL_SERVER_ERROR = 500
|
|
|
|
|
|
@app.route("/alarms", methods=["GET"])
|
|
def get_alarms() -> ResponseReturnValue:
|
|
"""Return every alarm currently on the topic, oldest first."""
|
|
alarms = []
|
|
conf = {
|
|
"bootstrap.servers": "localhost:9092",
|
|
"group.id": "alarm_group",
|
|
"auto.offset.reset": "earliest",
|
|
}
|
|
|
|
consumer = Consumer(**conf)
|
|
consumer.subscribe(["alarms"])
|
|
|
|
while True:
|
|
msg = consumer.poll(timeout=1.0)
|
|
if msg is None:
|
|
break
|
|
error = msg.error()
|
|
if error is not None:
|
|
if error.name() == PARTITION_EOF:
|
|
continue
|
|
return str(error), HTTP_INTERNAL_SERVER_ERROR
|
|
value = msg.value()
|
|
if value is not None:
|
|
alarms.append(json.loads(value.decode("utf-8")))
|
|
|
|
consumer.close()
|
|
return jsonify(alarms)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# Debug mode serves a console that executes arbitrary code, so it is opt-in
|
|
# rather than the default it used to be here.
|
|
app.run(debug=os.environ.get("FLASK_DEBUG") == "1")
|