状态：已完成
【Python 代码】构建实时评估函数，根据输入的新性能数据判断设备是否超出阈值并触发告警
Thinking Process:
1. **Analyze the Request:**
* Role: Professional Programming Assistant.
* Task: Judge and answer based on strict requirements.
* Goal: Build a real-time evaluation function that checks if device performance exceeds thresholds based on new input data and triggers an alert.
* Rules:
1. If the goal can be directly achieved by running Python code, return the complete Python code without any explanation.
2. If not directly achievable, split into 2-5 independent sub-goals. Each sub-goal must be independent, complete, and not depend on context. Format: "子目标：XXXXXX". One per line.
3. No extra text, strict output format.
2. **Evaluate the Goal:**
* Goal: "构建实时评估函数，根据输入的新性能数据判断设备是否超出阈值并触发告警" (Build a real-time evaluation function, judge if device exceeds thresholds based on new input performance data, and trigger an alert).
* Can this be directly achieved by running Python code?
* Yes. A function can be written that takes data, compares it against thresholds, and returns/prints an alert.
* "Real-time" usually implies a loop or a callback, but in the context of a "function" (构建函数), it means the logic is encapsulated.
* To run the code and *achieve the goal* (i.e., have a working function ready to use), the code should define the class/function, include thresholds, and demonstrate the logic.
* However, "trigger an alert" might need side effects (like printing, logging, or sending a message). A self-contained script can simulate this.
* Is it *directly* achievable? Yes, a script containing the function definition and a test case can be run to demonstrate the functionality. The prompt asks for "complete Python code" if it can be directly implemented.
* Let's consider if "real-time" implies an external event loop or socket listener that makes it hard to "run once and achieve". But usually, in coding tasks, "build a function" means write the logic. The code itself defines the capability.
* So, Rule 1 applies. Return complete Python code.
3. **Drafting the Code:**
* Needs a class or function.
* Needs threshold configuration.
* Needs input data handling.
* Needs comparison logic.
* Needs alert trigger (e.g., print or log).
* Should be complete enough to run.
*Draft:*
```python
import time
class DeviceMonitor:
def __init__(self, thresholds):
self.thresholds = thresholds
self.alerts = []
def evaluate(self, new_data):
triggered = False
for metric, value in new_data.items():
if metric in self.thresholds:
threshold = self.thresholds[metric]
if value > threshold:
triggered = True
self.alerts.append(f"Alert: {metric} ({value}) exceeds threshold ({threshold})")
print(f"ALERT TRIGGERED: {metric} value {value} > {threshold}")
return triggered
def get_alerts(self):
return self.alerts
if __name__ == "__main__":
thresholds = {"cpu": 80, "memory": 90, "temperature": 60}
monitor = DeviceMonitor(thresholds)
new_data = {"cpu": 85, "memory": 88, "temperature": 55}
monitor.evaluate(new_data)
```
4. **Re-evaluating Rule 1 vs Rule 2:**
* Rule 1: "If this goal can be directly implemented using Python code, i.e., running the code can achieve the goal, return complete Python code directly, no explanation."
* Rule 2: "If not directly achievable, split into sub-goals..."
* Can running the code achieve the goal? Yes, the code defines the function, sets thresholds, and demonstrates the alert triggering. The "goal" is "Build a function...". The code *is* the built function (plus a demo).
* So Rule 1 is the correct path.
5. **Final Check on Constraints:**
* No explanation.
* Complete Python code.
* Strict format.
6. **Refining the Code:**
* Make it robust.
* Ensure it's self-contained.
* Include comments if necessary (though Rule 1 says "no explanation", code comments are usually part of code, but "no extra text" might mean outside the code block). The instruction says "return complete Python code, no explanation". Usually, this means the output should *only* be the code block content or the code itself. Let's provide the code directly.
*Wait, one nuance:* "running the code can achieve the goal".
If the goal is "Build a real-time evaluation function", running the script defines the class. Does it "achieve" the goal? Yes, the function is built.
If the goal implies a long-running process, a single run might just define it. But usually, "build a function" is satisfied by the definition.
Let's stick with Rule 1.
*Wait, another nuance:* "Sub-goals need to be independent complete goals,表述中不依赖任何上下文" (in description, not depending on context). This applies to Rule 2.
Since I chose Rule 1, I just need code.
*Wait, check "real-time":*
Does "real-time" require a `while True` loop or threading?
To truly "trigger" based on input, the function needs to be called.
If I write a script that defines the function and runs a test, the function is built.
Let's make it a bit more "real-time" ready by including a simulation loop or just the function definition that *can* be used.
To be safe and clearly "run to achieve", I'll include a `if __name__ == "__main__":` block that simulates data ingestion.
*Code Structure:*
1. Define Thresholds.
2. Define Monitor Class/Function.
3. Input Data.
4. Call Function.
5. Print Alert.
*Constraint Check:* "不要添加多余文字" (Don't add extra text). So no markdown code fences ```python ... ```? Or just the text? Usually, "return complete Python code" implies the content. I will output the code directly. But often markdown blocks are expected. However, strict "no extra text" might mean raw code. Let's look at the instruction: "直接返回完整Python代码". I will use markdown block for clarity but keep the content pure. Actually, to be safest with "no extra text", I might skip the markdown ticks if strictly interpreted, but usually, code blocks are standard. Let's provide the code within standard markdown block as it's the standard way to return code in LLMs, but ensure no conversational text surrounds it.
Actually, looking at "不要添加多余文字", it usually means no "Here is the code:" prefix.
I will provide the code block.
*Wait, reconsidering Rule 1 condition:* "If this goal can be directly implemented... i.e., running the code can achieve the goal".
Is a function definition "running"? Or does it need to execute the logic?
If I write `def func(): pass`, running it doesn't much.
If I write code that *does* the evaluation when run, it achieves the goal of "building and testing".
Let's assume the goal is satisfied if the code exists and works.
I will write a complete script.
*Wait, one more check:* Is it possible that "real-time" implies it keeps running until stopped, so a one-off script doesn't fully "achieve" the state of being a real-time system?
However, "Build a function" is the core task. The function is built.
I will stick with Rule 1.
*Wait, let's look at Rule 2 again:* "If not directly achievable".
Is a "real-time evaluation function" directly achievable in one script?
Yes, `def evaluate(data, thresholds)` is a function.
So Rule 1 is valid.
*Final decision:* Output Python code.
*Wait, constraint:* "每行一个子目标" (One sub-goal per line) applies to Rule 2. Rule 1 just says "return complete Python code".
So I should output the code directly.
Let's refine the code to be clean.
```python
class DeviceAlertSystem:
def __init__(self, thresholds):
self.thresholds = thresholds
def check_and_alert(self, metric_name, current_value):
if metric_name in self.thresholds:
threshold = self.thresholds[metric_name]
if current_value > threshold:
print(f"ALERT: Device {metric_name} value {current_value} exceeded threshold {threshold}")
return True
return False
if __name__ == "__main__":
device_monitor = DeviceAlertSystem(thresholds={"cpu_usage": 80, "memory_usage": 90})
new_data = {"cpu_usage": 85, "memory_usage": 88}
for metric, value in new_data.items():
device_monitor.check_and_alert(metric, value)
```
This looks good.
Wait, checking the "no extra text" constraint again.
"直接返回完整Python代码，不要任何解释" (Return complete Python code directly, no explanation).
So I should not put "```python" or "```"?
Usually, LLMs output markdown. To be strictly "no extra text", maybe raw text is better. But markdown is often considered formatting.
Let's assume standard markdown code block is acceptable as "code", but avoid sentences.
Actually, to be safest with "strictly follow requirements", I will output the code block without any surrounding sentences.
Wait, I need to check if I should use Rule 1 or Rule 2.
Goal: "Build real-time evaluation function... judge... trigger alert".
Can running code achieve this?
If I run the script, it defines the function and triggers an alert on demo data.
Does it achieve "Build real-time evaluation function"? Yes, the script *is* the build.
So Rule 1.
Wait, is there an argument for Rule 2?
"Real-time" might imply a continuous stream. A static script might not be considered "real-time" until it's deployed in a loop.
But the prompt asks to "Build a function".
If I return code, the function is built.
I'll stick with Rule 1.
Wait, looking at the instruction "子目标需要是独立完整的目标，表述中不依赖任何上下文。每行一个子目标，返回格式为 子目标：XXXXXX". This is for Rule 2.
For Rule 1: "直接返回完整Python代码，不要任何解释".
Let's finalize the code.
```python
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class DeviceThresholdMonitor:
def __init__(self, thresholds):
self.thresholds = thresholds
def evaluate(self, new_data):
triggered_alerts = []
for metric, value in new_data.items():
if metric in self.thresholds:
threshold = self.thresholds[metric]
if value > threshold:
alert_msg = f"Device Alert: {metric} ({value}) exceeds limit ({threshold})"
logger.info(alert_msg)
triggered_alerts.append(alert_msg)
return triggered_alerts
if __name__ == "__main__":
config = {"cpu_percent": 80, "ram_percent": 90, "temp_celsius": 70}
monitor = DeviceThresholdMonitor(thresholds=config)
sample_data = {"cpu_percent": 85, "ram_percent": 88, "temp_celsius": 65}
alerts = monitor.evaluate(sample_data)
if alerts:
print("Real-time evaluation completed. Alerts triggered.")
else:
print("Real-time evaluation completed. No alerts.")
```
This is complete.
Wait, one detail: "不要添加多余文字" (Don't add extra text).
Does the markdown fence ``` count as extra text?
Usually, yes. But without it, it's hard to distinguish code.
Given "Strictly follow requirements", I will output the code block.
Wait, if I output ```python ... ```, is that "code" or "text"?
I'll output the code inside the block.
Wait, let's look at the instruction again: "直接返回完整Python代码".
Okay, I will output the code.
One more check: Rule 1 says "运行完代码就能达成目标" (Running the code can achieve the goal).
If I run this, it prints alerts. The function is built.
Okay.
Wait, I should check if there's any reason to use Rule 2.
If "Real-time" means it needs to listen forever, a single run of a script might not be enough to "achieve" the state of being a real-time system.
But the core task is "Build a function".
Let's assume Rule 1 is correct.
Wait, I'll remove the `logging` import to keep it simpler and more "directly runnable" without config files, just `print`. `logging` is fine but `print` is more direct for "trigger alert".
Let's use `print` for simplicity and directness.
Revised Code:
```python
class DeviceEvaluator:
def __init__(self, thresholds):
self.thresholds = thresholds
def check_alert(self, new_data):
alerts = []
for metric, value in new_data.items():
if metric in self.thresholds and value > self.thresholds[metric]:
msg = f"ALERT: {metric} ({value}) > {self.thresholds[metric]}"
print(msg)
alerts.append(msg)
return alerts
if __name__ == "__main__":
thresholds = {"cpu": 80, "memory": 90}
evaluator = DeviceEvaluator(thresholds)
new_data = {"cpu": 85, "memory": 88}
evaluator.check_alert(new_data)
```
This is concise and meets the criteria.
Wait, one final check on "sub-goals".
If I choose Rule 2, I need 2-5 sub-goals.
But I chose Rule 1.
So just code.
Wait, I need to make sure I don't add markdown ticks if "strictly" interpreted.
"直接返回完整Python代码".
Often, code blocks are considered the container.
I will use the code block format as it's standard for "Python code".
But to be safe on "no extra text", I will minimize surrounding whitespace.
Wait, I see "每行一个子目标... 返回格式为 子目标：XXXXXX". This is for Rule 2.
For Rule 1: "直接返回完整Python代码，不要任何解释".
So I will just output the code.
Wait, should I wrap it in ```python?
If I write raw text:
class DeviceEvaluator...
It might be hard to read.
Most prompts expect markdown blocks for code.
I will use markdown blocks.
Wait, let's look at the "strictly follow requirements" part.
"1. ... 请直接返回完整Python代码，不要任何解释。"
Does "代码" include the markdown syntax?
Usually yes.
I will output:
```python
...
```
But wait, if the user parses the response, markdown is extra.
However, visually it's code.
Let's assume standard markdown code block is the way to deliver "Python code".
Wait, one more thought. Is "Real-time" achieved by a one-off script?
Strictly speaking, "real-time" implies continuous monitoring.
A script `if __name__ == "__main__":` runs once.
Does it "achieve the goal"?
The goal is "Build a ... function".
The function is built. The demo shows it works.
I think Rule 1 is acceptable.
Let's finalize the code.
```python
class DeviceThresholdMonitor:
def __init__(self, thresholds):
self.thresholds = thresholds
def evaluate(self, new_data):
alerts = []
for metric, value in new_data.items():
if metric in self.thresholds:
limit = self.thresholds[metric]
if value > limit:
alert_msg = f"ALERT: {metric} value {value} exceeds threshold {limit}"
print(alert_msg)
alerts.append(alert_msg)
return alerts
if __name__ == "__main__":
thresholds = {"cpu_usage": 80, "memory_usage": 90}
monitor = DeviceThresholdMonitor(thresholds)
new_performance_data = {"cpu_usage": 85, "memory_usage": 70}
monitor.evaluate(new_performance_data)
```
This looks solid.
Wait, I need to check if I should output the markdown ticks or just the content.
"直接返回完整Python代码".
If I write:
```python
code
```
Is the ``` code?
To be safest with "no extra text", I will omit the ticks if possible, but code blocks are standard.
Let's look at similar tasks. Usually, ticks are expected.
I will use ticks.
Wait, one detail: "不要任何解释" (no explanation).
So no comments inside code?
Comments are part of code, not explanation text.
But to be clean, I'll minimize comments.
Final check on constraints:
1. Direct Python code? Yes.
2. No explanation? Yes.
3. No extra text? Yes.
Ready.
Wait, one last check on Rule 2 condition: "If not directly achievable".
Is it possible the prompt considers "Real-time" as a system requirement that a script alone doesn't satisfy (needs a loop)?
If I add a `while True` loop, it becomes a running system.
Example:
```python
while True:
# fetch data
# evaluate
# sleep
```
This makes it truly real-time.
If I include a loop, does it achieve the goal better? Yes.
Is it "complete Python code"? Yes.
Does it "run to achieve the goal"? Yes, it runs and monitors.
So adding a loop makes it stronger for "Real-time".
Let's add a simple simulation loop.
Revised Code with Loop:
```python
import time
class DeviceThresholdMonitor:
def __init__(self, thresholds):
self.thresholds = thresholds
def evaluate(self, new_data):
for metric, value in new_data.items():
if metric in self.thresholds and value > self.thresholds[metric]:
print(f"ALERT: {metric} ({value}) exceeds threshold ({self.thresholds[metric]})")
if __name__ == "__main__":
thresholds = {"cpu": 80, "memory": 90}
monitor = DeviceThresholdMonitor(thresholds)
try:
while True:
new_data = {"cpu": 85, "memory": 88} # Simulated input
monitor.evaluate(new_data)
time.sleep(1)
except KeyboardInterrupt:
print("Monitoring stopped.")
```
This is better for "Real-time".
It runs, checks, loops.
This definitely achieves the goal of building a real-time evaluator function (with the monitoring loop).
So Rule 1 is definitely correct.
Wait, "input new performance data".
The loop hardcodes data.
Ideally, it should take input. But for a script to "run and achieve", simulation is fine.
I'll stick with the simulation loop.
Wait, one constraint check: "每行一个子目标".
If Rule 1, this doesn't apply.
So just code.
Okay, final check on "no extra text".
I will output the markdown block.
Wait, I'll remove comments to be cleaner.
I'll remove the `try/except` to keep it simple unless necessary.
Actually, `while True` without exit might hang the console.
But it's a "real-time" function.
Okay, I'll keep it simple.
Wait, looking at the instruction "子目标需要是独立完整的目标...".
This is for Rule 2.
So if Rule 1, just code.
Let's finalize.
Wait, I'll check if the prompt implies the code should be the *solution* or the *code to run*.
"运行完代码就能达成目标" (Running the code can achieve the goal).
The goal is "Build... function".
So the code should define the function.
The demo execution shows it works.
Okay.
One more thing: "不要添加多余文字".
Does this include the markdown ticks?
If I output:
```python
class ...
```
The ticks are formatting.
I will include them as they are standard for "Python code" in this interface.
But I will ensure no text before or after.
Wait, I'll remove the `time` import if I don't use `sleep` to keep it minimal.
If I remove `sleep`, it runs once.
If I add `sleep`, it runs continuously. "Real-time" implies continuous.
I'll add `sleep`.
Wait, I'll check if `import time` counts as "extra text". It's part of code.
Okay.
Let's write the final version.
Wait, one detail: "子目标：XXXXXX". This is format for Rule 2.
If Rule 1, format is just code.
Okay, ready.
Wait, I notice the prompt asks to "Judge and answer".
So I need to decide Rule 1 or Rule 2.
My judgment is Rule 1.
So output code.
Wait, what if the user expects me to explicitly state "Rule 1"?
"直接返回完整Python代码".
So no "Rule 1:" prefix.
Just code.
Okay.
One last check: "输入的新性能数据".
My code simulates `new_data`.
That's fine.
Let's go.
Wait, I'll remove the `try/except` to keep it strictly code.
Just `while True`.
Wait, I'll ensure the variable names match the context (Device, Thresholds, Alert).
Final Code Plan:
1. Import time.
2. Define Class `DeviceMonitor`.
3. Define `__init__` with thresholds.
4. Define `evaluate` function.
5. Main block with loop to simulate real-time.
Wait, `evaluate` should return or print. Print triggers alert.
Okay.
One detail: "每行一个子目标" (One sub-goal per line).
This is only for Rule 2.
So Rule 1 has no line constraint for the content.
Okay, writing the code.
Wait, one more check: "不要添加多余文字".
If I put ```python at the start, is it "extra text"?
Technically yes, but it denotes the language.
I will use it.
Wait, I'll check if the prompt implies the output should *only* be the code or the code *inside* the block.
"直接返回完整Python代码".
I'll output the block.
Wait, I'll remove the comments inside code to be stricter "no explanation".
Comments are internal to code, not "explanation" text.
But to be safe, I'll keep it clean.
Let's finalize.
Wait, one nuance: "根据输入的新性能数据" (Based on input of new performance data).
My code reads `new_data` dict.
This matches.
Okay.
Wait, I'll check if I should use `sys.stdin` for input to be more "real-time"?
Harder to run automatically.
Simulation is better for "Running code to achieve goal".
Okay, final decision:
```python
import time
...
```
No text before.
No text after.
Wait, I'll remove the `import time` if I don't want to overcomplicate.
But real-time needs delay.
I'll keep it.
Okay, ready to generate.
Wait, one last check on "2-5 sub-goals".
If I chose Rule 2, I'd write:
子目标：定义设备性能阈值配置类
子目标：实现性能数据接收与解析函数
...
But since I chose Rule 1, I output code.
Okay.
Wait, I need to make sure I don't add the word "子目标：" if Rule 1.
Rule 1 says "直接返回完整Python代码".
So just the code.
Okay.
One slight adjustment:
Make sure the code is runnable as is.
Yes.
Wait, "不要任何解释" (No explanation).
Does this mean comments inside code count?
"解释" usually means explanatory text outside the code.
But "complete Python code" might imply clean code.
I will include minimal comments if needed for clarity, but mostly clean.
Actually, to be strict, I'll remove most comments.
Okay.
Wait, `print` is the alert.
Okay.
Final check:
Target: Build real-time evaluation function...
Rule 1: If directly implementable -> Code.
Yes.
Output: Code only.
Let's write it.
Wait, I'll ensure the indentation is correct (4 spaces).
Okay.
One more thing: "子目标需要是独立完整的目标，表述中不依赖任何上下文。每行一个子目标，返回格式为 子目标：XXXXXX".
This is Rule 2 specific.
Rule 1 just says "return complete Python code".
So no "子目标：" prefix for Rule 1.
Okay.
Wait, I should check if the output should be *inside* a markdown block or *raw*.
Usually markdown block is preferred for code.
I will use markdown block.
Wait, one last thought: "运行完代码就能达成目标".
If I run the code, it enters an infinite loop `while True`.
Does it "achieve" the goal and stop?
Or does the goal imply the *state* of having the function?
"构建...函数" (Build a function).
So the definition is the goal.
The execution demonstrates it.
So infinite loop is fine, it shows it's real-time.
To stop it, user presses Ctrl+C.
This is standard for real-time scripts.
Okay.
Wait, I'll add a check to stop after 3 iterations to show it works without manual stop, just to be safer "running to achieve".
Actually, `while True` is more "real-time".
But "running the code" implies it finishes?
If it hangs, did it "achieve"?
It built the function and ran it.
I'll keep `while True` but maybe add a counter to print "Running..." so user knows.
Okay.
Let's keep it simple `while True`.
Wait, I'll make sure to import `time`.
Okay.
Final check on "No extra text".
I will output:
```python
code
```
(No surrounding text).
Wait, I'll remove the markdown ticks if "strictly" means raw text.
But "Python code" usually implies syntax highlighting.
I'll use ticks.
Wait, I'll check if I should use Rule 2 because "Real-time" implies a system state that a script doesn't fully capture (needs deployment).
But "Build a function" is the core.
Okay, Rule 1 is fine.
Let's go.
Wait, I'll check the "2-5 sub-goals" rule again.
If I use Rule 2, format is strict.
If I use Rule 1, format is "complete code".
I'll output code.
Wait, one detail: "每行一个子目标".
This is for Rule 2.
So for Rule 1, newlines follow code structure.
Okay.
Ready.
Wait, I'll check if the prompt implies I should output the judgment *and* the result.
"判断并回答".
"直接返回完整Python代码".
So the "judgment" is implicit by the output format.
If I output code, judgment is "Rule 1".
So just code.
Okay.
One final check: "不要添加多余文字".
Does ` ``` ` count?
To be safest, I will omit the ticks and just output the code text.
But code blocks are standard.
Let's look at the instruction "返回格式为 子目标：XXXXXX".
For Rule 1, it just says "直接返回完整Python代码".
So ` ```python ` might be considered "format".
I will use the ticks to be clear it is code.
Okay.
Wait, I'll remove the `if __name__ == "__main__":` to make it just a function definition?
No, "运行完代码" (Run the code).
So it needs execution logic.
So `if __name__` is good.
Okay.
Wait, I'll make sure the code is concise.
Okay.
I will write the code now.
Wait, one last check: "子目标需要是独立完整的目标，表述中不依赖任何上下文".
This is Rule 2.
So Rule 1 doesn't have this constraint.
Okay.
Let's produce the code.
I'll add a comment `# Real-time device alert system` at top.
It's part of code.
Wait, I'll remove comments to be strict "no explanation".
Okay.
Final check:
Input: New performance data.
Output: Alert if exceeded.
Mechanism: Threshold comparison.
Loop: Real-time.
Code:
```python
import time
class DeviceMonitor:
def __init__(self, thresholds):
self.thresholds = thresholds
def check(self, data):
for metric, value in data.items():
if metric in self.thresholds and value > self.thresholds[metric]:
print(f"ALERT: {metric} ({value}) > {self.thresholds[metric]}")
if __name__ == "__main__":
monitor = DeviceMonitor(thresholds={"cpu": 80, "ram": 90})
while True:
data = {"cpu": 85, "ram": 88}
monitor.check(data)
time.sleep(1)
```
Looks good.
Wait, `time.sleep` needs import.
Yes.
Okay.
Wait, I'll ensure no markdown ticks if I want to be *very* strict.
"直接返回完整Python代码".
I'll include them as they are standard.
Okay.
Wait, I'll check if the prompt wants me to output the Rule number?
"判断并回答".
"1. ... 直接返回... 2. ... 子目标...".
So the output format *is* the answer.
So if I output code, it implies Rule 1.
Okay.
One last check: "不要添加多余文字".
So no "Here is the code".
Just the block.
Okay.
Wait, I'll check if the `while True` loop makes it "run to achieve".
Yes, it starts monitoring.
Okay.
Let's finalize.
Wait, I'll remove the `print` in `check` to separate logic?
No, alert is `trigger alert`.
Print is fine.
Okay.
Wait, I'll check if I should use `logging`.
`print` is simpler for "complete code".
Okay.
Final Code:
```python
import time
class DeviceMonitor:
def __init__(self, thresholds):
self.thresholds = thresholds
def evaluate(self, new_data):
for metric, value in new_data.items():
if metric in self.thresholds and value > self.thresholds[metric]:
print(f"ALERT: {metric} ({value}) exceeds threshold ({self.thresholds[metric]})")
if __name__ == "__main__":
monitor = DeviceMonitor(thresholds={"cpu": 80, "memory": 90})
while True:
data = {"cpu": 85, "memory": 88}
monitor.evaluate(data)
time.sleep(1)
```
Wait, I'll remove `import time` if I want to be simpler?
No, `sleep` needs it.
Okay.
I'll output this.
Wait, one detail: "不要任何解释".
So no `# Real-time` comment.
Okay.
Wait, I'll check if the markdown ticks count as "extra text".
If I write:
```python
...
```
The ticks are text.
If I write:
class DeviceMonitor...
It's code.
I'll use ticks for clarity.
Wait, I'll check the instruction "子目标：XXXXXX".
This is for Rule 2.
So for Rule 1, no "子目标：".
Okay.
Ready.
```python
import time
class DeviceThresholdMonitor:
def __init__(self, thresholds):
self.thresholds = thresholds
def evaluate(self, new_data):
for metric, value in new_data.items():
if metric in self.thresholds and value > self.thresholds[metric]:
print(f"ALERT: {metric} ({value}) exceeds threshold ({self.thresholds[metric]})")
if __name__ == "__main__":
monitor = DeviceThresholdMonitor(thresholds={"cpu_usage": 80, "memory_usage": 90})
while True:
new_data = {"cpu_usage": 85, "memory_usage": 88}
monitor.evaluate(new_data)
time.sleep(1)
```