Python API

8. Python API#

8.1. Introduction#

SpacePy is a scripting interface integrated into SpaceStudio and can be used to interact with SpaceStudio’s functionalities without the need to use the graphical user interface.

It allows scripting using Python 3.12.

8.1.1. Command-line interface#

Currently, SpaceStudio does not provide a REPL (Read-Eval-Print Loop) command-line interface, but only the ability to execute Python scripts in batch mode.

See Running a script in batch mode for more details.

8.1.2. Running a script in batch mode#

SpaceStudio can execute a Python script using the same executable as for starting the graphical interface :

SpaceStudio --batch <python_script> <arguments>

Note: The SpaceStudio executable used above is located in SpaceStudio’s installation directory.

From within the Python script itself, arguments are passed through the standard sys.argv list (the sys module must be imported first using import sys). The zero-th argument (i.e. sys.argv[0]) is the name of the Python script being executed, and the subsequent arguments are those passed after the script name in the command line.

In a script, the API entrypoint is the spacepy.Engine class, requiring the import of the spacepy module (using import spacepy). The spacepy.Engine class follows the singleton pattern, meaning it is used as follows :

import spacepy
engine = spacepy.Engine.instance()

You can then manipulate your SpaceStudio objects (projects, solutions, etc…) through the engine variable.

A full reference of the API is available in the API Documentation section.

8.2. Workflow Parameters#

spacepy.Workflow objects require attributes which depend on their type (e.g. simulation, architecture implementation, etc…).

The following sections describe these attributes.

8.2.1. Architecture Implementation#

Table 8.1 Architecture Implementation Workflow Parameters#
Name	Description	Required ?
`impl.general.directory`	Output directory	Yes
`impl.general.eda`	`spacepy.Implementation` object, represents the FPGA vendor-specific implementation tool	Yes
`impl.general.board`	`spacepy.Board` object, represents the target FPGA board \| Yes
`impl.general.thread`	Number of threads	Yes
`impl.hls.name`	`spacepy.HLSSynthesizer` object, represents the HLS tool for C/C++ synthesis	No
`impl.hls.modules`	A collection of `spacepy.ModuleInstance` to synthesize	No
`impl.tmr.mode`	TMR mode: {`"none"`, `"localized"`, `"distributed"`, `"global"`, `"intelligent_selective"`}	No
`impl.tmr.is_safe_fsm`	Is safe FSM enable?	No
`impl.tmr.safe_fsm`	Safe FSM mode: {`"none"`, `"basic"`, `"seu_detect"`, `"seu_tolerant"`}	No

8.2.2. FPGA-in-the-loop#

Table 8.2 FPGA-in-the-loop Workflow Parameters#
Name	Description	Required ?
`impl.general.eda`	`spacepy.Implementation` object, represents the FPGA vendor-specific implementation tool	Yes
`impl.general.board`	`spacepy.Board` object, represents the target FPGA board	Yes
`impl.general.thread`	Number of threads	Yes
`impl.hls.name`	`spacepy.HLSSynthesizer` object, represents the HLS tool for C/C++ synthesis	No
`impl.hls.modules`	A collection of `spacepy.ModuleInstance` to synthesize	No
`impl.tmr.mode`	TMR mode: {`"none"`, `"localized"`, `"distributed"`, `"global"`, `"intelligent_selective"`}	No
`impl.tmr.is_safe_fsm`	Is safe FSM enable?	No
`impl.tmr.safe_fsm`	Safe FSM mode: {`"none"`, `"basic"`, `"seu_detect"`, `"seu_tolerant"`}	No
`fil.setup.host_ip`	Host IP	Yes
`fil.setup.ssh_private_key`	Path for SSH private key	Yes
`fil.execution.wallclock_timeout`	Wallclock timeout for remote execution	No

8.2.3. FPGA Estimation#

Table 8.3 FPGA Estimation Workflow Parameters#
Name	Description	Required ?
`impl.general.eda`	`spacepy.Implementation` object, represents the FPGA vendor-specific implementation tool	Yes
`impl.general.board`	`spacepy.Board` object, represents the target FPGA board	Yes
`impl.general.thread`	Number of threads	Yes
`impl.hls.name`	`spacepy.HLSSynthesizer` object, represents the HLS tool for C/C++ synthesis	No
`impl.hls.modules`	A collection of `spacepy.ModuleInstance` to synthesize	No
`impl.tmr.mode`	TMR mode: {`"none"`, `"localized"`, `"distributed"`, `"global"`, `"intelligent_selective"`}	No
`impl.tmr.is_safe_fsm`	Is safe FSM enable?	No
`impl.tmr.safe_fsm`	Safe FSM mode: {`"none"`, `"basic"`, `"seu_detect"`, `"seu_tolerant"`}	No

8.3. Examples#

This section presents some examples that showcase the Python API.

8.3.1. Display the content of a project#

In this example, the script displays all the instantiable components of SpaceStudio and displays the content of a project.

Listing 8.1 display.py#

import os
import sys
import spacepy as spy
engine = spy.Engine.instance()

def main(project_path: str) -> None:
    for vlnv in engine.get_components():
        print('component with vlnv = [{} {} {} {}]'.format(vlnv.get_vendor(), vlnv.get_library(), vlnv.get_name(), vlnv.get_version()))
    
    project = engine.open(project_path)
    project.clean()
    
    print('project name = {}'.format(project.get_name()))
    for solution in project.get_solutions():
        print('\tsolution name = {}'.format(solution.get_name()))
        
        for module in solution.get_modules():
            print('\t\tmodule name = {}'.format(module.get_name()))
        for device in solution.get_devices():
            print('\t\tdevice name = {}'.format(device.get_name()))
            
        for architecture in solution.get_architectures():
            hls = None
            hardware_modules = []
            
            print('\t\tarchitecture name = {}'.format(architecture.get_name()))
            for instance in architecture.get_module_instances():
                print('\t\t\tmodule instance name = {}'.format(instance.get_name()))
                print('\t\t\tmodule instance classname = {}'.format(instance.get_module().get_name()))
                print('\t\t\tmodule instance is mapped in {}'.format('hardware' if instance.is_hardware() else 'software'))
                show_parameters(instance)
                if (instance.is_hardware()):
                    hardware_modules.append(instance)
            
            recursively_show_parameters(architecture.get_component_instances())
    project.close()

def show_parameters(instance):
    for param in instance.get_parameters():
        if (param.is_read_only()):
            print('\t\t\t{}={}\t(read only)'.format(param.get_name(), param.get_value()))
        else:
            print('\t\t\t{}={}'.format(param.get_name(), param.get_value()))

def recursively_show_parameters(instances):
    for instance in instances:
        print('\t\t\tcomponent instance name = {}'.format(instance.get_name()))
        print('\t\t\tcomponent instance vlnv = [{} {} {} {}]'.format(instance.get_vlnv().get_vendor(), instance.get_vlnv().get_library(), instance.get_vlnv().get_name(), instance.get_vlnv().get_version()))
        show_parameters(instance)
        if (instance.is_hierarchical()):
            recursively_show_parameters(instance.get_component_instances())
            
if __name__ == "__main__":
    main(sys.argv[1])

Save the code snippet above as display.py. The location of this script is denoted below as %script_dir%. Open a terminal, navigate to SpaceStudio’s installation directory (denoted as %install_dir%), and run the following command :

