Script Development / Writing and Calling Functions

This document is the most basic guide for developing scripts on DataFlux Func. After reading it, you will be able to perform the most basic development and usage tasks on DataFlux Func.

1. Pre-reading Tips

When using DataFlux Func,

Do not allow multiple users to log in with the same account, and do not allow multiple users to edit the same code simultaneously.

To avoid issues of code overwriting and loss.

2. Writing the First Function and Calling It

Writing code in DataFlux Func is not much different from writing Python code normally. For functions that need to be exported as APIs, simply add the built-in @DFF.API(...) decorator.

The return value of the function is the return value of the interface. When the return value is dict or list, the system will automatically return it as JSON.

A typical function looks like this:

@DFF.API('Hello, world')
def hello_world(message=None):
    ret = {
        'message': message
    }
    return ret

The DataFlux Func platform provides multiple ways to call functions decorated with DFF.API(...):

Execution Function	Characteristics	Use Cases
Sync API	Generates a synchronous HTTP API. Returns the result directly after calling.	Scenarios where processing time is short and the client needs immediate results.
Async API	Generates an asynchronous HTTP API. Responds immediately but does not return the processing result.	Scenarios where processing time is long and the interface call is only a start signal.
Cron Job	Automatically executes based on Crontab syntax.	Periodic data synchronization / caching, scheduled tasks, etc.

For details, see Script Development / Basic Concepts

Here, creating a Func API for this function allows it to be called via HTTP on the internet.

Assuming the Func API ID created for this function is func-api-xxxxx, the simplest way to call this function is as follows:

GET /api/v1/al/func-api-xxxxx/simplified?message=Hello

The response is as follows (some content omitted):

HTTP/1.1 200 OK
Content-Type: application/json

{"message":"Hello"}

3. Writing a Function That Supports File Uploads

DataFlux Func also supports file uploads via Func APIs.

When handling uploaded files, you can add a files parameter to the function to receive the file information. After uploading, DataFlux Func automatically stores the file in a temporary upload directory for subsequent processing by the script.

# Receives an Excel file and returns the contents of Sheet1
from openpyxl import load_workbook

@DFF.API('Read Excel')
def read_excel(files=None):
    excel_data = []
    if files:
        workbook = load_workbook(filename=files[0]['filePath'])
        for row in workbook['Sheet1'].iter_rows(min_row=1, values_only=True):
            excel_data.append(row)

    return excel_data

The files parameter is automatically filled by the DataFlux Func system and contains the following:

[
    {
        "filePath"    : "<Temporary file storage path>",
        "originalname": "<Original file name>",
        "encoding"    : "<Encoding>",
        "mimetype"    : "<MIME type>",
        "size"        : "<File size>"
    },
    ...
]

For an example command to upload files, see Script Development / Basic Concepts / Func API / POST Simplified Parameter Passing

4. Receiving Non-JSON, Non-Form Data

Added in version 1.6.9

In some cases, requests may be initiated by third-party systems or applications in their specific formats, and the request body may not be in JSON or Form format. In such scenarios, you can use **data as a parameter and call it in the POST simplified form.

When the system receives text or unparsable data, it automatically packages it as { "text": "<text>" } or { "base64": "<Base64 formatted binary data>"} and passes it to the function.

Example code:

import json
import binascii

@DFF.API('Function that accepts any format Body')
def tiger_balm(**data):
    if 'text' in data:
        # When the request body is text (e.g., Content-Type: text/plain)
        # The `data` parameter contains a single `text` field with the content
        return f"Text：{data['text']}"

    elif 'base64' in data:
        # When the request body is in an unparsable format (Content-Type: application/xxx)
        # The `data` parameter contains a single `base64` field with the Base64 string of the request body
        # The Base64 string can be converted to Python binary data using `binascii.a2b_base64(...)`
        b = binascii.a2b_base64(data['base64'])
        return f"Base64：{data['base64']} -> {b}"

When the Request Body is Text

Request as follows:

curl -X POST -H "Content-Type: text/plain" -d 'hello, world!' http://localhost:8089/api/v1/al/auln-unknow-body/simplified

Output as follows:

Text：hello, world!

When the Request Body is in an Unknown Format

Request as follows:

curl -X POST -H "Content-Type: unknow/type" -d 'hello, world!' http://localhost:8089/api/v1/al/auln-unknow-body/simplified

Output as follows:

Base64：aGVsbG8sIHdvcmxkIQ== -> b'hello, world!'