Not an issue as such, how to use on Raspi.. about hvac-ir-control HOT 4 OPEN

sudo apt-get install git -y
sudo apt-get install python python-dev python-pip python-rpi.gpio pigpio -y
sudo pip install git+https://github.com/Ericmas001/HVAC-IR-Control
sudo pip install pigpio
sudo pip install flask

#!/usr/bin/python

import logging 
from logging.handlers import RotatingFileHandler
from datetime import datetime, time
from flask import Flask, request, jsonify
from flask.json import JSONEncoder
import handler

class CustomJSONEncoder(JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, time):
            return obj.isoformat()
        
        return obj.__dict__

class MyFlask(Flask):
    def make_response(self, rv):
        if hasattr(rv, 'response') and rv.response is None:
            return super(MyFlask, self).make_response(rv)
        if hasattr(rv, 'new_url') and rv.new_url is not None:
            return super(MyFlask, self).make_response(rv)
        return super(MyFlask, self).make_response(jsonify(rv))

app = MyFlask(__name__)
app.json_encoder = CustomJSONEncoder

@app.route('/config/', methods=['GET'])
def list_config():
    return handler.list_config(app)

@app.route('/hvac/off/', methods=['GET'])
def power_off():
    return handler.power_off(app)

@app.route('/hvac/on/', methods=['GET'])
def power_on():
    return handler.send_last_command(app)

@app.route('/hvac/command/', methods=['POST'])
def send_command():
    return handler.send_command(app, request.json)

@app.route('/last/command/', methods=['GET'])
def last_command():
    return handler.last_command(app)

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=4242)

#!/usr/bin/python
from hvac_ircontrol.ir_sender import LogLevel
from hvac_ircontrol.mitsubishi import Mitsubishi, ClimateMode, FanMode, VanneVerticalMode, VanneHorizontalMode, ISeeMode, AreaMode, PowerfulMode, Constants
from models import *
import inspect
import json
from collections import namedtuple
import datetime
import traceback
import os

path = "/hvac/last_config.json"

def list_config(app):
    res = AvailableCommands()
    res.climate_modes = __list_attributes(ClimateMode)
    res.isee_modes = __list_attributes(ISeeMode)
    res.powerful_modes = __list_attributes(PowerfulMode)
    res.vanne_horizontal_modes = __list_attributes(VanneHorizontalMode)
    res.fan_modes = __list_attributes(FanMode)
    res.vanne_vertical_modes = __list_attributes(VanneVerticalMode)
    res.area_modes = __list_attributes(AreaMode)
    res.min_temp = Constants.MinTemp
    res.max_temp = Constants.MaxTemp
    return res

def power_off(app):
    hvac = Mitsubishi(23, LogLevel.ErrorsOnly)
    hvac.power_off()
    return "It was powered OFF"

def last_command(app):
    command = HvacCommand()
    if os.path.isfile(path):
        with open(path, 'r') as content_file:
            data = json.loads(content_file.read())
            command.from_json(data)
    return command

def send_command(app, data):
    command = HvacCommand()
    command.from_json(data)
    return __send_command(app, command)

def send_last_command(app):
    return __send_command(app, last_command(app))

def __send_command(app, command):
    try:
        hvac = Mitsubishi(23, LogLevel.Minimal)
        args = dict(
            climate_mode=__get_value(ClimateMode, command.climate_mode),
            temperature=command.temperature,
            fan_mode=__get_value(FanMode, command.fan_mode),
            vanne_vertical_mode=__get_value(VanneVerticalMode, command.vanne_vertical_mode),
            vanne_horizontal_mode=__get_value(VanneHorizontalMode, command.vanne_horizontal_mode),
            isee_mode=__get_value(ISeeMode, command.isee_mode),
            area_mode=__get_value(AreaMode, command.area_mode),
            start_time = __get_time_value(command.start_time),
            end_time = __get_time_value(command.end_time),
            powerful=__get_value(PowerfulMode, command.powerful_mode))
        hvac.send_command(**args)

        cfg = open(path, "w")
        cfg.write(command.to_json())
        return HvacCommandResponse(True,command,args)
    except:
        app.logger.error("There was an error: {0}".format(traceback.format_exc()))
        return HvacCommandResponse(False,data,"There was an error: {0}".format(traceback.format_exc()))