SpaceStudio --batch %script_dir%/display.py %install_dir%/projects/producer-consumer/producer-consumer.spacestudio

The output should look similar to the following :

Listing 8.2 Truncated output of the display.py script#

Space Codesign Systems Inc.
Copyright 2005-2026. All rights reserved
https://www.spacecodesign.com
SpaceStudio v5.0

Running script: display_components.py
Starting interpreter (may take some time)...
component with vlnv = [spacecodesign.com interconnect axi4_interconnect 1.0]
component with vlnv = [spacecodesign.com memory bram 1.0]
component with vlnv = [spacecodesign.com caip fft 1.0]
component with vlnv = [spacecodesign.com soc microblaze_soc 1.0]
component with vlnv = [spacecodesign.com soc ngultra 1.0]
component with vlnv = [spacecodesign.com ip register_file 1.0]
component with vlnv = [spacecodesign.com soc versal 1.0]
component with vlnv = [spacecodesign.com soc zynq 1.0]
component with vlnv = [spacecodesign.com soc zynq_ultrascale 1.0]
project name = producer-consumer
	solution name = simple
		module name = consumer
		module name = producer
		architecture name = all_hardware
			module instance name = consumer0
			module instance classname = consumer
			module instance is mapped in hardware
			documentation=
			domain_id=0
			id=4
			id_key=CONSUMER0_ID
			index=0
			instance_name=
			is_user_instantiable=true	(read only) 

8.3.2. Simulate all architectures of a project#

In this example, the script cleans the project (i.e. removes all generated files), and runs the simulation for all architectures.

Listing 8.3 simulate.py#

import os
import sys
import spacepy as spy

engine = spy.Engine.instance()

def main(project_path):
    project = engine.open(project_path)
    project.clean()
    print("project name = {}".format(project.get_name()))
    
    for solution in project.get_solutions():
        print("solution name = {}".format(solution.get_name()))
        for architecture in solution.get_architectures():
            print('\tarchitecture name = {}'.format(architecture.get_name()))
            workflow = architecture.get_workflow("simulation")
            metrics = workflow.execute()
            success = find_object_by_name(metrics, "Success")
            print("[{}] {}".format(workflow.get_workflow_type(), "Success" if success.evaluate() else "Error"))

    project.close()
    
def find_object_by_name(collection, target_name):
    for obj in collection:
        if obj.get_name() == target_name:
            return obj
    return None

if __name__ == "__main__":
    main(sys.argv[1])

Save the code snippet above as simulate.py. The location of this script is denoted below as %script_dir%. Open a terminal, navigate to SpaceStudio’s installation directory (denoted as %install_dir%), and run the following command :

SpaceStudio --batch %script_dir%/simulate.py %install_dir%/projects/producer-consumer/producer-consumer.spacestudio

The output should look similar to the following :

Listing 8.4 Truncated output of the simulate.py script#

Space Codesign Systems Inc.
Copyright 2005-2026. All rights reserved
https://www.spacecodesign.com
SpaceStudio v5.0

Running script: simulate_all.py
Starting interpreter (may take some time)...
solution name = simple
	architecture name = all_hardware
[Launching process] C:/SpaceCodesign/SpaceStudio-5.0/util/ninja/ninja.exe -f all.ninja
[1/7] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/solutions/simple/architectures/all_hardware/build/sim/hw/components.cpp
[2/7] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/solutions/simple/architectures/all_hardware/build/sim/hw/architecture.cpp
[3/7] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/solutions/simple/architectures/all_hardware/build/sim/hw/bus_addresses.cpp
[4/7] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/solutions/simple/architectures/all_hardware/build/sim/module/consumer0/consumer0.cpp
[5/7] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/solutions/simple/architectures/all_hardware/build/sim/module/producer0/producer0.cpp
[6/7] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/solutions/simple/architectures/all_hardware/build/sim/hw/main.cpp
[7/7] Creating C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/solutions/simple/architectures/all_hardware/build/sim/bin/all_hardware.exe
[Process completed] C:/SpaceCodesign/SpaceStudio-5.0/ninja.exe -f all.ninja

[Launching process] C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/solutions/simple/architectures/all_hardware/build/sim/bin/all_hardware.exe
 -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 Space Codesign Systems Inc.
 Copyright 2005-2026. All rights reserved
 https://www.spacecodesign.com
 SpaceStudio 5.0
 -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Starting simulation.
consumer0 running
producer0 running
consumer0 register value=240
consumer0 ddr value=240
consumer0 register value=241
consumer0 ddr value=241
consumer0 register value=242
consumer0 ddr value=242
consumer0 register value=243
consumer0 ddr value=243
consumer0 register value=244
consumer0 ddr value=244
consumer0 register value=245
consumer0 ddr value=245
consumer0 register value=246
consumer0 ddr value=246
consumer0 register value=247
consumer0 ddr value=247
consumer0 register value=248
consumer0 ddr value=248
consumer0 register value=249
consumer0 ddr value=249
consumer0 register value=250
consumer0 ddr value=250

8.3.3. Architecture Implementation export#

In this example, the script executes the architecture implementation workflow :

Enables preferences
Creates an architecture
Instantiates component instances
Maps modules to hardware and software
Runs architecture implementation using Vivado

Listing 8.5 complete_flow.py#

import os
import sys
import spacepy as spy

engine = spy.Engine.instance()

def main(project_path: str) -> None:
    project = engine.open(project_path)
    
    # Get instantiable components
    zynq_vlnv = engine.get_component("zynq")
    interconnect_vlnv = engine.get_component("axi4_interconnect")
    bram_vlnv = engine.get_component("bram")
    register_file_vlnv = engine.get_component("register_file")

    # Get exisiting solution and create the example architecture
    solution = project.get_solution("simple")
    solution.remove_architecture("example_architecture")
    architecture = solution.create_architecture("example_architecture")

    # Instantiate modules
    consumer0 = architecture.create_module_instance("consumer")
    producer0 = architecture.create_module_instance("producer")
    
    # Instantiate components
    zynq0 = architecture.create_component_instance(zynq_vlnv)
    interconn0 = architecture.create_component_instance(interconnect_vlnv)
    bram0 = architecture.create_component_instance(bram_vlnv)
    bram0.set_name("ddr_mem")
    architecture.create_component_instance(register_file_vlnv)

    # Connect bram with interconnect
    interconn0.get_bus_interface("axi_master_0").connect(bram0.get_bus_interface("axi_slave"))

    # Map module instances in SW or HW
    producer0.move_to_hardware()
    consumer0.move_to_software(zynq0)

    # Enable EDA
    engine.get_eda_preference("eda.vivado_2025-2.is_enabled").set_value("true")
    engine.get_eda_preference("eda.vitis_hls_2025-2.is_enabled").set_value("true")
    
    # Get architecture implementation workflow
    workflow = architecture.get_workflow("implementation")
    
    # Configure workflow
    implementation = architecture.get_implementation("vivado_2025-2")
    hls = implementation.get_synthesizer("vitis_hls_2025-2")
    board = implementation.get_board("zed")
    project_dir = os.path.join(os.path.dirname(project_path), "impl")
    workflow.get_parameter("impl.general.directory").set_value(project_dir)
    workflow.get_parameter("impl.general.eda").set_value(implementation)
    workflow.get_parameter("impl.general.board").set_value(board)
    workflow.get_parameter("impl.general.thread").set_value(4)
    workflow.get_parameter("impl.hls.name").set_value(hls)
    workflow.get_parameter("impl.hls.modules").set_value(producer0)
    
    # Execute workflow
    metrics = workflow.execute()
    success = find_object_by_name(metrics, "Success")
    print("[{}] {}".format(workflow.get_workflow_type(), "Success" if success.evaluate() else "Error"))

    # Exit
    project.save()
    project.close()
    
