# Import Gurobi Python 
import gurobipy as gp

model = gp.Model("Knapsack")

# Set items with weight and value
items = {
    'flashlight': {'weight': 1, 'value': 5},
    'sleeping_bag': {'weight': 3, 'value': 12},
    'food': {'weight': 2, 'value': 8},
    'water': {'weight': 4, 'value': 15}
}

# Set the max capacity
CAPACITY = 7

# Add variables
x = model.addVars(items.keys(), vtype=gp.GRB.BINARY, name="select")

model.addConstr(
    gp.quicksum(items[i]['weight'] * x[i] for i in items) <= CAPACITY,
    name="capacity"
)

model.setObjective(
    gp.quicksum(items[i]['value'] * x[i] for i in items),
    gp.GRB.MAXIMIZE,
)

model.optimize()

# Get model's status, gp.GRB.OPTIMAL == 2
model.status

# Get the objective value
model.objVal

# Print each variables' value
for i in model.getVars():
    print(f'{i.varName}, {i.x}')

# Import Gurobi
import gurobipy as gp

# Create a new model
m = gp.Model("Size")

# Define variables
height = m.addVar(vtype=gp.GRB.INTEGER, name="height")
width = m.addVar(vtype=gp.GRB.INTEGER, name="width")
x1 = m.addVar(vtype=gp.GRB.INTEGER, name="x1")
x2 = m.addVar(vtype=gp.GRB.INTEGER, name="x2")

# Define constraints
m.addConstr(x1 + width == 7, "7m")
m.addConstr(x2 + width == 8, "8m")
m.addConstr(x1 * height == 20, "20m2")
m.addConstr(x2 * height == 25, "25m2")

# Define objective
m.setObjective(height * width, gp.GRB.MAXIMIZE)

# Solve
m.optimize()

# Print values
m.getVars()

import asyncio
from bleak import BleakScanner
import uuid
import time
import datetime
import os
import configparser

# 全局变量控制扫描状态
_scanning_active = False

# 加载配置文件
def load_config():
    """从~/.ble/config.conf加载配置，如果不存在则创建默认配置"""
    config = configparser.ConfigParser()
    
    # 默认配置
    config['kafka'] = {
        'broker': 'localhost:9092',
        'topic': 'ble_beacons'
    }
    
    # 创建配置目录（如果不存在）
    config_dir = os.path.expanduser("~/.ble")
    os.makedirs(config_dir, exist_ok=True)
    
    config_file = os.path.join(config_dir, "config.conf")
    
    # 如果配置文件存在，读取它
    if os.path.exists(config_file):
        config.read(config_file)
    else:
        # 创建默认配置文件
        with open(config_file, 'w') as f:
            config.write(f)
    
    return config

async def scan_ble_devices():
    """扫描BLE设备并处理信标数据"""
    # 获取主机ID（用于数据标识）
    host_id = get_host_id()
    
    # 计数器（用于日志）
    scan_count = 0
    
    # 设置扫描状态
    global _scanning_active
    _scanning_active = True
    
    try:
        # 持续扫描循环
        while _scanning_active:
            scan_count += 1
            
            # 扫描设备（超时1秒）
            devices = await BleakScanner.discover(timeout=1.0)
            
            # 检查是否应该停止扫描
            if not _scanning_active:
                break
            
            # 处理每个设备
            beacons_found = 0
            for device in devices:
                # 提取制造商数据
                if device.metadata.get('manufacturer_data'):
                    for company_code, data in device.metadata['manufacturer_data'].items():
                        # 检测不同类型的信标
                        process_beacon_data(company_code, data, device)
            
            # 等待下一次扫描
            await asyncio.sleep(0)
    finally:
        # 清理资源
        pass

