docs: def processNickList(nicks, platforms=None, rutaDescarga="./", avoidProcessing=True, avoidDownload=True, nThreads=12, verbosity=1, logFolder="./logs"):
      """
      Process a list of nicks to check whether they exist.
  
      This method receives as a parameter a series of nicks and verifies whether
      those nicks have a profile associated in different social networks.
  
      Args:
      -----
          nicks: List of nicks to process.
          platforms: List of <Platform> objects to be processed.
          rutaDescarga: Local file where saving the obtained information.
          avoidProcessing: A boolean var that defines whether the profiles will
              NOT be processed.
          avoidDownload: A boolean var that defines whether the profiles will NOT
              be downloaded.
          verbosity: The level of verbosity to be used.
          logFolder: The path to the log folder.
  
      Returns:
      --------
          A dictionary where the key is the nick and the value another dictionary
          where the keys are the social networks and the value is the
          corresponding URL.
      """
      if platforms == None:
          platforms = platform_selection.getAllPlatformNames("usufy")
  
      # Defining the output results variable
      res = []
      # Processing the whole list of terms...
      for nick in nicks:
          # If the process is executed by the current app, we use the Processes. It is faster than pools.
          if nThreads <= 0 or nThreads > len(platforms):
              nThreads = len(platforms)
  
          # Using threads in a pool if we are not running the program in main
          # Example catched from: https://stackoverflow.com/questions/11312525/catch-ctrlc-sigint-and-exit-multiprocesses-gracefully-in-python
          try:
              original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
              pool = Pool(nThreads)
              signal.signal(signal.SIGINT, original_sigint_handler)
          except ValueError:
              # To avoid: ValueError: signal only works in main thread
              pool = Pool(nThreads)
  
          poolResults = []
          try:
              def log_result(result):
                  # This is called whenever foo_pool(i) returns a result.
                  # result_list is modified only by the main process, not the pool workers.
                  poolResults.append(result)
  
              for plat in platforms:
                  # We need to create all the arguments that will be needed
                  parameters = ( plat, nick, rutaDescarga, avoidProcessing, avoidDownload, verbosity)
                  pool.apply_async (pool_function, args=parameters, callback=log_result,)
  
              # Waiting for results to be finished
              while len(poolResults) < len(platforms):
                  time.sleep(1)
  
              # Closing normal termination
              pool.close()
          except KeyboardInterrupt:
              print(general.warning("\n[!] Process manually stopped by the user. Terminating workers.\n"))
              pool.terminate()
              print(general.warning("[!] The following platforms were not processed:"))
              pending = ""
              for p in platforms:
                  processed = False
                  for processedPlatform in poolResults:
                      if str(p) == processedPlatform["platform"]:
                          processed = True
                          break
                  if not processed:
                      print("\t- " + str(p))
                      pending += " " + str(p).lower()
              print("\n")
              print(general.warning("If you want to relaunch the app with these platforms you can always run the command with: "))
              print("\t usufy ... -p " + general.emphasis(pending))
              print("\n")
              print(general.warning("If you prefer to avoid these platforms you can manually evade them for whatever reason with: "))
              print("\t usufy ... -x " + general.emphasis(pending))
              print("\n")
          pool.join()
  
          # Collecting the results
          profiles = []
          errors = {}
          warnings = {}
  
          for info in poolResults:
              if info["status"] == "Ok":
                  array = json.loads(info["data"])
                  for r in array:
                      if r != "{}":
                          profiles.append(r)
              else:
                  e = info["status"]
                  if isinstance(e, OSRFrameworkError):
                      aux = errors.get(e.__class__.__name__, {})
                      aux["info"] = info["data"]
                      aux["counter"] = aux.get("counter", 0) + 1
                      errors[e.__class__.__name__] = aux
                  else:
                      aux = warnings.get(e.__class__.__name__, {})
                      aux["info"] = info["data"]
                      aux["counter"] = aux.get("counter", 0) + 1
                      warnings[e.__class__.__name__] = aux
          res += profiles
  
          if errors:
              now = dt.datetime.now()
              print("\n{}\tSome errors where found in the process:".format(now))
              for key, value in errors.items():
                  print(textwrap.fill("- {} (found: {}). Details:".format(general.error(key), general.error(value["counter"])), 90, initial_indent="\t"))
                  print(textwrap.fill("\t{}".format(value["info"]), 80, initial_indent="\t"))
  
          if warnings and verbosity >= 2:
              now = dt.datetime.now()
              print("\n{}\tSome warnings where found in the process:".format(now))
              for key, value in warnings.items():
                  print(textwrap.fill("- {} (found: {}). Details:".format(general.warning(key), general.warning(value["counter"])), 90, initial_indent="\t"))
                  print(textwrap.fill("\t{}".format(value["info"]), 80, initial_indent="\t"))
  
      return res