ORD 1.7.0__tar.gz

ORD-1.7.0/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-1.7.0/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-1.7.0/ORD/ord_core.py

@@ -0,0 +1,214 @@
+from libfptr10 import IFptr
+
+
+class SingletonMeta(type):
+    """
+    В Python класс Одиночка можно реализовать по-разному. Возможные способы
+    включают себя базовый класс, декоратор, метакласс. Мы воспользуемся
+    метаклассом, поскольку он лучше всего подходит для этой цели.
+    """
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+class Core(metaclass=SingletonMeta):
+    debug = False
+    casher_info = {
+        "name": "СИС. АДМИНИСТРАТОР",
+        "inn": ""
+    }
+
+    def __init__(self):
+        """
+        Инициализация драйвера:
+        Настройка драйвера
+        """
+        self.fptr = IFptr("")
+
+        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-1.7.0/ORD/ord_fn.py

@@ -0,0 +1,326 @@
+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_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

ORD-1.7.0/ORD/ord_receipt.py

@@ -0,0 +1,381 @@
+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)
+
+        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_DEPARTMENT - тип, привязанный к секции товара
+        LIBFPTR_TAX_VAT10 - НДС 10%
+        LIBFPTR_TAX_VAT110 - НДС расчитанный 10/110
+        LIBFPTR_TAX_VAT0 - НДС 0%
+        LIBFPTR_TAX_NO - не облагается
+        LIBFPTR_TAX_VAT20 - НДС 20%
+        LIBFPTR_TAX_VAT120 - НДС раcчитанный 20/120
+
+        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)
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT20)
+
+        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))
+            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(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)
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT20)
+            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)
+
+        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_tax(self, product_tax, money_position):
+        """
+        Регистрация налога на чек
+
+        Как выделить НДС?
+        Если у Вас под рукой не окажется интернета и надо будет выделить НДС - запомните этот простой алгоритм.
+        Чтобы выделить НДС из суммы, нужно разделить сумму на 1+НДС (т.е. если НДС 18%, то разделить нужно на 1.18),
+        вычесть из полученного исходную сумму, умножить на -1 и округлить до копеек в ближайшую сторону.
+        Если вы делаете это на калькуляторе, то последние два действия легко выполнить в уме.
+
+        Как начислить НДС?
+        Начислить НДС еще проще. Если ставка НДС 18%, то умножьте сумму без НДС на 0.18
+        и вы получите сумму налога, а умножив на 1.18 вы получите сумму с учетом налога.
+
+        :return: status
+        :rtype: bool
+        """
+        status = False
+
+        sum = money_position.get("sum")
+
+        if product_tax == 1102:
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT20)
+            koef = 1.2
+        elif product_tax == 1103:
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10)
+            koef = 1.1
+        elif product_tax == 1104:
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0)
+            koef = 1
+        elif product_tax == 1105:
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_NO)
+            koef = 1
+        elif product_tax == 1106:
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT120)
+            koef = 1
+        elif product_tax == 1107:
+            self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT110)
+            koef = 1
+        else:
+            return status
+
+        tax_sum = round(-1 * (sum * koef - sum), 2)
+
+        self.fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, tax_sum)
+
+        if self.fptr.receiptTax() < 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-1.7.0/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-1.7.0/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-1.7.0/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.7.0/ORD.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: ORD
+Version: 1.7.0
+Summary: Module for working with the ATOL cash register driver
+Home-page: https://brandshop.ru
+Author: Vladimir Smirnov
+Author-email: volodya@brandshop.ru
+Description-Content-Type: text/markdown
+
+Модуль для работы с драйвером кассы АТОЛ
+===========

ORD-1.7.0/ORD.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+setup.cfg
+setup.py
+ORD/__init__.py
+ORD/ord_cash.py
+ORD/ord_core.py
+ORD/ord_fn.py
+ORD/ord_receipt.py
+ORD/ord_setting.py
+ORD/ord_shift.py
+ORD.egg-info/PKG-INFO
+ORD.egg-info/SOURCES.txt
+ORD.egg-info/dependency_links.txt
+ORD.egg-info/top_level.txt
+ORD/test/ORD_test.py
+ORD/test/__init__.py

ORD-1.7.0/ORD.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ORD-1.7.0/ORD.egg-info/top_level.txt

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

ORD-1.7.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: ORD
+Version: 1.7.0
+Summary: Module for working with the ATOL cash register driver
+Home-page: https://brandshop.ru
+Author: Vladimir Smirnov
+Author-email: volodya@brandshop.ru
+Description-Content-Type: text/markdown
+
+Модуль для работы с драйвером кассы АТОЛ
+===========

ORD-1.7.0/README.md

@@ -0,0 +1,2 @@
+Модуль для работы с драйвером кассы АТОЛ
+===========

ORD-1.7.0/setup.cfg

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

ORD-1.7.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+from io import open
+
+def read(filename):
+    """Прочитаем наш README.md для того, чтобы установить большое описание."""
+    with open(filename, "r", encoding="utf-8") as file:
+        return file.read()
+
+setup(
+    name='ORD',
+    version='1.7.0',
+    author='Vladimir Smirnov',
+    author_email='volodya@brandshop.ru',
+    description='Module for working with the ATOL cash register driver',
+    url='https://brandshop.ru',
+    long_description=read("README.md"),
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+)