ORD 1.8.13__py3-none-any.whl

ORD/__init__.py

@@ -0,0 +1,6 @@
+from .ord_core import Core
+from .ord_shift import Shift
+from .ord_receipt import Receipt
+from .ord_cash import Cash
+from .ord_fn import Fn
+from .ord_setting import Setting

ORD/ord_cash.py

@@ -0,0 +1,168 @@
+from libfptr10 import IFptr
+from .ord_core import Core
+
+
+class Cash:
+    shift_stage = {
+        0: "CLOSED",
+        1: "OPENED",
+        2: "EXPIRED"
+    }
+
+    fn_state = {
+        0: "FNS_INITIAL",
+        1: "FNS_CONFIGURED",
+        3: "FNS_FISCAL_MODE",
+        7: "FNS_POSTFISCAL_MODE",
+        15: "FNS_ACCESS_ARCHIVE"
+    }
+
+    def __init__(self, core):
+        self.core = core
+        if self.core.is_opened() == 0:
+            if not self.core.open_connect():
+                return None
+        self.fptr = core.fptr
+
+    def get_cash_info(self):
+        """
+        Получение информации о ККТ
+
+        :returns: cash_info
+        :rtype: dict
+        """
+        cash_info = {
+            "fnNo": "",
+            "fnVersion": "",
+            "fnCountDocInShift": "",
+            "serialNo": "",
+            "modelName": "",
+            "modelId": "",
+            "firmwareVersion": "",
+            "vendorName": "АТОЛ",
+            "shiftNumber": "",
+            "shiftState": "",
+            "shiftDateTime": "",
+            "taxModes": "",
+            "ffdVersion": ""
+        }
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STATUS)
+        self.fptr.queryData()
+
+        serial_no = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER)
+        model_name = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME)
+        model_id = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL)
+
+        cash_info.update({"serialNo": serial_no})
+        cash_info.update({"modelName": model_name})
+        cash_info.update({"modelId": model_id})
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION)
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_FIRMWARE)
+        self.fptr.queryData()
+
+        firmware_version = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION)
+        cash_info.update({"firmwareVersion": firmware_version})
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_STATE)
+        self.fptr.queryData()
+
+        shift_state = self.shift_stage.get(self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE))
+        shift_number = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER)
+        shift_date_time = self.fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME)
+
+        cash_info.update({"shiftState": shift_state})
+        cash_info.update({"shiftNumber": shift_number})
+        cash_info.update({"shiftDateTime": shift_date_time.strftime("%Y-%m-%d %H:%M:%S")})
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_FN_INFO)
+        self.fptr.fnQueryData()
+
+        fn_serial = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER)
+        fn_version = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_FN_VERSION)
+
+        cash_info.update({"fnNo": fn_serial})
+        cash_info.update({"fnVersion": fn_version.strip()})
+
+        return cash_info
+
+    def get_uptime_cash(self):
+        """
+        Запрос времени работы ККТ
+        :returns: uptime
+        :rtype: int
+        """
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DEVICE_UPTIME)
+        self.fptr.queryData()
+
+        uptime = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_UPTIME)
+
+        return uptime
+
+    def cash_registration(self):
+        """
+        Регистрация кассы
+
+        Расчет регистрационного номера для МГМ
+        ВХОД:
+        1) порядковый номер зарегистрированного ККТ (дополняется лидирующими нулями до длины в 10 символов, используется ascii-коды в кодировке CP866);
+        2) ИНН пользователя ККТ (дополняется лидирующими нулями до длины в 12 символов, используется ascii-коды в кодировке CP866);
+        3) заводской номер ККТ (дополняется лидирующими нулями до длины в 20 символов, используется ascii-коды в кодировке CP866);
+
+        ВЫХОД:
+        1) вычисляется значение по алгоритму расчета контрольной суммы CRC16-CCITT
+        2) значение переводится в десятичную систему счислений
+        3) дополняется лидирующими нулями до длины строки в 6 символов
+
+        Пример:
+        порядковый номер зарегистрированного ККТ 0000000001
+        ИНН пользователя ККТ 770123456789
+        заводской номер ККТ 00000000000123456789
+
+        Вычисления:
+        1) CRC16-CCITT(000000000177012345678900000000000123456789) = 492D (hex)
+        2) 492D (hex) = 18733 (dec)
+        3) 018733
+
+        РНМ ККТ равен 0000000001018733
+
+        :return:
+        """
+        status = False
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_OPERATION_TYPE, IFptr.LIBFPTR_FNOP_REGISTRATION)
+
+        self.fptr.setParam(1060, "nalog.ru")
+
+        self.fptr.setParam(1009, "127051, г. Москва, Петровский б-р, 21")
+        self.fptr.setParam(1018, "9705112246")
+        self.fptr.setParam(1048, "ООО \"БШ СТОР\"")
+        self.fptr.setParam(1062, IFptr.LIBFPTR_TT_OSN)
+        self.fptr.setParam(1117, "volodya@brandshop.ru")
+        self.fptr.setParam(1057, IFptr.LIBFPTR_AT_NONE)
+
+        self.fptr.setParam(1187, "https://brandshop.ru")
+        self.fptr.setParam(1037, "0000000001030584")
+        self.fptr.setParam(1209, IFptr.LIBFPTR_FFD_UNKNOWN)
+        self.fptr.setParam(1001, False)
+        self.fptr.setParam(1002, False)
+        self.fptr.setParam(1056, False)
+        self.fptr.setParam(1108, True)
+        self.fptr.setParam(1109, False)
+        self.fptr.setParam(1110, False)
+        self.fptr.setParam(1126, False)
+        self.fptr.setParam(1193, False)
+
+        self.fptr.setParam(1221, False)
+
+        self.fptr.setParam(1017, "9715260691")
+        self.fptr.setParam(1046, "ООО ПС СТ")
+
+        if self.fptr.fnOperation() < 0:
+            self.core._error_log()
+        else:
+            self.core._check_document_close()
+            status = True
+
+        return status

