Get a single analysis.
979216
def analysis(self, analysis_id: int) -> models.Analysis:
        """"""
        return self.Analysis.query.get(analysis_id)
21884
def analyze(self,A):
        

        A = coo_matrix(A)
        
        self.mumps.set_shape(A.shape[0])
        self.mumps.set_centralized_assembled_rows_cols(A.row+1,A.col+1)
        self.mumps.run(job=1)

        self.analyzed = True
712307
def system_find_analyses(input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/system/findAnalyses', input_params, always_retry=always_retry, **kwargs)
1260964
def analysis(self):
        """"""
        if isinstance(self, PartitionProxy):
            return AnalysisPartition(self._obj)
        else:
            return AnalysisPartition(self)
496159
def analyze(self, s, method='chebyshev', order=30):
        """
        if s.ndim == 3 and s.shape[-1] != 1:
            raise ValueError('Last dimension (#features) should be '
                             '1, got {}.'.format(s.shape))
        return self.filter(s, method, order)
785719
def analyze(self):
        
        key = '/library/sections/%s/analyze' % self.key
        self._server.query(key, method=self._server._session.put)
467280
def getLate(self):
        
        for analysis in self.getAnalyses():
            if analysis.review_state == "retracted":
                continue
            analysis_obj = api.get_object(analysis)
            if analysis_obj.isLateAnalysis():
                return True
        return False
428948
def analyze(self, scratch, **kwargs):
        """"""
        results = Counter()
        for script in self.iter_scripts(scratch):
            gen = self.iter_blocks(script.blocks)
            name = 'start'
            level = None
            while name != '':
                if name in self.ANIMATION:
                    gen, count = self._check_animation(name, level, gen)
                    results.update(count)
                name, level, _ = next(gen, ('', 0, ''))
        return {'animation': results}
1337477
def get_one(self):
        """"""
        self.default_val = None
        o = self.default_val
        d = self._query('get_one')
        if d:
            o = self.orm_class(d, hydrate=True)
        return o
1355982
def analyze_script(self, index=None):
        """"""
        if self.is_analysis_done:
            return
        if index is None:
            index = self.get_stack_index()
        if self.data:
            finfo = self.data[index]
            if self.todolist_enabled:
                finfo.run_todo_finder()
        self.is_analysis_done = True
455757
def _analyze(self):
        """"""
        self._analyze_start_time = time.time()
        self._clear_ui()
        try:
            self._analysis_process.terminate()  # clear anything existing
        except AttributeError:  # there wasn't actually a process
            pass
        # self._analysis_process = _AsyncReadyFunction(self._analysis_function,
        #                                              None, 'async_results_q')
        out_q = mp.Queue()
        self._analysis_process = mp.Process(target=self._analysis_function,
                                            kwargs={'async_results_q': out_q})
        setattr(self._analysis_process, 'out_q', out_q)
        self._analysis_process.start()
        self._base.after(self._POLL_PERIOD_MILLISECONDS,
                         self._scheduled_check_for_summaries)
        self._update_notification('Analyzing the on-screen game.')
370129
def duplicate(self):
        """"""
        a_per = self.analysis_period.duplicate() if self.analysis_period else None
        return self.__class__(self.data_type, self.unit,
                              a_per, deepcopy(self.metadata))
35115
def get_one(self, qry, tpl):
        '''  '''
        self.cur.execute(qry + ' LIMIT 1', tpl)
        result = self.cur.fetchone()
        # unpack tuple if it has only
        # one element
        # TODO unpack results
        if type(result) is tuple and len(result) == 1:
            result = result[0]
        return result
238570
def request_analysis(self):
        
        if self._finished:
            _logger(self.__class__).log(5, 'running analysis')
            self._job_runner.request_job(self._request)
        elif self.editor:
            # retry later
            _logger(self.__class__).log(
                5, 'delaying analysis (previous analysis not finished)')
            QtCore.QTimer.singleShot(500, self.request_analysis)
271198
def analyze(self, using=None, **kwargs):
        
        return self._get_connection(using).indices.analyze(index=self._name, **kwargs)
414456
def get_analysis(self):
        
        if self.analysis_url:
            try:
                # Try the existing analysis_url first. This expires shortly
                # after creation.
                try:
                    json_string = urllib2.urlopen(self.analysis_url).read()
                except urllib2.HTTPError:
                    # Probably the analysis_url link has expired. Refresh it.
                    param_dict = dict(id = self.id)
                    new_track = _profile(param_dict, DEFAULT_ASYNC_TIMEOUT)
                    if new_track and new_track.analysis_url:
                        self.analysis_url = new_track.analysis_url
                        json_string = urllib2.urlopen(self.analysis_url).read()
                    else:
                        raise Exception("Failed to create track analysis.")

                analysis = json.loads(json_string)
                analysis_track = analysis.pop('track', {})
                self.__dict__.update(analysis)
                self.__dict__.update(analysis_track)
            except Exception: #pylint: disable=W0702
                # No detailed analysis found.
                raise Exception("Failed to create track analysis.")
        else:
            raise Exception("Failed to create track analysis.")
172195
def full_analysis(self, analysis_set, output_directory, verbose = True, compile_pdf = True, quick_plots = False):
        ''''''
        if not os.path.isdir(output_directory):
            os.makedirs(output_directory)
        self.analysis_directory = output_directory
        self.calculate_metrics(analysis_set = analysis_set, analysis_directory = output_directory, verbose = verbose)
        self.write_dataframe_to_csv( os.path.join(output_directory, 'data.csv') )

        # Return latex_report
        return self.plot(analysis_set = analysis_set, analysis_directory = output_directory, matplotlib_plots = True, verbose = verbose, compile_pdf = compile_pdf, quick_plots = quick_plots)