How to implement a callback?

[Timatgithub1]

I would like to access a Python package in Ruby using PyCall.

The non-blocking function in the Python code below activates a callback.

Could you help me implement the callback?

Original Python code

#!/usr/bin/env python
# start_reading.py
import time
import mercury

def found(tag):
    print(tag.epc.decode()) # Check check
    # print(tags[1].epc.decode())

reader = mercury.Reader("tmr:///dev/ttyUSB0")

reader.start_reading(found, on_time=250, off_time=0)
time.sleep(0.5)
reader.stop_reading()

Output start_reading.py:

b'001853000000000000000012'
b'34155CACB400000000000125'
b'34155CACB400000000000125'
b'34155CACB400000000000125'
b'001853000000000000000012'
b'34155CACB400000000000125'
b'001853000000000000000012'
b'34155CACB400000000000125'
b'34155CACB400000000000125'

Replacement Ruby code
The solution should be an improvement upon the following code.

#!/usr/bin/env ruby
# start_reading.rb
require 'pycall/import'
include PyCall::Import
pyimport :mercury

def found(tag)
  puts tag.epc
end

reader = mercury.Reader.new("tmr:///dev/ttyUSB0")

reader.start_reading(found, on_time=250, off_time=0) # What should I do here?
sleep(0.5)
reader.stop_reading()

Current output start_reading.rb

start_reading.rb:7:in `found': wrong number of arguments (given 0, expected 1) (ArgumentError)
	from start_reading.rb:14:in `<main>'

Docs
This pertains an api for ThingMagic RFID readers, which is a Python wrapper for the original api written in C.

From the docs:

reader.start_reading(callback, on_time=250, off_time=0)

Starts asynchronous reading. It returns immediately and begins a sequence of reads or a continuous read. The results are passed to the callback. The reads are repeated until the reader.stop_reading() method is called

• callback(TagReadData) will be invoked for every tag detected
• on_time sets the duration, in milliseconds, for the reader to be actively querying
• off_time duration, in milliseconds, for the reader to be quiet while querying

---

Proof of working parts
As follows the parts I got working using a single read function.

#!/usr/bin/env ruby
# read.rb
require 'pycall/import'
include PyCall::Import
pyimport :mercury

reader = mercury.Reader.new("tmr:///dev/ttyUSB0")

python_data = reader.read() 
puts "python_data: #{python_data}"
puts "python class: #{python_data.class}"
puts ""
ruby_data = python_data.to_ary
puts "ruby_data: #{ruby_data}"
puts "ruby class: #{ruby_data.class}"

Output read.rb:

python_data: [EPC(b'34155CACB400000000000125'), EPC(b'001853000000000000000012')]
python class: <class 'list'>

ruby_data: [EPC(b'34155CACB400000000000125'), EPC(b'001853000000000000000012')]
ruby class: Array

[kou]

Does this work?

#!/usr/bin/env ruby
# start_reading.rb
require 'pycall/import'
include PyCall::Import
pyimport :mercury

found = lambda do |tag|
  puts tag.epc
end

reader = mercury.Reader.new("tmr:///dev/ttyUSB0")

reader.start_reading(found, on_time=250, off_time=0) # What should I do here?
sleep(0.5)
reader.stop_reading()

[Timatgithub1]

Thank you for your fast response.

No the lambda does not work.

• The program jams on the start_reading function.
• I then have to quite using ctrl+z. After which the resource stays unavailable (which is the same situation as trying to use the reader with program X while program Y is using it).
• I presume you offered the lambda because the docs use it as an example, but that is not the issue. In Python both a function and a lambda work, in Ruby neither does (with the current implementation). The following also jams: reader.start_reading(->(tag){ puts tag.epc })

I think the solution should be sought in the following.

reader.start_reading() should receive something Python understands, right now it receives Ruby code.

Present (wrong):
reader.start_reading(ruby_code_that_is_send_to_python)

Proposed abstract solution:
reader.start_reading(ruby_code_that_is_bridged_with_PyCall_and_send_to_python)

Hence, the found function and the (optional) variables need to be translated before put into the found function.

[kou]

Does this work?

#!/usr/bin/env ruby
# start_reading.rb
require 'pycall/import'
include PyCall::Import
pyimport :mercury

found = lambda do |tag|
  puts tag.epc
end

reader = mercury.Reader.new("tmr:///dev/ttyUSB0")

reader.start_reading(PyCall.wrap_ruby_object(found), on_time=250, off_time=0) # What should I do here?
sleep(0.5)
reader.stop_reading()

[Timatgithub1]

Nope does not work.

Same behavior, the program jams, and I have to exit with ctrl+z.

Fyi, I omitted the on_time and off_time variables as those are optional.

[kou]

Could you provide another reproducible script that can be executed without an RFID device?

[Timatgithub1]

Als follow, software based pseudo-mercury

• It uses a sub-thread inside the python class to create the callback, I don't know if that creates issues for PyCall, but this is the best I could do.
• I also added read.py, read.rb, start_read.py, start_read.rb (to be put into the same folder as mercury.py) all work except the last one.

#!/usr/bin/env python
# mercury.py
import threading, time

