Esempio n. 1
0
    def preprocess_clif_file(self):
        # add the standard ending for CLIF files to the module name
        self.clif_file_name = filemgt.get_full_path(self.module_name,
                                                    ending=filemgt.read_config(
                                                        'cl', 'ending'))
        #print self.clif_file_name

        self.clif_processed_file_name = filemgt.get_full_path(
            self.module_name,
            folder=filemgt.read_config('converters', 'tempfolder'),
            ending=filemgt.read_config('cl', 'ending'))

        logging.getLogger(__name__).debug("Clif file name = " +
                                          self.clif_file_name)
        logging.getLogger(__name__).debug("Clif preprocessed file name = " +
                                          self.clif_processed_file_name)

        clif.remove_all_comments(self.clif_file_name,
                                 self.clif_processed_file_name)

        self.imports = clif.get_imports(self.clif_processed_file_name)

        logging.getLogger(__name__).debug("imports detected in " +
                                          self.module_name + ": " +
                                          str(self.imports))

        self.nonlogical_symbols = clif.get_all_nonlogical_symbols(
            self.clif_processed_file_name)
Esempio n. 2
0
def convert_single_clif_file(ontology,
                             output,
                             resolve,
                             loc=default_dir,
                             prefix=default_prefix):

    logging.getLogger(__name__).info("Converting " + ontology.name + " to " +
                                     output + " format")

    if (output == tptp_output):
        results = ontology.to_tptp(resolve)
    elif (output == ladr_output):
        results = ontology.to_ladr(resolve)

    # the following assumes that the names of the configuration sections are the same as the names of the output (tptp/ladr)
    if resolve:
        ending = Filemgt.read_config(output, 'all_ending')
    else:
        ending = ""

    ending = ending + Filemgt.read_config(output, 'ending')

    output_file_name = Filemgt.get_full_path(ontology.name,
                                             folder=Filemgt.read_config(
                                                 'tptp', 'folder'),
                                             ending=ending)
    #ontology.get_all_modules()

    with open(output_file_name, "w") as f:
        for sentence in results:
            print(sentence)
            f.write(sentence + "\n")
        f.close()

    return output_file_name
Esempio n. 3
0
    def run(self):
        # We need to capture the print statements from the parser
        backup = sys.stdout
        sys.stdout = self.error

        # Create a place to read the text from
        buffer = tempfile.mkstemp(".macleod")
        with open(buffer[1], 'w') as f:
            f.write(self.text)

        try:
            self.ontology = Parser.parse_file(buffer[1],
                                              filemgt.read_config('cl', 'prefix'),
                                              os.path.abspath(filemgt.read_config('system', 'path')),
                                              self.resolve,
                                              self.path)

        except Exception as e:
            print(e)
            # If it's not a CL error we need to find the problem in Python
            if not isinstance(e, TypeError):
                # This prints to the Python console, not to the console in the window
                traceback.print_exc()
            self.ontology = None

        # return to the previous output
        sys.stdout = backup

        # leave no trace of the buffer
        os.close(buffer[0])
        os.remove(buffer[1])
Esempio n. 4
0
def get_lemma_files_from_sentences(lemmas_name, sentences):

    sentences_files = []
    sentences_names = []

    import math
    # determine maximal number of digits
    digits = int(math.ceil(math.log10(len(sentences))))

    i = 1

    for lemma in sentences:
        name = lemmas_name + '_goal' + ('{0:0' + str(digits) + 'd}').format(i)

        filename = filemgt.get_full_path(
            name,
            folder=filemgt.read_config('ladr', 'folder'),
            ending=filemgt.read_config('ladr', 'ending'))
        output_file = open(filename, 'w')
        output_file.write('formulas(goals).\n')
        output_file.write(lemma + '\n')
        output_file.write('end_of_list.\n')
        output_file.close()
        sentences_files.append(filename)
        sentences_names.append(name)
        i += 1

    return (sentences_names, sentences_files)
Esempio n. 5
0
 def get_p9_file_name(self):
     """get the filename of the LADR translation of the module and translate the ClifModule if not yet done so."""
     if not self.p9_file_name:  # do the translation
         self.p9_file_name = filemgt.get_full_path(
             self.module_name,
             folder=filemgt.read_config('ladr', 'folder'),
             ending=filemgt.read_config('ladr', 'ending'))
         self.get_translated_file(self.p9_file_name, "LADR")
         logging.getLogger(__name__).info("CREATED LADR TRANSLATION: " +
                                          self.p9_file_name)
     return self.p9_file_name