ORD/ord_core.py

@@ -0,0 +1,218 @@
+import threading
+
+from libfptr10 import IFptr
+
+
+class SingletonMeta(type):
+    """
+    В Python класс Одиночка можно реализовать по-разному. Возможные способы
+    включают себя базовый класс, декоратор, метакласс. Мы воспользуемся
+    метаклассом, поскольку он лучше всего подходит для этой цели.
+    """
+    _instances = {}
+    _lock = threading.Lock()
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            with cls._lock:
+                if cls not in cls._instances:
+                    cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+class Core(metaclass=SingletonMeta):
+    casher_info = {
+        'name': 'СИС. АДМИНИСТРАТОР',
+        'inn': ''
+    }
+
+    def __init__(self, path: str = ''):
+        """
+        Инициализация драйвера:
+        Настройка драйвера
+        """
+        self.fptr = IFptr(path)
+
+        self.version = self.fptr.version()
+
+        settings = {
+            IFptr.LIBFPTR_SETTING_MODEL: IFptr.LIBFPTR_MODEL_ATOL_AUTO,
+            IFptr.LIBFPTR_SETTING_PORT: IFptr.LIBFPTR_PORT_USB,
+            IFptr.LIBFPTR_SETTING_USB_DEVICE_PATH: 'auto',
+            IFptr.LIBFPTR_SETTING_OFD_CHANNEL: IFptr.LIBFPTR_OFD_CHANNEL_AUTO
+        }
+
+        self.fptr.setSettings(settings)
+
+    def _set_casher(self):
+        """
+        Регистрация кассира
+
+        Рекомендуется вызывать данный метод перед каждой
+        фискальной операцией (открытие чека, печать отчета, ...).
+        :return: status
+        :rtype: bool
+        """
+        status = False
+
+        self.fptr.setParam(1021, self.casher_info.get('name'))
+        self.fptr.setParam(1203, self.casher_info.get('inn'))
+
+        if self.fptr.operatorLogin() < 0:
+            self._error_log()
+        else:
+            status = True
+
+        return status
+
+    def open_connect(self):
+        """
+        Открытие соединение с кассой
+        :returns: status
+        :rtype: bool
+        """
+        status = False
+        if self.fptr.open() < 0:
+            self._error_log()
+        else:
+            status = True
+
+        return status
+
+    def close_connect(self):
+        """
+        Закрытие соединения с кассой
+        :returns: status
+        :rtype: bool
+        """
+        status = False
+        if self.fptr.close() < 0:
+            self._error_log()
+        else:
+            status = True
+
+        return status
+
+    def is_opened(self):
+        """
+        Получение состояния соединения с кассой
+        Результат метода не отражает текущее состояние подключения - если с ККТ
+        была разорвана связь, то метод все также будет возвращать true, но методы,
+        выполняющие какие-либо операции над ККТ,
+        будут возвращать ошибку LIBFPTR_ERROR_NO_CONNECTION
+        :returns: self.fptr.isOpened()
+        :rtype: int
+        """
+        return self.fptr.isOpened()
+
+    def get_version_driver(self):
+        """
+        Получение версии драйвера
+        :returns: self.version
+        :rtype: str
+        """
+        return self.version
+
+    def get_current_datetime(self):
+        """
+        Текущие дата и время ККТ
+        :returns: date_time
+        :rtype: str
+        """
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DATE_TIME)
+        self.fptr.queryData()
+
+        date_time = self.fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME).strftime('%Y-%m-%d %H:%M:%S')
+
+        return date_time
+
+    def get_setting(self):
+        """
+        Получение настроек кассы
+        :returns: setting_cash
+        :rtype: dict
+        """
+        setting_cash = self.fptr.getSettings()
+
+        return setting_cash
+
+    def _check_document_close(self):
+        """
+        Проверка закрытия документа
+
+        В ряде ситуаций (окончание бумаги, потеря связи с
+        ККТ в момент регистрации документа) состояние документа остается неизвестным.
+        Он может закрыться в ФН (что является необратимой операцией), но не напечататься на чековой ленте.
+        Данный метод сверяет счетчики ККТ с сохраненными до закрытия документа копиями и вычисляет,
+        закрылся ли он, а также проверяет состояние печати документа.
+        :returns: status
+        :rtype: bool
+        """
+        status = True
+
+        while self.fptr.checkDocumentClosed() < 0:
+            # Не удалось проверить состояние документа.
+            # Вывести пользователю текст ошибки, попросить
+            # устранить неполадку и повторить запрос
+            self._error_log()
+            status = False
+            continue
+
+        # if not self.fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_CLOSED):
+        #     # Документ не закрылся.
+        #     # Требуется его отменить (если это чек) и сформировать заново
+        #     self.fptr.cancelReceipt()
+        #     return status
+
+        if not self.fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_PRINTED):
+            # Можно сразу вызвать метод допечатывания документа,
+            # он завершится с ошибкой, если это невозможно
+            while self.fptr.continuePrint() < 0:
+                # Если не удалось допечатать документ,
+                # показать пользователю ошибку и попробовать еще раз.
+                self._error_log()
+                status = False
+                continue
+
+        return status
+
+    def reboot(self):
+        """
+        Перезагрузка ККТ
+        :return:
+        """
+        status = False
+
+        if self.fptr.deviceReboot() < 0:
+            self._error_log()
+        else:
+            status = True
+
+        return status
+
+    def _error_log(self):
+        """
+        Логирование ошибок
+        Каждый метод драйвера возвращает индикатор результата выполнения.
+        Этот индикатор может принимать значения 0 и -1.
+        В случае если индикатор неравен 0, выполнение метода завершилось с ошибкой и
+        есть возможность получить подробности о ней.
+        Для этого у драйвера можно запросить код последней ошибки (метод errorCode()) и
+        её текстовое описание (метод errorDescription()).
+        Драйвер хранит информацию об ошибке до следующего вызова метода - после него информация об ошибке обновляется.
+        Для явного сброса информации о последней ошибке нужно использовать метод resetError().
+        """
+        error_msg = '{} [{}]'.format(self.fptr.errorCode(), self.fptr.errorDescription())
+        self.fptr.logWrite("FiscalPrinter", IFptr.LIBFPTR_LOG_ERROR, error_msg)
+
+    def info_log(self, msg):
+        """
+        Логирование нотификаций
+        :param msg:
+        :return:
+        """
+        self.fptr.logWrite("FiscalPrinter", IFptr.LIBFPTR_LOG_INFO, msg)
+
+    def __del__(self):
+        if self.is_opened() == 1:
+            self.close_connect()

