[Feature] Adapt acro to be ontology-driven

[jim-smith]

Is your feature request related to a problem? Please describe.
We should start making a branch that where the behaviour is driven by the ontology rather than being hard-coded

Describe the solution you'd like

1. Generate series of dictionaries from the ontology. (this is a one-off task rather than being done for each acro session) and stop as json?
2. those get read into acro as python dictionaries on startup
3. when an acro method that produces a query is called, the tests et that need ot be run are driven by those dictionaries, and the appropriate statements are written into the summary that gets written to results.json when the user calls acro.finalise()

Describe alternatives you've considered
.
Additional context
.

[jim-smith]

ideas sketched from meeting in early Feb

possible_risks:list =  HasRisk[statname]:

is_present:np.array(bool) = [False]*len(possible_risks)

for risk in possible_risks: 

      for check in ChecksForRisk[possible_risk']:

              if run(check):

                  is_present[risk]=True

        if is_present[risk]:

                set_status('Fail')

                 #add possible mitigations for risk to a list of lists

  if any is_present:

         #TODO advise users about mitigation that works for all the rirks detected

          themitigstion= get_users_choice()



           apply(themitigation)

           #v1

          if the_risk in MitigatesFor[thermitigation]

              set_status ("review")

              #not sure about that - might need ot do them all first

        #v2 do the other way round ie 

         if themitigation in IsMitigatedBy[risk]

[jim-smith]

Need to find all risks and checks to run in case pre-selected mitigations are not appropriate

[jim-smith]

Currently have got sorted for regression via a file checks.py

Separate process builds json file from ontology (has to be separate so it can be run outside the TRE and json files shipped with code to be available inside the TRE).

Key concepts

1. the acro() constructor creates a self.sdc_checks=SDCChecks() instance using the appropriate risk appettite for the analysis.
2. acro functions implementing different analyses (acro.crosstab(), acro.logit()) etc) just has other declare the type of analysis , build the model (stats model, or table, or ...) and then call run_checks_for_analysis():
   e.g. ols() just looks like

     logger.debug("ols()")
        command: str = utils.get_command("ols()", stack())

        model = sm.OLS(endog, exog=exog, missing=missing, hasconst=hasconst, **kwargs)
        results = model.fit()

        analysis_name = "GeneralLinearModel"
        status, summary, dof, fair_dict = self.sdc_checks.run_checks_for_analysis(
            analysis_name, model
        )

        tables: list[SimpleTable] = results.summary().tables
        self.results.add(
            status=status,
            output_type="regression",
            properties={"method": "ols", "dof": dof},
            command=command,
            summary=summary,
            outcome=DataFrame(),
            output=get_summary_dataframes(tables),
            sdc={},
            fair=fair_dict,
        )
        return results

3. run_checks_for_analysis()returns four things:

   • the status : one of 'pass', 'review', or 'fail'
   • the summary to be displayed to researchers/ output checkers
   • the actionable outcomes e.g. DoF for regression, a mask for a a table, or a set of masks as needed
   • a 'FAIR' dictionary saying what has been done and w ith what outcome
     • => this needs to be edited if a mitigation is applied.

4. All methods implementing checks have common format:

    Parameters are
        name:str
            the 'family name' of the type of analysis
            determines what needs to be run
        model: Any
            can be statsmodel or the details
            (rows,columns,values) to create a table
    Returns: tuple
        string (status  for that check)
        string: summary of that check
        Any: check details as
             single values (e.g. Dof) or
             a mask showing cell-by cell results for a table