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)
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 PackageExporter(object): """ Class PackageExporter is an interface with the OpenModelicaCompiler to facilitate extraction of all classes contained within 'external_packages' (and the MSL) """ 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 parse_argument(self, external_packages): """ This will update self.external_package_paths and self.package_names """ for potential_path in external_packages: if os.path.exists(potential_path): self.external_package_paths.append(potential_path) if os.path.basename( potential_path ) == 'package.mo': # check if the file name is 'package.mo' package_dir = os.path.dirname( potential_path) # get the path to the last directory package_name = os.path.basename( package_dir) # get the name of the last directory self.package_names.append(package_name) # store that name else: file_path, file_extension = os.path.splitext( potential_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 self.package_names.append( package_name) # store that name # else: # pass # should log that this package path is invalid? def load_packages(self, external_package_paths, load_msl=True): """ load all the external packages using OpenModelicaCompiler """ if load_msl: if self.omc.loadModel('Modelica'): 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.package_names.append('Modelica ' + regex_modelica_version[0]) else: self.package_names.append('Modelica') for package_path in external_package_paths: if os.path.isfile(package_path): # 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): # try to load the package file self.package_names.append( package_name) # log successful load self.logger.info( 'Library loaded from : {0}'.format(package_path)) else: self.failed_load_package_names.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): # try to load the package file self.package_names.append( package_name) # log successful load self.logger.info( 'Library loaded from : {0}'.format( package_path)) else: self.failed_load_package_names.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.failed_load_package_names.append(package_name) self.logger.warning( 'Failed to load: {0}'.format(package_path)) def get_class_details(self, package_names): """ Get the class details and write out a json file """ for package_name in package_names: get_comments = False # self.omc.getClassNames randomly (?) takes a long time to execute if 'Modelica' in package_name: class_names = self.omc.getClassNames('Modelica', recursive=True, sort=True) # get_comments = True # blacklist = ['.Utilities.', # '.UsersGuide.', # '.Examples.', # '.UnitConversions.', # '.Media.'] # for c_name in class_names: # # skip_it = False # # for bad_name in blacklist: # # if bad_name in c_name: # # skip_it = True # # self.logger.info(c_name + " is black-listed (not a model or block)") # # break # # if skip_it: # # continue # # class_details = dict() # class_details['ComponentName'] = c_name # class_details['Description'] = "" # self.omc.getClassComment(c_name) # self.class_details.append(class_details) else: class_names = self.omc.getClassNames(package_name, recursive=True, sort=True) # get_comments = True for c_name in class_names: class_details = dict() class_details['ComponentName'] = c_name if get_comments: class_details['Description'] = self.omc.getClassComment( c_name) else: class_details['Description'] = "None available" self.class_details.append(class_details) # model_type = self.omc.getClassRestriction(c_name) # if model_type in ['model', 'block']: # # 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.class_details.append(class_details) def json(self): """ Generate a dictionary from the Packages """ json_result = dict() json_result[ 'topLevelPackages'] = self.package_names + self.failed_load_package_names json_result['classDetails'] = self.class_details return json_result def export_to_json(self, filename): """ Write a json file of the Packages """ json_result = self.json() with open(filename, 'w') as f_p: json.dump(json_result, f_p, indent=4) return json_result
class TreeExporter(object): """ Class TreeExporter is an interface with the OpenModelicaCompiler to facilitate extraction of all contained classes """ 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) def parse_tree(self, class_name): """ gets all classes from within 'class_name' """ class_names = self.omc.getClassNames(class_name, recursive=True, sort=True) # filter and export only blocks and models for c_name in class_names: # if (self.omc.isModel(c_name)) or (self.omc.isBlock(c_name)): class_details = dict() class_details['ComponentName'] = c_name class_details[ 'Description'] = "None available" # self.omc.getClassComment(c_name) self.class_details.append(class_details) def json(self): """ Creates a dictionary from of all the classes contained in the Tree """ json_result = dict() json_result['topLevelPackages'] = self.class_names json_result['classDetails'] = self.class_details return json_result def xml(self): raise NotImplementedError def export_to_json(self, filename): """ Write out a json representation of the Tree """ 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 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 PackageExporter(object): """ Class PackageExporter is an interface with the OpenModelicaCompiler to facilitate extraction of all classes contained within 'external_packages' (and the MSL) """ 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 parse_argument(self, external_packages): """ This will update self.external_package_paths and self.package_names """ for potential_path in external_packages: if os.path.exists(potential_path): self.external_package_paths.append(potential_path) if os.path.basename(potential_path) == 'package.mo': # check if the file name is 'package.mo' package_dir = os.path.dirname(potential_path) # get the path to the last directory package_name = os.path.basename(package_dir) # get the name of the last directory self.package_names.append(package_name) # store that name else: file_path, file_extension = os.path.splitext(potential_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 self.package_names.append(package_name) # store that name # else: # pass # should log that this package path is invalid? def load_packages(self, external_package_paths, load_msl=True): """ load all the external packages using OpenModelicaCompiler """ if load_msl: if self.omc.loadModel('Modelica'): 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.package_names.append('Modelica ' + regex_modelica_version[0]) else: self.package_names.append('Modelica') for package_path in external_package_paths: if os.path.isfile(package_path): # 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): # try to load the package file self.package_names.append(package_name) # log successful load self.logger.info('Library loaded from : {0}'.format(package_path)) else: self.failed_load_package_names.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): # try to load the package file self.package_names.append(package_name) # log successful load self.logger.info('Library loaded from : {0}'.format(package_path)) else: self.failed_load_package_names.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.failed_load_package_names.append(package_name) self.logger.warning('Failed to load: {0}'.format(package_path)) def get_class_details(self, package_names): """ Get the class details and write out a json file """ for package_name in package_names: get_comments = False # self.omc.getClassNames randomly (?) takes a long time to execute if 'Modelica' in package_name: class_names = self.omc.getClassNames('Modelica', recursive=True, sort=True) # get_comments = True # blacklist = ['.Utilities.', # '.UsersGuide.', # '.Examples.', # '.UnitConversions.', # '.Media.'] # for c_name in class_names: # # skip_it = False # # for bad_name in blacklist: # # if bad_name in c_name: # # skip_it = True # # self.logger.info(c_name + " is black-listed (not a model or block)") # # break # # if skip_it: # # continue # # class_details = dict() # class_details['ComponentName'] = c_name # class_details['Description'] = "" # self.omc.getClassComment(c_name) # self.class_details.append(class_details) else: class_names = self.omc.getClassNames(package_name, recursive=True, sort=True) # get_comments = True for c_name in class_names: class_details = dict() class_details['ComponentName'] = c_name if get_comments: class_details['Description'] = self.omc.getClassComment(c_name) else: class_details['Description'] = "None available" self.class_details.append(class_details) # model_type = self.omc.getClassRestriction(c_name) # if model_type in ['model', 'block']: # # 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.class_details.append(class_details) def json(self): """ Generate a dictionary from the Packages """ json_result = dict() json_result['topLevelPackages'] = self.package_names + self.failed_load_package_names json_result['classDetails'] = self.class_details return json_result def export_to_json(self, filename): """ Write a json file of the Packages """ json_result = self.json() with open(filename, 'w') as f_p: json.dump(json_result, f_p, indent=4) return json_result
class TreeExporter(object): """ Class TreeExporter is an interface with the OpenModelicaCompiler to facilitate extraction of all contained classes """ 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) def parse_tree(self, class_name): """ gets all classes from within 'class_name' """ class_names = self.omc.getClassNames(class_name, recursive=True, sort=True) # filter and export only blocks and models for c_name in class_names: # if (self.omc.isModel(c_name)) or (self.omc.isBlock(c_name)): class_details = dict() class_details['ComponentName'] = c_name class_details['Description'] = "None available" # self.omc.getClassComment(c_name) self.class_details.append(class_details) def json(self): """ Creates a dictionary from of all the classes contained in the Tree """ json_result = dict() json_result['topLevelPackages'] = self.class_names json_result['classDetails'] = self.class_details return json_result def xml(self): raise NotImplementedError def export_to_json(self, filename): """ Write out a json representation of the Tree """ 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 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