ORD/ord_fn.py

@@ -0,0 +1,359 @@
+from libfptr10 import IFptr
+from .ord_core import Core
+
+
+class Fn:
+    fn_state = {
+        0: "FNS_INITIAL",
+        1: "FNS_CONFIGURED",
+        3: "FNS_FISCAL_MODE",
+        7: "FNS_POSTFISCAL_MODE",
+        15: "FNS_ACCESS_ARCHIVE"
+    }
+
+    ffd_version = {
+        0: "FFD_UNKNOWN",
+        100: "FFD_1_0",
+        105: "FFD_1_0_5",
+        110: "FFD_1_1",
+        120: "FFD_1_2"
+    }
+
+    tax_mode = {
+        1: "OSN",
+        2: "USN_INCOME",
+        4: "USN_INCOME_OUTCOME",
+        16: "ESN",
+        32: "PATENT",
+    }
+
+    receipt_type = {
+        0: "CLOSED",
+        1: "SELL",
+        2: "SELL_RETURN",
+        7: "SELL_CORRECTION",
+        8: "SELL_RETURN_CORRECTION",
+        4: "BUY",
+        5: "BUY_RETURN",
+        9: "BUY_CORRECTION",
+        10: "BUY_RETURN_CORRECTION"
+    }
+
+    doc_type = {
+        1: "REGISTRATION",
+        2: "OPEN_SHIFT",
+        3: "RECEIPT",
+        4: "BSO",
+        5: "CLOSE_SHIFT",
+        6: "CLOSE_FN",
+        7: "OPERATOR_CONFIRMATION",
+        11: "REREGISTRATION",
+        21: "EXCHANGE_STATUS",
+        31: "CORRECTION",
+        41: "BSO_CORRECTION"
+    }
+
+    def __init__(self, core):
+        self.core = core
+        if self.core.is_opened() == 0:
+            if not self.core.open_connect():
+                return None
+        self.fptr = core.fptr
+
+    def get_status_fn(self):
+        """
+        Получение статуса фискального накопителя
+        :return: fn_state
+        :rtype: str
+        """
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_FN_INFO)
+        self.fptr.fnQueryData()
+
+        fn_state = self.fn_state.get(self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_STATE))
+
+        return fn_state
+
+    def get_info_last_receipt(self):
+        """
+        Запрос информации о последнем чеке
+        :return: last_receipt_info
+        :rtype: dict
+        """
+        last_receipt_info = {
+            "receipt_number": "",
+            "receipt_type": "",
+            "receipt_sum": "",
+            "fiscal_sign": "",
+            "date_time": ""
+        }
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_LAST_RECEIPT)
+        self.fptr.fnQueryData()
+
+        receipt_number = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER)
+        last_receipt_info.update({"receipt_number": receipt_number})
+
+        receipt_type = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE)
+        last_receipt_info.update({"receipt_type": self.receipt_type.get(receipt_type)})
+
+        receipt_sum = self.fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM)
+        last_receipt_info.update({"receipt_sum": receipt_sum})
+
+        fiscal_sign = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_FISCAL_SIGN)
+        last_receipt_info.update({"fiscal_sign": fiscal_sign})
+
+        date_time = self.fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME)
+        last_receipt_info.update({"date_time": date_time.strftime("%Y-%m-%d %H:%M:%S")})
+
+        return last_receipt_info
+
+    def get_info_last_doc(self):
+        """
+        Запрос информации о последнем фискальном документе
+        :return: last_doc_info
+        :rtype: dict
+        """
+        last_doc_info = {
+            "document_number": "",
+            "receipt_type": "",
+            "fiscal_sign": "",
+            "date_time": ""
+        }
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_LAST_DOCUMENT)
+        self.fptr.fnQueryData()
+
+        document_number = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER)
+        last_doc_info.update({"document_number": document_number})
+
+        receipt_type = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE)
+        last_doc_info.update({"receipt_type": self.receipt_type.get(receipt_type)})
+
+        fiscal_sign = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_FISCAL_SIGN)
+        last_doc_info.update({"fiscal_sign": fiscal_sign})
+
+        date_time = self.fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME)
+        last_doc_info.update({"date_time": date_time.strftime("%Y-%m-%d %H:%M:%S")})
+
+        return last_doc_info
+
+    def get_version_ffd(self):
+        """
+        Запрос версий ФФД
+        :return:version_ffd
+        :rtype:dict
+        """
+        version_ffd = {
+            "device_ffd_version": "",
+            "fn_ffd_version": "",
+            "max_fn_ffd_version": "",
+            "ffd_version": "",
+            "max_ffd_version": "",
+            "min_ffd_version": ""
+        }
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_FFD_VERSIONS)
+        self.fptr.fnQueryData()
+
+        device_ffd_version = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_FFD_VERSION)
+        version_ffd.update({"device_ffd_version": self.ffd_version.get(device_ffd_version)})
+
+        fn_ffd_version = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_FFD_VERSION)
+        version_ffd.update({"fn_ffd_version": self.ffd_version.get(fn_ffd_version)})
+
+        max_fn_ffd_version = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_MAX_FFD_VERSION)
+        version_ffd.update({"max_fn_ffd_version": self.ffd_version.get(max_fn_ffd_version)})
+
+        ffd_version = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_FFD_VERSION)
+        version_ffd.update({"ffd_version": self.ffd_version.get(ffd_version)})
+
+        max_ffd_version = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_MAX_FFD_VERSION)
+        version_ffd.update({"max_ffd_version": self.ffd_version.get(max_ffd_version)})
+
+        min_ffd_version = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_MIN_FFD_VERSION)
+        version_ffd.update({"document_number": self.ffd_version.get(min_ffd_version)})
+
+        return version_ffd
+
+    def get_info_doc(self, number_doc):
+        """
+        Запрос информации о документе
+        :return: info_doc
+        :rtype: dict
+        """
+        info_doc = {
+            "document_type": "",
+            "document_number": "",
+            "has_ofd_ticket": "",
+            "date_time": "",
+            "fiscal_sign": ""
+        }
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_DOCUMENT_BY_NUMBER)
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER, number_doc)
+        self.fptr.fnQueryData()
+
+        document_type = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_DOCUMENT_TYPE)
+        info_doc.update({"document_type": self.doc_type.get(document_type)})
+
+        document_number = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER)
+        info_doc.update({"document_number": document_number})
+
+        has_ofd_ticket = self.fptr.getParamBool(IFptr.LIBFPTR_PARAM_HAS_OFD_TICKET)
+        info_doc.update({"has_ofd_ticket": has_ofd_ticket})
+
+        fiscal_sign = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_FISCAL_SIGN)
+        info_doc.update({"fiscal_sign": fiscal_sign})
+
+        date_time = self.fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME)
+        info_doc.update({"date_time": date_time.strftime("%Y-%m-%d %H:%M:%S")})
+
+        return info_doc
+
+    def get_ticket_ofd(self, number_doc):
+        """
+        Запрос квитанции ОФД
+        :return: ticket_ofd
+        :rtype:
+        """
+        ticket_ofd = {
+            "document_number": "",
+            "date_time": "",
+            "ofd_fiscal_sign": "",
+        }
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_TICKET_BY_DOC_NUMBER)
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER, number_doc)
+        self.fptr.fnQueryData()
+
+        document_number = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER)
+        ticket_ofd.update({"document_number": document_number})
+
+        date_time = self.fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME)
+        ticket_ofd.update({"date_time": date_time.strftime("%Y-%m-%d %H:%M:%S")})
+
+        ofd_fiscal_sign = self.fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_OFD_FISCAL_SIGN)
+        ticket_ofd.update({"ofd_fiscal_sign": ofd_fiscal_sign})
+
+        return ticket_ofd
+
+    def get_ofd_document_by_number(self, number_doc):
+        """
+        Метод чтения документа из ФН в виде TLV-структур
+        :param number_doc: номер документа
+        :return: array
+        """
+        tags = []
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_TYPE, IFptr.LIBFPTR_RT_FN_DOCUMENT_TLVS)
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER, number_doc)
+        self.fptr.beginReadRecords()
+        records_id = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_RECORDS_ID)
+
+        while self._readNextRecord(records_id) == IFptr.LIBFPTR_OK:
+            tag = {
+                "tag_value": self.fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE),
+                "tag_number": self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_TAG_NUMBER),
+                "tag_name": self.fptr.getParamString(IFptr.LIBFPTR_PARAM_TAG_NAME),
+                "tag_type": self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_TAG_TYPE),
+            }
+            tags.append(tag)
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_ID, records_id)
+        self.fptr.endReadRecords()
+
+        return tags
+
+    def get_fn_error(self):
+        """
+        Запрос ошибок ФН и ОФД
+        :return:
+        """
+        fn_error_info = {
+            "network": {
+                "error": "",
+                "error_text": ""
+            },
+            "ofd": {
+                "error": "",
+                "error_text": ""
+            },
+            "fn": {
+                "error": "",
+                "error_text": ""
+            }
+        }
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_ERRORS)
+        self.fptr.fnQueryData()
+
+        network_error = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_NETWORK_ERROR)
+        network_error_text = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_NETWORK_ERROR_TEXT)
+
+        network = fn_error_info.get("network")
+        network.update({"error": network_error})
+        network.update({"error_text": network_error_text})
+
+        ofd_error = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_OFD_ERROR)
+        ofd_error_text = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_OFD_ERROR_TEXT)
+
+        ofd = fn_error_info.get("ofd")
+        ofd.update({"error": ofd_error})
+        ofd.update({"error_text": ofd_error_text})
+
+        fn_error = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_FN_ERROR)
+        fn_error_text = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_FN_ERROR_TEXT)
+
+        fn = fn_error_info.get("fn")
+        fn.update({"error": fn_error})
+        fn.update({"error_text": fn_error_text})
+
+        return fn_error_info
+
+    def get_exchange_status(self):
+        """
+        Запрос статуса информационного обмена
+        :return:
+        """
+        fn_exchange_info = {
+            "exchange_status": "",
+            "unsent_count": "",
+            "first_unsent_number": "",
+            "ofd_message_read": "",
+            "date_time": "",
+        }
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_OFD_EXCHANGE_STATUS)
+        self.fptr.fnQueryData()
+
+        exchange_status = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_OFD_EXCHANGE_STATUS)
+        unsent_count = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT)
+        first_unsent_number = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER)
+        ofd_message_read = self.fptr.getParamBool(IFptr.LIBFPTR_PARAM_OFD_MESSAGE_READ)
+        date_time = self.fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME)
+
+        fn_exchange_info.update({"exchange_status": exchange_status})
+        fn_exchange_info.update({"unsent_count": unsent_count})
+        fn_exchange_info.update({"first_unsent_number": first_unsent_number})
+        fn_exchange_info.update({"ofd_message_read": ofd_message_read})
+        fn_exchange_info.update({"date_time": date_time.strftime("%Y-%m-%d %H:%M:%S")})
+
+        return fn_exchange_info
+
+    def get_registration_number(self):
+        """
+        Запрос РНМ
+        :return:registrationNumber
+        """
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_FN_DATA_TYPE, IFptr.LIBFPTR_FNDT_REG_INFO)
+        self.fptr.fnQueryData()
+
+        registration_number = self.fptr.getParamString(1037)
+
+        return registration_number
+
+        # Вспомогательная функция чтения следующей записи
+
+    def _readNextRecord(self, recordsID):
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_RECORDS_ID, recordsID)
+        return self.fptr.readNextRecord()