def find_object_by_name(collection, target_name):
    for obj in collection:
        if obj.get_name() == target_name:
            return obj
    return None

if __name__ == "__main__":
    main(sys.argv[1])

Save the code snippet above as complete_flow.py. The location of this script is denoted below as %script_dir%. Open a terminal, navigate to SpaceStudio’s installation directory (denoted as %install_dir%), and run the following command :

SpaceStudio --batch %script_dir%/complete_flow.py %install_dir%/projects/producer-consumer/producer-consumer.spacestudio

The output should look similar to the following :

Listing 8.6 Truncated output of the complete_flow.py script#

Space Codesign Systems Inc.
Copyright 2005-2026. All rights reserved
https://www.spacecodesign.com
SpaceStudio v5.0

Running script: impl_export.py
Starting interpreter (may take some time)...
Generation process [Starting]
Generation process [Completed successfully]

Architecture's transformation [Starting]
Architecture's transformation [Completed successfully]

Software build [Starting]
[Launching process] C:/SpaceCodesign/SpaceStudio-5.0/util/ninja/ninja.exe -f all.ninja
[1/8] Compiling C:/SpaceCodesign/SpaceStudio-5.0/data/sw/OS/linux/internal_api.c
[2/8] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/impl/processors/zynq_apu0/interrupts.cpp
[3/8] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/impl/processors/zynq_apu0/communication.cpp
[4/8] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/impl/processors/zynq_apu0/main.cpp
[5/8] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/impl/processors/zynq_apu0/fifo_monitor_hooks.cpp
[6/8] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/impl/processors/zynq_apu0/module/consumer0/consumer0.cpp
[7/8] Compiling C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/impl/processors/zynq_apu0/application_os_requirement.cpp
[8/8] Creating C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/impl/processors/zynq_apu0/zynq_apu0.core0.arm_a9.elf
[Process completed] C:/SpaceCodesign/SpaceStudio-5.0/util/ninja/ninja.exe -f all.ninja

Software build [Completed successfully]

High-level synthesis [Starting]
Synthesizing 'producer0' with Xilinx - Vitis HLS 2025.2 (log: C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/impl/hls/producer0/producer0_synth.log)
Exporting 'producer0' (log: C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/impl/hls/producer0/producer0_export.log)
Synthesis of producer0 completed
High-level synthesis [Completed successfully]

EDA Project Generation [Starting]

****** Vivado v2025.2 (64-bit)
  **** SW Build 6299465 on Fri Nov 14 19:35:11 GMT 2025
  **** IP Build 6300035 on Fri Nov 14 10:48:45 MST 2025
  **** SharedData Build 6298862 on Thu Nov 13 04:50:51 MST 2025
  **** Start of session at: Mon Mar 23 15:52:36 2026
    ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.
    ** Copyright 2022-2025 Advanced Micro Devices, Inc. All Rights Reserved.

source create_project.tcl
# variable SCRIPT_DIR [file dirname [file normalize [info script]]]
# variable PROJECT_DIR ${SCRIPT_DIR}
# set PROJECT_NAME "example_architecture"
# set BLOCK_DESIGN_NAME "bd"
# set PART_NAME "xc7z020clg484-1"
# set BOARD_VENDOR "em.avnet.com"
# set BOARD_LIBRARY "board"
# set BOARD_NAME "zed"
# set BOARD_VERSION "1.4"
# set REPOSITORY_PATH "C:/SpaceCodesign/SpaceStudio-5.0/projects/producer-consumer/impl/application_repository"
# set NUM_THREADS "4"
# proc set_board_parts {} {
# 	# Vivado doesn't come with the XML for certain third-party boards
# 	# (e.g. zedboard), so we have to provide them to it.
# 	global BOARD_REPO_PATH
# 	set_param board.repoPaths "${BOARD_REPO_PATH}"
# }
# set_board_parts
# create_project ${PROJECT_NAME} -force -part "${PART_NAME}"
# set_property board_part ${BOARD_VENDOR}:${BOARD_NAME}:part0:${BOARD_VERSION} [current_project]
# set_property STEPS.SYNTH_DESIGN.ARGS.FLATTEN_HIERARCHY none [get_runs synth_1]
# create_bd_design bd
create_bd_design: Time (s): cpu = 00:00:02 ; elapsed = 00:00:06 . Memory (MB): peak = 623.594 ; gain = 27.184
# proc spacestudio_set_severities {} {
# 	# Detect and stop if a Vivado synthesis ever detects that we've badly
# 	# connected a reset (e.g. we've connected a reset associated with clockA
# 	# to the reset pin of an interface that is associated with clockB). This
# 	# would easily be a cause for timing errors.
# 	set_msg_config -id "BD 41-1344" -new_severity "ERROR"
# 	# Downgrade warning that we're assigning to a vector of size 0; there's
# 	# nothing wrong with that.
# 	set_msg_config -id "Synth 8-3919" -new_severity "INFO"
# 	# Similar; downgrade warning that an entity's port is a vector of size 0.
# 	set_msg_config -id "Synth 8-506" -new_severity "INFO"
# 	# Similar; downgrade warning that a signal is a vector of size 0.
# 	set_msg_config -id "Synth 8-6774" -new_severity "INFO"
# 	# Downgrade warning that an instantiation's port mapping is assigned to
# 	# "open".
# 	set_msg_config -id "Synth 8-6778" -new_severity "INFO"

8.4. API Documentation#

The entry point for the API is the spacepy.Engine class.

class spacepy.Architecture#

Bases: object

An Architecture represents a virtual platform. It is composed of instances (i.e. ComponentInstance, ModuleInstance, and DeviceInstance) which are mapped onto the system architecture.

clean() → None#

Cleans the architecture.

Usually, this involves the removal of generated files, such as generated source files and compiled binaries.

Return type:: None

compile(build_type: str | None = None) → spacepy.Metric#

Compiles the architecture.

Parameters:: build_type (str | None) – The (optional) type of build to perform, one of "release" or "monitoring". If unspecified or None, the default build will be used.
Returns:: A Metric object that contains the result of the compilation.
Return type:: spacepy.Metric

create_component_instance(vlnv: spacepy.VLNV) → spacepy.ComponentInstance#

Creates a new component instance in the architecture based on the provided VLNV.

Parameters:: vlnv (spacepy.VLNV) – The VLNV of the component to create an instance of.
Returns:: The newly created component instance.
Return type:: spacepy.ComponentInstance

create_device_instance(device_name: str) → spacepy.DeviceInstance#

Creates a new device instance of the given device in the architecture. The device name must correspond to an existing device in the project, otherwise an exception is raised.

Parameters:: device_name (str) – The name of the device to create an instance of.
Returns:: The newly created device instance.
Return type:: spacepy.DeviceInstance