def process_beacon_data(company_code, data, device):
    """根据不同的信标类型解析数据"""
    # 检查iBeacon（苹果公司代码是0x004C）
    if company_code == 0x004C and len(data) >= 23:
        try:
            # 检查iBeacon标识符（0x02, 0x15）
            if data[0] == 0x02 and data[1] == 0x15:
                # 解析iBeacon数据
                uuid_bytes = data[2:18]
                uuid_str = str(uuid.UUID(bytes=bytes(uuid_bytes)))
                major = int.from_bytes(data[18:20], byteorder='big')
                minor = int.from_bytes(data[20:22], byteorder='big')
                tx_power = data[22] - 256 if data[22] > 127 else data[22]
                
                beacon_data = {
                    'uuid': uuid_str,
                    'major': major,
                    'minor': minor,
                    'tx_power': tx_power,
                    'rssi': device.rssi,
                    'address': device.address,
                    'name': device.name or 'Unknown'
                }
                
                # 处理iBeacon数据
                process_beacon('iBeacon', beacon_data)
        except Exception as e:
            print(f"处理iBeacon数据时出错: {e}")
    
    # 检查Eddystone信标（谷歌公司代码是0x00AA）
    elif company_code == 0x00AA and len(data) >= 20:
        try:
            # 检查Eddystone标识符
            if data[0] == 0xAA and data[1] == 0xFE:
                frame_type = data[2]
                
                # Eddystone-UID
                if frame_type == 0x00:
                    namespace = bytes(data[3:13]).hex()
                    instance = bytes(data[13:19]).hex()
                    
                    beacon_data = {
                        'namespace': namespace,
                        'instance': instance,
                        'rssi': device.rssi,
                        'address': device.address,
                        'name': device.name or 'Unknown'
                    }
                    
                    # 处理Eddystone-UID数据
                    process_beacon('Eddystone-UID', beacon_data)
                
                # Eddystone-URL
                elif frame_type == 0x10:
                    url_scheme = ['http://www.', 'https://www.', 'http://', 'https://'][data[3]]
                    url_data = bytes(data[4:]).decode('ascii')
                    url = url_scheme + url_data
                    
                    beacon_data = {
                        'url': url,
                        'rssi': device.rssi,
                        'address': device.address,
                        'name': device.name or 'Unknown'
                    }
                    
                    # 处理Eddystone-URL数据
                    process_beacon('Eddystone-URL', beacon_data)
        except Exception as e:
            print(f"处理Eddystone数据时出错: {e}")

def process_beacon(beacon_type, beacon_data):
    """处理信标数据"""
    timestamp = datetime.datetime.now().isoformat()
    
    # 添加通用字段
    message = {
        'type': beacon_type,
        'timestamp': timestamp,
        'rssi': beacon_data.get('rssi', 0),
        'address': beacon_data.get('address', 'unknown')
    }
    
    # 添加特定类型的字段
    message.update(beacon_data)
    
    # 这里可以添加数据处理逻辑
    # 例如：保存到文件、发送到服务器、更新GUI等
    
    return message

import asyncio
from bleak import BleakScanner
import uuid
import datetime

async def main():
    print("开始扫描BLE设备...")
    
    # 扫描设备
    devices = await BleakScanner.discover(timeout=5.0)
    
    print(f"发现 {len(devices)} 个设备")
    
    # 处理每个设备
    for device in devices:
        print(f"设备: {device.address} ({device.name or 'Unknown'}), RSSI: {device.rssi}")
        
        # 提取制造商数据
        if device.metadata.get('manufacturer_data'):
            for company_code, data in device.metadata['manufacturer_data'].items():
                # 检查iBeacon
                if company_code == 0x004C and len(data) >= 23:
                    if data[0] == 0x02 and data[1] == 0x15:
                        # 解析iBeacon数据
                        uuid_bytes = data[2:18]
                        uuid_str = str(uuid.UUID(bytes=bytes(uuid_bytes)))
                        major = int.from_bytes(data[18:20], byteorder='big')
                        minor = int.from_bytes(data[20:22], byteorder='big')
                        
                        print(f"  iBeacon: UUID={uuid_str}, Major={major}, Minor={minor}")

if __name__ == "__main__":
    asyncio.run(main())

import matplotlib.pyplot as plt
import numpy as np
import time
import asyncio
from bleak import BleakScanner

async def monitor_device(address, duration=60):
    """监控特定设备的信号强度"""
    timestamps = []
    rssi_values = []
    
    start_time = time.time()
    end_time = start_time + duration
    
    while time.time() < end_time:
        # 扫描设备
        devices = await BleakScanner.discover(timeout=1.0)
        
        # 查找目标设备
        for device in devices:
            if device.address == address:
                # 记录时间和RSSI
                timestamps.append(time.time() - start_time)
                rssi_values.append(device.rssi)
                print(f"时间: {timestamps[-1]:.1f}s, RSSI: {rssi_values[-1]} dBm")
                break
        
        # 等待下一次扫描
        await asyncio.sleep(0.5)
    
    # 绘制图表
    plt.figure(figsize=(10, 6))
    plt.plot(timestamps, rssi_values, 'b-')
    plt.xlabel('时间 (秒)')
    plt.ylabel('信号强度 (dBm)')
    plt.title(f'设备 {address} 的BLE信号强度')
    plt.grid(True)
    plt.savefig('ble_signal_strength.png')
    plt.show()

# 使用示例
# asyncio.run(monitor_device('XX:XX:XX:XX:XX:XX', 60))