ORD/ord_receipt.py

@@ -0,0 +1,342 @@
+from libfptr10 import IFptr
+from .ord_core import Core
+
+
+class Receipt:
+    """
+    Формирование чека состоит из следующих операций:
+
+        открытие чека и передача реквизитов чека
+        регистрация позиций, печать нефискальных данных (текст, штрихкоды, изображения)
+        регистрация итога (необязательный пункт - если регистрацию итога не провести, он автоматически расчитается из суммы всех позиций)
+        регистрация налогов на чек (необязательный пункт - налоги могут быть подтянуты из позиций и суммированы)
+        регистрация оплат
+        закрытие чека
+        проверка состояния чека
+
+        Пример:
+        {
+           "document":{
+              "id":"ofd_605df0bed5d8a",
+              "checkoutDateTime":"2021-03-26T17:33:34+03:00",
+              "docNum":"197452540",
+              "docType":"SALE",
+              "printReceipt":false,
+              "responseURL":null,
+              "email":"volodya@brandshop.ru",
+              "inventPositions":[
+                 {
+                    "name":"Сланцы adidas Originals YEEZY Foam Runner Moon Gray/Moon Gray/Moon Gray",
+                    "price":6990,
+                    "quantity":"1",
+                    "vatTag":1102,
+                    "discSum":0,
+                    "nomenclatureCode":"44 4D 03 B2 3C AF 78 CB 70 25 63 33 35 6F 7A 52 79 2C 72 3F 7A"
+                 },
+                 {
+                    "name":"Самовывоз",
+                    "price":"0.0000",
+                    "quantity":"1",
+                    "vatTag":1102,
+                    "discSum":0,
+                    "nomenclatureCode":null
+                 }
+              ],
+              "moneyPositions":[
+                 {
+                    "paymentType":"CARD",
+                    "sum":6990
+                 }
+              ]
+           }
+        }
+    """
+
+    tax_mode = {
+        "OSN": 1,
+        "USN_INCOME": 2,
+        "USN_INCOME_OUTCOME": 4,
+        "ESN": 16,
+        "PATENT": 32,
+    }
+
+    def __init__(self, core):
+        self.core = core
+        if self.core.is_opened() == 0:
+            if not self.core.open_connect():
+                return None
+        self.fptr = core.fptr
+
+    def open_receipt(self, receipt_data):
+        """
+        Открытие чека и передача реквизитов чека
+        Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:
+        LIBFPTR_RT_SELL - чек прихода (продажи)
+        LIBFPTR_RT_SELL_RETURN - чек возврата прихода (продажи)
+        LIBFPTR_RT_SELL_CORRECTION - чек коррекции прихода
+        LIBFPTR_RT_SELL_RETURN_CORRECTION - чек коррекции возврата прихода
+        LIBFPTR_RT_BUY - чек расхода (покупки)
+        LIBFPTR_RT_BUY_RETURN - чек возврата расхода (покупки)
+        LIBFPTR_RT_BUY_CORRECTION - чек коррекции расхода
+        LIBFPTR_RT_BUY_RETURN_CORRECTION - чек коррекции возврата расхода
+
+        Чтобы чек не печатался (электронный чек), нужно установить
+        параметру LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY значение true.
+
+        "id":"ofd_605df0bed5d8a",
+        "checkoutDateTime":"2021-03-26T17:33:34+03:00",
+        "docNum":"197452540",
+        "docType":"SALE",
+        "printReceipt":false,
+        "responseURL":null,
+        "email":"volodya@brandshop.ru",
+        "taxMode": "OSN"
+        """
+        status = False
+
+        if not self.core._set_casher():
+            return status
+
+        receipt_type = receipt_data.get("docType")
+        receipt_print = receipt_data.get("printReceipt")
+        receipt_email = receipt_data.get("email")
+        receipt_tax_mode = self.tax_mode.get(receipt_data.get("taxMode"))
+
+        if receipt_type == "SALE":
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
+        elif receipt_type == "RETURN":
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL_RETURN)
+        else:
+            return status
+
+        if receipt_print:
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, False)
+        else:
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, True)
+
+        self.fptr.setParam(1008, receipt_email)
+        self.fptr.setParam(1055, receipt_tax_mode)
+        # Признак расчета в интернете
+        self.fptr.setParam(1125, 1)
+
+        if self.fptr.openReceipt() < 0:
+            self.core._error_log()
+        else:
+            status = True
+
+        return status
+
+    def cancel_receipt(self):
+        """
+        Отмена чека
+        :return: status
+        :rtype: bool
+        """
+        status = False
+
+        if self.fptr.cancelReceipt() < 0:
+            self.core._error_log()
+        else:
+            status = True
+
+        return status
+
+    def receipt_registration(self, product):
+        """
+        Регистрация позиции
+        Тип налога (LIBFPTR_PARAM_TAX_TYPE) может принимать следующие значения:
+
+        LIBFPTR_TAX_VAT10 - НДС 10%;
+        LIBFPTR_TAX_VAT110 - НДС рассчитанный 10/110;
+        LIBFPTR_TAX_VAT0 - НДС 0%;
+        LIBFPTR_TAX_NO - не облагается;
+        LIBFPTR_TAX_VAT20 - НДС 20%;
+        LIBFPTR_TAX_VAT120 - НДС рассчитанный 20/120;
+        LIBFPTR_TAX_VAT5 - НДС 5%;
+        LIBFPTR_TAX_VAT105 - НДС рассчитанный 5/105;
+        LIBFPTR_TAX_VAT7 - НДС 7%;
+        LIBFPTR_TAX_VAT107 - НДС рассчитанный 7/107;
+        LIBFPTR_TAX_VAT22 - НДС 22%;
+        LIBFPTR_TAX_VAT122 - НДС рассчитанный 22/122.
+
+        1102	Сумма НДС чека по ставке 20%	double
+        1103	Сумма НДС чека по ставке 10%	double
+        1104	Сумма расчёта по чеку с НДС по ставке 0%	double
+        1105	Сумма расчёта по чека без НДС	double
+        1106	Сумма НДС чека по расч. ставке 20/120	double
+        1107	Сумма НДС чека по расч. ставке 10/110	double
+
+        "inventPositions":[
+            {
+                "name":"Сланцы adidas Originals YEEZY Foam Runner Moon Gray/Moon Gray/Moon Gray",
+                "price":6990,
+                "quantity":"1",
+                "vatTag":1102,
+                "discSum":0,
+                "nomenclatureCode":"44 4D 03 B2 3C AF 78 CB 70 25 63 33 35 6F 7A 52 79 2C 72 3F 7A"
+            },
+            {
+                "name":"Самовывоз",
+                "price":"0.0000",
+                "quantity":"1",
+                "vatTag":1102,
+                "discSum":0,
+                "nomenclatureCode":null
+            }
+          ],
+        :return: status
+        :rtype: bool
+        """
+        status = False
+
+        product_name = product.get("name")
+        product_price = product.get("price")
+        product_quantity = product.get("quantity")
+        # product_tax = product.get("vatTag")
+        product_nomenclature_code = product.get("nomenclatureCode")
+        product_code_check = product.get("codeCheck")
+        product_disc_sum = product.get("discSum")
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, product_name)
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, product_price)
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, product_quantity)
+        # Для запроса суммы налога за чек необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE
+        # равным LIBFPTR_DT_RECEIPT_TAX_SUM и указать тип налога LIBFPTR_PARAM_TAX_TYPE.
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT22)
+
+        if product_nomenclature_code:
+            # Запускаем проверку КМ
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE, product_nomenclature_code)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_STATUS, 2)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_MEASUREMENT_UNIT, IFptr.LIBFPTR_IU_PIECE)
+            self.fptr.beginMarkingCodeValidation()
+
+            # Дожидаемся окончания проверки и запоминаем результат
+            while True:
+                self.fptr.getMarkingCodeValidationStatus()
+                if self.fptr.getParamBool(IFptr.LIBFPTR_PARAM_MARKING_CODE_VALIDATION_READY):
+                    break
+
+            validation_result = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT)
+
+            # Подтверждаем реализацию товара с указанным КМ
+            self.fptr.acceptMarkingCode()
+
+            # Результат проверки разрешительного режима кода маркировки(Регистрация позиции с отраслевым
+            # реквизитом предмета расчета (тег 1260, ФФД 1.2))
+            if product_code_check:
+                self.fptr.setParam(1262, '030')
+                self.fptr.setParam(1263, '21.11.2023')
+                self.fptr.setParam(1264, '1944')
+                self.fptr.setParam(1265, product_code_check)
+                self.fptr.utilFormTlv()
+                industry_info = self.fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE)
+                self.fptr.setParam(1260, industry_info)
+                self.fptr.setParam(1212, 33)
+
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, product_name)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, product_price)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, product_quantity)
+            # Для запроса суммы налога за чек необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE
+            # равным LIBFPTR_DT_RECEIPT_TAX_SUM и указать тип налога LIBFPTR_PARAM_TAX_TYPE.
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT22)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_ONLINE_VALIDATION_RESULT, validation_result)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE, product_nomenclature_code)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_CODE_STATUS, 2)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_MARKING_PROCESSING_MODE, 0)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_MEASUREMENT_UNIT, IFptr.LIBFPTR_IU_PIECE)
+        else:
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_MEASUREMENT_UNIT, IFptr.LIBFPTR_IU_PIECE)
+            self.fptr.setParam(1212, 1)
+
+        if product_disc_sum > 0:
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_INFO_DISCOUNT_SUM, product_disc_sum)
+
+        if self.fptr.registration() < 0:
+            self.core._error_log()
+        else:
+            status = True
+
+        return status
+
+    def receipt_payment(self, money_position):
+        """
+        Регистрация оплаты
+
+        Способ расчета (LIBFPTR_PARAM_PAYMENT_TYPE) может принимать следующие значения:
+            LIBFPTR_PT_CASH - наличными
+            LIBFPTR_PT_ELECTRONICALLY - безналичными
+            LIBFPTR_PT_PREPAID - предварительная оплата (аванс)
+            LIBFPTR_PT_CREDIT - последующая оплата (кредит)
+            LIBFPTR_PT_OTHER - иная форма оплаты (встречное предоставление)
+            LIBFPTR_PT_6 - способ расчета №6
+            LIBFPTR_PT_7 - способ расчета №7
+            LIBFPTR_PT_8 - способ расчета №8
+            LIBFPTR_PT_9 - способ расчета №9
+            LIBFPTR_PT_10 - способ расчета №10
+
+        Пример:
+        "moneyPositions": {
+            "paymentType": "CARD",
+            "sum": 46.8
+        }
+
+        :return: status
+        :rtype: bool
+        """
+        status = False
+
+        sum = money_position.get("sum")
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_ELECTRONICALLY)
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_SUM, sum)
+
+        if self.fptr.payment() < 0:
+            self.core._error_log()
+        else:
+            status = True
+
+        return status
+
+    def receipt_total(self, money_position):
+        """
+        Регистрация итога на чек
+
+        "moneyPositions":[
+            {
+                "paymentType":"CARD",
+                "sum":6990
+            }
+        ]
+
+        :return: status
+        :rtype: bool
+        """
+        status = False
+
+        sum = money_position.get("sum")
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, sum)
+
+        if self.fptr.receiptTotal() < 0:
+            self.core._error_log()
+        else:
+            status = True
+
+        return status
+
+    def receipt_close(self):
+        """
+        Закрытие чека
+        :return: status
+        :rtype: bool
+        """
+        status = False
+
+        if self.fptr.closeReceipt() < 0:
+            self.core._error_log()
+        else:
+            status = True
+
+        return status