create_module_instance(module_name: str) → spacepy.ModuleInstance#

Creates a new module instance of the given module in the architecture. The module name must correspond to an existing module in the project, otherwise an exception is raised.

Parameters:: module_name (str) – The name of the module to create an instance of.
Returns:: The newly created module instance.
Return type:: spacepy.ModuleInstance

get_communications() → Iterable[spacepy.Communication]#

Returns the result of the communications analysis, i.e. a collection of the communications in the architecture.

Returns:: A collection of the communications in the architecture.
Return type:: Iterable[spacepy.Communication]

get_component_instance(instance_name: str) → spacepy.ComponentInstance#

Returns the component instance with the specified name in the architecture. If no component instance with the specified name exists, an exception is raised.

Parameters:: instance_name (str) – The name of the component instance to return.
Returns:: The component instance with the specified name.
Return type:: spacepy.ComponentInstance

get_component_instances() → Iterable[spacepy.ComponentInstance]#

Returns a collection of the component instances in the architecture. Note : the returned collection does not include device and module instances, use get_device_instances() and get_module_instances() for those.

Return type:: Iterable[spacepy.ComponentInstance]

get_device_instance(instance_name: str) → spacepy.DeviceInstance#

Returns the device instance with the specified name in the architecture. If no device instance with the specified name exists, an exception is raised.

Parameters:: instance_name (str) – The name of the device instance to return.
Returns:: The device instance with the specified name.
Return type:: spacepy.DeviceInstance

get_device_instances() → Iterable[spacepy.DeviceInstance]#

Returns a collection of the device instances in the architecture.

Returns:: A collection of the device instances in the architecture.
Return type:: Iterable[spacepy.DeviceInstance]

get_implementation(tool_name: str) → spacepy.Implementation#

Returns the implementation tool with the specified name in the architecture. If no implementation tool with the specified name exists, an exception is raised.

Parameters:: tool_name (str) – The name of the implementation tool.
Returns:: The implementation tool with the specified name.
Return type:: spacepy.Implementation

get_implementations() → Iterable[spacepy.Implementation]#

Returns a collection of the implementation tools available in the architecture.

Returns:: A collection of the implementation tools available in the architecture.
Return type:: Iterable[spacepy.Implementation]

get_module_instance(instance_name: str) → spacepy.ModuleInstance#

Returns the module instance with the specified name in the architecture. If no module instance with the specified name exists, an exception is raised.

Parameters:: instance_name (str) – The name of the module instance to return.
Returns:: The module instance with the specified name.
Return type:: spacepy.ModuleInstance

get_module_instances() → Iterable[spacepy.ModuleInstance]#

Returns a collection of the module instances in the architecture.

Returns:: A collection of the module instances in the architecture.
Return type:: Iterable[spacepy.ModuleInstance]

get_name() → str#

Returns the name of the architecture.

Returns:: The name of the architecture.
Return type:: str

get_preferences() → Iterable[spacepy.Preference]#

Returns a collection of the preferences for the architecture.

Returns:: A collection of the preferences for the architecture.
Return type:: Iterable[spacepy.Preference]

get_workflow(workflow: str, build: str | None = None) → spacepy.Workflow#

Returns the workflow corresponding to the given workflow and build type.

Parameters:

workflow (str) – The type of workflow to return. One of {“simulation”, “implementation”, “estimation”, “fpga-in-the-loop”}.
build (str | None) – The type of build to return. One of {“release”, “monitoring”}.

Returns:

The workflow corresponding to the given workflow and build type.

Return type:

spacepy.Workflow

remove_component_instance(instance_name: str) → None#

Removes a component instance with the specified name from the architecture. If no component instance with the specified name exists, does nothing.

Parameters:: instance_name (str) – The name of the component instance to remove.
Return type:: None

save() → None#

Saves the architecture.

Return type:: None

class spacepy.Board#

Bases: object

A Board contains information about a specific board’s resources.

The quantity of resources needed to implement a specific architecture depends on the targeted FPGA. A Board gives access to Metric objects which can evaluate a specific resource’s usage and the quantity of resources available on the FPGA.

get_available_resources() → Iterable[spacepy.Metric]#

Returns a collection of Metric objects representing the available resources on the board’s FPGA.

Returns:: A collection of Metric objects representing the available resources on the board’s FPGA.
Return type:: Iterable[spacepy.Metric]

get_name() → str#

Returns the name of the board.

Returns:: The name of the board.
Return type:: str

class spacepy.BusInterface#

Bases: object

A BusInterface is an interface that belongs to a component instance and can be connected to other bus interfaces.

belongs_to() → spacepy.ComponentInstance#

Returns the component instance to which the bus interface belongs.

Returns:: The component instance to which the bus interface belongs.
Return type:: spacepy.ComponentInstance

connect(bus_interface: spacepy.BusInterface) → None#

Connects the bus interface to another bus interface.

Parameters:: bus_interface (spacepy.BusInterface) – The bus interface to connect to.
Return type:: None

disconnect() → None#

Disconnects the bus interface from any bus interface it is currently connected to, if any.

If the bus interface is not currently connected to any other bus interface, does nothing.

Return type:: None

get_bus_definition() → spacepy.VLNV#

Returns the VLNV of the bus definition associated with the bus interface.

Returns:: The VLNV of the bus definition associated with the bus interface.
Return type:: spacepy.VLNV

get_connected_bus_interface() → Iterable[spacepy.BusInterface]#

Returns the bus interface(s) currently connected to the bus interface.

Returns:: The bus interface(s) currently connected to the bus interface. If the bus interface is not currently connected to any other bus interface, returns an empty collection.
Return type:: Iterable[spacepy.BusInterface]

get_mode() → str#

Returns the mode of the bus interface.

Returns:: The mode of the bus interface, one of {“master”, “slave”, “mmaster”, “mslave”}.
Return type:: str

get_name() → str#

Returns the name of the bus interface.

Returns:: The name of the bus interface.
Return type:: str

is_connected() → bool#

Returns whether the bus interface is currently connected to another bus interface.

Returns:: True if the bus interface is currently connected to another bus interface, False otherwise.
Return type:: bool

class spacepy.Communication#

Bases: object

A Communication represents a communication of a certain type between two module instances. One module instance is the reader of the communication, and the other is the writer.

get_channel_width() → int#

Returns the channel width of the communication, in bits.

Returns:: The channel width of the communication, in bits.
Return type:: int

get_possible_types() → Iterable[str]#

Returns the possible types this communication can support, based on the reader and writer module instances’ mapping.

Returns:: The possible types for the communication.
Return type:: Iterable[str]

get_reader() → spacepy.ModuleInstance#

Returns the reader module instance of the communication.

Returns:: The reader module instance of the communication.
Return type:: spacepy.ModuleInstance

get_type() → spacepy.CommunicationType#

Returns the type of the communication.

Returns:: The type of the communication. One of {"fifo_hw", "fifo_sw", "dma"}.
Return type:: spacepy.CommunicationType

get_writer() → spacepy.ModuleInstance#

Returns the writer module instance of the communication.

Returns:: The writer module instance of the communication.
Return type:: spacepy.ModuleInstance

set_type(new_type: spacepy.CommunicationType) → None#

Sets the type of the communication.

