API 处理机器人和 Python Class

Question

What is the best way to handle objects with robot framework? I am starting to write a python class to handle API interactions, which I can therefore use as keywords in robot framework (RF). My question is how does one pass data from one method to another? Do I have to pass the object back to every function to get the data?

In the example below, I call the class and it initializes, but can I reference an instance of the class if I wanted? Or am I supposed to write every method to handle the entire object I get back from another method? Hopefully this makes sense, I basically want to use python like I normally would but inside of RF.

More specifically, is it feasible to distinguish between several instances if I call them all at once?

Test python foo.py:

class foo:
   def intialize(self, api):
        self.api_item = api 
   def get_api():
         return self.api_item
   def do_something_with_api
        # doing something with an API, then return results
   def do_something_else_with_api
        # doing something with an API, then return results
   

Test Robot file:

*** Settings ***
Library             /path/foo.py

*** Variables ***
${api_url}   "https://apiurl.com/"


*** Tasks ***
Setup Initialize Settings
     ${session}=    MgsRestApiHandler.intialize     ${api_url}
    

Answer 1

In RF when a class is loaded as a Library there's always an instance object that's created for it. Thus if you have state variables within it, they'll be present for all class methods ("keywords") in your RF source. In other words, in your example all methods will have access to self.api_item (after initialize() is called); by the way, why don't you add a normal constructor __init()__ and define the var there, even with None value, so it's cleaner?

---

is it feasible to distinguish between several instances

You can instantiate several instances of the same class ("Library") by importing them multiple times and using the WITH NAME Robot Framework syntax:

*** Settings ***
Library             /path/foo.py    WITH NAME    o1
Library             /path/foo.py    WITH NAME    o2

The "drawback" is you now have to prefix the method call with the instance name - otherwise the framework doesn't know for which object you want to call it:

*** Tasks ***
Setup Initialize Settings
     ${session1}=   o1.intialize     ${api_url}
     ${session2}=   o2.intialize     ${api_url2} 

---

And if I understand one of your questions correctly (or if not - take this as a general trivia:) - in RF whatever a method/keyword returns - from primitives to complex objects (egnclass instances) is assigned to that variable that in front of the call.
So if you have a method/keyword down the line that expects a complex object, you can pass that returned value - the framework will not mangle it in any way, it'll be passing around a normal pyhton object.