combien d'espace coûte un paquet et des dépendances donnés?

étant donné un nom de package, je veux savoir combien d'espace serait libéré si le package et ses dépendances étaient supprimés.

Comme les dépendances peuvent être partagées entre les packages, la bonne façon de le dire est peut-être la suivante: combien d'espace un package prend-il, y compris toutes les dépendances qui ne sont utilisées que par ce package

Je préférerais des solutions CLI, car je les utiliserais dans des scripts

Le moyen le plus simple et sans bug pour obtenir l'espace utilisé par un programme et toutes ses dépendances est d'utiliser apt lui-même. Notez que les dépendances qui ne sont pas utilisées par un autre programme, mais installées avec un package, ne sont pas prises en compte car elles ne sont pas supprimées.
Simplement

sudo apt-get --assume-no autoremove PACKAGENAME

ou

apt-space-used-by() { sudo apt-get --assume-no autoremove $@ | grep freed | cut -d' ' -f4-5 ;}

usage apt-space-used-by PACKAGENAME

Ce script python semble prometteur (bigpkg - recherchez les packages qui nécessitent beaucoup d'espace sur votre système)

• Essayez simplement la commande suivante (pour libérer de l'espace disque par purge):

  echo -n | sudo apt-get purge <package> | grep "disk space will be freed"
  

  ou

  echo -n | sudo apt-get purge --auto-remove <package> | grep "disk space will be freed"
  

  où remplacer <package>votre package-name(exemple: gimp)

  Cela ne purgera pas le paquet avec les dépendances mais ne donnera que l'espace disque qui sera libéré à l'aide de grep!

• Utilisation de dpkg --print-availou apt-cache show:

  apt-cache show <package> | grep "Installed-Size"
  

  ou

  dpkg --print-avail <package> | grep "Installed-Size"
  

  Cela affichera la taille installée de <package>.

  Exemple:

  $ apt-cache show gimp | grep "Installed-Size"
  Installed-Size: 15024
  

• Trier la liste des packages installés par taille

  dpkg-query -W -f='${Installed-Size;8}  ${Package}\n' | sort -n
  

  Vous pouvez en utiliser davantage pour les pages:

  dpkg-query -W -f='${Installed-Size;8}  ${Package}\n' | sort -n | more
  

  Au-dessus de la liste des packages en fonction de leur taille, vous pouvez utiliser tailpour répertorier les packages consommant la taille maximale comme suit:

  dpkg-query -W -f='${Installed-Size;8}  ${Package}\n' | sort -n | tail
  

• Utilisation dpigs(de l'homme dpigs):

  dpigs - Montre quels packages installés occupent le plus d'espace

  dpigs trie les packages installés par taille et génère les plus gros. Par défaut, dpigs affiche les 10 plus grands packages. Vous pouvez changer
     cette valeur en utilisant l'option -n (voir "OPTIONS"). Les informations sont extraites du fichier d'état dpkg avec grep-status (1)

  Cela peut être installé par: Exemple de commande d'exécutionsudo apt-get install debian-goodies
  

  $ dpigs
  115449 wine1.6-i386
  110356 linux-image-extra-3.13.0-24-generic
  103828 libreoffice-core
  86240 fonts-horai-umefont
  74016 libreoffice-common
  72709 liboxideqtcore0
  61736 linux-headers-3.13.0-24
  60821 libpyzy-1.0-0
  59477 firefox
  59443 thunderbird
  

• Trouver la taille du paquet non utilisé: -

  popularity-contest (8) - list the most popular Debian packages
  popcon-largest-unused (8) - List size of unused packages
  

  Exécutez d'abord popularity-contestet ensuite popcon-largest-unused, cela vous aidera à trouver la taille du paquet inutilisé. Consultez les pages de manuel pour plus d'informations.

J'ai fait de mon mieux pour fournir des commandes utiles par étapes.
J'espère que ces aides!

apt-cache show packagenamerépertorie, entre autres, la taille installée d'un package et les dépendances d'un package. Il doit également apt-cache rdepends packagenamerépertorier les packages qui utilisent ce package.

Vous souhaiterez peut-être utiliser cette dernière commande et apt-cache policy packagenamedéterminer si une dépendance inverse est installée.

Voici un script qui fait ça. Pas de sortie facile à utiliser.

sudo apt-get install python-apt

et vous êtes prêt à partir.

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

from __future__ import (absolute_import, division,
                        print_function, unicode_literals)
import apt
from apt.cache import Filter, FilteredCache

MB = 1024*1024

class InstalledFilter(Filter):
    def apply(self, pkg):
        return pkg.is_installed

def iter_base_deps(cache, package):
    deps = []
    version = package.installed
    for dep_type in ('Depends', 'PreDepends', 'Recommends'):
        deps.extend(version.get_dependencies(dep_type))
    for dep in deps:
        for base_dep in dep:
            if base_dep.name in cache:
                yield base_dep

def main():
    package_ref_count = {}
    results = []

    cache = FilteredCache(apt.Cache())
    cache.set_filter(InstalledFilter())
    for package in cache:
        for base_dep in iter_base_deps(cache, package):
            if base_dep.name in package_ref_count:
                package_ref_count[base_dep.name] += 1
            else:
                package_ref_count[base_dep.name] = 1

    for package in cache:
        base_deps_size = 0
        base_deps = []
        for base_dep in iter_base_deps(cache, package):
            if package_ref_count[base_dep.name] == 1:
                base_deps.append(base_dep)
                base_deps_size += cache[base_dep.name].installed.installed_size
        total_size = package.installed.installed_size + base_deps_size
        results.append((total_size, package, base_deps_size, base_deps))

    for total_size, package, base_deps_size, base_deps in sorted(results, reverse=True):
        if package.name in package_ref_count:
            continue
        if total_size < MB:
            break
        self_size = package.installed.installed_size
        base_dep_count = len(base_deps)
        print('{:.1f} MB  {}'.format(total_size/MB, package.name) + \
              (' with {} deps'.format(base_dep_count) if base_dep_count else ''))
        if base_dep_count:
            print('    {:.1f} MB  self'.format(self_size/MB))
            for base_dep in base_deps:
                size = cache[base_dep.name].installed.installed_size
                print('    {:.1f} MB  {}'.format(size/MB, base_dep.name))


if __name__ == '__main__':
    main()

Exemple de sortie:

72.6 MB  gthumb with 4 deps
    3.0 MB  self
    61.0 MB  libwebkit2gtk-3.0-25
    8.0 MB  gthumb-data
    0.1 MB  gstreamer0.10-gnomevfs
    0.5 MB  flex