Parameters:: new_type (spacepy.CommunicationType) – The new type of the communication. One of {"fifo_hw", "fifo_sw", "dma"}.
Return type:: None

class spacepy.CommunicationType#

Bases: object

A CommunicationType represents the type of a communication, (either hardware FIFO, software FIFO, or DMA). It also gives access to the specific parameters of each type of communication.

get_depth() → int#

Returns the depth of the communication.

Only applicable if the communication type is "fifo_hw" or "fifo_sw". Otherwise, behavior is undefined.

Return type:: int

get_latency() → int#

Returns the latency of the communication, in clock cycles.

Only applicable if the communication type is "fifo_hw". Otherwise, behavior is undefined.

Return type:: int

get_name() → str#

Returns the name of the communication type.

Returns:: The name of the communication type, one of {"fifo_hw", "fifo_sw", "dma"}.
Return type:: str

set_depth(depth: int) → None#

Sets the depth of the communication.

Only applicable if the communication type is "fifo_hw" or "fifo_sw". Otherwise, behavior is undefined.

Parameters:: depth (int) – The new depth of the communication, in number of data elements.
Return type:: None

set_latency(latency: int) → None#

Sets the latency of the communication.

Only applicable if the communication type is "fifo_hw". Otherwise, behavior is undefined.

Parameters:: latency (int) – The new latency of the communication, in clock cycles.
Return type:: None

class spacepy.ComponentInstance#

Bases: object

A ComponentInstance is an instance of an IP (Intellectual Property) core such as processors, user devices, memories, UARTs, etc…

These core can be instantiated in any architecture.

get_bus_interface(bus_interface_name: str) → spacepy.BusInterface#

Returns the bus interface with the specified name belonging to the component instance.

If no bus interface with the specified name exists, an exception is raised.

Parameters:: bus_interface_name (str) – The name of the bus interface to return.
Returns:: The bus interface with the specified name belonging to the component instance.
Return type:: spacepy.BusInterface

get_bus_interfaces() → Iterable[spacepy.BusInterface]#

Returns a collection of the bus interfaces belonging to the component instance.

Returns:: A collection of the bus interfaces belonging to the component instance.
Return type:: Iterable[spacepy.BusInterface]

get_component_instance(name: str) → spacepy.ComponentInstance#

Returns the component instance with the specified name contained in the component instance.

This exists for hierarchical components only, such as a SoC component which contains a processor and some peripherals.

If no component instance with the specified name exists, an exception is raised.

Parameters:: name (str) – The name of the component instance to return.
Returns:: The component instance with the specified name contained in the component instance.
Return type:: spacepy.ComponentInstance

get_component_instances() → Iterable[spacepy.ComponentInstance]#

Returns a collection of the component instances contained in the component instance.

This exists for hierarchical components only, such as a SoC component which contains a processor and some peripherals.

Returns:: A collection of the component instances contained in the component instance.
Return type:: Iterable[spacepy.ComponentInstance]

get_cores() → Iterable[spacepy.Core]#

Returns a collection of the cores contained in the component instance.

This exists for processors instances only. Processor instances can be identified by having the string "processor" as their VLNV library name.

Returns:: A collection of the cores contained in the component instance.
Return type:: Iterable[spacepy.Core]

get_name() → str#

Returns the name of the component instance.

Returns:: The name of the component instance.
Return type:: str

get_parameter(parameter_name: str) → spacepy.Parameter#

Returns the parameter with the specified name belonging to the component instance.

If no parameter with the specified name exists, an exception is raised.

Parameters:: parameter_name (str) – The name of the parameter to return.
Returns:: The parameter with the specified name belonging to the component instance.
Return type:: spacepy.Parameter

get_parameters() → Iterable[spacepy.Parameter]#

Returns a collection of the parameters belonging to the component instance.

Returns:: A collection of the parameters belonging to the component instance.
Return type:: Iterable[spacepy.Parameter]

get_vlnv() → spacepy.VLNV#

Returns the VLNV of the component instance.

Returns:: The VLNV of the component instance.
Return type:: spacepy.VLNV

is_hierarchical() → bool#

Returns whether the component instance is hierarchical, i.e. contains other component instances.

This is the case for SoC components, which may reveal multiple processor instances and other peripherals as component instances contained in the SoC component instance.

Returns:: True if the component instance is hierarchical, False otherwise.
Return type:: bool

set_name(name: str) → None#

Sets the name of the component instance.

Parameters:: name (str) – The new name of the component instance.
Return type:: None

class spacepy.Core#

Bases: object

Represents a physical core of a processor. A ModuleInstance can be mapped to a core to be executed as a software therad.

get_operating_system() → str#

Returns the operating system running on the core.

Returns:: The operating system running on the core, as a string.
Return type:: str

get_supported_operating_systems() → Iterable[str]#

Returns the operating systems supported by the core.

Returns:: The operating systems supported by the core, as a collection of strings. Each string is one of {"microc", "baremetal", "rtems", "linux", "freertos"}.
Return type:: Iterable[str]

set_operating_system(os: str) → None#

Sets the operating system running on the core.

Parameters:: os (str) – The new operating system to run on the core, as a string. One of {"microc", "baremetal", "rtems", "linux", "freertos"}.
Return type:: None

class spacepy.Device#

Bases: object

Represents a SpaceStudio device “spec” (i.e., not an instance, but a device as defined in the project, from which instances can be created).

add_import(path: str) → None#

Adds an import to the device.

Parameters:: path (str) – The absolute path to the file or folder to import.
Return type:: None

add_parameter(name: str, value: str) → None#

Defines a new user parameter for the device with the given name and value.

If the given parameter name already exists for the device, an exception is raised. To update a parameter’s value, use the Parameter.set_value() method of the object returned by get_parameter().

Parameters:

name (str) – The name of the user parameter to add.
value (str) – The value of the user parameter to add.

Return type:

None

get_compiler_build_option(option_name: str) → spacepy.ToolchainBuildOption#

Returns the compiler build option with the specified name related to the device.

If no compiler build option with the specified name exists, an exception is raised.

Parameters:: option_name (str) – The name of the compiler build option to return.
Returns:: The compiler build option with the specified name related to the device.
Return type:: spacepy.ToolchainBuildOption

get_compiler_build_options() → Iterable[spacepy.ToolchainBuildOption]#

Returns the collection of all build options for the compiler related to the device.

Returns:: A collection of all build options for the compiler related to the device.
Return type:: Iterable[spacepy.ToolchainBuildOption]

get_header_path() → str#

Returns the absolute path to the device’s header (.h) file.

Returns:: The absolute path to the device’s header file.
Return type:: str

get_imports() → Iterable[str]#

Returns a collection of the device’s imported files and folders.

Returns:: A collection of the device’s imported files and folders.
Return type:: Iterable[str]

get_name() → str#

Returns the name of the device.

Returns:: The name of the device.
Return type:: str

get_parameter(parameter_name: str) → spacepy.Parameter#

Returns the user parameter with the specified name belonging to the device.

If no user parameter with the specified name exists, an exception is raised.

Parameters:: parameter_name (str) – The name of the user parameter to return.
Returns:: The user parameter with the specified name belonging to the device.
Return type:: spacepy.Parameter

get_parameters() → Iterable[spacepy.Parameter]#

Returns a collection of all the user parameters defined for the device.

