search

ljean / modbus-tk

Create Modbus app easily with Python
Other
569 stars 213 forks source link

Project dependencies may have API risk issues #174

Open PyDeps opened 1 year ago

PyDeps commented 1 year ago

Hi, In modbus-tk, inappropriate dependency versioning constraints can cause risks.

Below are the dependencies and version constraints that the project is using

pyserial>=3.1

The version constraint == will introduce the risk of dependency conflicts because the scope of dependencies is too strict. The version constraint No Upper Bound and * will introduce the risk of the missing API Error because the latest version of the dependencies may remove some APIs.

After further analysis, in this project, The version constraint of dependency pyserial can be changed to >=2.3,<=2.4.

The above modification suggestions can reduce the dependency conflicts as much as possible, and introduce the latest version as much as possible without calling Error in the projects.

The invocation of the current project includes all the following methods.

The calling methods from the pyserial 
serial.Serial
The calling methods from the all methods 
self._response_mbap.pack
socket.socket.recv
digits.append
self._databank.remove_slave
modbus_tk.utils.WorkerThread.start
to_data
self.request.send
modbus_tk.exceptions.ModbusInvalidRequestError
s.set_values
modbus_tk.utils.get_log_buffer
self.assertRaises
socket.socket.settimeout
self._data.__getitem__
self._thread.join
time.sleep
simu.server.add_slave.add_block
modbus_tk.modbus_tcp.TcpMbap
_cpu.Properties_
sock.send
self._blocks.pop
modbus_tk.exceptions.ModbusFunctionNotSupportedError
self.server.get_slave.remove_all_blocks
self.format
ModbusBlock
self._rpc_call.split
modbus_tk.modbus_tcp.TcpQuery._get_transaction_id
expected_values.append
self._thread.is_alive
self._make_query.parse_request
self.ConsoleInterface.super.__init__
self._read_continuous_blocks
modbus_tk.modbus_rtu.RtuQuery.parse_request
modbus_tk.modbus_tcp.TcpServer
self._sock.accept
s.add_block
modbus_tk.utils.calculate_rtu_inter_char
self.RtuServer.super.__init__
self._response_mbap.check_response
threading.Thread
self._check_console_input
modbus_tk.modbus_tcp.TcpServer.get_slave
self.server.get_slave
isinstance
self._do_open
self.master.set_timeout
modbus_tk.modbus_rtu.RtuQuery
self.rpc.start
Slave
client.setblocking
modbus_tk.simulator.Simulator.start
modbus_tk.modbus.ModbusInvalidRequestError
self.client.execute
NotImplementedError
modbus_tk.modbus_tcp.TcpServer._get_request_length
socketserver.TCPServer
self.master.execute
self.RtuServer.super.start
self._fcts
all_values.append
s.str.find
RtuQuery
sys.exit
threading.RLock
SimulatorRpcClient.add_slave
server.get_slave.get_values
modbus_tk.modbus_rtu.RtuMaster.execute
srv.start
self.request.recv.strip
modbus_tk.modbus.Master.set_timeout
self._response_to_values
self._recv
self._handle
modbus_tk.modbus.ModbusInvalidResponseError
modbus_tk.exceptions.InvalidModbusBlockError
excpt.get_exception_code
self.server._databank.handle_request
i.queries.build_request
self_.master.execute
len
ctypes.windll.Kernel32.WaitForSingleObject
logging.getLogger.addHandler
self._do_exit
self.outq.get
modbus_tk.exceptions.OutOfModbusBlockError
map
slave.get_values.append
self.request.recv
modbus_tk.modbus_tcp.TcpServer.stop
modbus_tk.utils.flush_socket
self._do_close
self.server.stop
MySimulator.start
ctypes.c_ulong
self.master.set_verbose
sys.stdin.readline
modbus_tk.modbus_tcp.TcpMaster
sock.recv
self.server.add_slave.add_block
self.server.get_slave.add_block
cmd.strip.split
time.time
modbus_tk.modbus_tcp.TcpQuery
self.TcpQuery.super.__init__
self.open
Databank
self._slave.set_values
chr
self.TcpServer.super.__init__
CompositeServer
modbus_tk.hooks.install_hook
self._get_request_length
self._slave.handle_request
self.console.start
threads.append
name._HOOKS.remove
modbus_tk.modbus_rtu.RtuServer
kwargs.pop
self.assert_
self.server.get_slave.get_values
SimulatorRpcClient
select.select
self.TcpMaster.super.__init__
self._tuple_to_str
SimulatorRpcClient.remove_slave
server.get_slave.add_block
self.CompositeServer.super.__init__
self.master.open
modbus_tk.modbus_rtu.RtuMaster.set_timeout
modbus_tk.utils.create_logger.info
DummyHandler.setFormatter
the_class
modbus_tk.utils.WorkerThread
self.get_slave.handle_request
self.rpc_server.serve_forever
self._go.set
self.mbap1.pack
self.slave5.add_block
modbus_tk.simulator.LOGGER.info
logging.Handler.__init__
self.rpc_server.shutdown
self.add_command
self.server.get_slave.remove_block
self._slave._get_block
fcn
modbus_tk.simulator.Simulator.__init__
threading.RLock.release
win32com.client.GetObject.InstancesOf
Exception.__init__
thread.start
modbus_tk.utils.create_logger.debug
modbus_tk.simulator_rpc_client.SimulatorRpcClient
socket.socket
self.inq.get.find
self.assertNotEqual
self.server.remove_all_slaves
win32com.client.GetObject
self._sock.bind
self._slaves.clear
modbus_tk.modbus_tcp.TcpQuery.parse_request
args.self.cmds
self._rpc_call
self.check_length
self._do_init
key.self._slaves.handle_request
modbus_tk.modbus_tcp.TcpMaster.open
self._make_thread
pow
self._make_response
self._databank.get_slave
sock.recv.strip
self.inq.get
self.assertEquals
self._sock.setblocking
modbus_tk.hooks.uninstall_hook
master.execute
self._read_out_of_blocks
ConsoleHandler
modbus_tk.modbus_tcp.TcpMbap.unpack
self.slave1.set_values
self.slave1.add_block
query.split
logging.getLogger.setLevel
self.server._make_query
self._read_too_many_registers
self._sock.settimeout
modbus_tk.modbus.Slave
main
self._sock.sendto
socket.socket.connect
modbus_tk.modbus_tcp.TcpServer.start
self._get_transaction_id
self.close
self.master.close
self._get_block_and_offset
modbus_tk.utils.create_logger.warning
self._slave.add_block
self._go.isSet
Simulator.start
self._response_mbap.unpack
modbus_tk.modbus_rtu.RtuServer.start
self.assertTrue
self.server.add_slave
self.server.add_slave.set_values
self._thread.start
self._make_query.build_response
modbus_tk.modbus_rtu.RtuServer.add_slave
self.assertEqual
self.master._send
self._sock.recv
self._slaves.pop
queue.Queue.get
SimulatorRpcClient.install_hook
self._check_ids
unittest.main
modbus_tk.modbus_tcp.TcpServer.add_slave
self.client.close
avoid_duplicates.append
self._sock.setsockopt
self.inq.get.strip
modbus_tk.modbus.LOGGER.info
self.server.add_slave._get_block
i.threads.start
self.RpcInterface.super.__init__
setuptools.setup
queue.Queue.put
modbus_tk.modbus_tcp.TcpQuery.build_request
bytearray
data.decode
Simulator.declare_hook
MySimulator.close
self.set_timeout
LogitHandler
crc16_alternative
str
modbus_tk.modbus_tcp.TcpMbap.clone
modbus_tk.exceptions.InvalidArgumentError
modbus_tk.exceptions.DuplicatedKeyError
self._serial.close
self._sock.send
int
modbus_tk.utils.WorkerThread.stop
self._get_master
swap_bytes
format
socket.socket.close
self.server.set_verbose
struct.unpack
avoid_duplicates
self._simu.set_values
modbus_tk.modbus_rtu.RtuQuery.build_request
SystemDataCollector
self.slave5.get_values
struct.pack
print
threading.RLock.acquire
self.slave1.get_values
self._sock.connect
function_code.self._fn_code_map
self._get_server
self.DummyHandler.super.__init__
self.console.close
client.fileno
self._serial.reset_input_buffer
self._make_query.build_request
self._serial.write
self._sockets.remove
self._sockets.append
self._read_registers
self.server.add_slave.get_values
modbus_tk.modbus_rtu.RtuQuery.build_response
threading.Event
sys.stdin.readline.find
SimulatorRpcClient.remove_block
modbus_tk.exceptions.MissingKeyError
struct.calcsize
self._databank.remove_all_slaves
self._go.clear
modbus_tk.modbus_rtu.RtuMaster
modbus_tk.modbus_tcp.TcpQuery.parse_response
modbus_tk.modbus.Databank
tuple
Simulator.close
self._sock.listen
self._get_block
ConsoleInterface
run_simulator
modbus_tk.exceptions.OverlapModbusBlockError
self._response_mbap.clone
SimulatorRpcClient.add_block
t.join
modbus_tk.modbus_tcp.TcpMaster.execute
modbus_tk.utils.create_logger.error
t.start
modbus_tk.utils.create_logger
Exception
self._make_query.parse_response
self.RtuMaster.super.__init__
RpcInterface
modbus_tk.exceptions.ModbusError
modbus_tk.exceptions.ModbusInvalidResponseError
modbus_tk.utils.swap_bytes
modbus_tk.modbus_tcp.TcpMaster.set_timeout
modbus_tk.modbus_rtu.RtuServer.stop
self._do_run
server.add_slave.add_block
modbus_tk.LOGGER.error
queue.Queue.empty
self._data.__setitem__
modbus_tk.modbus_rtu.RtuQuery.parse_response
SimulatorRpcClient.has_slave
modbus_tk.modbus_rtu.RtuServer.get_slave
logging.Formatter
self.rpc.close
list
self.master._sock.send
self._make_query
self.client.open
socket.socket.send
modbus_tk.LOGGER.warning
self._serial.flush
self._databank.handle_request
queue.Queue
serial.Serial
self._read_digital_data
modbus_tk.simulator.Simulator.close
modbus_tk.utils.to_data
modbus_tk.utils.calculate_crc
self.outq.put
self.server.start
modbus_tk.simulator.Simulator
self._databank.add_slave
simu.server.add_slave
sock.close
self._slave.remove_block
self._get_block.is_in
modbus_tk.modbus.LOGGER.debug
server.get_slave.set_values
self._request_mbap.check_length
range
check_length_hook.test.assertEqual
modbus_tk.hooks.call_hooks
sock.recv.find
Simulator
modbus_tk.modbus_tcp.TcpMaster._send
logging.getLogger
sys.stdout.write
block_type.self._memory.remove
self.RtuQuery.super.__init__
modbus_tk.modbus.Server
SimulatorRpcClient.remove_all_slaves
self.get_db
MySimulator
self.inq.put
modbus_tk.modbus_rtu.RtuMaster.set_verbose
self._serial.reset_output_buffer
join
TcpQuery
self._sock.close
sum
srv.set_verbose
self.mbap1.check_response
self._serial.read
modbus_tk.modbus_tcp.TcpMaster.close
self.RtuServer.super.stop
modbus_tk.modbus_tcp.TcpQuery.build_response
ctypes.windll.Kernel32.GetStdHandle
self.join
fct
sys.stdin.readline.split
ModbusInvalidMbapError
modbus_tk.modbus.InvalidArgumentError
self._serial.cancel_read
self.master._recv
self.get_timeout
issubclass
SimulatorRpcClient.remove_all_blocks
self._slave.get_values
self.slave5.set_values
thread.join
self.get_slave
self._request_mbap.unpack
modbus_tk.LOGGER.debug
exc.get_exception_code
srv.stop
self.server.remove_slave
sock.fileno
self._blocks.clear
self.TcpMaster.super.set_timeout
self._send
super
ex.get_exception_code
self.server.get_slave.set_values
DummyHandler
re.match
self._request_mbap.pack
TcpMbap
sock.settimeout
SimulatorRpcClient.set_values
self._serial.open
self.assertAlmostEqual
self.server._make_query.build_request
self._read_digital
zip
name._HOOKS.append
block_type.self._memory.insert
SimulatorRpcClient.get_values
ord

@developer Could please help me check this issue? May I pull a request to fix it? Thank you very much.

ljean commented 1 year ago

Hello.

Thanks for your message and sorry for late answer.

It is strange because your proposal of >=2.3,<=2.4 doesn't include the original ">=3.1" condition... I didn't heard any problem with 3.1. How did you find the "2.4" limit?

I am ok for a PR but I don't want to limit pySerial too much and cause dependency issues.

I am not using modbus-tk on a regular basis anymore. Does anyone has an opinion on the versions of pyserial to be used?