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                   "string",
  33                   "path",
  34                   _("Optional: Search the duplicate files in the given "
  35                     "directory path."))
  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(path, extension_ignored, files_ignored, directories_ignored):
  61     '''Make the list of all files and paths that are not filtered
  62
  63     :param path Str: The path to of the directory where to search for duplicates
  64     :param extension_ignored List: The list of extensions to ignore
  65     :param files_ignored List: The list of files to ignore
  66     :param directories_ignored List: The list of directory paths to ignore
  67     :return: files_arb_out is the list of [file, path]
  68              and files_out is is the list of files
  69     :rtype: List, List
  70     '''
  71     files_out = []
  72     files_arb_out=[]
  73     for root, __, files in os.walk(path):
  74         for fic in files:
  75             extension = fic.split('.')[-1]
  76             if extension not in extension_ignored and fic not in files_ignored:
  77                 in_ignored_dir = False
  78                 for rep in directories_ignored:
  79                     if rep in root:
  80                         in_ignored_dir = True
  81                 if not in_ignored_dir:
  82                     files_out.append([fic])
  83                     files_arb_out.append([fic, root])
  84     return files_arb_out, files_out
  85
  86 def format_list_of_str(l_str):
  87     '''Make a list from a string
  88
  89     :param l_str List or Str: The variable to format
  90     :return: the formatted variable
  91     :rtype: List
  92     '''
  93     if not isinstance(l_str, list):
  94         return l_str
  95     return ",".join(l_str)
  96
  97 def print_info(logger, info, level=2):
  98     '''Format a display
  99
 100     :param logger Logger: The logger instance
 101     :param info List: the list of tuple to display
 102     :param valMax float: the maximum value of the variable
 103     :param level int: the verbose level that will be used
 104     '''
 105     smax = max(map(lambda l: len(l[0]), info))
 106     for i in info:
 107         sp = " " * (smax - len(i[0]))
 108         src.printcolors.print_value(logger,
 109                                     sp + i[0],
 110                                     format_list_of_str(i[1]),
 111                                     2)
 112     logger.write("\n", level)
 113
 114 class Progress_bar:
 115     "Create a progress bar in the terminal"
 116
 117     def __init__(self, name, valMin, valMax, logger, length = 50):
 118         '''Initialization of the progress bar.
 119
 120         :param name str: The name of the progress bar
 121         :param valMin float: the minimum value of the variable
 122         :param valMax float: the maximum value of the variable
 123         :param logger Logger: the logger instance
 124         :param length int: the lenght of the progress bar
 125         '''
 126         self.name = name
 127         self.valMin = valMin
 128         self.valMax = valMax
 129         self.length = length
 130         self.logger = logger
 131         if (self.valMax - self.valMin) <= 0 or length <= 0:
 132             out_err = _('ERROR: Wrong init values for the progress bar\n')
 133             raise src.SatException(out_err)
 134
 135     def display_value_progression(self,val):
 136         '''Display the progress bar.
 137
 138         :param val float: val must be between valMin and valMax.
 139         '''
 140         if val < self.valMin or val > self.valMax:
 141             self.logger.write(src.printcolors.printcWarning(_(
 142                            'WARNING : wrong value for the progress bar.\n')), 3)
 143         else:
 144             perc = (float(val-self.valMin) / (self.valMax - self.valMin)) * 100.
 145             nb_equals = int(perc * self.length / 100)
 146             out = '\r %s : %3d %% [%s%s]' % (self.name, perc, nb_equals*'=',
 147                                              (self.length - nb_equals)*' ' )
 148             self.logger.write(out, 3)
 149             self.logger.flush()
 150
 151 def description():
 152     '''method that is called when salomeTools is called with --help option.
 153
 154     :return: The text to display for the find_duplicates command description.
 155     :rtype: str
 156     '''
 157     return _("The find_duplicates command search recursively for all duplicates"
 158              " files in a the INSTALL directory (or the optionally given "
 159              "directory) and prints the found files to the terminal.\n\n"
 160              "example:\nsat find_duplicates --path /tmp")
 161
 162 def run(args, runner, logger):
 163     '''method that is called when salomeTools is called with find_duplicates
 164        parameter.
 165     '''
 166     # parse the arguments
 167     (options, args) = parser.parse_args(args)
 168
 169     # Determine the directory path where to search
 170     # for duplicates files regarding the options
 171     if options.path:
 172         dir_path = options.path
 173     else:
 174         src.check_config_has_application(runner.cfg)
 175         if options.sources:
 176             dir_path = os.path.join(runner.cfg.APPLICATION.workdir, "SOURCES")
 177         else:
 178             dir_path = os.path.join(runner.cfg.APPLICATION.workdir, "INSTALL")
 179
 180     # Get the files to ignore during the searching
 181     files_ignored = default_files_ignored
 182     if options.exclude_file:
 183         files_ignored = options.exclude_file
 184
 185     # Get the extension to ignore during the searching
 186     extension_ignored = default_extension_ignored
 187     if options.exclude_extension:
 188         extension_ignored = options.exclude_extension
 189
 190     # Get the directory paths to ignore during the searching
 191     directories_ignored = default_directories_ignored
 192     if options.exclude_path:
 193         directories_ignored = options.exclude_path
 194
 195     # Check the directory
 196     if not(os.path.isdir(dir_path)):
 197         msg = _("%s has to be a valid repository path." % dir_path)
 198         logger.write(src.printcolors.printcError(msg), 1)
 199         return 1
 200
 201     # Display some information
 202     info = [(_("Directory"), dir_path),
 203             (_("Ignored files"), files_ignored),
 204             (_("Ignored extensions"), extension_ignored),
 205             (_("Ignored directories"), directories_ignored)
 206            ]
 207     print_info(logger, info)
 208
 209     # Get all the files and paths
 210     logger.write(_("Store all file paths ... "), 3)
 211     logger.flush()
 212     dic, fic = list_directory(dir_path,
 213                               extension_ignored,
 214                               files_ignored,
 215                               directories_ignored)
 216     logger.write(src.printcolors.printcSuccess('OK\n'), 3)
 217
 218     # Eliminate all the singletons
 219     len_fic = len(fic)
 220     range_fic = range(0,len_fic)
 221     range_fic.reverse()
 222     my_bar = Progress_bar(_('Eliminate the files that are not duplicated'),
 223                           0,
 224                           len_fic,
 225                           logger,
 226                           length = 50)
 227     for i in range_fic:
 228         my_bar.display_value_progression(len_fic - i)
 229         if fic.count(fic[i])==1:
 230             fic.remove(fic[i])
 231             dic.remove(dic[i])
 232
 233     # Format the resulting variable to get a dictionary
 234     logger.write(_("\n\nCompute the dict {files : [list of pathes]} ... "), 3)
 235     fic.sort()
 236     len_fic = len(fic)
 237     rg_fic = range(0,len_fic)
 238     rg_fic.reverse()
 239     for i in rg_fic:
 240         if fic[i-1] != fic[i]:
 241             fic.remove(fic[i])
 242
 243     dic_fic_paths = {}
 244     for fichier in fic:
 245         the_file = fichier[0]
 246         l_path = []
 247         for fic_path in dic:
 248             if fic_path[0] == the_file:
 249                 l_path.append(fic_path[1])
 250         dic_fic_paths[the_file] = l_path
 251
 252     logger.write(src.printcolors.printcSuccess('OK\n'), 3)
 253
 254     # End the execution if no duplicates were found
 255     if len(dic_fic_paths) == 0:
 256         logger.write(_("No duplicate files found.\n"), 3)
 257         return 0
 258
 259     # Check that there are no singletons in the result (it would be a bug)
 260     for elem in dic_fic_paths:
 261         if len(dic_fic_paths[elem])<2:
 262             logger.write(_("Warning : element %s has not more than"
 263                          " two paths.\n") % elem, 3)
 264
 265
 266     # Display the results
 267     logger.write(src.printcolors.printcInfo(_('\nResults:\n\n')), 3)
 268     max_file_name_lenght = max(map(lambda l: len(l), dic_fic_paths.keys()))
 269     for fich in dic_fic_paths:
 270         logger.write(src.printcolors.printcLabel(fich), 1)
 271         sp = " " * (max_file_name_lenght - len(fich))
 272         logger.write(sp, 1)
 273         for rep in dic_fic_paths[fich]:
 274             logger.write(rep, 1)
 275             logger.write(" ", 1)
 276         logger.write("\n", 1)
 277
 278     return 0