class TreeExporter(object):
def __init__(self, className):
self.classNames = list()
self.classNames.append(className)
self.classDetails = list()
self.logger = logging.getLogger('py_modelica_exporter.TreeExporter')
self.logger.setLevel(logging.NOTSET)
self.logger.info('Initializing TreeExporter({0})'.format(className))
self.omc = OMCSession()
# load all packages
success = self.omc.loadModel('Modelica')
# TODO: load all external packages
self.parse_tree(className)
def parse_tree(self, className):
classNames = self.omc.getClassNames(className,
recursive=True,
sort=True)
# filter and export only blocks and models
for c_name in classNames:
if (self.omc.isModel(c_name)) or (self.omc.isBlock(c_name)):
class_details = dict()
class_details['ComponentName'] = c_name
class_details['Description'] = self.omc.getClassComment(c_name)
self.classDetails.append(class_details)
def json(self):
json_result = dict()
json_result['topLevelPackages'] = self.classNames
json_result['classDetails'] = self.classDetails
return json_result
def xml(self):
raise NotImplementedError
def export_to_json(self, filename):
json_result = self.json()
with open(filename, 'w') as f_p:
json.dump(json_result, f_p, indent=4)
return json_result
def export_to_xml(self, filename):
raise NotImplementedError
class TreeExporter(object):
def __init__(self, className):
self.classNames = list()
self.classNames.append(className)
self.classDetails = list()
self.logger = logging.getLogger('py_modelica_exporter.TreeExporter')
self.logger.setLevel(logging.NOTSET)
self.logger.info('Initializing TreeExporter({0})'.format(className))
self.omc = OMCSession()
# load all packages
success = self.omc.loadModel('Modelica')
# TODO: load all external packages
self.parse_tree(className)
def parse_tree(self, className):
classNames = self.omc.getClassNames(className, recursive=True, sort=True)
# filter and export only blocks and models
for c_name in classNames:
if (self.omc.isModel(c_name)) or (self.omc.isBlock(c_name)):
class_details = dict()
class_details['ComponentName'] = c_name
class_details['Description'] = self.omc.getClassComment(c_name)
self.classDetails.append(class_details)
def json(self):
json_result = dict()
json_result['topLevelPackages'] = self.classNames
json_result['classDetails'] = self.classDetails
return json_result
def xml(self):
raise NotImplementedError
def export_to_json(self, filename):
json_result = self.json()
with open(filename, 'w') as f_p:
json.dump(json_result, f_p, indent=4)
return json_result
def export_to_xml(self, filename):
raise NotImplementedError
class ComponentAssemblyExporter(object):
"""
Class ComponentAssemblyExporter is an interface with the OpenModelicaCompiler to facilitate
extracting class information in a 'ComponentAssembly' format
"""
def __init__(self, external_packages=None, msl_version='3.2'):
"""
Create an instance of the ComponentAssemblyExporter
"""
self.logger = logging.getLogger(
'py_modelica_exporter::ComponentExporter')
self.logger.setLevel(logging.DEBUG)
# create console handler with a higher log level
self.logger_console_handler = logging.StreamHandler()
self.logger_console_handler.setLevel(logging.INFO)
# create formatter and add it to the handlers
self.logger_formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
self.logger_console_handler.setFormatter(self.logger_formatter)
# add the handlers to the logger
self.logger.addHandler(self.logger_console_handler)
# start om session
self.omc = OMCSession()
# start om session
self.omc = OMCSession()
# load all packages
self.omc.loadModel('Modelica, {{"{0}"}}'.format(msl_version))
self.logger.info('Modelica {0} loaded.'.format(msl_version))
if external_packages:
self.load_external_packages(external_packages)
self.logger.debug('ComponentAssemblyExporter __init__ finished.')
def load_external_packages(self, external_packages):
"""
Load all the external packages
"""
for package_path in (os.path.abspath(p.strip()).replace("\\", "/")
for p in external_packages):
file_name = os.path.basename(package_path)
if file_name == 'package.mo':
package_name = os.path.basename(os.path.dirname(package_path))
else:
package_name, dot_mo = os.path.splitext(file_name)
if self.omc.loadFile(package_path):
self.logger.info('Loaded {0} at {1}'.format(
package_name, package_path))
else:
self.logger.error('Failed loading {0} from {1}!'.format(
package_name, package_path))
def get_component_assembly_json(self, modelica_uri):
"""
create a dictionary description of the Modelica class, enumerating all the contained classes
"""
ca = ComponentAssembly()
ca.name = modelica_uri.split('.')[-1]
ca.full_name = modelica_uri
try:
mo_components = self.omc.getComponents(modelica_uri)
except ValueError as value_error_exception:
if value_error_exception.args[
0] == 'Could not parse OMC response.':
raise ParsingException
for (mo_type, mo_name, mo_annotation, mo_modification, v5, v6, v7,
isReplaceable, component_type, v10, v11, v12) in mo_components:
if self.omc.isModel(mo_type) or self.omc.isBlock(mo_type):
if v10 in ['inner', 'outer']:
self.logger.debug('Skipping {0} - it is {1}'.format(
mo_name, v10))
continue
component_shell = ComponentShell()
component_shell.name = mo_name
ca.component_shells.update({mo_name: component_shell})
elif self.omc.isConnector(mo_type):
connector = Connector()
connector.full_name = mo_type
connector.name = mo_name
connector.description = mo_annotation
ca.connectors.append(connector)
for n in range(1, self.omc.getConnectionCount(modelica_uri) + 1):
src, dst, v3 = self.omc.getNthConnection(modelica_uri, n)
connection = Connection()
src_name, src_parent = self._get_connector_and_parent(src)
dst_name, dst_parent = self._get_connector_and_parent(dst)
try:
if src_parent:
connection.src_parent = src_parent
component_shell = ca.component_shells[src_parent]
assert isinstance(component_shell, ComponentShell)
connector = Connector()
connector.name = src_name
component_shell.connectors.append(connector)
if dst_parent:
connection.dst_parent = dst_parent
component_shell = ca.component_shells[dst_parent]
assert isinstance(component_shell, ComponentShell)
connector = Connector()
connector.name = src_name
component_shell.connectors.append(connector)
except KeyError as err:
self.logger.debug('Skipping connections to {0}'.format(
err.message))
continue
connection.src_name = src_name
connection.dst_name = dst_name
ca.connections.append(connection)
return ca.json()
def _get_connector_and_parent(self, connected):
"""
Get the connection details
"""
pieces = connected.split('.')
parent = ""
if len(pieces) == 2:
parent = pieces[0]
connector = pieces[1]
else:
connector = connected
return connector, parent
class ComponentAssemblyExporter(object):
def __init__(self, external_packages=None, msl_version='3.2'):
self.logger = logging.getLogger('py_modelica_exporter::ComponentExporter')
self.logger.setLevel(logging.DEBUG)
# create console handler with a higher log level
self.logger_console_handler = logging.StreamHandler()
self.logger_console_handler.setLevel(logging.INFO)
# create formatter and add it to the handlers
self.logger_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
self.logger_console_handler.setFormatter(self.logger_formatter)
# add the handlers to the logger
self.logger.addHandler(self.logger_console_handler)
# start om session
self.omc = OMCSession()
# start om session
self.omc = OMCSession()
# load all packages
self.omc.loadModel('Modelica, {{"{0}"}}'.format(msl_version))
self.logger.info('Modelica {0} loaded.'.format(msl_version))
if external_packages:
self.load_external_packages(external_packages)
self.logger.debug('ComponentAssemblyExporter __init__ finished.')
def load_external_packages(self, external_packages):
for package_path in (os.path.abspath(p.strip()).replace("\\", "/") for p in external_packages):
file_name = os.path.basename(package_path)
if file_name == 'package.mo':
package_name = os.path.basename(os.path.dirname(package_path))
else:
package_name, dot_mo = os.path.splitext(file_name)
if self.omc.loadFile(package_path):
self.logger.info('Loaded {0} at {1}'.format(package_name, package_path))
else:
self.logger.error('Failed loading {0} from {1}!'.format(package_name, package_path))
def get_component_assembly_json(self, modelica_uri):
ca = ComponentAssembly()
ca.name = modelica_uri.split('.')[-1]
ca.full_name = modelica_uri
try:
mo_components = self.omc.getComponents(modelica_uri)
except ValueError as ex:
if ex.args[0] == 'Could not parse OMC response.':
raise ParsingException
for (mo_type, mo_name, mo_annotation, mo_modification, v5, v6, v7, isReplaceable, component_type, v10, v11, v12) in mo_components:
if self.omc.isModel(mo_type) or self.omc.isBlock(mo_type):
if v10 in ['inner', 'outer']:
self.logger.debug('Skipping {0} - it is {1}'.format(mo_name, v10))
continue
component_shell = ComponentShell()
component_shell.name = mo_name
ca.component_shells.update({mo_name: component_shell})
elif self.omc.isConnector(mo_type):
connector = Connector()
connector.full_name = mo_type
connector.name = mo_name
connector.description = mo_annotation
ca.connectors.append(connector)
for n in range(1, self.omc.getConnectionCount(modelica_uri) + 1):
src, dst, v3 = self.omc.getNthConnection(modelica_uri, n)
connection = Connection()
src_name, src_parent = self._get_connector_and_parent(src)
dst_name, dst_parent = self._get_connector_and_parent(dst)
try:
if src_parent:
connection.src_parent = src_parent
component_shell = ca.component_shells[src_parent]
assert isinstance(component_shell, ComponentShell)
connector = Connector()
connector.name = src_name
component_shell.connectors.append(connector)
if dst_parent:
connection.dst_parent = dst_parent
component_shell = ca.component_shells[dst_parent]
assert isinstance(component_shell, ComponentShell)
connector = Connector()
connector.name = src_name
component_shell.connectors.append(connector)
except KeyError as err:
self.logger.debug('Skipping connections to {0}'.format(err.message))
continue
connection.src_name = src_name
connection.dst_name = dst_name
ca.connections.append(connection)
return ca.json()
def _get_connector_and_parent(self, connected):
pieces = connected.split('.')
parent = ""
if len(pieces) == 2:
parent = pieces[0]
connector = pieces[1]
else:
connector = connected
return connector, parent
class PackageExporter(object):
def __init__(self, external_packages, load_MSL=True):
self.externalPackagePaths = make_paths_safe_for_omc(external_packages)
self.packageNames = list()
self.failedLoadPackageNames = list()
self.classDetails = list()
self.logger = logging.getLogger('py_modelica_exporter.PackageExporter')
self.logger.setLevel(logging.NOTSET)
self.logger.info('Initializing PackageExporter({0})'.format(self.externalPackagePaths))
self.omc = OMCSession()
self.loadPackages(self.externalPackagePaths, load_MSL=load_MSL)
self.getClassDetails(self.packageNames)
def parseArgument(self, externalPackages):
# this will update self.externalPackagePaths and self.externalPackageNames
for potentialPath in externalPackages:
if os.path.exists(potentialPath):
self.externalPackagePaths.append(potentialPath)
if os.path.basename(potentialPath) == 'package.mo': # check if the file name is 'package.mo'
packageDir = os.path.dirname(potentialPath) # get the path to the last directory
packageName = os.path.basename(packageDir) # get the name of the last directory
self.packageNames.append(packageName) # store that name
else:
file_path, file_extension = os.path.splitext(potentialPath)
if file_extension == '.mo': # make sure it is a '.mo' file
packageName = os.path.basename(file_path) # get the name of the file
self.packageNames.append(packageName) # store that name
else:
pass # should log that this package path is invalid?
def loadPackages(self, external_package_paths, load_MSL=True):
if load_MSL:
if self.omc.loadModel('Modelica') == True:
comment = self.omc.getClassComment('Modelica')
import re
modelica_version_pattern = '.*Version ([\d\.]*)'
regex_modelica_version = re.findall(modelica_version_pattern, comment)
if regex_modelica_version[0]:
self.packageNames.append('Modelica ' + regex_modelica_version[0])
else:
self.packageNames.append('Modelica')
for package_path in external_package_paths:
if os.path.isfile(package_path) == True: # make sure the file exists
if os.path.basename(package_path) == 'package.mo': # check if the file name is 'package.mo'
package_dir = os.path.dirname(package_path) # get the path to the last directory
package_name = os.path.basename(package_dir) # get the name of the last directory (package_name)
if self.omc.loadFile(package_path) == True: # try to load the package file
self.packageNames.append(package_name) # log successful load
self.logger.info('Library loaded from : {0}'.format(package_path))
else:
self.failedLoadPackageNames.append("FAILED_" + package_name) # log failure
self.logger.warning('Failed to load: {0}'.format(package_path))
else:
file_path, file_extension = os.path.splitext(package_path)
if file_extension == '.mo': # make sure it is a '.mo' file
package_name = os.path.basename(file_path) # get the name of the file
if self.omc.loadFile(package_path) == True: # try to load the package file
self.packageNames.append(package_name) # log successful load
self.logger.info('Library loaded from : {0}'.format(package_path))
else:
self.failedLoadPackageNames.append("FAILED_" + package_name) # log failure
self.logger.warning('Failed to load: {0}'.format(package_path))
else:
file_path, file_extension = os.path.splitext(package_path)
if file_extension == '.mo': # make sure it is a '.mo' file
package_name = os.path.basename(file_path) # get the name of the file
if package_name == 'package':
package_name = os.path.basename(os.path.dirname(file_path))
self.failedLoadPackageNames.append(package_name)
self.logger.warning('Failed to load: {0}'.format(package_path))
def getClassDetails(self, packageNames):
for packageName in packageNames:
if 'Modelica' in packageName:
classNames = self.omc.getClassNames('Modelica', recursive=True, sort=True)
else:
classNames = self.omc.getClassNames(packageName, recursive=True, sort=True)
for c_name in classNames:
if (self.omc.isModel(c_name)) or (self.omc.isBlock(c_name)): # only blocks and models are exported
class_details = dict()
class_details['ComponentName'] = c_name
class_details['Description'] = self.omc.getClassComment(c_name)
self.classDetails.append(class_details)
def json(self):
json_result = dict()
json_result['topLevelPackages'] = self.packageNames + self.failedLoadPackageNames
json_result['classDetails'] = self.classDetails
return json_result
def exportToJson(self, filename):
json_result = self.json()
with open(filename, 'w') as f_p:
json.dump(json_result, f_p, indent=4)
return json_result
class LayoutExporter(object):
def __init__(self, external_packages=None):
self.external_package_paths = make_paths_safe_for_omc(
external_packages)
self.logger = logging.getLogger('py_modelica_exporter.LayoutExporter')
self.logger.setLevel(logging.NOTSET)
self.logger.info(
'Initializing LayoutExporter({0})'.format(external_packages))
# start om session
self.omc = OMCSession()
# load all packages
self.load_packages(self.external_package_paths)
def load_packages(self, external_package_paths):
self.omc.loadModel('Modelica')
for package_path in external_package_paths:
if os.path.isfile(package_path): # make sure the file exists
if self.omc.loadFile(
package_path): # try to load the package file
self.logger.info(
'Library loaded from : {0}'.format(package_path))
else:
self.logger.warning(
'Failed to load: {0}'.format(package_path))
else:
self.logger.warning(
'File does not exist! Failed to load: {0}'.format(
package_path))
def get_nth_comp_location(self, modelica_uri, n):
x_origin = 0
y_origin = 0
x_extent = 0
y_extent = 0
rotation = 0
flip_x = False
flip_y = False
# get the annotation info for Nth component (index begins at 1)
try:
nth_component_annotation = self.omc.getNthComponentAnnotation(
modelica_uri, n)
x_1 = nth_component_annotation[3]
x_2 = nth_component_annotation[5]
if x_1 > x_2:
flip_x = True
y_1 = nth_component_annotation[4]
y_2 = nth_component_annotation[6]
if y_1 > y_2:
flip_y = True
x_extent = abs(x_2 - x_1)
y_extent = abs(y_2 - y_1)
x_origin = nth_component_annotation[1]
y_origin = nth_component_annotation[2]
if x_origin == 0:
x_origin = (x_1 + x_2) / 2
if y_origin == 0:
y_origin = (y_1 + y_2) / 2
rotation = nth_component_annotation[7]
except:
self.logger.warning(
'Could not get annotation for Nth component of {0}, N = {1}'.
format(modelica_uri, n))
return x_origin, y_origin, x_extent, y_extent, rotation, flip_x, flip_y
def extract_assembly_layout(self, modelica_uri, assembly=None):
if not assembly:
assembly = ComponentAssembly()
assembly.full_name = modelica_uri
assembly.name = modelica_uri.split('.')[-1]
try:
mo_components = self.omc.getComponents(modelica_uri)
except ValueError as value_error_exception:
if value_error_exception.args[
0] == 'Could not parse OMC response.':
self.logger.warning(
'Could not parse OMC response for getComponents({0})'.
format(modelica_uri))
raise ParsingException
for n in range(1, len(mo_components) + 1):
nth_component_info = self.omc.getNthComponent(modelica_uri, n)
x_origin, y_origin, x_extent, y_extent, rotation, flip_x, flip_y = self.get_nth_comp_location(
modelica_uri, n)
if x_origin - 0.5 * x_extent < assembly.extent['x_min']:
assembly.extent['x_min'] = x_origin - 0.5 * x_extent
if x_origin + 0.5 * x_extent > assembly.extent['x_max']:
assembly.extent['x_max'] = x_origin + 0.5 * x_extent
if y_origin - 0.5 * y_extent < assembly.extent['y_min']:
assembly.extent['y_min'] = y_origin - 0.5 * y_extent
if y_origin + 0.5 * y_extent > assembly.extent['y_max']:
assembly.extent['y_max'] = y_origin + 0.5 * y_extent
mo_type = nth_component_info[0]
if self.omc.isConnector(mo_type):
#connector = Connector()
connector = ComponentShell()
connector.full_name = mo_type
connector.name = nth_component_info[1]
connector.description = nth_component_info[2]
#connector.relative_position['x'] = x_origin
#connector.relative_position['y'] = y_origin
connector.position['x'] = x_origin
connector.position['y'] = y_origin
connector.size['width'] = x_extent
connector.size['height'] = y_extent
#assembly.connectors.append(connector)
assembly.component_shells[connector.name] = connector
# We should only get 'internal' models within assemblies
if self.omc.isModel(mo_type) or self.omc.isBlock(mo_type):
comp_shell = ComponentShell()
comp_shell.full_name = mo_type
comp_shell.name = nth_component_info[1]
comp_shell.description = nth_component_info[2]
comp_shell.position['x'] = x_origin
comp_shell.position['y'] = y_origin
comp_shell.size['width'] = x_extent
comp_shell.size['height'] = y_extent
comp_shell.rotation = rotation
comp_shell.flip_x = flip_x
comp_shell.flip_y = flip_y
comp_shell = self.extract_comp_shell_layout(
mo_type, comp_shell)
assembly.component_shells[comp_shell.name] = comp_shell
# Get internal connections
for n in range(1, self.omc.getConnectionCount(modelica_uri) + 1):
src, dst, v3 = self.omc.getNthConnection(modelica_uri, n)
src_name, src_parent = self._get_connector_and_parent(src)
dst_name, dst_parent = self._get_connector_and_parent(dst)
connection = Connection()
if src_name:
connection.src_name = src_name
if src_parent:
connection.src_parent = src_parent
if dst_name:
connection.dst_name = dst_name
if dst_parent:
connection.dst_parent = dst_parent
connection.path_points = self.omc.getNthConnectionPathPoints(
modelica_uri, n)
assembly.connections.append(connection)
# Get inherited members
mo_inheritance_count = self.omc.getInheritanceCount(modelica_uri)
for i in range(1, mo_inheritance_count + 1):
mo_extend_class_name = self.omc.getNthInheritedClass(
modelica_uri, i)
assembly = self.extract_assembly_layout(mo_extend_class_name,
assembly)
return assembly
def extract_comp_shell_layout(self, modelica_uri, comp_shell):
try:
mo_components = self.omc.getComponents(modelica_uri)
except ValueError as value_error_exception:
if value_error_exception.args[
0] == 'Could not parse OMC response.':
self.logger.warning(
'Could not parse OMC response for getComponents({0})'.
format(modelica_uri))
raise ParsingException
for n in range(1, len(mo_components) + 1):
nth_component_info = self.omc.getNthComponent(modelica_uri, n)
x_origin, y_origin, x_extent, y_extent, rotation, flip_x, flip_y = self.get_nth_comp_location(
modelica_uri, n)
mo_type = nth_component_info[0]
if self.omc.isConnector(mo_type):
connector = Connector()
connector.full_name = mo_type
connector.name = nth_component_info[1]
connector.description = nth_component_info[2]
connector.relative_position['x'] = x_origin
connector.relative_position['y'] = y_origin
connector.size['width'] = x_extent
connector.size['height'] = y_extent
comp_shell.connectors.append(connector)
# Get inherited members
mo_inheritance_count = self.omc.getInheritanceCount(modelica_uri)
for i in range(1, mo_inheritance_count + 1):
mo_extend_class_name = self.omc.getNthInheritedClass(
modelica_uri, i)
comp_shell = self.extract_comp_shell_layout(
mo_extend_class_name, comp_shell)
return comp_shell
def scale_layout_for_webgme(self, assembly_layout, scale=5):
if isinstance(assembly_layout, ComponentAssembly):
x_offset = abs(assembly_layout.extent['x_min']) + 10
y_offset = abs(assembly_layout.extent['y_max']) + 10
for name, comp_shell in assembly_layout.component_shells.iteritems(
):
left_edge = comp_shell.position[
'x'] - 0.5 * comp_shell.size['width']
top_edge = comp_shell.position[
'y'] + 0.5 * comp_shell.size['height']
comp_shell.position['x'] = scale * (left_edge + x_offset)
comp_shell.position['y'] = scale * (y_offset - top_edge)
comp_shell.size['width'] *= scale
comp_shell.size['height'] *= scale
for connector in comp_shell.connectors:
rel_x = connector.relative_position['x']
rel_y = connector.relative_position['y']
# handle rotations, so port relative positions are correct
if comp_shell.rotation != 0:
import math
cos_theta = math.cos(comp_shell.rotation * math.pi /
180)
sin_theta = math.sin(comp_shell.rotation * math.pi /
180)
x_theta = rel_x * cos_theta - rel_y * sin_theta
y_theta = rel_x * sin_theta + rel_y * cos_theta
rel_x = x_theta
rel_y = y_theta
if comp_shell.flip_x:
rel_x = -rel_x
if comp_shell.flip_y:
rel_y = -rel_y
connector.relative_position['x'] = (
(rel_x + 100) / 200) * comp_shell.size['width']
connector.relative_position['y'] = (
1 - (rel_y + 100) / 200) * comp_shell.size['height']
for connector in assembly_layout.connectors:
connector.relative_position['x'] = scale * (
connector.relative_position['x'] + x_offset)
connector.relative_position['y'] = scale * (
-connector.relative_position['y'] + y_offset)
for connection in assembly_layout.connections:
for pp in connection.path_points:
pp['x'] = scale * (pp['x'] + x_offset)
pp['y'] = scale * (-pp['y'] + y_offset)
# first_path_point = connection.path_points[0]
# last_path_point = connection.path_points[-1]
#
# connection.path_points = list()
# connection.path_points.append(first_path_point)
# connection.path_points.append(last_path_point)
def test_omc_get_components(self, modelica_uri):
with open('omcTest.txt', 'w') as f_out:
components = self.omc.getComponents(modelica_uri)
n = 0
for tu in components:
msg = '{0}: {1} (index in getComponents)\r'.format(
components.index(tu), tu)
f_out.write(msg)
n = n + 1
nthComponentInfo = self.omc.getNthComponent(modelica_uri, n)
msg = '{0}: {1} (getNthComponent)\r'.format(
n, nthComponentInfo)
f_out.write(msg)
def _get_connector_and_parent(self, connected):
pieces = connected.split('.')
parent = ""
if len(pieces) == 2:
parent = pieces[0]
connector = pieces[1]
else:
connector = connected
return connector, parent
class PackageExporter(object):
def __init__(self, external_packages, load_MSL=True):
self.externalPackagePaths = make_paths_safe_for_omc(external_packages)
self.packageNames = list()
self.failedLoadPackageNames = list()
self.classDetails = list()
self.logger = logging.getLogger('py_modelica_exporter.PackageExporter')
self.logger.setLevel(logging.NOTSET)
self.logger.info('Initializing PackageExporter({0})'.format(
self.externalPackagePaths))
self.omc = OMCSession()
self.loadPackages(self.externalPackagePaths, load_MSL=load_MSL)
self.getClassDetails(self.packageNames)
def parseArgument(self, externalPackages):
# this will update self.externalPackagePaths and self.externalPackageNames
for potentialPath in externalPackages:
if os.path.exists(potentialPath):
self.externalPackagePaths.append(potentialPath)
if os.path.basename(
potentialPath
) == 'package.mo': # check if the file name is 'package.mo'
packageDir = os.path.dirname(
potentialPath) # get the path to the last directory
packageName = os.path.basename(
packageDir) # get the name of the last directory
self.packageNames.append(packageName) # store that name
else:
file_path, file_extension = os.path.splitext(potentialPath)
if file_extension == '.mo': # make sure it is a '.mo' file
packageName = os.path.basename(
file_path) # get the name of the file
self.packageNames.append(
packageName) # store that name
else:
pass # should log that this package path is invalid?
def loadPackages(self, external_package_paths, load_MSL=True):
if load_MSL:
if self.omc.loadModel('Modelica') == True:
comment = self.omc.getClassComment('Modelica')
import re
modelica_version_pattern = '.*Version ([\d\.]*)'
regex_modelica_version = re.findall(modelica_version_pattern,
comment)
if regex_modelica_version[0]:
self.packageNames.append('Modelica ' +
regex_modelica_version[0])
else:
self.packageNames.append('Modelica')
for package_path in external_package_paths:
if os.path.isfile(
package_path) == True: # make sure the file exists
if os.path.basename(
package_path
) == 'package.mo': # check if the file name is 'package.mo'
package_dir = os.path.dirname(
package_path) # get the path to the last directory
package_name = os.path.basename(
package_dir
) # get the name of the last directory (package_name)
if self.omc.loadFile(
package_path
) == True: # try to load the package file
self.packageNames.append(
package_name) # log successful load
self.logger.info(
'Library loaded from : {0}'.format(package_path))
else:
self.failedLoadPackageNames.append(
"FAILED_" + package_name) # log failure
self.logger.warning(
'Failed to load: {0}'.format(package_path))
else:
file_path, file_extension = os.path.splitext(package_path)
if file_extension == '.mo': # make sure it is a '.mo' file
package_name = os.path.basename(
file_path) # get the name of the file
if self.omc.loadFile(
package_path
) == True: # try to load the package file
self.packageNames.append(
package_name) # log successful load
self.logger.info(
'Library loaded from : {0}'.format(
package_path))
else:
self.failedLoadPackageNames.append(
"FAILED_" + package_name) # log failure
self.logger.warning(
'Failed to load: {0}'.format(package_path))
else:
file_path, file_extension = os.path.splitext(package_path)
if file_extension == '.mo': # make sure it is a '.mo' file
package_name = os.path.basename(
file_path) # get the name of the file
if package_name == 'package':
package_name = os.path.basename(
os.path.dirname(file_path))
self.failedLoadPackageNames.append(package_name)
self.logger.warning(
'Failed to load: {0}'.format(package_path))
def getClassDetails(self, packageNames):
for packageName in packageNames:
if 'Modelica' in packageName:
classNames = self.omc.getClassNames('Modelica',
recursive=True,
sort=True)
else:
classNames = self.omc.getClassNames(packageName,
recursive=True,
sort=True)
for c_name in classNames:
if (self.omc.isModel(c_name)) or (self.omc.isBlock(
c_name)): # only blocks and models are exported
class_details = dict()
class_details['ComponentName'] = c_name
class_details['Description'] = self.omc.getClassComment(
c_name)
self.classDetails.append(class_details)
def json(self):
json_result = dict()
json_result[
'topLevelPackages'] = self.packageNames + self.failedLoadPackageNames
json_result['classDetails'] = self.classDetails
return json_result
def exportToJson(self, filename):
json_result = self.json()
with open(filename, 'w') as f_p:
json.dump(json_result, f_p, indent=4)
return json_result
