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 main():
parser = argparse.ArgumentParser()
parser.add_argument("-l", "--library", help="External library to load.")
parser.add_argument("-p", "--package", help="Package name to parse like: Modelica.SIunits",
default="Modelica.SIunits")
args = parser.parse_args()
omc = OMCSession()
print "Loading Modelica library ..."
success = omc.loadModel('Modelica')
if success:
print "[OK]"
else:
print "[FAILED]"
return
if args.library:
print "Loading External library {0} ...".format(args.library)
cwd = os.getcwd()
dir_name = os.path.dirname(args.library)
os.chdir(dir_name)
success = success and omc.loadFile(args.library)
os.chdir(cwd)
if success:
print "[OK]"
else:
print "[FAILED]"
if success:
print "Getting all class names for package: {0}".format(args.package)
modelica_classes = omc.getClassNames(args.package, recursive=True, qualified=True, sort=True)
#print modelica_classes
result = []
for modelica_class in modelica_classes:
info = {}
info['name'] = modelica_class
class_restriction = omc.getClassRestriction(modelica_class)
info['class'] = class_restriction
#info['text'] = omc.list(modelica_class)
info['modifiers'] = {}
print modelica_class
modifiers = omc.getDerivedClassModifierNames(modelica_class)
for modifier in modifiers:
modifier_value = omc.getDerivedClassModifierValue(modelica_class, modifier)
# ' = "value"' => 'value'
modifier_value = modifier_value[3:].strip('"')
info['modifiers'][modifier] = modifier_value
getBaseClassModifiers(omc, modelica_class, info['modifiers'])
result.append(info)
output_filename = 'modelica_units.json'
with open(output_filename, 'w') as f_p:
json.dump(result, f_p)
print 'File was generated: {0}'.format(output_filename)
def __init__(self,
external_packages=None,
export_icons=False,
msl_version='3.2'):
"""
Creates a new instance of ComponentExporter. Opens up a OMCSession and loads
all necessary Modelica packages.
"""
self.external_package_paths = make_paths_safe_for_omc(
external_packages)
self.logger = logging.getLogger(
'py_modelica_exporter.ComponentExporter')
self.logger.setLevel(logging.NOTSET)
self.logger.info(
'Initializing ComponentExporter({0})'.format(external_packages))
# start om session
self.omc = OMCSession()
# load all packages
self.load_packages(self.external_package_paths)
self.export_icons = export_icons
if self.export_icons:
icon_dir_name = 'Icons'
if not os.path.isdir(icon_dir_name):
os.mkdir(icon_dir_name)
self.icon_exporter = IconExporter(self.omc, icon_dir_name)
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 __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 __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 __init__(self, external_packages, load_msl=True):
"""
Create an instance of the PackageExporter
"""
self.external_package_paths = make_paths_safe_for_omc(
external_packages)
self.package_names = list()
self.failed_load_package_names = list()
self.class_details = list()
self.logger = logging.getLogger('py_modelica_exporter.PackageExporter')
self.logger.setLevel(logging.NOTSET)
self.logger.info('Initializing PackageExporter({0})'.format(
self.external_package_paths))
self.omc = OMCSession()
self.load_packages(self.external_package_paths, load_msl=load_msl)
self.get_class_details(self.package_names)
def __init__(self, class_name):
"""
creates an instance of TreeExporter
"""
self.class_names = list()
self.class_names.append(class_name)
self.class_details = list()
self.logger = logging.getLogger('py_modelica_exporter.TreeExporter')
self.logger.setLevel(logging.NOTSET)
self.logger.info('Initializing TreeExporter({0})'.format(class_name))
self.omc = OMCSession()
# load all packages
success = self.omc.loadModel('Modelica')
self.parse_tree(class_name)