def __list_attributes(my_type):
    return [a[0] for a in inspect.getmembers(my_type, lambda c:not(inspect.isroutine(c))) if not a[0].startswith('_')]

def __get_value(my_type, my_value):
    return [a[1] for a in inspect.getmembers(my_type, lambda c:not(inspect.isroutine(c))) if a[0] == my_value][0]

def __get_time_value(my_value):
    if my_value is None or my_value < 0 or my_value >= 24:
        return None
    
    return datetime.time(int(my_value)//1, int((my_value*100)%100))

import json

class AvailableCommands:
    def __init__(self):
        self.climate_modes = []
        self.isee_modes = []
        self.powerful_modes = []
        self.vanne_horizontal_modes = []
        self.fan_modes = []
        self.vanne_vertical_modes = []
        self.area_modes = []
        self.min_temp = -1
        self.max_temp = -1

class HvacCommandResponse:
    def __init__(self, success, command, decoded):
        self.success = success
        self.command = command
        self.decoded_command = decoded

class HvacCommand:
    def __init__(self):
        self.climate_mode = "Cold"
        self.isee_mode = "ISeeOn"
        self.powerful_mode = "PowerfulOff"
        self.vanne_horizontal_mode = "NotSet"
        self.fan_mode = "Auto"
        self.vanne_vertical_mode = "Auto"
        self.area_mode = "NotSet"
        self.temperature = 21
        self.start_time = None
        self.end_time = None
    
    def from_json(self, data):
        self.climate_mode = data["climate_mode"]
        self.isee_mode = data["isee_mode"]
        self.powerful_mode = data["powerful_mode"]
        self.vanne_horizontal_mode = data["vanne_horizontal_mode"]
        self.fan_mode = data["fan_mode"]
        self.vanne_vertical_mode = data["vanne_vertical_mode"]
        self.area_mode = data["area_mode"]
        self.temperature = data["temperature"]
        self.start_time = data["start_time"]
        self.end_time = data["end_time"]

    def to_json(self):
        return json.dumps(self.__dict__, sort_keys=True, indent=4, separators=(',', ': '))

I/REQUEST: http://localhost:4242/hvac/off/
I/METHOD: GET
I/RESPONSE: "It was powered OFF"

I/REQUEST: http://localhost:4242/hvac/on/
I/DATA:
{
  "climate_mode": "Hot",
  "isee_mode": "ISeeOn",
  "powerful_mode": "PowerfulOff",
  "vanne_horizontal_mode": "NotSet",
  "fan_mode": "Auto",
  "vanne_vertical_mode": "Auto",
  "area_mode": "Full",
  "temperature": 21,
  "start_time": -1,
  "end_time": -1
}
I/METHOD: POST
I/RESPONSE:
{
  "command": {
    "area_mode": "Full",
    "climate_mode": "Hot",
    "end_time": -1,
    "fan_mode": "Auto",
    "isee_mode": "ISeeOn",
    "powerful_mode": "PowerfulOff",
    "start_time": -1,
    "temperature": 21,
    "vanne_horizontal_mode": "NotSet",
    "vanne_vertical_mode": "Auto"
  },
  "decoded_command": {
    "area_mode": 128,
    "climate_mode": 8,
    "end_time": null,
    "fan_mode": 128,
    "isee_mode": 64,
    "powerful": 0,
    "start_time": null,
    "temperature": 21,
    "vanne_horizontal_mode": 0,
    "vanne_vertical_mode": 64
  },
  "success": true
}