Configuration options

Python

The Pipeline.from_denkflow(file_name, **kwargs) method is the primary way to load pre-built .denkflow pipelines. Here are several configuration options for different scenarios:

from denkflow import Pipeline, HubLicenseSource, OneTimeLicenseSource

# Common parameters (replace with your actual values)
denkflow_file_path = "path/to/your_model.denkflow"
your_pat = "YOUR-PERSONAL-ACCESS-TOKEN"
your_license_id = "YOUR-LICENSE-ID" # Optional
custom_hub_endpoint = "https://your.custom.hub.endpoint" # Optional

# 1. Basic: Using PAT only (Recommended for simplicity)
# DENKflow uses the PAT to handle licensing, typically creating a HubLicenseSource internally.
pipeline_pat_only = Pipeline.from_denkflow(denkflow_file_path, pat=your_pat)
print("Pipeline loaded using PAT only.")

# 2. PAT with a specific License ID
# Useful if your PAT has access to multiple licenses and you need to select one.
pipeline_pat_license_id = Pipeline.from_denkflow(
    denkflow_file_path,
    pat=your_pat,
    license_id=your_license_id
)
print(f"Pipeline loaded using PAT and License ID: {your_license_id}")

# 3. PAT with a custom Hub endpoint
# For testing instances of the DENKweit Vision AI Hub.
pipeline_pat_custom_endpoint = Pipeline.from_denkflow(
    denkflow_file_path,
    pat=your_pat,
    endpoint=custom_hub_endpoint
)
print(f"Pipeline loaded using PAT and custom endpoint: {custom_hub_endpoint}")

# 4. Using a pre-configured HubLicenseSource
# Provides more control over license source creation.
hub_license_source = HubLicenseSource.from_pat(pat=your_pat, license_id=your_license_id)
pipeline_hub_ls = Pipeline.from_denkflow(
    denkflow_file_path,
    license_source=hub_license_source
)
print("Pipeline loaded using a pre-configured HubLicenseSource.")

# 5. Using a pre-configured OneTimeLicenseSource
initial_hub_src = HubLicenseSource.from_pat(pat=your_pat, license_id=your_license_id)
one_time_license_source = initial_hub_src.to_one_time_license_source()
pipeline_one_time_ls = Pipeline.from_denkflow(
    denkflow_file_path,
    license_source=one_time_license_source
)
print("Pipeline loaded using a pre-configured OneTimeLicenseSource.")

# 6. PAT with `one_time_registration=True` (Enables offline use after first run)
pipeline_one_time_reg = Pipeline.from_denkflow(
    denkflow_file_path,
    pat=your_pat,
    one_time_registration=True
)
print("Pipeline loaded using PAT with one_time_registration=True.")

Parameter reference

The Pipeline.from_denkflow method accepts the following key parameters:

• file_name: str (Required): The path to your .denkflow model file.
• pat: Optional[str] = None: Your Personal Access Token from the Vision AI Hub.
• license_source: Optional[HubLicenseSource | OneTimeLicenseSource] = None: A pre-configured license source object.
• license_id: Optional[str] = None: When pat is used for licensing, this optionally specifies a license_id.
• endpoint: Optional[str] = None: Custom URL for the Vision AI Hub endpoint.
• one_time_registration: bool = False: When True, enables offline use after the first successful run.

C / C++

There are different options when creating a HubLicenseSource:

// Create a HubLicensSource using only a PAT
DenkflowHubLicenseSource* hub_license_source = NULL;
const char*               pat                = "personal_access_token";
denkflow_hub_license_source_from_pat(&hub_license_source, pat, NULL, NULL);

// Create a HubLicensSource using a PAT and a custom license ID
DenkflowHubLicenseSource* hub_license_source = NULL;
const char*               pat                = "personal_access_token";
const char*               license_id         = "license_id";
denkflow_hub_license_source_from_pat(&hub_license_source, pat, license_id, NULL);

// Create a HubLicensSource using a PAT and a custom endpoint
DenkflowHubLicenseSource* hub_license_source = NULL;
const char*               pat                = "personal_access_token";
const char*               endpoint           = "alternative_endpoint";
denkflow_hub_license_source_from_pat(&hub_license_source, pat, NULL, endpoint);

// Create a DenkflowOneTimeLicenseSource from a HubLicensSource
DenkflowHubLicenseSource*     hub_license_source      = NULL;
DenkflowOneTimeLicenseSource* one_time_license_source = NULL;
denkflow_hub_license_source_to_one_time_license_source(&one_time_license_source, &hub_license_source);

After creating the license source, the pipeline can be created via:

DenkflowPipeline* pipeline   = NULL;
const char*       model_file = "path/to/model/file.denkflow";
denkflow_pipeline_from_denkflow(&pipeline, model_file, (void*)license_source);

Important Notes:

• For any licensing method involving offline persistence, ensure the SDK data directory is on persistent storage. In Docker you can mount a host volume at the default path (for Linux as root, /root/.config/denkflow, i.e. $HOME/.config/denkflow) without setting DENKFLOW_DATA_DIRECTORY; otherwise set DENKFLOW_DATA_DIRECTORY and mount a volume at that path.
• If both pat and license_source are provided, the license_source takes precedence.

Thread configuration

You can configure the number of threads used by ONNX Runtime for model inference. This allows you to optimize performance based on your hardware and workload.

Python

from denkflow import Pipeline

# Create a pipeline
pipeline = Pipeline.from_denkflow("path/to/model.denkflow", pat="your_pat")

# Configure thread counts (must be done before initialize())
pipeline.set_intra_threads(8)  # Threads for parallelism within operators
pipeline.set_inter_threads(2)  # Threads for parallelism between operators

# Initialize the pipeline
pipeline.initialize()

Thread configuration methods

• set_intra_threads(intra_threads: int): Sets the number of intra-op threads. Controls parallelism within individual nodes/operators. Default is 4.
• set_inter_threads(inter_threads: int): Sets the number of inter-op threads. Controls parallelism between independent nodes/operators. Default is 4.

Note: These methods must be called before pipeline.initialize(). Calling them after initialization will raise a RuntimeError.

Performance tuning tips

• Intra-op threads: Higher values (8-16) can improve performance for compute-intensive operations on multi-core CPUs.
• Inter-op threads: Lower values (2-4) are typically sufficient, as most pipelines have sequential dependencies.
• Start with the defaults (4/4) and adjust based on profiling results.

C / C++

// Create a pipeline
DenkflowPipeline* pipeline = NULL;
denkflow_pipeline_from_denkflow(&pipeline, "path/to/model.denkflow", (void*)license_source);

// Configure thread counts (must be done before denkflow_initialize_pipeline())
denkflow_pipeline_with_intra_threads(pipeline, 8);  // Threads for parallelism within operators
denkflow_pipeline_with_inter_threads(pipeline, 2);  // Threads for parallelism between operators

// Initialize the pipeline
DenkflowInitializedPipeline* initialized_pipeline = NULL;
denkflow_initialize_pipeline(&initialized_pipeline, &pipeline);

Thread configuration functions

• denkflow_pipeline_with_intra_threads(pipeline, intra_threads): Sets the number of intra-op threads. Controls parallelism within individual nodes/operators. Default is 4.
• denkflow_pipeline_with_inter_threads(pipeline, inter_threads): Sets the number of inter-op threads. Controls parallelism between independent nodes/operators. Default is 4.

Note: These functions must be called before denkflow_initialize_pipeline(). The pipeline object remains valid after these calls.