GreyCat Python

GreyCat offers an SDK (software development kit) to allow interaction with python code. The motivation is to allow users to make use of the efficient database of GreyCat, while at the same time take advantage of flexibility of Python. Here we will go through a basic tutorial that will teach you how to talk to a GreyCat server from a Python script and how to receive or send data. You can find a git repository with the same tutorial here. A more advanced tutorial, demonstrating the workflow of training Transformer models in Python while the data and result storage is hosted by GreyCat, can be found here.

Requirements

• Python >= 3.9
• pip
• greycat package

In some operating systems python executable is exposed as python3 and others python. Please adapt the examples below according to your system. We recommend using a virtual environment for the python installation. Our SDK is tested both with pyenv an miniconda.

You can access Python SDK versions at https://get.greycat.io/files/sdk/python/. Please make sure to download the respective version for GreyCat version installed on your system. For example:

  greycat --v
  # 7.0.633-dev i.e greycat version 7.0

Latest version of the SDK is available there: https://get.greycat.io/testing.html

Install the respcetive SDK version using pip:

pip install https://get.greycat.io/files/sdk/python/testing/7.0/greycat-7.0.170+testing-py3-none-any.whl

Hello World

Let’s create a very simple client-server application.

Server side (GreyCat)

First we will create a simple project.gcl file that will help us to run a simple GreyCat server hosting a dataset as a nodeList of 10 integer. We will also expose some functions that we will later call from Python.

// Imports

// Model
var data: nodeList<int>;

// Main entrypoint
fn main() {
  if (data.size() == 0) {
    init();
  }
}

// Model initialization
fn init() {
  for (var i = 0; i < 10; i++)  {
    data.add(i);
  }
}

// Endpoints

@expose
fn helloWorld() {
  println("Hello, World!");
}

@expose
fn getData(): Array<int> {
  var res = Array<int>::new(data!!.size());
  for (index, value in data?) {
    res[index] = value;
  }
  return res;
}

@expose
fn greet(firstName: String, lastName: String): String {
  var greeting = "Hello, ${firstName} ${lastName}!";
  println(greeting);
  return greeting;
}

To allow Python to access the exposed endpoint (tagged with @exposed), we need to generate the binding like so:

  greycat codegen python

Client Side (Python)

We will create an src folder to start developing some simple client applications in python to make use of the GreyCat server defined above.

  mkdir src
  cd src
  touch hello_world.py
  touch greet.py
  touch get_data.py

# src/hello_world.py
from project_types import *

greycat: GreyCat = GreyCat("http://localhost:8080") # instatiate client to GreyCat server
project.helloWorld() # call exposed helloWorld() function on server

# src/greet.py
from project_types import *

greycat: GreyCat = GreyCat("http://localhost:8080") # instatiate client to GreyCat server
greeting: str = project.greet("John", "Doe") # call exposed greet() function
print(greeting)

# src/get_data.py
from project_types import *

greycat: GreyCat = GreyCat("http://localhost:8080") # instatiate client to GreyCat server

data = project.getData() # call exposed getData() function

print(f"# Data: {data}")
print(f"# Type: {type(data)}[{type(data[0])}]")

Running the Client-Server application

Now that the code is ready and generated we can run the GreyCat server like:

greycat serve --user=1

While the server is running we can call our client scirpts:

python -m src.hello_world

Server: Hello, World!

python -m src.greet

Server: Hello, John Doe!

Client: Hello, John Doe!

python -m src.get_data

Client:

# Data: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Type: <class 'greycat.std.std.core.Array'>[<class 'int'>]