\n SCADE has always been open and provided Application Programming Interfaces (APIs) to ease integration into any workflow and environment. Ansys application engineers and customers have created many tools and extensions thanks to these APIs. We have started making some of these utilities available on GitHub<\/a>, to make it easier to for our users to access them. <\/p>\n Scade One is no different and the goal of PyScadeOne is to take this openness to the next level. PyScadeOne is part of the PyAnsys initiative<\/a> to provide easy access to Ansys tools from Python. That is why PyScadeOne is delivered as an open-source library on GitHub, that can be easily deployed in any compatible Python environment (it supports Windows and Linux, and any version of Python greater than 3.9). It can be installed like any other Python library, using for instance pip:<\/p>\n <\/p>\n PyScadeOne comes with an extensive user documentation, including examples, at https:\/\/scadeone.docs.pyansys.com\/<\/a>, so you can quickly get started with the library.<\/p>\n Note that PyScadeOne is also delivered as a Python wheel file ( <\/p>\n PyScadeOne offers the following services:<\/p>\n PyScadeOne will continue evolving in future versions to provide even more services. For instance, future versions will include a rule checker<\/em>, to define and verify modeling rules automatically.<\/p>\n After this quick introduction to PyScadeOne, let us now look at an example of a Python script using this library. Our goal is to print an instance tree<\/em> from a model: if an operator \n Such a visualization could be useful for instance in a model report, to better understand the structure of the model.<\/p>\n Our script will proceed as follows to create the instance tree:<\/p>\n We will now describe each of these steps.<\/p>\n Our first step is to open a project and access the corresponding model. First, we import the PyScadeOne library:<\/p>\n <\/p>\n Then, we load the project (given here as input of the script, using the standard argparse<\/a> library):<\/p>\n <\/p>\n To build the instance tree, we first traverse the model to compute the list of operators called by each operator. We then use this information to build a tree starting from the root operator we have chosen. <\/p>\n We are in luck, because one of the examples<\/a> provided with PyScadeOne is already computing this information. This example uses the Swan model visitor<\/a>, which is a standard way to traverse an Abstract Syntax Tree<\/em> (AST) like a Swan model. Remember that Swan is the domain-specific language used for modeling in Scade One, that has been described in previous blogs<\/a>. A visitor is a class that contains one method for each kind of object in the model. The visitor traverses the model and calls the corresponding methods for each object. Methods can be redefined to implement the desired behavior. <\/p>\n In our case, we redefine two methods:<\/p>\n Here is the complete code of our visitor:<\/p>\n <\/p>\n We can then easily apply our visitor to the complete model:<\/p>\n <\/p>\n At this point, calling Now that we have computed the list of used operators, the rest of the code is standard Python, so we won’t go into too much detail. To simplify our task, we leverage the rich ecosystem of Python libraries. We use NetworkX<\/a> to represent the tree\/graph and pydot<\/a> to print it, using the famous Graphviz<\/a> tool. That is one of the main strengths of Python: whatever you want to do, there’s always a library to help you.<\/p>\n For instance, the following function is used to add an operator to the tree, represented as a NetworkX graph, starting from the root operator. Note that we are considering library operators as leaves in the instance tree.<\/p>\n <\/p>\n Similarly, we have also created a function To be able to run the script, you first must install its dependencies using the included <\/p>\n You also must install the Graphviz<\/a> tool, that will generate the PNG file from the graph description.<\/p>\n Note: make sure that the path of your local Graphviz installation matches the one near the beginning of the <\/p>\n We can now apply our script to the <\/p>\n It generates the following tree:<\/p>\n \n Note that we have added the library operators in blue boxes as a bonus. We could get some inspiration from the Graphviz gallery<\/a> to generate a better-looking tree (and we probably should), but that’s a topic for another day.<\/p>\n You can download the script from this blog here<\/a>. And of course, you can install PyScadeOne using your favorite method, like If you want to learn more about PyScadeOne, a webinar will be hosted on April 3, 2025 (link<\/a>). You may also schedule a live demo of Scade One using this link<\/a>. Also, if you are a SCADE user, access Scade One Essential with your existing licenses on the Ansys Download Portal<\/a>.<\/p>\n PyScadeOne will continue to evolve in future versions, so expect regular blogs about it, demonstrating its capabilities and how it can be used to extend Scade One, for instance to connect it to 3rd party tools.<\/p>\n Stay tuned for more information about the new features in Scade One 2025 R1, including model-based testing thanks to the test harness concept.<\/p>\n![](\"https:\/\/innovationspace.ansys.com\/knowledge\/wp-content\/uploads\/sites\/4\/2025\/02\/scade-032-banner-scaled.jpg\")
\n Photo credit: Godfrey Atima @ Pexels<\/a><\/em>\n<\/p>\nAbout PyScadeOne<\/h3>\n
<\/span>> pip install ansys-scadeone-core\r\n<\/pre>\n<\/div>\n.whl<\/code>) inside the Scade One installation, that can be installed for instance with:<\/p>\n<\/span>> pip install pyscadeone\/ansys_scadeone-0.6.0+43-py3-none-any.whl\r\n<\/pre>\n<\/div>\nPyScadeOne in the 2025 R1 release<\/h3>\n
\n
\n
Using PyScadeOne to print an instance tree<\/h3>\n
Op1<\/code> uses an instance of operator Op2<\/code>, then Op2<\/code> is a child of Op1<\/code> in the instance tree. Here is an example of such tree, based on the QuadFlightControl<\/code> example delivered with Scade One:<\/p>\n![](\"https:\/\/innovationspace.ansys.com\/knowledge\/wp-content\/uploads\/sites\/4\/2025\/02\/scade-032-quadflightcontrol-motorcontrol-graph.svg\")
\n <\/em>\n<\/p>\n\n
Accessing the model<\/h5>\n
<\/span>from<\/span> ansys.scadeone.core.scadeone<\/span> import<\/span> ScadeOne\r\n<\/pre>\n<\/div>\n<\/span>app =<\/span> ScadeOne(install_dir=<\/span>scade_one_install_dir)\r\nproject =<\/span> app.<\/span>load_project(args.<\/span>project)\r\nproject.<\/span>model.<\/span>load_all_modules()\r\n<\/pre>\n<\/div>\nComputing the list of used operators<\/h5>\n
\n
visit_Operator<\/code>, which is called for each operator definition, to remember what operator we are currently traversing (in the self._current_op<\/code> field)<\/li>\nvisit_PathIdOpCall<\/code>, which is called for each instance of a named operator. We will add this operator name to the list of operators called by self._current_op<\/code> in the self._called<\/code> dictionary.<\/li>\n<\/ul>\n<\/span>class<\/span> InstanceVisitor<\/span>(SwanVisitor):\r\n <\/span>"""Visitor to compute the operators called by all operators in the model"""<\/span>\r\n\r\n def<\/span> __init__<\/span>(self<\/span>) -><\/span> None<\/span>:\r\n super<\/span>().<\/span>__init__<\/span>()\r\n self<\/span>.<\/span>_current_op: swan.<\/span>Operator =<\/span> None<\/span>\r\n self<\/span>.<\/span>_called =<\/span> {}\r\n\r\n def<\/span> get_called<\/span>(self<\/span>, op):\r\n <\/span>"""Returns the list of operators called by 'op'"""<\/span>\r\n return<\/span> self<\/span>.<\/span>_called.<\/span>get(op, None<\/span>)\r\n\r\n def<\/span> visit_Operator<\/span>(\r\n self<\/span>, swan_obj: swan.<\/span>Operator, owner: Union[swan.<\/span>Any, None<\/span>], property<\/span>: Union[str<\/span>, None<\/span>]\r\n ) -><\/span> None<\/span>:\r\n # Called when visiting an operator. Sets _current_op to the current operator and continues traversal<\/span>\r\n self<\/span>.<\/span>_current_op =<\/span> swan_obj\r\n self<\/span>.<\/span>_called[swan_obj.<\/span>get_full_path()] =<\/span> []\r\n super<\/span>().<\/span>visit_Operator(swan_obj, owner, property<\/span>)\r\n self<\/span>.<\/span>_current_op =<\/span> None<\/span>\r\n\r\n def<\/span> visit_PathIdOpCall<\/span>(\r\n self<\/span>, swan_obj: swan.<\/span>PathIdOpCall, owner: Union[swan.<\/span>Any, None<\/span>], property<\/span>: Union[str<\/span>, None<\/span>]\r\n ) -><\/span> None<\/span>:\r\n # ignore unknown operators<\/span>\r\n if<\/span> self<\/span>.<\/span>_current_op is<\/span> None<\/span>:\r\n return<\/span>\r\n name =<\/span> str<\/span>(swan_obj.<\/span>path_id)\r\n op =<\/span> self<\/span>.<\/span>_current_op.<\/span>body.<\/span>get_declaration(name)\r\n if<\/span> op is<\/span> None<\/span>:\r\n return<\/span>\r\n\r\n # add called_operator to the list of called operators<\/span>\r\n called_operator =<\/span> cast(swan.<\/span>Operator, op).<\/span>get_full_path()\r\n current_op_name =<\/span> self<\/span>.<\/span>_current_op.<\/span>get_full_path()\r\n if<\/span> called_operator not<\/span> in<\/span> self<\/span>.<\/span>_called[current_op_name]:\r\n self<\/span>.<\/span>_called[current_op_name].<\/span>append(called_operator)\r\n<\/pre>\n<\/div>\n<\/span>visitor =<\/span> InstanceVisitor()\r\nfor<\/span> module in<\/span> model.<\/span>modules:\r\n visitor.<\/span>visit(module)\r\n<\/pre>\n<\/div>\nvisitor.get_called(op)<\/code> will return the list of operators called by any operator in the model.<\/p>\nBuilding and printing the instance tree<\/h5>\n
<\/span>def<\/span> add_to_graph<\/span>(G, op, visitor):\r\n <\/span>"""Add node `op` to the graph `G`, using info from `visitor`"""<\/span>\r\n G.<\/span>add_node(op)\r\n called_ops =<\/span> visitor.<\/span>get_called(op)\r\n # ignore called operators for library operators<\/span>\r\n if<\/span> not<\/span> is_library_operator(op) and<\/span> called_ops:\r\n for<\/span> called_op in<\/span> called_ops:\r\n G.<\/span>add_edge(op, called_op)\r\n add_to_graph(G, called_op, visitor)\r\n<\/pre>\n<\/div>\nprint_graph<\/code> that takes as input a graph and an output path, and generates the PNG file using Graphviz (that we won’t show here).<\/p>\nRunning the script<\/h5>\n
requirements.txt<\/code> file. You just need to run, for instance in a virtual environment<\/a>:<\/p>\n<\/span>> pip install -r requirements.txt\r\n<\/pre>\n<\/div>\ninstance_tree.py<\/code> script:<\/p>\n<\/span>graphviz_path =<\/span> r'C:\\Program Files\\Graphviz\\bin'<\/span> # Should be manually set if not already in PATH<\/span>\r\n<\/pre>\n<\/div>\nQuadFlightControl<\/code> example, with the QuadFlightControl::QuadFlightControl<\/code> operator as root, with the following command line:<\/p>\n<\/span>> python instance_tree.py "C:\\Program Files\\ANSYS Inc\\v251\\Scade One\\examples\\QuadFlightControl\\QuadFlightControl\\QuadFlightControl.sproj"<\/span> "QuadFlightControl::QuadFlightControl"<\/span>\r\n<\/pre>\n<\/div>\n![](\"https:\/\/innovationspace.ansys.com\/knowledge\/wp-content\/uploads\/sites\/4\/2025\/02\/scade-032-quadflightcontrol-quadflightcontrol-graph.svg\")
\n <\/em>\n<\/p>\nWant to learn more?<\/h3>\n
pip<\/code>, as shown at the beginning of the blog.<\/p>\nAbout the author<\/h3>\n
\n
\n \n
![](\"https:\/\/innovationspace.ansys.com\/knowledge\/wp-content\/uploads\/sites\/4\/2025\/02\/scade-032-author.png\")