pyxcp 0.21.10__cp311-cp311-win_amd64.whl → 0.22.23__cp311-cp311-win_amd64.whl

pyxcp/cxx/win/socket.hpp

@@ -1,185 +0,0 @@
-
-#if !defined(__SOCKET_HPP)
-#define __SOCKET_HPP
-
-#include <array>
-
-#include <WinSock2.h>
-#include <Ws2tcpip.h>
-#include <Mstcpip.h>
-#include <MSWSock.h>
-#include <Windows.h>
-
-#include "isocket.hpp"
-#include "timeout.hpp"
-#include "periodata.hpp"
-#include "perhandledata.hpp"
-#include "pool.hpp"
-#include "poolmgr.hpp"
-
-class IOCP;
-
-class Socket : public ISocket {
-public:
-
-    using Pool_t = Pool<PerIoData, 16>;
-
-    Socket(int family = PF_INET, int socktype = SOCK_STREAM, int protocol = IPPROTO_TCP) :
-        m_family(family), m_socktype(socktype), m_protocol(protocol), m_connected(false),
-        m_pool_mgr(PoolManager()), m_addr(nullptr) {
-        m_socket = ::WSASocket(m_family, m_socktype, m_protocol, NULL, 0, WSA_FLAG_OVERLAPPED);
-        if (m_socket == INVALID_SOCKET) {
-            SocketErrorExit("Socket::Socket()");
-        }
-        ZeroOut(&m_peerAddress, sizeof(SOCKADDR_STORAGE));
-    }
-
-    ~Socket() {
-        ::closesocket(m_socket);
-    }
-
-    void option(int optname, int level, int * value) {
-        int len;
-
-        len = sizeof(*value);
-        if (*value == 0) {
-            ::getsockopt(m_socket, level, optname, (char*) value, &len);
-        } else {
-            ::setsockopt(m_socket, level, optname, (const char*) value, len);
-        }
-    }
-
-    bool getaddrinfo(int family, int socktype, int protocol, const char * hostname, int port, CAddress & address, int flags = AI_PASSIVE) {
-        int err;
-        ADDRINFO hints;
-        ADDRINFO * t_addr;
-        char port_str[16] = {0};
-
-        ZeroOut(&hints, sizeof(hints));
-        hints.ai_family = family;
-        hints.ai_socktype = socktype;
-        hints.ai_protocol = protocol;
-        hints.ai_flags = flags;
-
-        ::sprintf(port_str, "%d", port);
-        err = ::getaddrinfo(hostname, port_str, &hints, &t_addr);
-        if (err != 0) {
-            printf("%s\n", gai_strerror(err));
-            ::freeaddrinfo(t_addr);
-            SocketErrorExit("getaddrinfo()");
-            return false;
-        }
-
-        address.length = t_addr->ai_addrlen;
-        ::CopyMemory(&address.address, t_addr->ai_addr, sizeof(struct sockaddr));
-
-        ::freeaddrinfo(t_addr);
-        return true;
-    }
-
-    void connect(CAddress & address) {
-        if (::connect(m_socket, &address.address, address.length) == SOCKET_ERROR) {
-            SocketErrorExit("Socket::connect()");
-        }
-        PerHandleData handleData(HandleType::HANDLE_SOCKET, getHandle());
-    }
-
-    void bind(CAddress & address) {
-        if (::bind(m_socket, &address.address, address.length) == SOCKET_ERROR) {
-            SocketErrorExit("Socket::bind()");
-        }
-    }
-
-    void listen(int backlog = 5) {
-        if (::listen(m_socket, backlog) == SOCKET_ERROR) {
-            SocketErrorExit("Socket::listen()");
-        }
-    }
-
-    void accept(CAddress & peerAddress) {
-        SOCKET sock;
-
-        peerAddress.length = sizeof peerAddress.address;
-        sock = ::accept(m_socket, (sockaddr *)&peerAddress.address, &peerAddress.length);
-
-        if (sock  == INVALID_SOCKET) {
-            SocketErrorExit("Socket::accept()");
-        }
-    }
-
-    template <typename T, size_t N>
-    void write(std::array<T, N>& arr, bool alloc = true) {
-        DWORD bytesWritten = 0;
-        int addrLen;
-        //PerIoData * iod = new PerIoData(128);
-        PerIoData * iod;
-
-        if (alloc == true) {
-            iod = m_pool_mgr.get_iod().acquire();
-            //iod = m_iod_pool.acquire();
-        }
-        m_timeout.arm();
-        iod->reset();
-        iod->set_buffer(arr);
-        iod->set_opcode(IoType::IO_WRITE);
-        iod->set_transfer_length(arr.size());
-        if (m_socktype == SOCK_DGRAM) {
-            addrLen = sizeof(SOCKADDR_STORAGE);
-            if (::WSASendTo(m_socket,
-                iod->get_buffer(),
-                1,
-                &bytesWritten,
-                0,
-                (LPSOCKADDR)&m_peerAddress,
-                addrLen,
-                (LPWSAOVERLAPPED)iod,
-                nullptr
-            ) == SOCKET_ERROR) {
-                // WSA_IO_PENDING
-                SocketErrorExit("Socket::send()");
-            }
-        } else if (m_socktype == SOCK_STREAM) {
-            if (::WSASend(
-                m_socket,
-                iod->get_buffer(),
-                1,
-                &bytesWritten,
-                0,
-                (LPWSAOVERLAPPED)iod,
-                nullptr) == SOCKET_ERROR) {
-                    SocketErrorExit("Socket::send()");
-                closesocket(m_socket);
-            }
-        }
-        printf("Status: %d bytes_written: %d\n", WSAGetLastError(), bytesWritten);
-    }
-    void triggerRead(unsigned int len);
-
-    HANDLE getHandle() const {
-        return reinterpret_cast<HANDLE>(m_socket);
-    }
-
-    const TimeoutTimer& getTimeoutTimer() const {
-        return m_timeout;
-    }
-
-    void setIOCP(IOCP * iocp) {
-        m_iocp = iocp;
-        m_timeout.setIOCP(iocp);
-    }
-
-private:
-    int m_family;
-    int m_socktype;
-    int m_protocol;
-    bool m_connected;
-    PoolManager m_pool_mgr;
-    ADDRINFO * m_addr;
-    SOCKET m_socket;
-    //CAddress ourAddress;
-    SOCKADDR_STORAGE m_peerAddress;
-    TimeoutTimer m_timeout {150};
-    IOCP * m_iocp = nullptr;
-};
-
-#endif  // __SOCKET_HPP

