:return: name of the report file of L2A products
        :rtype: str
334953
def get_report_name(self):
        
        return '{}_{}_report.{}'.format(self.product_id, self.get_report_time(), MimeType.XML.value)
1350940
def ft2file(self, **kwargs):
        
        kwargs_copy = self.base_dict.copy()
        kwargs_copy.update(**kwargs)
        kwargs_copy['data_time'] = kwargs.get(
            'data_time', self.dataset(**kwargs))
        self._replace_none(kwargs_copy)        
        localpath = NameFactory.ft2file_format.format(**kwargs_copy)
        if kwargs.get('fullpath', False):
            return self.fullpath(localpath=localpath)
        return localpath
484854
def get_file_list(self, lstPaths, lstXtn, lstExcluded, VERBOSE = False):
        
        if VERBOSE:
            print("Generating list of Files...")
            print("Paths = ", lstPaths)
            print("Xtns  = ", lstXtn)
            print("exclude = ", lstExcluded)
        numFiles = 0
        self.filelist = []
        self.fl_metadata = []
        for rootPath in lstPaths:
            if VERBOSE:
                print(rootPath)
            for root, dirs, files in os.walk(rootPath):
                if VERBOSE:
                    print(dirs)
                for basename in files:
                    for xtn in lstXtn:
                        if fnmatch.fnmatch(basename, xtn):
                            filename = os.path.join(root, basename)
                            includeThisFile = "Y"
                            if len(lstExcluded) > 0:
                                for exclude in lstExcluded:
                                    if filename.find(exclude) != -1:
                                        includeThisFile = "N"
                            if includeThisFile == "Y":
                                numFiles = numFiles + 1
                                self.filelist.append(filename)
                                self.add_file_metadata(filename)    # not sure why there is a 2nd list, but there is.

        if VERBOSE:
            print("Found ", numFiles, " files")
        return self.filelist
697596
def name(self):
        ''''''
        if self.mako_template.filename:
            return os.path.basename(self.mako_template.filename)
        return 'string'
835220
def get_joined_file_name(self, atts, optional_atts = None):
        

        return '_'.join(
            [getattr(self, x) for x in atts] +
            [getattr(self, x) for x in optional_atts if x in self.__dict__]
        ) + '.nc'
60284
def sct_report_string(report):
    
    ret = []
    namespaces = {"svrl": "http://purl.oclc.org/dsdl/svrl"}
    for index, failed_assert_el in enumerate(
        report.findall("svrl:failed-assert", namespaces=namespaces)
    ):
        ret.append(
            "{}. {}".format(
                index + 1,
                failed_assert_el.find("svrl:text", namespaces=namespaces).text,
            )
        )
        ret.append("   test: {}".format(failed_assert_el.attrib["test"]))
        ret.append("   location: {}".format(failed_assert_el.attrib["location"]))
        ret.append("\n")
    return "\n".join(ret)
628364
def get_report_time(self):
        
        tree = get_xml(self.get_url(AwsConstants.REPORT))

        try:
            timestamp = tree.find('check/inspection').attrib['execution']
            return timestamp.split(',')[0].replace(' ', 'T').replace(':', '').replace('-', '')
        except AttributeError:
            warnings.warn('Could not obtain the L2A report creation time')
            return 'unknown'
779477
def filenames(self):
        
        fns = set()
        for fn2var in self._type2filename2variable.values():
            fns.update(fn2var.keys())
        return sorted(fns)
459848
def getAllExports(self, plugin_list=None):
        
        if plugin_list is None:
            # All plugins should be exported
            plugin_list = self._plugins
        return [self._plugins[p].get_export() for p in self._plugins]
571251
def get_dump_order(self, names):
        
        finded_names = self.get_dump_names(names)
        return [item for item in self if item in finded_names]
83409
def product_name(self):
        
        buf = (ctypes.c_char * self.MAX_BUF_SIZE)()
        self._dll.JLINKARM_EMU_GetProductName(buf, self.MAX_BUF_SIZE)
        return ctypes.string_at(buf).decode()
216369
def get_file_list(self):
        
        if os.path.isdir(self.root_path):
            return [os.path.join(self.root_path, f) for f in os.listdir(self.root_path)
                    if os.path.isfile(os.path.join(self.root_path, f))]
        else:
            return [self.root_path]
1091661
def filenames(self):
        
        if self._is_reader:
            assert self._filenames is not None
            return self._filenames
        else:
            return self.data_producer.filenames
906844
def files(self):
        
        files_description = [
            [ self.project_name,
              self.project_name + '.tex',
              'LaTeXBookFileTemplate'
            ],
            [ self.project_name,
              'references.bib',
              'BibTeXFileTemplate'
            ],
            [ self.project_name,
              'Makefile',
              'LaTeXMakefileFileTemplate'
            ],
        ]
        return files_description
1267008
def filenames(self):
        
        return [os.path.basename(source) for source in self.sources if source]
1263359
def report_import(self, name, filename):
        
        data = self._upload(filename)
        return self.raw_query('report', 'import', data={
            'filename': data['filename'],
            'name': name,
        })
664752
def get_report(report=None):
    
    if not report:
        report = list_reports()[-1:][0]
    report_path = _get_reports_path(report)
    report_dict = {"report": report}
    for filename in os.listdir(report_path):
        with open(os.path.join(report_path, filename), "r") as f:
            report_dict[filename] = f.read()
    return report_dict