ORD/ord_setting.py

@@ -0,0 +1,86 @@
+from libfptr10 import IFptr
+from .ord_core import Core
+
+
+class Setting(Core):
+
+    def __init__(self, core):
+        self.core = core
+        if self.core.is_opened() == 0:
+            if not self.core.open_connect():
+                return None
+        self.fptr = core.fptr
+
+    def init_setting(self):
+        """
+        Инициализация системных таблиц
+        :returns: status
+        :rtype: bool
+        """
+
+        status = False
+
+        if self.fptr.initSettings() < 0:
+            self._error_log()
+        else:
+            status = True
+
+        return status
+
+    def get_device_setting_by_id(self, id_setting, type_setting):
+        """
+        Чтение настройки кассы
+        :param id_setting:
+        :param type_setting
+        :return: setting_value
+        :rtype: bool, int, str
+        """
+        setting_value = False
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_SETTING_ID, id_setting)
+        self.fptr.readDeviceSetting()
+
+        if type_setting == "int":
+            setting_value = self.fptr.getParamInt(IFptr.LIBFPTR_PARAM_SETTING_VALUE)
+        if type_setting == "string":
+            setting_value = self.fptr.getParamString(IFptr.LIBFPTR_PARAM_SETTING_VALUE)
+
+        return setting_value
+
+    def set_device_setting_by_id(self, id_setting, value_setting):
+        """
+        Запись настройки кассы
+        :param id_setting:
+        :param value_setting:
+        :return status
+        :rtype bool
+        """
+        status = False
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_SETTING_ID, id_setting)
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_SETTING_VALUE, value_setting)
+
+        if self.fptr.writeDeviceSetting() < 0:
+            self._error_log()
+        else:
+            status = True
+
+        return status
+
+    def commit_setting(self):
+        """
+        Сохранение настроек
+        :returns: status
+        :rtype: bool
+        """
+        status = False
+
+        if self.fptr.commitSettings() < 0:
+            self._error_log()
+        else:
+            status = True
+
+        return status
+
+    def __del__(self):
+        if self.is_opened() == 1:
+            self.close_connect()