pyxcp/cxx/win/timeout.hpp

@@ -1,83 +0,0 @@
-
-#if !defined(__TIMEOUT_HPP)
-#define __TIMEOUT_HPP
-
-#include <Windows.h>
-
-#include "utils.hpp"
-
-
-/*
- *
- * Implements a timer queue based time-out.
- *
- * Resolution is milli-seconds.
- *
- *
- */
-
-class IOCP;
-
-void CALLBACK Timeout_CB(void * lpParam, unsigned char TimerOrWaitFired);
-
-
-class TimeoutTimer {
-public:
-
-    explicit TimeoutTimer(uint64_t value) : m_millis(value) {
-        m_timer_queue = ::CreateTimerQueue();
-        if (m_timer_queue == nullptr)
-            OsErrorExit("TimeoutTimer::TimeoutTimer() -- CreateTimerQueue");
-        }
-
-    TimeoutTimer(const TimeoutTimer&) = default;
-    TimeoutTimer(const TimeoutTimer&&) = delete;
-
-    ~TimeoutTimer() {
-        if (!::DeleteTimerQueue(m_timer_queue)) {
-            OsErrorExit("TimeoutTimer::~TimeoutTimer() -- DeleteTimerQueueEx");
-        }
-    }
-
-    void arm() {
-        if (m_iocp != nullptr) {
-            if (!::CreateTimerQueueTimer(&m_timer, m_timer_queue, Timeout_CB, reinterpret_cast<void*>(m_iocp), m_millis, 0, 0)) {
-                OsErrorExit("TimeoutTimer::arm() -- CreateTimerQueueTimer");
-            }
-        }
-    }
-
-    void disarm() {
-        if (m_timer != INVALID_HANDLE_VALUE) {
-            if (!::DeleteTimerQueueTimer(m_timer_queue, m_timer, nullptr)) {
-                OsErrorExit("TimeoutTimer::disarm() -- DeleteTimerQueueTimer");
-            }
-            m_timer = INVALID_HANDLE_VALUE;
-        }
-    }
-
-    HANDLE getHandle() const {
-        return m_timer_queue;
-    }
-
-    uint64_t getValue() const {
-        return m_millis;
-    }
-
-    void setValue(uint64_t new_millis) {
-        m_millis = new_millis;
-    }
-
-    void setIOCP(IOCP * iocp) {
-        m_iocp = iocp;
-    }
-
-private:
-
-    uint64_t m_millis;
-    HANDLE m_timer_queue {INVALID_HANDLE_VALUE};
-    HANDLE m_timer {INVALID_HANDLE_VALUE};
-    IOCP * m_iocp = nullptr;
-};
-
-#endif // __TIMEOUT_HPP

