gravity-controller-operator 2.0.0__tar.gz

gravity_controller_operator-2.0.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gravity_controller_operator-2.0.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.1
+Name: gravity_controller_operator
+Version: 2.0.0
+Summary: SDK предоставляющий универсальный интерфейс для работы со многими промышленными контроллерами ввода-вывода (количество расширяемо)
+Author: PunchyArchy
+Author-email: ksmdrmvscthny@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyModbusTCP
+Requires-Dist: pymodbus==3.6.9
+
+# Gravity Controller Operator
+
+Модуль для унифицированной работы с промышленными контроллерами (реле, дискретные входы и т.д.). Позволяет взаимодействовать с различными устройствами через единый интерфейс.
+
+---
+
+## 🚀 Поддерживаемые контроллеры
+
+- **EmulatorController** — заглушка для тестов
+- **ARMK210Controller** — Modbus TCP
+- **WBMR6LV** — Modbus RTU
+- **NetPing2Controller** — HTTP API
+- **Sigur** — доступ через TCP (СКУД)
+- **MoxaE1214** — REST API (vdn.dac.v1)
+
+---
+
+## 🧩 Архитектура
+
+### 🧠 Интерфейсы:
+
+- `DIInterface`: чтение дискретных входов
+- `RelayInterface`: чтение/управление релейными выходами
+- `ControllerInterface`: объединяет оба
+
+Все интерфейсы наследуют `SoftStateMixin`, в котором реализовано хранение состояния точек (`state`, `changed`, `addr`).
+
+### 🛠 Контроллер
+Каждый контроллер реализует:
+```python
+self.interface = ControllerInterface(di_interface=..., relay_interface=...)
+```
+
+### 🧪 Обёртки:
+
+- `ControllerOperator` — отвечает за автоматическое обновление, mutex-безопасность и удобный API
+- `ControllerCreator` — фабрика создания контроллеров по имени модели (см. `controller_factory.py`)
+
+---
+
+## 🧪 Как использовать
+
+```python
+from gravity_controller_operator.controllers.moxa import MoxaE1214
+from gravity_controller_operator.controller_operator import ControllerOperator
+
+moxa = MoxaE1214("192.168.60.103")
+operator = ControllerOperator(moxa)
+
+print(operator.get_points())
+operator.change_relay_state(0, 1)  # включить реле 0
+```
+
+---
+
+## 🔬 Тестирование
+
+Установка:
+```bash
+pip install pytest
+```
+
+Запуск:
+```bash
+pytest gravity_controller_operator/tests/
+```
+
+---
+
+## 📦 Добавление нового контроллера
+
+1. Реализуй `YourControllerDI` и `YourControllerRelay`, наследуя `DIInterface`, `RelayInterface`
+2. Создай `YourController`, в котором:
+```python
+self.interface = ControllerInterface(di_interface=..., relay_interface=...)
+```
+3. Добавь контроллер в `AVAILABLE_CONTROLLERS` в `controller_factory.py`
+
+---
+
+## 📁 Структура
+
+```
+controllers_super.py          # Базовые интерфейсы
+controllers/                  # Реализации контроллеров
+controller_operator.py        # Обёртка ControllerOperator ✅
+controller_factory.py         # AVAILABLE_CONTROLLERS + фабрика ✅
+exceptions.py                 # Кастомные исключения ✅
+tests/                        # Тесты
+README.md
+```
+
+---
+
+## 🤝 Контакты
+
+- 📧 Email: ksmdrmvstchny@gmail.com
+- 💬 Telegram: [@PunchyArchy](https://t.me/PunchyArchy)
+- 📞 Phone: +7 996 294-75-95
+
+Проект поддерживается Артуром (PunchyArchy, Qodex)

gravity_controller_operator-2.0.0/README.md

@@ -0,0 +1,101 @@
+# Gravity Controller Operator
+
+Модуль для унифицированной работы с промышленными контроллерами (реле, дискретные входы и т.д.). Позволяет взаимодействовать с различными устройствами через единый интерфейс.
+
+---
+
+## 🚀 Поддерживаемые контроллеры
+
+- **EmulatorController** — заглушка для тестов
+- **ARMK210Controller** — Modbus TCP
+- **WBMR6LV** — Modbus RTU
+- **NetPing2Controller** — HTTP API
+- **Sigur** — доступ через TCP (СКУД)
+- **MoxaE1214** — REST API (vdn.dac.v1)
+
+---
+
+## 🧩 Архитектура
+
+### 🧠 Интерфейсы:
+
+- `DIInterface`: чтение дискретных входов
+- `RelayInterface`: чтение/управление релейными выходами
+- `ControllerInterface`: объединяет оба
+
+Все интерфейсы наследуют `SoftStateMixin`, в котором реализовано хранение состояния точек (`state`, `changed`, `addr`).
+
+### 🛠 Контроллер
+Каждый контроллер реализует:
+```python
+self.interface = ControllerInterface(di_interface=..., relay_interface=...)
+```
+
+### 🧪 Обёртки:
+
+- `ControllerOperator` — отвечает за автоматическое обновление, mutex-безопасность и удобный API
+- `ControllerCreator` — фабрика создания контроллеров по имени модели (см. `controller_factory.py`)
+
+---
+
+## 🧪 Как использовать
+
+```python
+from gravity_controller_operator.controllers.moxa import MoxaE1214
+from gravity_controller_operator.controller_operator import ControllerOperator
+
+moxa = MoxaE1214("192.168.60.103")
+operator = ControllerOperator(moxa)
+
+print(operator.get_points())
+operator.change_relay_state(0, 1)  # включить реле 0
+```
+
+---
+
+## 🔬 Тестирование
+
+Установка:
+```bash
+pip install pytest
+```
+
+Запуск:
+```bash
+pytest gravity_controller_operator/tests/
+```
+
+---
+
+## 📦 Добавление нового контроллера
+
+1. Реализуй `YourControllerDI` и `YourControllerRelay`, наследуя `DIInterface`, `RelayInterface`
+2. Создай `YourController`, в котором:
+```python
+self.interface = ControllerInterface(di_interface=..., relay_interface=...)
+```
+3. Добавь контроллер в `AVAILABLE_CONTROLLERS` в `controller_factory.py`
+
+---
+
+## 📁 Структура
+
+```
+controllers_super.py          # Базовые интерфейсы
+controllers/                  # Реализации контроллеров
+controller_operator.py        # Обёртка ControllerOperator ✅
+controller_factory.py         # AVAILABLE_CONTROLLERS + фабрика ✅
+exceptions.py                 # Кастомные исключения ✅
+tests/                        # Тесты
+README.md
+```
+
+---
+
+## 🤝 Контакты
+
+- 📧 Email: ksmdrmvstchny@gmail.com
+- 💬 Telegram: [@PunchyArchy](https://t.me/PunchyArchy)
+- 📞 Phone: +7 996 294-75-95
+
+Проект поддерживается Артуром (PunchyArchy, Qodex)

gravity_controller_operator-2.0.0/gravity_controller_operator/controller_factory.py

@@ -0,0 +1,26 @@
+from gravity_controller_operator.controllers.emulator_contr import EmulatorController
+from gravity_controller_operator.controllers.netping_relay import NetPing2Controller
+from gravity_controller_operator.controllers.arm_k210 import ARMK210Controller
+from gravity_controller_operator.controllers.wb_mr6lv import WBMR6LV
+from gravity_controller_operator.exceptions import UnknownController
+from gravity_controller_operator.controllers.sigur import Sigur
+
+
+AVAILABLE_CONTROLLERS = [
+    ARMK210Controller,
+    WBMR6LV,
+    NetPing2Controller,
+    EmulatorController,
+    Sigur
+]
+
+
+class ControllerCreator:
+    @staticmethod
+    def get_controller(model, emulator=False, *args, **kwargs):
+        for contr in AVAILABLE_CONTROLLERS:
+            if emulator:
+                return EmulatorController(*args, **kwargs)
+            if contr.model.lower() == model.lower():
+                return contr(*args, **kwargs)
+        raise UnknownController(model, [contr.model for contr in AVAILABLE_CONTROLLERS])

gravity_controller_operator-2.0.0/gravity_controller_operator/controllers/arm_k210.py

@@ -0,0 +1,47 @@
+from gravity_controller_operator.controllers_super import DIInterface, RelayInterface, ControllerInterface
+from pyModbusTCP.client import ModbusClient
+
+
+class ARMK210ControllerDI(DIInterface):
+    map_keys_amount = 8
+    starts_with = 0
+
+    def __init__(self, client):
+        self.client = client
+        super().__init__()
+
+    def get_phys_dict(self):
+        response = self.client.read_input_registers(self.starts_with, self.map_keys_amount)
+        while not response:
+            response = self.client.read_input_registers(self.starts_with, self.map_keys_amount)
+        return {i: val for i, val in enumerate(response)}
+
+
+class ARMK210ControllerRelay(RelayInterface):
+    map_keys_amount = 8
+    starts_with = 0
+
+    def __init__(self, client):
+        self.client = client
+        super().__init__()
+
+    def get_phys_dict(self):
+        response = self.client.read_holding_registers(self.starts_with, self.map_keys_amount)
+        while not response:
+            response = self.client.read_holding_registers(self.starts_with, self.map_keys_amount)
+        return {i: val for i, val in enumerate(response)}
+
+    def change_phys_relay_state(self, addr, state: bool):
+        result = self.client.write_single_coil(addr, state)
+        while not result:
+            result = self.client.write_single_coil(addr, state)
+
+
+class ARMK210Controller:
+    model = "arm_k210"
+
+    def __init__(self, ip: str, port: int = 8234, name="ARM_K210_Controller", *args, **kwargs):
+        client = ModbusClient(host=ip, port=port)
+        di = ARMK210ControllerDI(client)
+        relay = ARMK210ControllerRelay(client)
+        self.interface = ControllerInterface(di_interface=di, relay_interface=relay)

gravity_controller_operator-2.0.0/gravity_controller_operator/controllers/emulator_contr.py

@@ -0,0 +1,37 @@
+from gravity_controller_operator.controllers_super import DIInterface, \
+    RelayInterface, ControllerInterface
+
+
+class EmulatorDI(DIInterface):
+    map_keys_amount = 4
+    starts_with = 1
+
+    def __init__(self):
+        super().__init__()
+
+    def get_phys_dict(self):
+        return {1: 0, 2: 0, 3: 0, 4: 0}
+
+
+class EmulatorRelay(RelayInterface):
+    map_keys_amount = 4
+    starts_with = 1
+
+    def __init__(self):
+        super().__init__()
+
+    def get_phys_dict(self):
+        return {1: 0, 2: 0, 3: 0, 4: 0}
+
+    def change_phys_relay_state(self, addr, state: bool):
+        # Ничего не делает, просто имитация
+        pass
+
+
+class EmulatorController:
+    model = "emulator_controller"
+
+    def __init__(self):
+        di = EmulatorDI()
+        relay = EmulatorRelay()
+        self.interface = ControllerInterface(di_interface=di, relay_interface=relay)

gravity_controller_operator-2.0.0/gravity_controller_operator/controllers/moxa.py

@@ -0,0 +1,80 @@
+import requests
+from gravity_controller_operator.controllers_super import DIInterface, RelayInterface, ControllerInterface
+
+
+class MoxaClient:
+    def __init__(self, ip: str):
+        self.base_url = f"http://{ip}/api/slot/0/io"
+        self.headers = {
+            "Content-Type": "application/json",
+            "Accept": "vdn.dac.v1"
+        }
+
+    def get_di(self):
+        url = f"{self.base_url}/di"
+        r = requests.get(url, headers=self.headers, timeout=2)
+        r.raise_for_status()
+        return r.json()["io"]["di"]
+
+    def get_relays(self):
+        url = f"{self.base_url}/relay"
+        r = requests.get(url, headers=self.headers, timeout=2)
+        r.raise_for_status()
+        return r.json()["io"]["relay"]
+
+    def set_relay(self, channel: int, state: int):
+        url = f"{self.base_url}/relay/{channel}/relayStatus"
+        payload = {
+            "slot": "0",
+            "io": {
+                "relay": {
+                    str(channel): {
+                        "relayStatus": str(state)
+                    }
+                }
+            }
+        }
+        headers = self.headers.copy()
+        headers["Content-Length"] = str(len(str(payload)))
+        r = requests.put(url, headers=headers, json=payload, timeout=2)
+        r.raise_for_status()
+        return r.status_code == 200
+
+
+class MoxaDI(DIInterface):
+    map_keys_amount = 16
+    starts_with = 0
+
+    def __init__(self, client):
+        self.client = client
+        super().__init__()
+
+    def get_phys_dict(self):
+        data = self.client.get_di()
+        return {int(item["diIndex"]): item["diStatus"] for item in data}
+
+
+class MoxaRelay(RelayInterface):
+    map_keys_amount = 4
+    starts_with = 0
+
+    def __init__(self, client):
+        self.client = client
+        super().__init__()
+
+    def get_phys_dict(self):
+        data = self.client.get_relays()
+        return {int(item["relayIndex"]): int(item["relayStatus"]) for item in data}
+
+    def change_phys_relay_state(self, addr, state: bool):
+        return self.client.set_relay(addr, int(state))
+
+
+class MoxaE1214:
+    model = "moxa_e1214"
+
+    def __init__(self, ip):
+        client = MoxaClient(ip)
+        di = MoxaDI(client)
+        relay = MoxaRelay(client)
+        self.interface = ControllerInterface(di_interface=di, relay_interface=relay)

gravity_controller_operator-2.0.0/gravity_controller_operator/controllers/netping_relay.py

@@ -0,0 +1,76 @@
+from gravity_controller_operator.controllers_super import DIInterface, RelayInterface, ControllerInterface
+from netping_contr import mixins
+import requests
+from requests.auth import HTTPBasicAuth
+
+
+class NetPingDevice(mixins.NetPingResponseParser):
+    def __init__(self, ip, port=80, username="visor", password="ping"):
+        self.ip = ip
+        self.port = port
+        self.username = username
+        self.password = password
+        self.schema = "http://"
+
+    def get_full_url(self):
+        return f"{self.schema}{self.ip}:{self.port}"
+
+    def get_all_di_status(self):
+        return requests.get(
+            url=f"{self.get_full_url()}/io.cgi?io",
+            auth=HTTPBasicAuth(self.username, self.password))
+
+    def get_all_relay_states(self):
+        states = {}
+        for i in range(1, 5):
+            r = requests.get(
+                url=f"{self.get_full_url()}/relay.cgi?r{i}",
+                auth=HTTPBasicAuth(self.username, self.password))
+            states[i] = self.parse_relay_state(r)
+        return states
+
+    def change_relay_status(self, relay_num, state):
+        return requests.get(
+            url=f"{self.get_full_url()}/relay.cgi?r{relay_num}={state}",
+            auth=HTTPBasicAuth(self.username, self.password))
+
+
+class NetPingDI(DIInterface):
+    map_keys_amount = 4
+    starts_with = 1
+
+    def __init__(self, controller):
+        self.controller = controller
+        super().__init__()
+
+    def get_phys_dict(self):
+        raw = self.controller.get_all_di_status()
+        return self.controller.parse_all_lines_request(raw)
+
+
+class NetPingRelay(RelayInterface):
+    map_keys_amount = 4
+    starts_with = 1
+
+    def __init__(self, controller):
+        self.controller = controller
+        super().__init__()
+
+    def get_phys_dict(self):
+        return self.controller.get_all_relay_states()
+
+    def change_phys_relay_state(self, addr, state: bool):
+        result = self.controller.change_relay_status(addr, state)
+        while "error" in result:
+            result = self.controller.change_relay_status(addr, state)
+
+
+class NetPing2Controller:
+    model = "netping_relay"
+
+    def __init__(self, ip, port=80, username="visor", password="ping",
+                 name="netping_relay2", *args, **kwargs):
+        device = NetPingDevice(ip=ip, port=port, username=username, password=password)
+        di = NetPingDI(device)
+        relay = NetPingRelay(device)
+        self.interface = ControllerInterface(di_interface=di, relay_interface=relay)

gravity_controller_operator-2.0.0/gravity_controller_operator/controllers/sigur.py

@@ -0,0 +1,75 @@
+from gravity_controller_operator.controllers_super import DIInterface, RelayInterface, ControllerInterface
+from _thread import allocate_lock
+from socket import socket
+
+
+class SigurBase:
+    def __init__(self, sock):
+        self.sock = sock
+        self.mutex = allocate_lock()
+        self.login()
+
+    def login(self, login="Administrator", password=""):
+        return self._send_command(f'"LOGIN" 1.8 "{login}" "{password}"')
+
+    def _send_command(self, command, get_response=True):
+        self.mutex.acquire()
+        command = f'{command}\r\n'
+        self.sock.send(command.encode("utf-8"))
+        if get_response:
+            response = self.sock.recv(1024)
+            self.mutex.release()
+            return response
+        self.mutex.release()
+
+
+class SigurDI(DIInterface, SigurBase):
+    map_keys_amount = 5
+    starts_with = 3
+
+    def __init__(self, sock):
+        SigurBase.__init__(self, sock)
+        DIInterface.__init__(self)
+
+    def get_phys_dict(self):
+        result = {}
+        for point in range(self.starts_with, self.starts_with + self.map_keys_amount):
+            raw = self._send_command(f'"GETAPINFO" {point}')
+            response = raw.decode()
+            status = response.split(" ")[-2]
+            result[point] = 0 if status in ("ONLINE_UNLOCKED", "ONLINE_NORMAL") else 1
+        return result
+
+
+class SigurRelay(RelayInterface, SigurBase):
+    map_keys_amount = 3
+    starts_with = 1
+
+    def __init__(self, sock):
+        SigurBase.__init__(self, sock)
+        RelayInterface.__init__(self)
+
+    def get_phys_dict(self):
+        result = {}
+        for point in range(self.starts_with, self.starts_with + self.map_keys_amount):
+            raw = self._send_command(f'"GETAPINFO" {point}')
+            response = raw.decode()
+            status = response.split(" ")[-2]
+            result[point] = 0 if status in ("ONLINE_UNLOCKED", "ONLINE_NORMAL") else 1
+        return result
+
+    def change_phys_relay_state(self, addr, state: bool):
+        # Имитация действия, при необходимости можно добавить настоящую команду
+        pass
+
+
+class Sigur:
+    model = "sigur"
+
+    def __init__(self, ip, port=3312, login="Administrator", password="",
+                 name="Sigur", *args, **kwargs):
+        sock = socket()
+        sock.connect((ip, port))
+        di = SigurDI(sock)
+        relay = SigurRelay(sock)
+        self.interface = ControllerInterface(di_interface=di, relay_interface=relay)

gravity_controller_operator-2.0.0/gravity_controller_operator/controllers/tests/test_moxa_controller.py

@@ -0,0 +1,31 @@
+import pytest
+from gravity_controller_operator.main import ControllerOperator
+from gravity_controller_operator.controllers.moxa import MoxaE1214
+
+
+@pytest.fixture(scope="module")
+def moxa_operator():
+    controller = MoxaE1214("192.168.60.103")
+    return ControllerOperator(controller, auto_update_points=False)
+
+
+def test_di_states(moxa_operator):
+    di = moxa_operator.get_points()["di"]
+    assert isinstance(di, dict)
+    assert all(isinstance(v["state"], (int, type(None))) for v in di.values())
+
+
+def test_relay_states(moxa_operator):
+    relays = moxa_operator.get_points()["relays"]
+    assert isinstance(relays, dict)
+    assert all(isinstance(v["state"], (int, type(None))) for v in relays.values())
+
+
+def test_relay_toggle(moxa_operator):
+    moxa_operator.change_relay_state(0, 0)
+    moxa_operator.update_points()
+    assert moxa_operator.get_points()["relays"][0]["state"] == 0
+
+    moxa_operator.change_relay_state(0, 1)
+    moxa_operator.update_points()
+    assert moxa_operator.get_points()["relays"][0]["state"] == 1

gravity_controller_operator-2.0.0/gravity_controller_operator/controllers/wb_mr6lv.py

@@ -0,0 +1,63 @@
+from gravity_controller_operator.controllers_super import DIInterface, RelayInterface, ControllerInterface
+from pymodbus.client import ModbusSerialClient
+from pymodbus import Framer
+
+
+class WBMR6LVDI(DIInterface):
+    map_keys_amount = 8
+    starts_with = 0
+    spec_addr = {0: 7, 1: 0, 2: 1, 3: 2, 4: 3, 5: 4, 6: 5}
+
+    def __init__(self, client, slave_id):
+        self.client = client
+        self.slave_id = slave_id
+        super().__init__()
+
+    def get_phys_dict(self):
+        response = self.client.read_discrete_inputs(
+            self.starts_with, self.map_keys_amount, slave=self.slave_id)
+        while not response or response.isError():
+            response = self.client.read_discrete_inputs(
+                self.starts_with, self.map_keys_amount, slave=self.slave_id)
+        return {i: bit for i, bit in enumerate(response.bits)}
+
+
+class WBMR6LVRelay(RelayInterface):
+    map_keys_amount = 6
+    starts_with = 0
+    spec_addr = {1: 0, 2: 1, 3: 2, 4: 3, 5: 4, 6: 5}
+
+    def __init__(self, client, slave_id):
+        self.client = client
+        self.slave_id = slave_id
+        super().__init__()
+
+    def get_phys_dict(self):
+        response = self.client.read_coils(
+            self.starts_with, self.map_keys_amount, slave=self.slave_id)
+        while not response or response.isError():
+            response = self.client.read_coils(
+                self.starts_with, self.map_keys_amount, slave=self.slave_id)
+        return {i: bit for i, bit in enumerate(response.bits)}
+
+    def change_phys_relay_state(self, addr, state: bool):
+        result = self.client.write_coil(addr, state, slave=self.slave_id)
+        while not result or result.isError():
+            result = self.client.write_coil(addr, state, slave=self.slave_id)
+
+
+class WBMR6LV:
+    model = "wb_mr6lv"
+
+    def __init__(self, device, slave_id, baudrate=9600, stopbits=2, bytesize=8,
+                 name="WBMR6LV", *args, **kwargs):
+        client = ModbusSerialClient(
+            device,
+            framer=Framer.RTU,
+            baudrate=baudrate,
+            stopbits=stopbits,
+            bytesize=bytesize,
+        )
+        di = WBMR6LVDI(client, slave_id)
+        relay = WBMR6LVRelay(client, slave_id)
+        self.interface = ControllerInterface(di_interface=di, relay_interface=relay)

gravity_controller_operator-2.0.0/gravity_controller_operator/controllers_super.py

@@ -0,0 +1,105 @@
+from abc import ABC, abstractmethod
+import datetime
+
+
+class SoftStateMixin:
+    """
+    Хранит программное состояние входов/выходов.
+    Позволяет обновлять состояния и получать их по ключу.
+    """
+    spec_addr = {}      # переназначение адресов (если физический != логическому)
+    map_keys_amount = 0
+    starts_with = 0
+
+    def __init__(self):
+        self.state = self._init_state()
+
+    def _init_state(self):
+        points = {}
+        for i in range(self.map_keys_amount):
+            logical_ch = self.starts_with + i
+            addr = self.spec_addr.get(logical_ch, logical_ch)
+            points[logical_ch] = {"state": None, "changed": None, "addr": addr}
+        return points
+
+    def update_state(self, addr, value, mark_time=True):
+        now = datetime.datetime.now() if mark_time else None
+        for logical_ch, info in self.state.items():
+            if info["addr"] == addr:
+                info["state"] = value
+                info["changed"] = now
+
+    def get_state(self):
+        return self.state
+
+    def get_point(self, num):
+        return self.state.get(num, {"error": f"channel {num} not found"})
+
+
+class BasePhysInterface(ABC):
+    """
+    Абстрактный интерфейс работы с железом.
+    Потомки реализуют конкретную работу с DI или Relay.
+    """
+    @abstractmethod
+    def get_phys_dict(self) -> dict:
+        """
+        Вернуть словарь {канал: значение} с физического устройства.
+        """
+        pass
+
+
+class RelayPhysInterface(BasePhysInterface):
+    @abstractmethod
+    def change_phys_relay_state(self, addr: int, state: bool):
+        """
+        Изменить состояние реле на физическом устройстве.
+        """
+        pass
+
+class DIInterface(SoftStateMixin, BasePhysInterface):
+    def __init__(self):
+        super().__init__()
+        self.update_from_device()
+
+    def update_from_device(self):
+        values = self.get_phys_dict()
+        for addr, value in values.items():
+            self.update_state(addr, value, mark_time=False)
+
+
+class RelayInterface(SoftStateMixin, RelayPhysInterface):
+    def __init__(self):
+        super().__init__()
+        self.update_from_device()
+
+    def update_from_device(self):
+        values = self.get_phys_dict()
+        for addr, value in values.items():
+            self.update_state(addr, value, mark_time=False)
+
+    def change_relay_state(self, logical_ch: int, state: bool):
+        self.update_state(logical_ch, state)
+        addr = self.state[logical_ch]["addr"]
+        return self.change_phys_relay_state(addr, state)
+
+
+class ControllerInterface:
+    """
+    Комбинирует доступ к DI и Relay интерфейсам.
+    """
+    def __init__(self, di_interface=None, relay_interface=None):
+        self.di_interface = di_interface
+        self.relay_interface = relay_interface
+
+    def update_all(self):
+        if self.di_interface:
+            self.di_interface.update_from_device()
+        if self.relay_interface:
+            self.relay_interface.update_from_device()
+
+    def get_all_states(self):
+        return {
+            "di": self.di_interface.get_state() if self.di_interface else {},
+            "relays": self.relay_interface.get_state() if self.relay_interface else {}
+        }

gravity_controller_operator-2.0.0/gravity_controller_operator/exceptions.py

@@ -0,0 +1,8 @@
+class UnknownController(Exception):
+    # Исключение, возникающее при неизвестном имени терминала
+    def __init__(self, contr_name=None, contr_list=[]):
+        text = f'Контроллер {contr_name} не обнаружен! Создайте класс с контроллером ' \
+               'в директории controllers, укажите его модель через атрибут ' \
+               'model, затем добавьте этот класс в список ' \
+               f'AVAILABLE_CONTROLLERS {tuple(contr_list)}'
+        super().__init__(text)

gravity_controller_operator-2.0.0/gravity_controller_operator/main.py

@@ -0,0 +1,47 @@
+import threading
+import time
+from threading import Lock
+
+
+class ControllerOperator:
+    def __init__(self, controller, auto_update_points=True, update_cooldown=0.25):
+        self.controller = controller
+        self.interface = controller.interface
+        self.mutex = Lock()
+        self.update_cooldown = update_cooldown
+        self.auto_update_points_enabled = auto_update_points
+
+        if auto_update_points:
+            threading.Thread(target=self._auto_update_loop, daemon=True).start()
+
+    def _auto_update_loop(self):
+        while self.auto_update_points_enabled:
+            self.update_points()
+            time.sleep(self.update_cooldown)
+
+    def update_points(self):
+        with self.mutex:
+            self.interface.update_all()
+
+    def get_points(self):
+        with self.mutex:
+            return self.interface.get_all_states()
+
+    def change_relay_state(self, ch: int, value: int):
+        with self.mutex:
+            return self.interface.relay_interface.change_relay_state(ch, value)
+
+    def get_point(self, typ, ch):
+        if typ == "di":
+            return self.interface.di_interface.get_point(ch)
+        elif typ == "relays":
+            return self.interface.relay_interface.get_point(ch)
+
+    def get_di_state(self, ch):
+        return self.get_point("di", ch)
+
+    def get_relay_state(self, ch):
+        return self.get_point("relays", ch)
+
+    def get_model(self):
+        return self.controller.model

gravity_controller_operator-2.0.0/gravity_controller_operator/tests/main_tests.py

@@ -0,0 +1,19 @@
+import unittest
+from gravity_controller_operator.main import ControllerOperator, \
+    ControllerCreater
+
+
+class TestCase(unittest.TestCase):
+    def test_operator(self):
+        inst = ControllerCreater.get_controller(
+            "wb_mr6lv12",False)
+        co = ControllerOperator(inst)
+        print(co.get_points())
+        # inst = ControllerOperator("localhost", 8234, "arm_k210",
+        #                          auto_update_points=True)
+        # while True:
+        #   print(inst.get_points())
+
+
+if __name__ == "__main__":
+    unittest.main()

gravity_controller_operator-2.0.0/gravity_controller_operator.egg-info/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.1
+Name: gravity_controller_operator
+Version: 2.0.0
+Summary: SDK предоставляющий универсальный интерфейс для работы со многими промышленными контроллерами ввода-вывода (количество расширяемо)
+Author: PunchyArchy
+Author-email: ksmdrmvscthny@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyModbusTCP
+Requires-Dist: pymodbus==3.6.9
+
+# Gravity Controller Operator
+
+Модуль для унифицированной работы с промышленными контроллерами (реле, дискретные входы и т.д.). Позволяет взаимодействовать с различными устройствами через единый интерфейс.
+
+---
+
+## 🚀 Поддерживаемые контроллеры
+
+- **EmulatorController** — заглушка для тестов
+- **ARMK210Controller** — Modbus TCP
+- **WBMR6LV** — Modbus RTU
+- **NetPing2Controller** — HTTP API
+- **Sigur** — доступ через TCP (СКУД)
+- **MoxaE1214** — REST API (vdn.dac.v1)
+
+---
+
+## 🧩 Архитектура
+
+### 🧠 Интерфейсы:
+
+- `DIInterface`: чтение дискретных входов
+- `RelayInterface`: чтение/управление релейными выходами
+- `ControllerInterface`: объединяет оба
+
+Все интерфейсы наследуют `SoftStateMixin`, в котором реализовано хранение состояния точек (`state`, `changed`, `addr`).
+
+### 🛠 Контроллер
+Каждый контроллер реализует:
+```python
+self.interface = ControllerInterface(di_interface=..., relay_interface=...)
+```
+
+### 🧪 Обёртки:
+
+- `ControllerOperator` — отвечает за автоматическое обновление, mutex-безопасность и удобный API
+- `ControllerCreator` — фабрика создания контроллеров по имени модели (см. `controller_factory.py`)
+
+---
+
+## 🧪 Как использовать
+
+```python
+from gravity_controller_operator.controllers.moxa import MoxaE1214
+from gravity_controller_operator.controller_operator import ControllerOperator
+
+moxa = MoxaE1214("192.168.60.103")
+operator = ControllerOperator(moxa)
+
+print(operator.get_points())
+operator.change_relay_state(0, 1)  # включить реле 0
+```
+
+---
+
+## 🔬 Тестирование
+
+Установка:
+```bash
+pip install pytest
+```
+
+Запуск:
+```bash
+pytest gravity_controller_operator/tests/
+```
+
+---
+
+## 📦 Добавление нового контроллера
+
+1. Реализуй `YourControllerDI` и `YourControllerRelay`, наследуя `DIInterface`, `RelayInterface`
+2. Создай `YourController`, в котором:
+```python
+self.interface = ControllerInterface(di_interface=..., relay_interface=...)
+```
+3. Добавь контроллер в `AVAILABLE_CONTROLLERS` в `controller_factory.py`
+
+---
+
+## 📁 Структура
+
+```
+controllers_super.py          # Базовые интерфейсы
+controllers/                  # Реализации контроллеров
+controller_operator.py        # Обёртка ControllerOperator ✅
+controller_factory.py         # AVAILABLE_CONTROLLERS + фабрика ✅
+exceptions.py                 # Кастомные исключения ✅
+tests/                        # Тесты
+README.md
+```
+
+---
+
+## 🤝 Контакты
+
+- 📧 Email: ksmdrmvstchny@gmail.com
+- 💬 Telegram: [@PunchyArchy](https://t.me/PunchyArchy)
+- 📞 Phone: +7 996 294-75-95
+
+Проект поддерживается Артуром (PunchyArchy, Qodex)

gravity_controller_operator-2.0.0/gravity_controller_operator.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+LICENSE
+README.md
+setup.py
+gravity_controller_operator/__init__.py
+gravity_controller_operator/controller_factory.py
+gravity_controller_operator/controllers_super.py
+gravity_controller_operator/exceptions.py
+gravity_controller_operator/main.py
+gravity_controller_operator.egg-info/PKG-INFO
+gravity_controller_operator.egg-info/SOURCES.txt
+gravity_controller_operator.egg-info/dependency_links.txt
+gravity_controller_operator.egg-info/requires.txt
+gravity_controller_operator.egg-info/top_level.txt
+gravity_controller_operator/controllers/__init__.py
+gravity_controller_operator/controllers/arm_k210.py
+gravity_controller_operator/controllers/emulator_contr.py
+gravity_controller_operator/controllers/moxa.py
+gravity_controller_operator/controllers/netping_relay.py
+gravity_controller_operator/controllers/sigur.py
+gravity_controller_operator/controllers/wb_mr6lv.py
+gravity_controller_operator/controllers/tests/__init__.py
+gravity_controller_operator/controllers/tests/test_moxa_controller.py
+gravity_controller_operator/docs/__init__.py
+gravity_controller_operator/tests/__init__.py
+gravity_controller_operator/tests/main_tests.py

gravity_controller_operator-2.0.0/gravity_controller_operator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gravity_controller_operator-2.0.0/gravity_controller_operator.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pyModbusTCP
+pymodbus==3.6.9

gravity_controller_operator-2.0.0/gravity_controller_operator.egg-info/top_level.txt

@@ -0,0 +1 @@
+gravity_controller_operator

gravity_controller_operator-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gravity_controller_operator-2.0.0/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="gravity_controller_operator",
+    version="2.0.0",
+    description="SDK предоставляющий универсальный интерфейс для работы со многими промышленными контроллерами ввода-вывода (количество расширяемо)",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    author="PunchyArchy",
+    author_email="ksmdrmvscthny@gmail.com",
+    packages=find_packages(),
+    python_requires=">=3.7",
+    install_requires=[
+        "pyModbusTCP",
+        "pymodbus==3.6.9",
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+)