def load_data(path):
    with open(path, 'r') as f:
        data = f.readlines()

    customer_utterances = []
    seller_utterances = []

    for idx, line in tqdm(enumerate(data)):
        utterances = line.strip().split('\t')
        utterances = [re.sub(r'[\s\n\t]', '', utterance) for utterance in utterances]

        if utterances[0] == '1':
            customer_utterances += utterances[1::2]
            seller_utterances += utterances[2::2]

    # Remove utterances only contain digits. If it contains digits and other characters, keep it.
    customer_utterances = [utterance for utterance in customer_utterances if not re.match(r'^[0-9]+$', utterance)]
    seller_utterances = [utterance for utterance in seller_utterances if not re.match(r'^[0-9]+$', utterance)]

    # Only keep utterances with more than 5 characters
    customer_utterances = [utterance for utterance in customer_utterances if len(utterance) > 5]
    seller_utterances = [utterance for utterance in seller_utterances if len(utterance) > 5]

    # If the utterance are the same in both customer and seller, remove duplicates using sets
    customer_set = set(customer_utterances)
    seller_set = set(seller_utterances)
    
    # Remove duplicates that appear in both sets
    unique_customer = list(customer_set - seller_set)
    unique_seller = list(seller_set - customer_set)
    
    return unique_customer, unique_seller

def generate_fasttext_data(customer_utterances, seller_utterances, output_path):
    """Generate FastText training data with labels."""
    with open(output_path, 'w', encoding='utf-8') as f:
        # Write customer utterances
        for utterance in customer_utterances:
            f.write(f"__label__customer {utterance}\n")
        
        # Write seller utterances
        for utterance in seller_utterances:
            f.write(f"__label__seller {utterance}\n")
    
    print(f"FastText training data saved to {output_path}")
    print(f"Total samples: {len(customer_utterances) + len(seller_utterances)}")
    print(f"Customer samples: {len(customer_utterances)}")
    print(f"Seller samples: {len(seller_utterances)}")

model = fasttext.train_supervised(
    input=input_path, 
    epoch=100, 
    lr=0.1, 
    wordNgrams=2, 
    verbose=2
)
model.save_model(output_path)

def get_file_size_mb(file_path):
    """
    Get file size in megabytes.
    
    Args:
        file_path (str): Path to the file
        
    Returns:
        float: File size in MB
    """
    size_bytes = os.path.getsize(file_path)
    size_mb = size_bytes / (1024 * 1024)
    return round(size_mb, 2)

def train_and_evaluate_model(config, input_path, test_path):
    mlflow.set_tracking_uri(MLFLOW_TRACKING_URI)
    mlflow.set_experiment("fasttext-demo-v3")

    context = ray.train.get_context()
    trial_id = context.get_trial_id()

    with mlflow.start_run(run_name=f'trial_{trial_id}') as run:
        model_path = f'model_trail_{trial_id}.bin'

        training_df = convert_file_into_dataframe(input_path=input_path)
        dataset = mlflow.data.from_pandas(
            training_df, name='traing data', targets='label'
        )
        mlflow.log_input(dataset=dataset, context='training')

        mlflow.log_params(config)

        # Use the dictionary's attributes in the function call
        model = fasttext.train_supervised(**config)

        model.save_model(model_path)

        model_size_mb = get_file_size_mb(model_path)

        num_of_samples, precision, recall = model.test(test_path)
        f1_score = 2 * precision * recall / (precision + recall)

        mlflow.log_metrics({
            "f1_score": f1_score,
            "precision": precision,
            "recall": recall,
            "model_size": model.get_output_matrix().size,
            "model_size_mb": model_size_mb,
        })

        tune.report({
            "f1_score": f1_score,
            "precision": precision,
            "recall": recall,
            "model_size": model.get_output_matrix().size,
            "model_size_mb": model_size_mb,
            "model_path": model_path,
        })

def tune_fasttext_parameters(input_path, test_path, num_samples=50):
    ray.init()

    config = {
        "input": input_path,
        "epoch": tune.randint(50, 300),
        "lr": tune.loguniform(1e-5, 1e-3),  # Reduced max learning rate
        "wordNgrams": tune.randint(1, 4),
        "dim": tune.randint(10, 50),
        "ws": tune.randint(3, 7),
        "minCount": tune.randint(2, 10),
        "minn": 1,
        "maxn": 3,
        "bucket": tune.choice([50000, 100000, 200000]),
        "thread": 4,
        "loss": "softmax",
        "verbose": 2,
    }

    search_algo = OptunaSearch(
        metric=["f1_score", "model_size_mb"],
        mode=["max", "min"],
    )

    analysis = tune.run(
        lambda trail_config: train_and_evaluate_model(trail_config, input_path, test_path),
        config=config,
        num_samples=num_samples,
        search_alg=search_algo,
        resources_per_trial={"cpu": 4}
    )

    # Get the best trial based on both metrics
    best_trial = analysis.get_best_trial(
        metric="f1_score",  # Primary metric
        mode="max",
        scope="last"  # Consider only the last reported results
    )
    print(f"Best trial: {best_trial}")

    return best_trial

