commands/find_duplicates.py

   1 #!/usr/bin/env python
   2 #-*- coding:utf-8 -*-
   3 #  Copyright (C) 2010-2013  CEA/DEN
   4 #
   5 #  This library is free software; you can redistribute it and/or
   6 #  modify it under the terms of the GNU Lesser General Public
   7 #  License as published by the Free Software Foundation; either
   8 #  version 2.1 of the License.
   9 #
  10 #  This library is distributed in the hope that it will be useful,
  11 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 #  Lesser General Public License for more details.
  14 #
  15 #  You should have received a copy of the GNU Lesser General Public
  16 #  License along with this library; if not, write to the Free Software
  17 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18
  19 import os
  20
  21 import src
  22
  23 # create a parser for command line options
  24 parser = src.options.Options()
  25 parser.add_option("s",
  26                   "sources",
  27                   "boolean",
  28                   "sources",
  29                   _("Search the duplicate files in the SOURCES directory."))
  30 parser.add_option("p",
  31                   "path",
  32                   "list2",
  33                   "path",
  34                   _("Optional: Search the duplicate files in the given "
  35                     "directory paths."))
  36 parser.add_option("",
  37                   "exclude-file",
  38                   "list2",
  39                   "exclude_file",
  40                   _("Optional: Override the default list of filtered files."))
  41 parser.add_option("",
  42                   "exclude-extension",
  43                   "list2",
  44                   "exclude_extension",
  45                   _("Optional: Override the default list of filtered "
  46                     "extensions."))
  47 parser.add_option("",
  48                   "exclude-path",
  49                   "list2",
  50                   "exclude_path",
  51                   _("Optional: Override the default list of filtered paths."))
  52
  53 default_extension_ignored = ['html', 'png', 'txt', 'js', 'xml', 'cmake', 'gif',
  54                      'm4', 'in', 'pyo', 'pyc', 'doctree', 'css']
  55 default_files_ignored = ['__init__.py', 'Makefile.am', 'VERSION',
  56                          'build_configure',
  57                          'README', 'AUTHORS', 'NEWS', 'COPYING', 'ChangeLog']
  58 default_directories_ignored = []
  59
  60 def list_directory(lpath, extension_ignored, files_ignored, directories_ignored):
  61     '''Make the list of all files and paths that are not filtered
  62
  63     :param lpath List: The list of path to of the directories where to
  64                        search for duplicates
  65     :param extension_ignored List: The list of extensions to ignore
  66     :param files_ignored List: The list of files to ignore
  67     :param directories_ignored List: The list of directory paths to ignore
  68     :return: files_arb_out is the list of [file, path]
  69              and files_out is is the list of files
  70     :rtype: List, List
  71     '''
  72     files_out = []
  73     files_arb_out=[]
  74     for path in lpath:
  75         for root, __, files in os.walk(path):
  76             for fic in files:
  77                 extension = fic.split('.')[-1]
  78                 if (extension not in extension_ignored and
  79                                                       fic not in files_ignored):
  80                     in_ignored_dir = False
  81                     for rep in directories_ignored:
  82                         if rep in root:
  83                             in_ignored_dir = True
  84                     if not in_ignored_dir:
  85                         files_out.append([fic])
  86                         files_arb_out.append([fic, root])
  87     return files_arb_out, files_out
  88
  89 def format_list_of_str(l_str):
  90     '''Make a list from a string
  91
  92     :param l_str List or Str: The variable to format
  93     :return: the formatted variable
  94     :rtype: List
  95     '''
  96     if not isinstance(l_str, list):
  97         return l_str
  98     return ",".join(l_str)
  99
 100 def print_info(logger, info, level=2):
 101     '''Format a display
 102
 103     :param logger Logger: The logger instance
 104     :param info List: the list of tuple to display
 105     :param valMax float: the maximum value of the variable
 106     :param level int: the verbose level that will be used
 107     '''
 108     smax = max(map(lambda l: len(l[0]), info))
 109     for i in info:
 110         sp = " " * (smax - len(i[0]))
 111         src.printcolors.print_value(logger,
 112                                     sp + i[0],
 113                                     format_list_of_str(i[1]),
 114                                     2)
 115     logger.write("\n", level)
 116
 117 class Progress_bar:
 118     "Create a progress bar in the terminal"
 119
 120     def __init__(self, name, valMin, valMax, logger, length = 50):
 121         '''Initialization of the progress bar.
 122
 123         :param name str: The name of the progress bar
 124         :param valMin float: the minimum value of the variable
 125         :param valMax float: the maximum value of the variable
 126         :param logger Logger: the logger instance
 127         :param length int: the lenght of the progress bar
 128         '''
 129         self.name = name
 130         self.valMin = valMin
 131         self.valMax = valMax
 132         self.length = length
 133         self.logger = logger
 134         if (self.valMax - self.valMin) <= 0 or length <= 0:
 135             out_err = _('ERROR: Wrong init values for the progress bar\n')
 136             raise src.SatException(out_err)
 137
 138     def display_value_progression(self,val):
 139         '''Display the progress bar.
 140
 141         :param val float: val must be between valMin and valMax.
 142         '''
 143         if val < self.valMin or val > self.valMax:
 144             self.logger.write(src.printcolors.printcWarning(_(
 145                            'WARNING : wrong value for the progress bar.\n')), 3)
 146         else:
 147             perc = (float(val-self.valMin) / (self.valMax - self.valMin)) * 100.
 148             nb_equals = int(perc * self.length / 100)
 149             out = '\r %s : %3d %% [%s%s]' % (self.name, perc, nb_equals*'=',
 150                                              (self.length - nb_equals)*' ' )
 151             self.logger.write(out, 3)
 152             self.logger.flush()
 153
 154 def description():
 155     '''method that is called when salomeTools is called with --help option.
 156
 157     :return: The text to display for the find_duplicates command description.
 158     :rtype: str
 159     '''
 160     return _("The find_duplicates command search recursively for all duplicates"
 161              " files in a the INSTALL directory (or the optionally given "
 162              "directory) and prints the found files to the terminal.\n\n"
 163              "example:\nsat find_duplicates --path /tmp")
 164
 165 def run(args, runner, logger):
 166     '''method that is called when salomeTools is called with find_duplicates
 167        parameter.
 168     '''
 169     # parse the arguments
 170     (options, args) = parser.parse_args(args)
 171
 172     # Determine the directory path where to search
 173     # for duplicates files regarding the options
 174     if options.path:
 175         l_dir_path = options.path
 176     else:
 177         src.check_config_has_application(runner.cfg)
 178         if options.sources:
 179             l_dir_path = [os.path.join(runner.cfg.APPLICATION.workdir,
 180                                        "SOURCES")]
 181         else:
 182             # find all installation paths
 183             all_products = runner.cfg.APPLICATION.products.keys()
 184             l_product_cfg = src.product.get_products_infos(all_products,
 185                                                            runner.cfg)
 186             l_dir_path = [pi.install_dir for __, pi in l_product_cfg]
 187
 188     # Get the files to ignore during the searching
 189     files_ignored = default_files_ignored
 190     if options.exclude_file:
 191         files_ignored = options.exclude_file
 192
 193     # Get the extension to ignore during the searching
 194     extension_ignored = default_extension_ignored
 195     if options.exclude_extension:
 196         extension_ignored = options.exclude_extension
 197
 198     # Get the directory paths to ignore during the searching
 199     directories_ignored = default_directories_ignored
 200     if options.exclude_path:
 201         directories_ignored = options.exclude_path
 202
 203     # Check the directories
 204     l_path = src.deepcopy_list(l_dir_path)
 205     l_dir_path = []
 206     for dir_path in l_path:
 207         if not(os.path.isdir(dir_path)):
 208             msg = _("%s does not exists or is not a directory path: "
 209                     "it will be ignored" % dir_path)
 210             logger.write("%s\n" % src.printcolors.printcWarning(msg), 3)
 211             continue
 212         l_dir_path.append(dir_path)
 213
 214
 215     # Display some information
 216     info = [(_("Directories"), "\n".join(l_dir_path)),
 217             (_("Ignored files"), files_ignored),
 218             (_("Ignored extensions"), extension_ignored),
 219             (_("Ignored directories"), directories_ignored)
 220            ]
 221     print_info(logger, info)
 222
 223     # Get all the files and paths
 224     logger.write(_("Store all file paths ... "), 3)
 225     logger.flush()
 226     dic, fic = list_directory(l_dir_path,
 227                               extension_ignored,
 228                               files_ignored,
 229                               directories_ignored)
 230     logger.write(src.printcolors.printcSuccess('OK\n'), 3)
 231
 232     # Eliminate all the singletons
 233     len_fic = len(fic)
 234     range_fic = range(0,len_fic)
 235     range_fic.reverse()
 236     my_bar = Progress_bar(_('Eliminate the files that are not duplicated'),
 237                           0,
 238                           len_fic,
 239                           logger,
 240                           length = 50)
 241     for i in range_fic:
 242         my_bar.display_value_progression(len_fic - i)
 243         if fic.count(fic[i])==1:
 244             fic.remove(fic[i])
 245             dic.remove(dic[i])
 246
 247     # Format the resulting variable to get a dictionary
 248     logger.write(_("\n\nCompute the dict {files : [list of pathes]} ... "), 3)
 249     fic.sort()
 250     len_fic = len(fic)
 251     rg_fic = range(0,len_fic)
 252     rg_fic.reverse()
 253     for i in rg_fic:
 254         if fic[i-1] != fic[i]:
 255             fic.remove(fic[i])
 256
 257     dic_fic_paths = {}
 258     for fichier in fic:
 259         the_file = fichier[0]
 260         l_path = []
 261         for fic_path in dic:
 262             if fic_path[0] == the_file:
 263                 l_path.append(fic_path[1])
 264         dic_fic_paths[the_file] = l_path
 265
 266     logger.write(src.printcolors.printcSuccess('OK\n'), 3)
 267
 268     # End the execution if no duplicates were found
 269     if len(dic_fic_paths) == 0:
 270         logger.write(_("No duplicate files found.\n"), 3)
 271         return 0
 272
 273     # Check that there are no singletons in the result (it would be a bug)
 274     for elem in dic_fic_paths:
 275         if len(dic_fic_paths[elem])<2:
 276             logger.write(_("Warning : element %s has not more than"
 277                          " two paths.\n") % elem, 3)
 278
 279
 280     # Display the results
 281     logger.write(src.printcolors.printcInfo(_('\nResults:\n\n')), 3)
 282     max_file_name_lenght = max(map(lambda l: len(l), dic_fic_paths.keys()))
 283     for fich in dic_fic_paths:
 284         logger.write(src.printcolors.printcLabel(fich), 1)
 285         sp = " " * (max_file_name_lenght - len(fich))
 286         logger.write(sp, 1)
 287         for rep in dic_fic_paths[fich]:
 288             logger.write(rep, 1)
 289             logger.write(" ", 1)
 290         logger.write("\n", 1)
 291
 292     return 0