Esempio n. 6
0
    def get_tptp_file_name(self):
        """get the filename of the TPTP translation of the module and translate the ClifModule if not yet done so.
        This version does not rely on the clif to ladr translation, but does a direct translation."""

        if not self.tptp_file_name:
            self.tptp_file_name = filemgt.get_full_path(
                self.module_name,
                folder=filemgt.read_config('tptp', 'folder'),
                ending=filemgt.read_config('tptp', 'ending'))

            self.get_translated_file(self.tptp_file_name, "TPTP")
            logging.getLogger(__name__).info("CREATED TPTP TRANSLATION: " +
                                             self.tptp_file_name)
        return self.tptp_file_name
Esempio n. 7
0
def get_p9_cmd(imports, output_stem, option_files=None):
    """get a formatted command to run Prover9 with options (timeout, etc.) set in the class instance."""

    args = []
    args.append(filemgt.read_config('prover9', 'command'))
    args.append('-t' + filemgt.read_config('prover9', 'timeout'))
    args.append('-f')
    # append all ladr input files
    for m in imports:
        args.append(m.get_p9_file_name())
    if option_files:
        for f in option_files:
            args.append(f)

    return (args, [])
Esempio n. 8
0
def get_paradox_cmd(imports, output_stem):
    """ we only care about the first element in the list of imports, which will we use as base name to obtain a single tptp file of the imports,
    which is the input for paradox."""
    args = []
    args.append(filemgt.read_config('paradox', 'command'))
    args.append('--time')
    args.append(filemgt.read_config('paradox', 'timeout'))
    args.append('--verbose')
    args.append('2')
    args.append('--model')
    args.append('--tstp')
    # append all tptp input files
    args.append(
        list(imports)[0].get_module_set(imports).get_single_tptp_file(imports))

    return (args, [])
Esempio n. 9
0
def get_m4_cmd(imports, output_stem):
    """get a formatted command to run Mace4 with options (timeout, etc.) set in the class instance."""

    args = []
    args.append(filemgt.read_config('mace4', 'command'))
    args.append('-v0')
    args.append('-t' + filemgt.read_config('mace4', 'timeout'))
    args.append('-s' + filemgt.read_config('mace4', 'timeout_per'))
    args.append('-n' + filemgt.read_config('mace4', 'start_size'))
    args.append('-N' + filemgt.read_config('mace4', 'end_size'))
    args.append('-f')
    # append all ladr input files
    for m in imports:
        args.append(m.get_p9_file_name())

    return (args, [])
Esempio n. 10
0
    def __init__(self, name, reasoner_type=None, reasoner_id=None):

        logging.getLogger(__name__).debug('Initializing ' + name)

        self.identifier = ''

        self.type = Reasoner.PROVER

        self.args = []

        self.modules = []

        self.input_files = ''

        self.output_file = ''

        self.ontology = ''

        self.time = -1

        self.output = None

        self.name = name
        if reasoner_type:
            self.type = reasoner_type
        if reasoner_id:
            self.identifier = reasoner_id
        else:
            self.identifier = name

        self.timeout = Filemgt.read_config(self.name, 'timeout')

        logging.getLogger(__name__).debug('Finished initializing ' + name)
Esempio n. 11
0
def get_p9_empty_optionsfile(p9_file_name, verbose=True):

    # currently one option file for all!!
    #print 'OPTIONS FILE - P9 file name = ' + p9_file_name
    options_file_name = os.path.join(
        os.path.dirname(p9_file_name),
        os.path.splitext(os.path.basename(p9_file_name))[0] +
        filemgt.read_config('prover9', 'options_ending'))

    #print 'OPTIONS FILE = ' + options_file_name

    ladr.options_files.append(options_file_name)

    if os.path.isfile(options_file_name):
        return options_file_name
    else:
        #    options_file_name = module_p9_file + '.options'
        options_file = open(options_file_name, 'w')
        options_file.write('clear(auto_denials).\n')
        if not verbose:
            options_file.write('clear(print_initial_clauses).\n')
            options_file.write('clear(print_kept).\n')
            options_file.write('clear(print_given).\n')
            #options_file.write('set(quiet).')
        options_file.close()
        return options_file_name