class TagReadData:
    def __init__(self, epc = b''):
        self.epc = epc
    def __str__(self):
        return f'{self.epc}'
    def __repr__(self):
        return f'EPC({self.epc})'

class Reader:
    def __init__(self, address):
        self.address = address
        self._reading = False

    def read(self):
        tag_1 = TagReadData(epc = b'001853000000000000000012')
        tag_2 = TagReadData(epc = b'34155CACB400000000000125')
        tags = [tag_1, tag_2]
        return tags

    # Note: on_time & off_time variables are only defined, not functionally implemented.
    def start_reading(self, callback, on_time=250, off_time=0):
        self._reading = True
        self._reader_thread = threading.Thread(target=self._reader_func,
                                               args = (self._reading, callback),
                                               daemon=True)
        self._reader_thread.start()

    def stop_reading(self):
        self._reading = False

    def _reader_func(self, _reading, _callback):
        while _reading == True:
            tag_read_data = TagReadData(epc = b'001853000000000000000012')
            _callback(tag_read_data)
            time.sleep(0.2)

#!/usr/bin/env python
# read.py - works
import mercury

reader = mercury.Reader("tmr:///dev/ttyUSB0")

data = reader.read()
print(f"data: {data}")
print(f"data[0]: {data[0]}")
print(f"type: {type(data)}")
print(f"type[0]: {type(data[0])}")

#!/usr/bin/env ruby
# read.rb - works
require 'pycall/import'
include PyCall::Import
PyCall.sys.path.append('.')
PyCall.import_module("mercury")
pyimport :mercury

reader = mercury.Reader.new("tmr:///dev/ttyUSB0")

python_data = reader.read()
puts "python_data: #{python_data}"
puts "python class: #{python_data.class}"
puts ""
ruby_data = python_data.to_ary
puts "ruby_data: #{ruby_data}"
puts "ruby class: #{ruby_data.class}"

#!/usr/bin/env python
# start_reading.py - works
import time
import mercury

def found(tag):
    print(f"tag: {tag}")
    print(f"tag.epc: {tag.epc}")

reader = mercury.Reader("tmr:///dev/ttyUSB0")

reader.start_reading(found, on_time=250, off_time=0)
time.sleep(0.5)
reader.stop_reading()

#!/usr/bin/env ruby
# start_reading.rb - does not work
require 'os'
require 'pycall/import'
include PyCall::Import
PyCall.sys.path.append('.')
PyCall.import_module("mercury")
pyimport :mercury

def found(tag)
  puts tag.epc
end

reader = mercury.Reader.new("tmr:///dev/ttyUSB0")

reader.start_reading(found, on_time=250, off_time=0)
sleep(0.5)
reader.stop_reading()

[kou]

We can't use Ruby code in Python's thread. If we use it, this error message [BUG] rb_thread_call_with_gvl() is called by non-ruby thread was reported.

[Timatgithub1]

Understood.
Side note: I got the same message but wasn't sure if that was a hard restriction. I presumed the thread-safety limitation described in the PyCall docs had to do with using Python code among Ruby threads.

[Timatgithub1]

Regarding the callback. In essence the question is, how can I offer the Python program a Ruby function?
That is the essence of a callback:
https://www.askpython.com/python/built-in-methods/callback-functions-in-python

If there is a typical PyCall way to do this, then I suppose that would be the answer to this question.

The same applies to the variables, of course.

As follows I have made a simple alteration to tests just that.

#!/usr/bin/env python
# pseudo_mercury.py

class TagReadData:
    def __init__(self, epc = b''):
        self.epc = epc
    def __str__(self):
        return f'{self.epc}'
    def __repr__(self):
        return f'EPC({self.epc})'

class Reader:
    def __init__(self, address):
        self.address = address
        self._reading = False

    def callback_read(self, callback, on_time=250, off_time=0):
        tag_read_data = TagReadData(epc = b'001853000000000000000012')
        callback(tag_read_data)

#!/usr/bin/env python
# callback_read.py
import platform
import pseudo_mercury as mercury

def found(tag):
    print(f"tag: {tag}")
    print(f"tag.epc: {tag.epc}")

reader = mercury.Reader("tmr:///dev/ttyUSB0")

reader.callback_read(found, on_time=250, off_time=0)

#!/usr/bin/env ruby
# callback_read.rb
require 'pycall/import'
include PyCall::Import
PyCall.sys.path.append('.')
PyCall.import_module("pseudo_mercury")
pyimport 'pseudo_mercury', as: :mercury

def found(tag)
  puts tag.epc
end

reader = mercury.Reader.new("tmr:///dev/ttyUSB0")
reader.callback_read(found)

[kou]

In the case, lambda works:

#!/usr/bin/env ruby
# callback_read.rb
require 'pycall/import'
include PyCall::Import
PyCall.sys.path.append('.')
PyCall.import_module("pseudo_mercury")
pyimport 'pseudo_mercury', as: :mercury

found = lambda do |tag|
  puts tag.epc
end

reader = mercury.Reader.new("tmr:///dev/ttyUSB0")
reader.callback_read(found)