Returns:: A collection of all the user parameters defined for the device.
Return type:: Iterable[spacepy.Parameter]

get_source_path() → str#

Returns the absolute path to the device’s source (.cpp) file.

Returns:: The absolute path to the device’s source file.
Return type:: str

remove_import(path: str) → None#

Removes an import from the device.

Parameters:: path (str) – The absolute path to the file or folder to remove.
Return type:: None

remove_parameter(name: str) → None#

Removes the user parameter with the given name from the device.

If no user parameter with the given name exists for the device, fails with an exception.

Parameters:: name (str) – The name of the user parameter to remove.
Return type:: None

class spacepy.DeviceInstance#

Bases: spacepy.ComponentInstance

Provides access to an instance of a Device.

A DeviceInstance is a ComponentInstance. Therefore, all methods defined for ComponentInstance are also available for DeviceInstance.

get_device() → spacepy.Device#

Returns the Device corresponding to the DeviceInstance.

Returns:: The Device corresponding to the DeviceInstance.
Return type:: spacepy.Device

class spacepy.Engine#

Bases: object

The Engine is the entry point to the SpacePy API. It follows the singleton pattern, and can thus be accessed as follows :

from spacepy import Engine
engine = Engine.instance()

create(project_name: str, project_path: str) → spacepy.Project#

Creates a new SpaceStudio project with the given name and path, and returns the created Project object.

Parameters:

project_name (str) – The name of the project to create.
project_path (str) – The absolute path to the folder in which to create the project.

Returns:

The created Project object.

Return type:

spacepy.Project

get_component(name: str) → spacepy.VLNV#

Retrieves the platform IP with the given name (i.e. name field of the VLNV). If no platform IP with the given name exists, an exception is raised.

Parameters:: name (str) – The name of the platform IP to retrieve.
Returns:: The VLNV corresponding to the platform IP with the given name.
Return type:: spacepy.VLNV

get_components() → Iterable[spacepy.VLNV]#

Returns all the platform IPs that can be instantiated in an architecture.

Returns:: A collection of VLNVs corresponding to all the platform IPs that can be instantiated in an architecture.
Return type:: Iterable[spacepy.VLNV]

get_eda_preference(name: str) → spacepy.Preference#

Returns the EDA preference with the given name.

If no EDA preference with the given name exists, an exception is raised.

Parameters:: name (str) – The name of the EDA preference to return.
Returns:: The EDA preference with the given name.
Return type:: spacepy.Preference

get_eda_preferences() → Iterable[spacepy.Preference]#

Returns all EDA preferences.

Returns:: A collection of all EDA preferences.
Return type:: Iterable[spacepy.Preference]

get_sys() → Any#

Retrieves system information

Returns:: System information.
Return type:: Any

get_toolchain_preference(name: str) → spacepy.Preference#

Returns the toolchain preference with the given name.

If no toolchain preference with the given name exists, an exception is raised.

Parameters:: name (str) – The name of the toolchain preference to return.
Returns:: The toolchain preference with the given name.
Return type:: spacepy.Preference

get_toolchain_preferences() → Iterable[spacepy.Preference]#

Returns all the preferences of the engine regarding the toolchains

Returns:: A collection of all the preferences of the engine regarding the toolchains.
Return type:: Iterable[spacepy.Preference]

get_version() → spacepy.Version#

This method retrieves a Version instance representing the version of SpaceStudio currently running.

The Version.get_major(), Version.get_minor(), and Version.get_patch() methods of the returned Version instance are always guaranteed to return strings that can be cast as an integer between 0 and 999,999, as base-10 integers.

Therefore, version-checking can be performed as follows:

def make_version_number(major_int, minor_int = 0, patch_int = 0):
    return major_int * 1000000000000 + minor_int * 1000000 + patch_int

major_int = int(version.get_major())
minor_int = int(version.get_minor())
patch_int = int(version.get_patch())
ss_ver_num = make_version_number(major_int, minor_int, patch_int)

if ss_ver_num >= make_version_number(4, 4):
    # SpaceStudio >= 4.4.0
else:
    # SpaceStudio < 4.4.0

Note: this function was introduced in SpaceStudio 4.3, Python code that needs to remain compatible with versions prior to 4.3 can do something along the lines of the following :

try:
    version = space_engine.get_version()
    # SpaceStudio >= 4.3
    ss_with_version = True
except AttributeError:
    # SpaceStudio < 4.3
    ss_with_version = False

Returns:: A Version instance representing the version of SpaceStudio currently running.
Return type:: spacepy.Version

static instance() → spacepy.Engine#

Returns the singleton instance of the Engine.

Returns:: The singleton instance of the Engine.
Return type:: spacepy.Engine

open(project_file: str) → spacepy.Project#

Opens the SpaceStudio project at the given file path, and returns the corresponding Project object.

If any error occurs while opening the project (e.g., if the file does not exist, or if the file is not a valid .spacestudio project file), an exception is raised.

Parameters:: project_file (str) – The absolute path to the .spacestudio file of the project to open.
Returns:: The Project object corresponding to the opened project.
Return type:: spacepy.Project

class spacepy.HLSSynthesizer#

Bases: object

Provides control over a High-Level Synthesis (HLS) tool used for hardware synthesis.

get_name() → str#

Returns the name of the HLS synthesizer.

Returns:: The name of the HLS synthesizer.
Return type:: str

class spacepy.Implementation#

Bases: object

Provides control over an implementation tool used for hardware implementation (place and route, bitstream generation, etc…) for FPGA estimation and architecture implementation.

clean() → None#

Cleans the implementation cache for the implementation tool.

Return type:: None

get_board(name: str) → spacepy.Board#

Retrieves the board with the given name among the boards supported by the implementation tool.

If no board with the given name exists among the boards supported by the implementation tool, an exception is raised.

Parameters:: name (str) – The name of the board to retrieve.
Returns:: The Board object representing the board with the given name.
Return type:: spacepy.Board

get_boards() → Iterable[spacepy.Board]#

Returns a collection of Board objects representing the boards supported by the implementation tool.

Returns:: A collection of Board objects representing the boards supported by the implementation tool.
Return type:: Iterable[spacepy.Board]

get_name() → str#

Returns the name of the implementation tool.

Returns:: The name of the implementation tool.
Return type:: str

get_synthesizer(name: str) → spacepy.HLSSynthesizer#

Retrieves the HLS synthesizer with the given name among the HLS synthesizers supported by the implementation tool.

If no HLS synthesizer with the given name exists among the HLS synthesizers supported by the implementation tool, an exception is raised.

Parameters:: name (str) – The name of the HLS synthesizer to retrieve.
Returns:: The HLSSynthesizer object representing the HLS synthesizer with the given name.
Return type:: spacepy.HLSSynthesizer

get_synthesizers() → Iterable[spacepy.HLSSynthesizer]#

Returns a collection of HLSSynthesizer objects representing the HLS synthesizers supported by the implementation tool.

Returns:: A collection of HLSSynthesizer objects representing the HLS synthesizers supported by the implementation tool.
Return type:: Iterable[spacepy.HLSSynthesizer]

class spacepy.Metric#

Bases: object

A Metric is a named quantity measuring a specific property (i.e. simulation time, board resource usage, power consumption, etc…).

get_name() → str#

Returns the name of the metric.