Esempio n. 12
0
def convert_folder(folder, args):

    tempfolder = Filemgt.read_config('converters', 'tempfolder')
    ignores = [tempfolder]
    cl_ending = Filemgt.read_config('cl', 'ending')
    #logging.getLogger(__name__).info("Traversing folder " + folder)

    for directory, subdirs, files in os.walk(folder):
        if any(ignore in directory for ignore in ignores):
            pass
        else:
            for single_file in files:
                if single_file.endswith(cl_ending):
                    file = os.path.join(directory, single_file)
                    logging.getLogger(__name__).info("Parsing CLIF file " + file)
                    convert_file(file, args=args)
Esempio n. 13
0
def get_output_filename(ontology, resolve, output_type):

    # the following assumes that the names of the configuration sections
    # are the same as the names of the output (tptp/ladr/owl)
    if resolve:
        ending = Filemgt.read_config(output_type, 'all_ending')
    else:
        ending = ""

    ending = ending + Filemgt.read_config(output_type, 'ending')

    output_filename = Filemgt.get_full_path(ontology.name,
                                           folder=Filemgt.read_config(output_type,'folder'),
                                           ending=ending)

    return output_filename
Esempio n. 14
0
    def __init__(self, parent=None):
        super(MacleodSettings, self).__init__(parent)
        self.resize(WINDOW_WIDTH, WINDOW_HEIGHT)
        self.setWindowTitle("Macleod Settings")
        root_dir_path = filemgt.read_config('system', 'path')
        sp = QSizePolicy()
        sp.setHorizontalPolicy(QSizePolicy.Expanding)
        sp.setVerticalPolicy(QSizePolicy.Expanding)
        self.setSizePolicy(sp)

        # root directory settings
        root_dir_label = QLabel("Project Root Directory")

        self.root_dir_edit = QLineEdit()
        self.root_dir_edit.setText(root_dir_path)

        # color settings
        self._color_equals = self.__create_color_button("color_equals")
        self._color_predicate = self.__create_color_button("color_predicate")
        self._color_function = self.__create_color_button("color_function")
        self._color_connective = self.__create_color_button("color_connective")
        self._color_not = self.__create_color_button("color_not")
        self._color_quantifier = self.__create_color_button("color_quantifier")
        self._color_parentheses = self.__create_color_button("color_parentheses")
        self._color_find = self.__create_color_button("color_find")

        # exit buttons
        exit_buttons = QDialogButtonBox(self)
        exit_buttons.addButton(QDialogButtonBox.Ok)
        exit_buttons.addButton(QDialogButtonBox.Cancel)
        exit_buttons.button(QDialogButtonBox.Ok).clicked.connect(self.ok_event)
        exit_buttons.button(QDialogButtonBox.Cancel).clicked.connect(self.close)

        # layout & tabs
        tab_controller = QTabWidget()
        main_layout = QVBoxLayout(self)
        main_layout.addWidget(tab_controller)

        highlighter_layout = QFormLayout(self)
        highlighter_layout.addRow("Equals: ", self._color_equals)
        highlighter_layout.addRow("Predicates: ", self._color_predicate)
        highlighter_layout.addRow("Functions: ", self._color_function)
        highlighter_layout.addRow("Connectives: ", self._color_connective)
        highlighter_layout.addRow("Negation: ", self._color_not)
        highlighter_layout.addRow("Quantifiers: ", self._color_quantifier)
        highlighter_layout.addRow("Parentheses: ", self._color_parentheses)
        highlighter_layout.addRow("Find (Highlight): ", self._color_find)

        parser_layout = QFormLayout(self)
        parser_layout.addWidget(root_dir_label)
        parser_layout.addWidget(self.root_dir_edit)
        main_layout.addWidget(exit_buttons)
        parser_tab = QWidget(self)
        parser_tab.setLayout(parser_layout)
        highlighter_tab = QWidget(self)
        highlighter_tab.setLayout(highlighter_layout)
        tab_controller.addTab(parser_tab, "Parser Settings")
        tab_controller.addTab(highlighter_tab, "Highlighter Settings")
        self.setLayout(main_layout)
Esempio n. 15
0
def get_m4_cmd(ontology):
    """get a formatted command to run Mace4 with options (timeout, etc.) set in the class instance."""

    args = []
    args.append(filemgt.read_config('mace4', 'command'))
    args.append('-v0')
    args.append('-t' + filemgt.read_config('mace4', 'timeout'))
    args.append('-s' + filemgt.read_config('mace4', 'timeout_per'))
    args.append('-n' + filemgt.read_config('mace4', 'start_size'))
    args.append('-N' + filemgt.read_config('mace4', 'end_size'))
    args.append('-f')
    args.append(
        clif_converter.convert_single_clif_file(ontology,
                                                clif_converter.ladr_output,
                                                True))

    return args
