casp_be.py

"""! This module defines all necessary functions to
 
 - start CASP Block Editor process
 - create a new block as a project
 - modify block internal parameters
 - add block user parameters
 - add block ports
 - save the block to the disk
 - and finally when every thing is done, close the Block Editor process
 
 All functions in this module uses global object \ref _casp_process.casp_be_proc from \ref _casp_process.py module.
"""

import importlib
 
import sys
if sys.version_info[:3] < (3,9):
    from typing import List as list
 
from _casp_process import casp_be_proc
import casp_utils as utils
import casp_defs as defs

def Init(casp_file: str="BlockEditor"):
    """! Initializes CASP Block Editor subprocess. This is the first function to be called before using any other function in this module.
 
    Arguments:
 
        casp_file: Set executable file to be invoked. Set this argument only if the executable file version is different from 'BlockEditor'.
    """
    casp_be_proc.init(casp_file)

def HelpPython():
    """! Opens CASP Python Libraries documentation.
    """
    response = casp_proc.write("casp.help.python")

def Close():
    """! Terminates CASP Block Editor subprocess and releases the resources.
    """
    casp_be_proc.close()

def Open(blk_name: str, visible_title: str, parent_dir_path: str="", overwrite_existing: bool=True) -> bool:
    """! Creates new block and opens it for further configuration.
 
    Arguments:
 
        blk_name: Block name to be created. The block name should follow standard file naming conventions.
 
        visible_title: Block visible title text.
 
        parent_dir_path: Block location/arent directory path. If empty, the new block will be created in 'casp_user_data/blocks' folder.
 
        overwrite_existing: True to overwrite existing block if path matches.
 
    Return Value:
 
        Returns True if successful or else False.
    """
    response = casp_be_proc.write("casp.open", [blk_name, visible_title, parent_dir_path, str(int(overwrite_existing))])
    print(f"CASP: {response.strip()}")
    if "Error" in response.strip():
        return False
    return True

def AddPort(port_name: str, visible_text: str, output_port: bool=False, data_type: str=defs.DATA_TYPE_INT32, data_size :int=1) -> bool:
    """! Adds new port to the block.
 
    Arguments:
 
        port_name: Block port name to be added. The port name should follow standard file naming conventions.
 
        visible_text: Block port visible text.
 
        output_port: True for output port or False for input port
 
        data_type: Port data type. Set one of the data type constants from \ref casp_defs.py module.
 
        data_size: Port data size. Value should be > 0.
 
    Return Value:
 
        Returns True if successful or else False.
    """
    response = casp_be_proc.write("casp.add_port", [port_name, visible_text, str(int(output_port)), data_type, str(data_size)])
    print(f"CASP: {response.strip()}")
    if "Error" in response.strip():
        return False
    return True

def AddPara(para_name: str, var_name: str, data_type: str=defs.DATA_TYPE_INT32, para_values :list[str]=["None"]) -> bool:
    """! Adds new parameter to the block.
 
    Arguments:
 
        para_name: Block parameter name to be added. The parameter name should follow standard file naming conventions.
 
        var_name: Internal variable name of the block parameter. It should be as per C/C++ variable naming conventions.
 
        data_type: Parameter value data type. Set one of the data type constants from \ref casp_defs.py module.
 
        para_values: Set Parameter values as a string list.
 
    Return Value:
 
        Returns True if successful or else False.
    """
    args = [para_name, var_name, data_type] + para_values
    response = casp_be_proc.write("casp.add_para", args)
    print(f"CASP: {response.strip()}")
    if "Error" in response.strip():
        return False
    return True

def SetOtherLangSupport(lang_type: int=defs.LANG_PYTHON) -> bool:
    """! Set support for other languages such as Python, Fortran and Verilog.
 
    Arguments:
 
        lang_type: Set additional languages supported (if any). Set one of the constants from \ref casp_defs.py module.
 
    Return Value:
 
        Returns True if successful or else False.
    """
    response = casp_be_proc.write("casp.oth_lang_support", [str(lang_type)])
    print(f"CASP: {response.strip()}")
    if "Error" in response.strip():
        return False
    return True

def Save() -> bool:
    """! Save block data to disk. This function actually creates the block folder on disk. Should be called only once and at the end of your script.
 
    Returns True if successful or else False
    """
    response = casp_be_proc.write("casp.save")
    print(f"CASP: {response.strip()}")
    if "Error" in response.strip():
        return False
    return True

def Folder():
    """! Show block folder.
    """
    response = casp_be_proc.write("casp.show_dir")
    print(f"CASP: {response.strip()}")