pyxcp/examples/conf_can.json

@@ -1,20 +0,0 @@
-{
-    "TRANSPORT": "CAN",
-    "CAN_DRIVER": "Kvaser",
-    "CAN_USE_DEFAULT_LISTENER": true,
-    "CHANNEL": 0,
-    "ACCEPT_VIRTUAL": true,
-    "BAUDRATE_PRESET": true,
-    "CAN_ID_MASTER": 257,
-    "CAN_ID_SLAVE": 258,
-    "CAN_ID_BROADCAST": 256,
-    "MAX_DLC_REQUIRED": false,
-    "BITRATE": 250000,
-    "BTL_CYCLES": 16,
-    "SAMPLE_RATE": 1,
-    "SAMPLE_POINT": 87.5,
-    "SJW": 2,
-    "TSEG1": 5,
-    "TSEG2": 2,
-    "CREATE_DAQ_TIMESTAMPS": false
-}

pyxcp/examples/conf_eth.json

@@ -1,8 +0,0 @@
-{
-    "TRANSPORT": "ETH",
-    "HOST": "localhost",
-    "PORT": 5555,
-    "PROTOCOL": "TCP",
-    "IPV6": false,
-    "CREATE_DAQ_TIMESTAMPS": false
-}

pyxcp/logger.py

@@ -1,67 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-import logging
-
-logging.basicConfig()
-
-
-class Logger(object):
-
-    LOGGER_BASE_NAME = "pyxcp"
-    FORMAT = "[%(levelname)s (%(name)s)]: %(message)s"
-
-    def __init__(self, name, level=logging.WARN):
-        self.logger = logging.getLogger("{0}.{1}".format(self.LOGGER_BASE_NAME, name))
-        self.logger.setLevel(level)
-        handler = logging.StreamHandler()
-        handler.setLevel(level)
-        formatter = logging.Formatter(self.FORMAT)
-        handler.setFormatter(formatter)
-        self.logger.addHandler(handler)
-        #self.logger.propagate = False
-        self.lastMessage = None
-        self.lastSeverity = None
-
-    def getLastError(self):
-        result = (self.lastSeverity, self.lastMessage)
-        self.lastSeverity = self.lastMessage = None
-        return result
-
-    def log(self, message, level):
-        self.lastSeverity = level
-        self.lastMessage = message
-        self.logger.log(level, "{0}".format(message))
-        # print("{0}{1}".format(level, message))
-
-    def info(self, message):
-        self.log(message, logging.INFO)
-
-    def warn(self, message):
-        self.log(message, logging.WARN)
-
-    def debug(self, message):
-        self.log(message, logging.DEBUG)
-
-    def error(self, message):
-        self.log(message, logging.ERROR)
-
-    def critical(self, message):
-        self.log(message, logging.CRITICAL)
-
-    def verbose(self):
-        self.logger.setLevel(logging.DEBUG)
-
-    def silent(self):
-        self.logger.setLevel(logging.CRITICAL)
-
-    def setLevel(self, level):
-        LEVEL_MAP = {
-            "INFO": logging.INFO,
-            "WARN": logging.WARN,
-            "DEBUG": logging.DEBUG,
-            "ERROR": logging.ERROR,
-            "CRITICAL": logging.CRITICAL,
-        }
-        if isinstance(level, str):
-            level = LEVEL_MAP.get(level.upper(), logging.WARN)
-        self.logger.setLevel(level)