Returns:: The name of the metric.
Return type:: str

get_value() → float#

This method evaluates the representation of the metric

Returns:: The value of the metric, as a float (actually a double in Java backend code).
Return type:: float

class spacepy.Module#

Bases: object

Provides access to a SpaceStudio module “spec” (i.e., not an instance, but a module as defined in the project, from which instances can be created).

add_import(path: str) → None#

Adds an import to the module.

Parameters:: path (str) – The absolute path to the file or folder to import.
Return type:: None

add_parameter(name: str, value: str) → None#

Defines a new user parameter for the module with the given name and value.

If the given parameter name already exists for the module, an exception is raised. To update a parameter’s value, use the Parameter.set_value() method of the object returned by get_parameter().

Parameters:

name (str) – The name of the user parameter to add.
value (str) – The value of the user parameter to add.

Return type:

None

get_compiler_build_option(option_name: str) → spacepy.ToolchainBuildOption#

Returns the compiler build option with the given name.

If no compiler build option with the given name exists for the module, an exception is raised. :param option_name: The name of the compiler build option to return. :return: The compiler build option with the given name.

Parameters:: option_name (str) –
Return type:: spacepy.ToolchainBuildOption

get_compiler_build_options() → Iterable[spacepy.ToolchainBuildOption]#

Returns a collection of the compiler build options for the module.

Returns:: A collection of the compiler build options for the module.
Return type:: Iterable[spacepy.ToolchainBuildOption]

get_header_path() → str#

Returns the absolute path to the module’s header (.h) file.

Returns:: The absolute path to the module’s header file.
Return type:: str

get_imports() → Iterable[str]#

Returns a collection of the module’s imported files and folders.

Returns:: A collection of the module’s imported files and folders.
Return type:: Iterable[str]

get_name() → str#

Returns the name of the module.

Returns:: The name of the module.
Return type:: str

get_parameter(parameter_name: str) → spacepy.Parameter#

Returns the user parameter with the specified name belonging to the module.

If no user parameter with the specified name exists, an exception is raised. :param parameter_name: The name of the user parameter to return. :return: The user parameter with the specified name belonging to the module.

Parameters:: parameter_name (str) –
Return type:: spacepy.Parameter

get_parameters() → Iterable[spacepy.Parameter]#

Returns a collection of all the user parameters defined for the module.

Returns:: A collection of all the user parameters defined for the module.
Return type:: Iterable[spacepy.Parameter]

get_source_path() → str#

Returns the absolute path to the module’s source (.cpp) file.

Returns:: The absolute path to the module’s source file.
Return type:: str

remove_import(path: str) → None#

Removes an import from the module.

Parameters:: path (str) – The absolute path to the file or folder to remove.
Return type:: None

remove_parameter(name: str) → None#

Removes the user parameter with the given name from the module.

If no user parameter with the given name exists for the module, fails with an exception.

Parameters:: name (str) – The name of the user parameter to remove.
Return type:: None

class spacepy.ModuleInstance#

Bases: spacepy.ComponentInstance

Provides access to an instance of a Module.

A ModuleInstance can be instantiated as a hardware accelerator or as a software thread running on a processor.

A ModuleInstance is a ComponentInstance. Therefore, all methods defined for ComponentInstance are also available for ModuleInstance.

get_module() → spacepy.Module#

Returns the Module corresponding to the ModuleInstance.

Returns:: The Module corresponding to the ModuleInstance.
Return type:: spacepy.Module

is_hardware() → bool#

Retrieves whether the ModuleInstance is currently mapped to hardware. :return: True if the ModuleInstance is mapped to hardware, False otherwise.

Return type:: bool

is_software() → bool#

Retrieves whether the ModuleInstance is currently mapped to software.

Returns:: True if the ModuleInstance is mapped to software, False otherwise.
Return type:: bool

move_to_hardware() → None#

Maps the ModuleInstance to hardware to be executed as a hardware accelerator.

Return type:: None

move_to_software(core: spacepy.Core) → None#

Maps the ModuleInstance to the given core to be executed as a software thread.

Parameters:: core (spacepy.Core) – The core to which the ModuleInstance will be mapped.
Return type:: None

class spacepy.Parameter#

Bases: object

A Parameter is a user-defined name-value that can be used in a Module or Device.

get_name() → str#

Returns the name of the parameter.

Returns:: The name of the parameter.
Return type:: str

get_value() → str#

Returns the value of the parameter.

Returns:: The value of the parameter.
Return type:: str

is_read_only() → bool#

Returns whether the parameter is read-only, i.e. whether its value cannot be updated by the user.

Returns:: True if the parameter is read-only, False otherwise.
Return type:: bool

set_value(value: str) → None#

Sets the value of the parameter.

If the parameter is read-only, an exception is raised.

Parameters:: value (str) – The new value of the parameter.
Return type:: None

class spacepy.Preference#

Bases: object

A Preference is a setting in the SpaceStudio environment that can be manipulated. It can be architecture-specific or global to the whole engine.

get_description() → str#

Returns the description of the preference.

Returns:: The description of the preference.
Return type:: str

get_name() → str#

Returns the name of the preference.

Returns:: The name of the preference.
Return type:: str

get_value() → str#

Returns the value of the preference.

Returns:: The value of the preference.
Return type:: str

restore_default() → None#

Restores the default value(s) of the preference.

Return type:: None

set_value(*value: str) → None#

Sets the value of the preference.

Parameters:: value (str) – One or many new values. Some preferences may require multiple values to be set at the same time, in which case multiple values can be passed as arguments to this method. If the preference only requires a single value, only the first argument will be considered, and the rest will be ignored.
Return type:: None

class spacepy.Project#

Bases: object

Represents a SpaceStudio project, i.e. a set of solutions.

clean() → None#

Cleans the project.

Removes all generated files for all solutions of the project.

Return type:: None

close() → None#

Closes the project.

Return type:: None

create_solution(solution_name: str) → spacepy.Solution#

Creates a new solution with the given name in the project, and returns the created Solution object.

Parameters:: solution_name (str) – The name of the solution to create.
Returns:: The created Solution object.
Return type:: spacepy.Solution

get_name() → str#

Returns the name of the project.

Returns:: The name of the project.
Return type:: str

get_solution(name: str) → spacepy.Solution#

Returns the solution with the specified name contained in the project.

If no solution with the specified name exists, an exception is raised.

Parameters:: name (str) – The name of the solution to return.
Returns:: The solution with the specified name contained in the project.
Return type:: spacepy.Solution

get_solutions() → Iterable[spacepy.Solution]#

Returns a collection of the solutions contained in the project.

Returns:: A collection of the solutions contained in the project.
Return type:: Iterable[spacepy.Solution]

remove_solution(solution_name: str) → None#

Removes the solution with the given name from the project.

If no solution with the given name exists in the project, does nothing.

Parameters:: solution_name (str) – The name of the solution to remove.
Return type:: None

save() → None#

Saves the project.

Return type:: None

class spacepy.Solution#

Bases: object

A solution consists of a set of modules, devices, and architectures.

create_architecture(architecture_name: str) → spacepy.Architecture#

Creates a new architecture with the given name in the solution, and returns the created Architecture object.

Parameters:: architecture_name (str) – The name of the architecture to create.
Returns:: The created Architecture object.
Return type:: spacepy.Architecture