Esempio n. 16
0
    def __init__(self, name, depth=None):
        '''
        Constructor
        '''
        self.module_set = None

        self.module_name = ''

        self.hierarchy_name = ''
        """set of all imported module names """
        self.imports = set([])
        """ set of all parent module names"""
        self.parents = None
        self.ancestors = None

        self.clif_file_name = ''
        """Location of the clif input file that has undergone preprocessing"""
        self.clif_processed_file_name = ''

        self.p9_file_name = None

        self.tptp_file_name = None

        # the distinction between nonlogical_symbols and nonlogical_variables assumes that a single symbol is not used as both in different sentences
        self.nonlogical_symbols = set([])
        self.import_closure_nonlogical_symbols = None

        self.properly_defined_symbols = None
        #self.parents_nonlogical_symbols = set([])

        # stores the depth of the import hierarchy
        self.depth = depth

        self.set_module_name(name)
        logging.getLogger(__name__).info('processing module: ' +
                                         self.module_name)
        # remove any obsolete URL ending as specified in the configuration file
        if self.module_name.endswith(filemgt.read_config('cl', 'ending')):
            self.module_name = os.path.normpath(
                self.module_name.replace(filemgt.read_config('cl', 'ending'),
                                         ''))

        self.hierarchy_name = filemgt.get_hierarchy_name(self.module_name)

        self.preprocess_clif_file()
Esempio n. 17
0
def get_vampire_cmd(imports, ouput_stem):
    args = []
    args.append(filemgt.read_config('vampire', 'command'))
    args.append('--mode')
    args.append('casc')
    args.append('--proof')
    args.append('tptp')
    args.append('-t')
    args.append(filemgt.read_config('vampire', 'timeout'))
    # needed for Windows
    args.append('--input_file')
    args.append(
        list(imports)[0].get_module_set(imports).get_single_tptp_file(imports))
    logging.getLogger(__name__).debug("COMMAND FOR vampire IS " + str(args))
    # works for linux, not for Windows
    #return (args, [list(imports)[0].get_module_set(imports).get_single_tptp_file(imports)])

    return (args, [])
Esempio n. 18
0
    def __init__(self, parent=None):
        super(MacleodWindow, self).__init__(parent)

        # store the project path
        self.root_path = filemgt.read_config('system', 'path')

        # key: CodeEditor object, value: ontology object
        self.ontologies = dict()
        self.setup_widgets()
        self.setup_layout()
Esempio n. 19
0
    def __create_color_button(self, name):
        '''Generate a color button for a particular setting, returns the button.'''
        new_button = QColorButton(name, self)
        try :
            new_button.set_color(filemgt.read_config("gui", name))
        except configparser.NoOptionError:
            pass

        # This will be a blank color if the setting doesn't exist
        return new_button
Esempio n. 20
0
def get_p9_cmd(ontology):
    """get a formatted command to run Prover9 with options (timeout, etc.) set in the class instance."""

    args = []
    args.append(filemgt.read_config('prover9', 'command'))
    args.append('-t' + filemgt.read_config('prover9', 'timeout'))
    args.append('-f')
    args.append(
        clif_converter.convert_single_clif_file(ontology,
                                                clif_converter.ladr_output,
                                                True))

    # check for possible options file (to change predicate order or other parameters)
    options_file = filemgt.read_config('prover9', 'options')

    if options_file is not None:
        options_file = os.path.abspath(options_file)
        args.append(options_file)

    return args
Esempio n. 21
0
def get_paradox_cmd(ontology):
    """ we only care about the first element in the list of imports, which will we use as base name to obtain a single tptp file of the imports,
    which is the input for paradox."""
    args = []
    args.append(filemgt.read_config('paradox', 'command'))
    # this option is needed for linux or mac to run paradox using wine, where "wine" is the command, but the path to paradox is the first argument, stored in the key "options"
    option = filemgt.read_config('paradox', 'options')
    if option is not None:
        args.append(option)
    args.append('--time')
    args.append(filemgt.read_config('paradox', 'timeout'))
    args.append('--verbose')
    args.append('2')
    args.append('--model')
    args.append('--tstp')
    args.append(
        clif_converter.convert_single_clif_file(ontology,
                                                clif_converter.tptp_output,
                                                True))

    return args