pyxcp/tests/test_config.py

@@ -1,62 +0,0 @@
-from collections import OrderedDict
-from io import StringIO
-from pyxcp.config import readConfiguration
-
-JSON = """{
-    "PORT": "COM10",
-    "BITRATE": 38400,
-    "BYTESIZE": 8,
-    "PARITY": "N",
-    "STOPBITS": 1,
-    "CREATE_DAQ_TIMESTAMPS": false
-}"""
-
-TOML = """PORT = "COM10"
-BITRATE = 38400
-PARITY = "N"
-BYTESIZE = 8
-STOPBITS = 1
-CREATE_DAQ_TIMESTAMPS = false
-"""
-
-CONF_JSON = StringIO(JSON)
-CONF_JSON.name = "hello.json"
-
-CONF_TOML = StringIO(TOML)
-CONF_TOML.name = "hello.toml"
-
-
-def test_read_empty_config():
-    assert readConfiguration(None) == {}
-    assert readConfiguration({}) == {}
-
-
-def test_read_json_config():
-    assert readConfiguration(CONF_JSON) == {
-        "BITRATE": 38400,
-        "BYTESIZE": 8,
-        "CREATE_DAQ_TIMESTAMPS": False,
-        "PARITY": "N",
-        "PORT": "COM10",
-        "STOPBITS": 1,
-    }
-
-
-def test_read_toml_config():
-    assert readConfiguration(CONF_TOML) == {
-        "BITRATE": 38400,
-        "BYTESIZE": 8,
-        "CREATE_DAQ_TIMESTAMPS": False,
-        "PARITY": "N",
-        "PORT": "COM10",
-        "STOPBITS": 1,
-    }
-
-
-def test_read_dict():
-    assert readConfiguration({"A": 1, "B": 2, "C": 3}) == {"A": 1, "B": 2, "C": 3}
-    assert readConfiguration(OrderedDict({"A": 1, "B": 2, "C": 3})) == {
-        "A": 1,
-        "B": 2,
-        "C": 3,
-    }

pyxcp/transport/candriver/__init__.py

@@ -1,2 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-

pyxcp/transport/candriver/pc_canalystii.py

@@ -1,27 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for CANalyst-II(+) by ZLG ZHIYUAN Electronics interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class Canalystii(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "BAUD  ": (int, False, None),
-        "TIMING0": (int, False, None),
-        "TIMING1": (int, False, None),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "BAUD": "baud",
-        "TIMING0": "Timing0",
-        "TIMING1": "Timing1",
-    }
-
-    def __init__(self):
-        super(Canalystii, self).__init__(bustype="canalystii")

pyxcp/transport/candriver/pc_etas.py

@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for ETAS BOA interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class Etas(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "FD": (bool, False, False),
-        "DATA_BITRATE": (int, False, None),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "FD": "fd",
-        "DATA_BITRATE": "data_bitrate",
-    }
-
-    def __init__(self):
-        super(Etas, self).__init__(bustype="etas")