ORD/ord_shift.py

@@ -0,0 +1,69 @@
+from libfptr10 import IFptr
+from .ord_core import Core
+
+
+class Shift:
+
+    def __init__(self, core):
+        self.core = core
+        if self.core.is_opened() == 0:
+            if not self.core.open_connect():
+                return None
+        self.fptr = core.fptr
+
+    def open_shift(self):
+        """
+        Открытие смены
+
+        Открывать смену необязательно, т.к. она будет открыта первой фискальной операцией автоматически.
+        На некоторых ККТ возможно отключить печать отчета об открытии смены
+        с помощью установки параметра LIBFPTR_PARAM_REPORT_ELECTRONICALLY в true.
+        Если ККТ не поддерживает такой функционал, параметр будет проигнорирован и отчет будет напечатан.
+        :returns: status
+        :rtype: bool
+        """
+
+        status = False
+
+        if not self.core._set_casher():
+            return status
+
+        if self.fptr.openShift() < 0:
+            self.core._error_log()
+        else:
+            self.core._check_document_close()
+            status = True
+
+        return status
+
+    def close_shift(self):
+        """
+        Закрытие смены
+
+        Автоматически может напечататься так же и Z-отчет.
+        На некоторых ККТ возможно отключить печать отчета о закрытии смены с помощью установки
+        параметра LIBFPTR_PARAM_REPORT_ELECTRONICALLY в true.
+        Если ККТ не поддерживает такой функционал, параметр будет
+        проигнорирован и отчет будет напечатан.
+        :returns: status
+        :rtype: bool
+        """
+        status = False
+
+        if not self.core._set_casher():
+            return status
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_CLOSE_SHIFT)
+
+        if self.fptr.report() < 0:
+            self.core._error_log()
+        else:
+            self.core._check_document_close()
+            status = True
+
+        return status
+
+
+    # def __del__(self):
+    #     if core.is_opened() == 1:
+    #         self.close_connect()