Esempio n. 22
0
    def detect_systems(self):
        """Read the active provers from the configuration file."""

        # local variables
        provers = filemgt.read_config('active', 'provers').split(',')
        finders = filemgt.read_config('active', 'modelfinders').split(',')

        provers = [s.strip() for s in provers]
        finders = [s.strip() for s in finders]

        provers = [x for x in provers if len(x) > 0]
        finders = [x for x in finders if len(x) > 0]

        self.extend([Reasoner(r) for r in provers])
        self.extend([
            Reasoner(r, reasoner_type=Reasoner.MODEL_FINDER) for r in finders
        ])

        logging.getLogger(__name__).debug("REASONER SET: " +
                                          str(provers + finders))

        return True
Esempio n. 23
0
    def constructCommand(self, ontology):
        import os
        """Return the command (includes constructing it if necessary) to invoke the reasoner."""
        self.args = commands.get_system_command(self.name, ontology)

        ending = None

        if ontology.resolve:
            ending = Filemgt.read_config(self.name, 'all_ending')
        if ending is None:
            ending = ""

        ending = ending + Filemgt.read_config(self.name, 'ending')

        self.output_file = Filemgt.get_full_path(ontology.name,
                                                 folder=Filemgt.read_config(
                                                     'output', 'folder'),
                                                 ending=ending)
        self.ontology = ontology
        logging.getLogger(__name__).debug('Reasoner command: ' +
                                          str(self.args))
        return self.args
Esempio n. 24
0
def convert_all_clif_files(folder,
                           output,
                           resolve,
                           loc=default_dir,
                           prefix=default_prefix):

    tempfolder = Filemgt.read_config('converters', 'tempfolder')
    ignores = [tempfolder]
    cl_ending = Filemgt.read_config('cl', 'ending')
    logging.getLogger(__name__).info("Traversing folder " + folder)

    for directory, subdirs, files in os.walk(folder):
        if any(ignore in directory for ignore in ignores):
            pass
        else:
            for single_file in files:
                if single_file.endswith(cl_ending):
                    file = os.path.join(directory, single_file)
                    logging.getLogger(__name__).info("Found CL file " + file)
                    ontology = Parser.parse_file(file, prefix, loc, resolve)
                    convert_single_clif_file(ontology, output, resolve, loc,
                                             prefix)
Esempio n. 25
0
    def extract_p9_predicates_and_functions(self):

        #print 'extract predicates and functions'
        prover9args = 'prover9 -t 0 -f '

        for f in self.imports:
            prover9args += f.p9_file_name + ' '

        options_file = commands.get_p9_empty_optionsfile(
            self.get_p9_file_name(), verbose=False)
        prover9args += ' ' + options_file + ' '

        # would be better to create a temporary file or read the output stream directly
        temp_file = self.get_module_name() + '_order' + filemgt.read_config(
            'ladr', 'ending')
        prover9args += ' > ' + temp_file
        logging.getLogger(__name__).debug(prover9args)
        process.executeSubprocess(prover9args)

        order_file = open(temp_file, 'r')
        line = order_file.readline()
        predicates = None
        functions = None
        while line:
            if line.find('predicate_order') > -1:
                predicateline = line[line.find('predicate_order([') +
                                     len('predicate_order([') + 1:-4]
                predicates = predicateline.split()
                for i in range(len(predicates)):
                    predicates[i] = predicates[i].replace(',', '')
                line = order_file.readline()
                functionline = line[line.find('function_order([') +
                                    len('function_order([') + 1:-4]
                functions = functionline.split()
                for i in range(len(functions)):
                    functions[i] = functions[i].replace(',', '')
                break
            line = order_file.readline()

        order_file.close()
        #print 'temp file : ' + temp_file
        #print 'options file : ' + options_file
        os.remove(temp_file)
        os.remove(options_file)
        if predicates and functions:
            return (predicates, functions)
        else:
            return ([], [])