pyxcp/transport/candriver/pc_gsusb.py

@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for CAN driver for Geschwister Schneider USB/CAN devices and bytewerk.org candleLight USB CAN interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class GsUsb(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    """
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-    }
-    """
-
-    def __init__(self):
-        super(GsUsb, self).__init__(bustype="gs_usb")

pyxcp/transport/candriver/pc_iscan.py

@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for isCAN from Thorsis Technologies GmbH.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class IsCAN(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "POLL_INTERVAL": (float, False, 0.01),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "POLL_INTERVAL": "poll_interval",
-    }
-
-    def __init__(self):
-        super(IsCAN, self).__init__(bustype="iscan")

pyxcp/transport/candriver/pc_ixxat.py

@@ -1,27 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for Ixxat interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class Ixxat(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "UNIQUE_HARDWARE_ID": (str, False, None),
-        "RX_FIFO_SIZE": (int, False, 16),
-        "TX_FIFO_SIZE": (int, False, 16),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "UNIQUE_HARDWARE_ID": "UniqueHardwareId",
-        "RX_FIFO_SIZE": "rxFifoSize",
-        "TX_FIFO_SIZE": "txFifoSize",
-    }
-
-    def __init__(self):
-        super(Ixxat, self).__init__(bustype="ixxat")

pyxcp/transport/candriver/pc_kvaser.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for Kvaser interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class Kvaser(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                        Type    Req'd   Default
-        "ACCEPT_VIRTUAL": (bool, False, True),
-        "DRIVER_MODE": (bool, False, True),
-        "NO_SAMP": (int, False, 1),
-        "SJW": (int, False, 2),
-        "TSEG1": (int, False, 5),
-        "TSEG2": (int, False, 2),
-        "SINGLE_HANDLE": (bool, False, True),
-        "FD": (bool, False, False),
-        "DATA_BITRATE": (int, False, None),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "ACCEPT_VIRTUAL": "accept_virtual",
-        "TSEG1": "tseg1",
-        "TSEG2": "tseg2",
-        "SJW": "sjw",
-        "NO_SAMP": "no_samp",
-        "DRIVER_MODE": "driver_mode",
-        "SINGLE_HANDLE": "single_handle",
-        "FD": "fd",
-        "DATA_BITRATE": "data_bitrate",
-    }
-
-    def __init__(self):
-        super(Kvaser, self).__init__(bustype="kvaser")

pyxcp/transport/candriver/pc_neovi.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for ICS NeoVi interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class Neovi(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "FD": (bool, False, False),
-        "DATA_BITRATE": (int, False, None),
-        "USE_SYSTEM_TIMESTAMP": (bool, False, False),
-        "SERIAL": (str, False, None),
-        "OVERRIDE_LIBRARY_NAME": (str, False, None),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "FD": "fd",
-        "DATA_BITRATE": "data_bitrate",
-        "USE_SYSTEM_TIMESTAMP": "use_system_timestamp",
-        "SERIAL": "serial",
-        "OVERRIDE_LIBRARY_NAME": "override_library_name",
-    }
-
-    def __init__(self):
-        super(Neovi, self).__init__(bustype="neovi")

pyxcp/transport/candriver/pc_nican.py

@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for National Instruments interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class NiCan(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "LOG_ERRORS": (bool, False, False),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "LOG_ERRORS": "log_errors",
-    }
-
-    def __init__(self):
-        super(NiCan, self).__init__(bustype="nican")

pyxcp/transport/candriver/pc_nixnet.py

@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for National Instruments xnet interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class NiXnet(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "LOG_ERRORS": (bool, False, False),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "LOG_ERRORS": "log_errors",
-    }
-
-    def __init__(self):
-        super(NiXnet, self).__init__(bustype="nixnet")