def train_and_evaluate_model(config, input_path, test_path):
    # ...
        try:
            # Use the dictionary's attributes in the function call
            model = fasttext.train_supervised(**config)

            model.save_model(model_path)

            model_size_mb = get_file_size_mb(model_path)

            num_of_samples, precision, recall = model.test(test_path)
            f1_score = 2 * precision * recall / (precision + recall)

            mlflow.log_metrics({
                "f1_score": f1_score,
                "precision": precision,
                "recall": recall,
                "model_size": model.get_output_matrix().size,
                "model_size_mb": model_size_mb,
            })

            tune.report({
                "f1_score": f1_score,
                "precision": precision,
                "recall": recall,
                "model_size": model.get_output_matrix().size,
                "model_size_mb": model_size_mb,
                "model_path": model_path,
            })
        except Exception as e:
            print(f"Error: {e}")
            mlflow.log_param('error_message', str(e))
            mlflow.log_metric('failed', 1)

            tune.report({
                "f1_score": -1,
                "precision": -1,
                "recall": -1,
                "model_size": -1,
                "model_size_mb": sys.float_info.max,
                "model_path": model_path,
            })
    # ...

class FastTextWrapper(mlflow.pyfunc.PythonModel):
    def load_context(self, context):
        self.model = fasttext.load_model(context.artifacts["fasttext_model"])
    
    def predict(self, context, model_input):
        predictions = []
        for text in model_input["text"]:
            label, prob = self.model.predict(text)
            predictions.append({"label": label[0], "probability": prob[0]})
        return predictions

# Log the model as an artifact
mlflow.log_artifact(model_path, "model")

mlflow.pyfunc.log_model(
    artifact_path="fasttext_model",
    python_model=FastTextWrapper(),
    artifacts={
        "fasttext_model": model_path
    },
    registered_model_name="fasttext_classifier"
)

# Log the sklearn model and register
mlflow.sklearn.log_model(
    sk_model=model,
    artifact_path="sklearn-model",
    signature=signature,
    registered_model_name="sk-learn-random-forest-reg-model",
)

import numpy as np
from stable_baselines3 import DQN

class MLflowDQNWrapper(mlflow.pyfunc.PythonModel):
    def __init__(self):
        self.model = None
    
    def load_context(self, context):
        # Load the model from the saved path
        self.model = DQN.load(context.artifacts["model_path"])

    def predict(self, context, model_input):
        # Convert model_input to numpy array if it's a pandas DataFrame
        if hasattr(model_input, 'to_numpy'):
            model_input = model_input.to_numpy()
        action, _states = self.model.predict(model_input, deterministic=True)
        return action

# Get the best model path
best_model_path = os.path.join(best_model_save_path, "best_model.zip")

# Create and log the wrapped model
wrapped_model = MLflowDQNWrapper()
input_example = np.array([[0.0, 0.0, 0.0, 0.0]])

# Log the model with MLflow
mlflow.pyfunc.log_model(
    artifact_path="model",
    python_model=wrapped_model,
    artifacts={"model_path": best_model_path},
    signature=mlflow.models.signature.infer_signature(
        model_input=input_example,
        model_output=np.array([0])
    ),
    input_example=input_example,
    registered_model_name="cartpole-v1-dqn"
)

import os
import numpy as np
import mlflow
import gymnasium as gym
from tqdm import tqdm

def evaluate_mlflow():
    # Set up MLflow tracking URI
    mlflow.set_tracking_uri(MLFLOW_TRACKING_URI)

    # Create environment
    env = CartPoleWrapper(gym.make("CartPole-v1", render_mode=None))
    
    # Load the model from MLflow Model Registry using the "Champion" stage
    model_name = "cartpole-v1-dqn"
    alias = "champion"
    loaded_model = mlflow.pyfunc.load_model(f"models:/{model_name}@{alias}")
    
    # Evaluate the model
    n_eval_episodes = 100
    episode_rewards = []
    
    for episode in tqdm(range(n_eval_episodes)):
        obs, _ = env.reset()
        done = False
        episode_reward = 0
        
        while not done:
            # Get prediction from MLflow model
            action = loaded_model.predict(np.array([obs], dtype=np.float64))
            obs, reward, terminated, truncated, _ = env.step(action[0])
            episode_reward += reward
            done = terminated or truncated
            
        episode_rewards.append(episode_reward)
    
    mean_reward = np.mean(episode_rewards)
    std_reward = np.std(episode_rewards)
    
    print(f"Mean reward: {mean_reward:.2f} +/- {std_reward:.2f}")
    print(f"Episode rewards: {episode_rewards}")
    
    return mean_reward, std_reward