create_device(device_name: str, is_master: bool) → spacepy.Device#

Creates a new device with the given name in the solution, and returns the created Device object.

Parameters:

device_name (str) – The name of the device to create.
is_master (bool) – Whether the device is a master device (i.e. initiates communications with other devices) or a slave device (i.e. only responds to communications initiated by other devices).

Returns:

The created Device object.

Return type:

spacepy.Device

create_module(module_name: str) → spacepy.Module#

Creates a new module with the given name in the solution, and returns the created Module object.

Parameters:: module_name (str) – The name of the module to create.
Returns:: The created Module object.
Return type:: spacepy.Module

get_architecture(name: str) → spacepy.Architecture#

Returns the architecture with the specified name contained in the solution.

If no architecture with the specified name exists, an exception is raised.

Parameters:: name (str) – The name of the architecture to return.
Returns:: The architecture with the specified name contained in the solution.
Return type:: spacepy.Architecture

get_architectures() → Iterable[spacepy.Architecture]#

Returns a collection of the architectures contained in the solution.

Returns:: A collection of the architectures contained in the solution.
Return type:: Iterable[spacepy.Architecture]

get_device(name: str) → spacepy.Device#

Returns the device with the specified name contained in the solution.

If no device with the specified name exists, an exception is raised.

Parameters:: name (str) – The name of the device to return.
Returns:: The device with the specified name contained in the solution.
Return type:: spacepy.Device

get_devices() → Iterable[spacepy.Device]#

Returns a collection of the devices contained in the solution.

Returns:: A collection of the devices contained in the solution.
Return type:: Iterable[spacepy.Device]

get_linker_build_option(name: str) → spacepy.ToolchainBuildOption#

Returns the linker build option with the given name.

If no linker build option with the given name exists for the solution, an exception is raised.

Parameters:: name (str) – The name of the linker build option to return.
Returns:: The linker build option with the given name.
Return type:: spacepy.ToolchainBuildOption

get_linker_build_options() → Iterable[spacepy.ToolchainBuildOption]#

Returns a collection of the linker build options for the solution.

Returns:: A collection of the linker build options for the solution.
Return type:: Iterable[spacepy.ToolchainBuildOption]

get_module(name: str) → spacepy.Module#

Returns the module with the specified name contained in the solution.

If no module with the specified name exists, an exception is raised.

Parameters:: name (str) – The name of the module to return.
Returns:: The module with the specified name contained in the solution.
Return type:: spacepy.Module

get_modules() → Iterable[spacepy.Module]#

Returns a collection of the modules contained in the solution.

Returns:: A collection of the modules contained in the solution.
Return type:: Iterable[spacepy.Module]

get_name() → str#

Returns the name of the solution.

Returns:: The name of the solution.
Return type:: str

remove_architecture(architecture_name: str) → None#

Removes the architecture with the given name from the solution.

If no architecture with the given name exists in the solution, does nothing.

Parameters:: architecture_name (str) – The name of the architecture to remove.
Return type:: None

remove_device(device_name: str) → None#

Removes the device with the given name from the solution.

If no device with the given name exists in the solution, does nothing.

Parameters:: device_name (str) – The name of the device to remove.
Return type:: None

remove_module(module_name: str) → None#

Removes the module with the given name from the solution.

If no module with the given name exists in the solution, does nothing.

Parameters:: module_name (str) – The name of the module to remove.
Return type:: None

save() → None#

Saves the solution.

Return type:: None

class spacepy.ToolchainBuildOption#

Bases: object

A ToolchainBuildOption corresponds to a build option made of flags and directories. It can be associated with the linker and be specific to a solution, or be associated with the compiler and be specific to a module or device.

add_directory(file_path: str) → None#

Adds a directory to the build option.

Parameters:: file_path (str) – The absolute path to the directory to add.
Return type:: None

get_directories() → Iterable[str]#

Returns a collection of the directories of the build option.

Returns:: A collection of the directories of the build option.
Return type:: Iterable[str]

get_flags() → str#

Returns the flags of the build option, as a single string.

Returns:: The flags of the build option, as a single string.
Return type:: str

get_name() → str#

Returns the name of the build option.

Returns:: The name of the build option.
Return type:: str

remove_directory(file_path: str) → None#

Removes a directory from the build option.

Parameters:: file_path (str) – The absolute path to the directory to remove.
Return type:: None

set_flags(flags: str) → None#

Sets the flags of the build option.

Parameters:: flags (str) – The new flags of the build option, as a single string.
Return type:: None

class spacepy.VLNV#

Bases: object

Unique identifier for an IP core.

get_library() → str#

Returns the library field of the VLNV.

Returns:: The library field of the VLNV.
Return type:: str

get_name() → str#

Returns the name field of the VLNV.

Returns:: The name field of the VLNV.
Return type:: str

get_vendor() → str#

Returns the vendor field of the VLNV.

Returns:: The vendor field of the VLNV.
Return type:: str

get_version() → spacepy.Version#

Returns the version field of the VLNV.

Returns:: The version field of the VLNV, as a Version object.
Return type:: spacepy.Version

class spacepy.Version#

Bases: object

A version represented in a major.minor.patch format, where all three fields can be any string.

Note : the Version object returned by Engine.get_version() has additional guarantees, see Engine.get_version() documentation for details.

get_major() → str#

Returns the major field of the version.

Returns:: The major field of the version. Can be any alphanumeric string.
Return type:: str

get_minor() → str#

Returns the minor field of the version.

Returns:: The minor field of the version. Can be any alphanumeric string.
Return type:: str

get_patch() → str#

Returns the patch field of the version.

Returns:: The patch field of the version. Can be any alphanumeric string.
Return type:: str

class spacepy.Workflow#

Bases: object

Represents an executable process within SpaceStudio, namely : simulation, FPGA estimation, architecture implementation and FPGA-in-the-loop.

A Workflow is configured through named parameters. A detailed description of the parameters available for each workflow type can be found in Workflow Parameters.

execute() → Iterable[spacepy.Metric]#

Executes the workflow, and returns a collection of Metric objects representing the metrics resulting from the execution.

Returns:: A collection of Metric objects representing the metrics resulting from the execution.
Return type:: Iterable[spacepy.Metric]

get_build_type() → str#

Returns the build type of the workflow, as a string.

Returns:: The build type of the workflow, as a string. One of {"debug", "monitoring"}.
Return type:: str

get_parameter(parameter_name: str) → spacepy.Parameter#

Returns the parameter with the specified name belonging to the workflow.

If no parameter with the specified name exists, an exception is raised.

A detailed description of the parameters available for each workflow type can be found in Workflow Parameters.

Parameters:: parameter_name (str) – The name of the parameter to return.
Returns:: The parameter with the specified name belonging to the workflow.
Return type:: spacepy.Parameter

get_parameters() → Iterable[spacepy.Parameter]#

Returns a collection of all the parameters defined for the workflow.

A detailed description of the parameters available for each workflow type can be found in Workflow Parameters.

Returns:: A collection of all the parameters defined for the workflow.
Return type:: Iterable[spacepy.Parameter]

get_workflow_type() → str#

Returns the type of the workflow, as a string.

Returns:: The type of the workflow, as a string. One of {"simulation", "estimation", "implementation", "fpga-in-the-loop"}.
Return type:: str