ORD/test/ORD_test.py

@@ -0,0 +1,12 @@
+import unittest
+import ORD
+
+
+class TestCash(unittest.TestCase):
+    def test_connect(self):
+        cash = ORD()
+        self.assertTrue(cash.open_connect())
+
+
+if __name__ == '__main__':
+    unittest.main()

ord-1.8.13.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: ORD
+Version: 1.8.13
+Summary: Module for working with the ATOL cash register driver
+Home-page: https://github.com/brandshopru
+Author: Vladimir Smirnov
+Author-email: volodya@brandshop.ru
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: summary
+
+Модуль для работы с драйвером кассы АТОЛ
+===========

ord-1.8.13.dist-info/RECORD

@@ -0,0 +1,13 @@
+ORD/__init__.py,sha256=hr4slw4ghZ11wmJnxZ1Pq8aWBQWumqzeu6iNYudVJxE,172
+ORD/ord_cash.py,sha256=liZc_QUgFvysPXkbX6Pc_87be0LFYPuZe3wBYJ90pDw,6468
+ORD/ord_core.py,sha256=uWwV1wQf178i6UxdHGCyD4c2D8qn8m6sOoU51VX23RE,8497
+ORD/ord_fn.py,sha256=NoKB2CITV_r15KSsv69zYH91mjQY7o97XdwcvLQfaj0,12771
+ORD/ord_receipt.py,sha256=6YTN1lRcFUfKgyYaT0kc9gwKdEH7BpEpmqcS75COtLE,14066
+ORD/ord_setting.py,sha256=i4q3G8olOIx14IMGiT8TGfGdhS2YKiTPP9ropohcV5k,2228
+ORD/ord_shift.py,sha256=AIz-y0oilkgtCXM2q8TOFoIspvP3CCoqHBoL7Gzwdlg,2427
+ORD/test/ORD_test.py,sha256=Ak6cKbfcBr4Dss3bySNfSBoLHZzPtHwe1CVFFoUF0KM,207
+ORD/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ord-1.8.13.dist-info/METADATA,sha256=G6MQoEJvOg_ISQX_wfEOkkhOG9iVFyg9exRjrAhR90A,470
+ord-1.8.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ord-1.8.13.dist-info/top_level.txt,sha256=8n708F8RT49tSXTCLyLkv9Pjh79msvpquJ5RQKK3gb4,4
+ord-1.8.13.dist-info/RECORD,,

ord-1.8.13.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ord-1.8.13.dist-info/top_level.txt

@@ -0,0 +1 @@
+ORD