Esempio n. 26
0
def reformat_urls(lines):
    """Delete URL prefixes from all import declarations."""
    lines = list(lines)
    prefixes = filemgt.read_config('cl', 'prefix').split(',')
    prefixes = [p.strip().strip('"') for p in prefixes]
    prefixes = sorted([p.strip() for p in prefixes],
                      key=lambda s: len(s),
                      reverse=True)
    for i in range(0, len(lines)):
        for prefix in prefixes:
            if prefix in lines[i]:
                if not prefix.endswith('/'):
                    prefix = prefix + '/'
                # print "replacing prefix: " + prefix + " in " + lines[i]
                lines[i] = lines[i].replace(prefix, '')
                # print lines[i]
    return lines
Esempio n. 27
0
    def run_module_consistency_check(self, module):
        """check a single module for consistency."""
        outfile_stem = filemgt.get_full_path(module.module_name,
                                             folder=filemgt.read_config(
                                                 'output', 'folder'))

        reasoners = ReasonerSet()
        reasoners.constructAllCommands([module])
        logging.getLogger(__name__).info("USING " + str(len(reasoners)) +
                                         " REASONERS: " +
                                         str([r.name for r in reasoners]))

        # run provers and modelfinders simultaneously and wait until one returns
        reasoners = process.raceProcesses(reasoners)

        (return_value, _) = self.consolidate_results(reasoners)
        self.pretty_print_result(module.module_name, return_value)

        return return_value
Esempio n. 28
0
    def enforce_limits(self, pid):
        limit = int(filemgt.read_config('system', 'memory_limit')
                    )  # read custom memory limit from configuration file
        if limit is None:
            logging.getLogger(__name__).debug(
                "USING DEFAULT MEMORY LIMIT OF 2GB FOR EACH REASONER")
            limit = 2048  # default memory limit for each reasoner is 2GB

        memory = get_memory(pid)
        #enforce memory limit
        if memory > limit:
            logging.getLogger(__name__).info("MEMORY EXCEEDED: " + self.name +
                                             ", command = " + self.args[0])
            self.status = 'ALLOTED MEMORY EXCEEDED: ' + str(limit) + 'GB'
            self.shutdown()
        # enforce time limit
        if self.cputime > self.timeout:
            logging.getLogger(__name__).info("TIME EXCEEDED: " + self.name +
                                             ", command = " + self.args[0])
            self.status = 'ALLOTED TIME EXCEEDED: ' + str(
                self.timeout) + ' seconds'
            self.shutdown()
Esempio n. 29
0
    def add_lemmas (self):

        # first get LADR translation of ClifModule
        # logging.getLogger(__name__).debug("CREATING LADR TRANSLATION OF LEMMA: " + self.module.module_name)
        #self.module.get_p9_file_name()

        (lemma_names, ladr_files) = ladr.get_ladr_goal_files(self.module.get_p9_file_name(), self.module.module_name)
        logging.getLogger(__name__).debug("CREATED LADR TRANSLATION OF LEMMA: " + self.module.get_p9_file_name())

        # translate to tptp as goal
        tptp_sentences = clif.translate_sentences([self.module.clif_processed_file_name], "TPTP", axiom=False)

        logging.getLogger(__name__).debug("Goal created with " + str(len(tptp_sentences))+ " sentences")

#        for t in tptp_sentences:
#            print t

        # populate the list of lemmas        
        for i in range(0,len(ladr_files)):
            name = os.path.join(os.path.dirname(lemma_names[i]),
                                os.path.basename(ladr_files[i].replace(filemgt.read_config('ladr','ending'),'')))
            #print "NAME = " + name
            m = LemmaModule(name,ladr_files[i],tptp_sentences[i])
            self.lemmas.append(m)
Esempio n. 30
0
'''
Created on 2013-03-19

@author: Torsten Hahmann
'''
import os, sys, argparse, logging

sys.path.append(os.path.dirname(os.path.abspath(__file__)) + "/../")

import macleod.scripts.licence
import macleod.Filemgt as Filemgt
import macleod.parsing.Parser as Parser
#from macleod.Filemgt import Filemgt

# defaults for the ontology directory and basepath
default_dir = Filemgt.read_config('system', 'path')
default_prefix = Filemgt.read_config('cl', 'prefix')


def consistent(filename, m, options=[]):

    if '-module' in options:
        results = m.run_consistency_check_by_subset(
            abort=True, abort_signal=ClifModuleSet.CONSISTENT)
    elif '-depth' in options:
        results = m.run_consistency_check_by_depth(
            abort=True, abort_signal=ClifModuleSet.CONSISTENT)
    elif '-simple' in options:
        results = m.run_simple_consistency_check()
    else:
        results = m.run_full_consistency_check(