Supprimer stdout / stderr imprimer à partir de fonctions Python

J'ai un script Python qui est l'utilisation de certaines fermé la boîte de fonctions Python (c'est à dire je ne peux pas modifier ces fonctions) fourni par mon employeur. Quand j'ai appeler ces fonctions, ils sont d'impression sortie de mon terminal linux que je voudrais supprimer. J'ai essayé de rediriger stdout /stderr via;

orig_out = sys.stdout
sys.stdout = StringIO()
rogue_function()
sys.stdout = orig_out

mais cela ne parvient pas à attraper la sortie. Je pense que les fonctions, je vais appeler via-Python (rogue_function() à partir de ci-dessus) sont vraiment des wrappers pour compilé en code C, qui sont en train de faire l'impression.

Personne ne sait d'une manière que je peux faire un "profond-capture" de toute impression remis à stdout /stderr par une fonction (et tous les sous-fonctions que les appels de fonction)?

Mise à JOUR:

J'ai fini par prendre la méthode décrite dans la réponse sélectionnée ci-dessous et l'écriture d'un gestionnaire de contexte de suppression des stdout et stderr:

# Define a context manager to suppress stdout and stderr.
class suppress_stdout_stderr(object):
    '''
    A context manager for doing a "deep suppression" of stdout and stderr in 
    Python, i.e. will suppress all print, even if the print originates in a 
    compiled C/Fortran sub-function.
       This will not suppress raised exceptions, since exceptions are printed
    to stderr just before a script exits, and after the context manager has
    exited (at least, I think that is why it lets exceptions through).      

    '''
    def __init__(self):
        # Open a pair of null files
        self.null_fds =  [os.open(os.devnull,os.O_RDWR) for x in range(2)]
        # Save the actual stdout (1) and stderr (2) file descriptors.
        self.save_fds = [os.dup(1), os.dup(2)]

    def __enter__(self):
        # Assign the null pointers to stdout and stderr.
        os.dup2(self.null_fds[0],1)
        os.dup2(self.null_fds[1],2)

    def __exit__(self, *_):
        # Re-assign the real stdout/stderr back to (1) and (2)
        os.dup2(self.save_fds[0],1)
        os.dup2(self.save_fds[1],2)
        # Close all file descriptors
        for fd in self.null_fds + self.save_fds:
            os.close(fd)

À utiliser il vous suffit de:

with suppress_stdout_stderr():
    rogue_function()

Cela fonctionne "assez bonne". Il ne réprimer l'impression de la rogue les fonctions qui ont été encombrer mon script. J'ai remarqué en testant qu'il laisse passer ont soulevé des exceptions ainsi que certains enregistreur d'impression, et je ne suis pas tout à fait clair pourquoi. Je pense qu'il a quelque chose à voir avec quand ces messages sont envoyés sur la sortie standard stdout /stderr (je pense qu'il se passe après mon gestionnaire de contexte sorties). Si quelqu'un peut confirmer, je serais intéressé par les détails ...

Ne cette approche (de la barre latérale) de travail?
Au lieu de définir sys.stdout à StringIO(), avez-vous essayé de le définir dans un fichier? c'est à dire sys.stdout = open('log.txt','w')
Dougal, merci, ça a l'air prometteur, je vais l'essayer demain. nullpointer, j'ai essayé de le diriger vers une coutume NullPointer() de la classe, et qui ne fonctionne pas non plus.
merci, cela a fonctionné! Si vous êtes si incliné, post ce lien comme une réponse et je vais sélectionner.
Je me demandais si il existe un moyen de supprimer toutes les données de sortie, et pas seulement le résultat qui vient à partir du code C. Je m'attends à ce que si je suis dans le contexte de avec suppress_stdout_stderr() ensuite, toutes les sorties doivent être intercepté. Des idées?
Juste une remarque que j'ai édité cet extrait légèrement de sorte que tous les descripteurs de fichiers sont fermés dans __exit__. Sans fermer la fd dans self.save_fds ce contexte, le gestionnaire a eu des fuites deux descripteurs de fichier à chaque fois qu'il a été appelé conduisant à l'exécution de descripteurs de fichiers dans le long processus en cours d'exécution.

InformationsquelleAutor jeremiahbuddha | 2012-06-21

python stdout

6

Cette approche (trouvé par le biais des barre latérale) pourrait fonctionner. Il réaffecte les descripteurs de fichier plutôt que de simplement les wrappers dans sys.stdout, etc.

InformationsquelleAutor Dougal

De python 3.5, nous pouvons le faire avec un minimum de travail à l'aide de built-ins dans contextlib, à savoir redirect_stdout et redirect_stderr. Nous avons seulement besoin de combiner ces deux construit-dans le contexte des gestionnaires dans un contexte personnalisé gestionnaire de la nôtre, qui peut être facilement fait en utilisant le joli motif de Martijn de réponse ici. Redirection deux sorties à os.devnull doit être sûr et portable.

from contextlib import contextmanager,redirect_stderr,redirect_stdout
from os import devnull

@contextmanager
def suppress_stdout_stderr():
    """A context manager that redirects stdout and stderr to devnull"""
    with open(devnull, 'w') as fnull:
        with redirect_stderr(fnull) as err, redirect_stdout(fnull) as out:
            yield (err, out)

Noter que la suppression de stderr vous donnera plein retraçage quand quelque chose se brise, ce qui est une bonne chose:

import sys

def rogue_function():
    print('spam to stdout')
    print('important warning', file=sys.stderr)
    1 + 'a'
    return 42

with suppress_stdout_stderr():
    rogue_function()

Quand exécuter le dessus imprime seulement les

Traceback (most recent call last):
  File "tmp.py", line 20, in <module>
    rogue_function()
  File "foo.py", line 16, in rogue_function
    1 + 'a'
TypeError: unsupported operand type(s) for +: 'int' and 'str'

à la borne. Les exceptions non gérées ne doit jamais passer inaperçu.

InformationsquelleAutor Andras Deak

Ma solution est semblable à la vôtre, mais utilise contextlib et est un peu plus court et plus facile à comprendre (à mon humble avis).

import contextlib


@contextlib.contextmanager
def stdchannel_redirected(stdchannel, dest_filename):
    """
    A context manager to temporarily redirect stdout or stderr

    e.g.:


    with stdchannel_redirected(sys.stderr, os.devnull):
        if compiler.has_function('clock_gettime', libraries=['rt']):
            libraries.append('rt')
    """

    try:
        oldstdchannel = os.dup(stdchannel.fileno())
        dest_file = open(dest_filename, 'w')
        os.dup2(dest_file.fileno(), stdchannel.fileno())

        yield
    finally:
        if oldstdchannel is not None:
            os.dup2(oldstdchannel, stdchannel.fileno())
        if dest_file is not None:
            dest_file.close()

Le contexte pour laquelle j'ai créé ce est à ce blog. Semblable à la vôtre, je pense.

Je l'utilise comme cela dans un setup.py:

with stdchannel_redirected(sys.stderr, os.devnull):
    if compiler.has_function('clock_gettime', libraries=['rt']):
        libraries.append('rt')

InformationsquelleAutor Marc Abramowitz

2

Avez-vous essayer de rediriger stderr trop?
par exemple,
```
sys.stdout = StringIO()
sys.stderr = StringIO()
foo(bar)
sys.stdout = sys.__stdout__ # These are provided by python
sys.stderr = sys.__stderr__
```
Également à l'aide de StringIO peut utiliser de la mémoire supplémentaire. Vous pouvez utiliser un mannequin de l'appareil à la place (par exemple http://coreygoldberg.blogspot.com/2009/05/python-redirect-or-turn-off-stdout-and.html).
- Ouais, j'ai essayé les deux, stdout et stderr, pas de dés ...
- Il se pourrait que le code C est écrit directement sur la sortie standard; vous n'auriez probablement pas être en mesure de rediriger les que. Désolé.
- Sont-elles compatibles avec Python 3?
InformationsquelleAutor Bob

Pas vraiment demandé par l'OP, mais j'avais besoin de cacher et de stocker la sortie, et a fait comme suit:

from io import StringIO
import sys

class Hider:
    def __init__(self, channels=('stdout',)):
        self._stomach = StringIO()
        self._orig = {ch : None for ch in channels}

    def __enter__(self):
        for ch in self._orig:
            self._orig[ch] = getattr(sys, ch)
            setattr(sys, ch, self)
        return self

    def write(self, string):
        self._stomach.write(string)

    def flush(self):
        pass

    def autopsy(self):
        return self._stomach.getvalue()

    def __exit__(self, *args):
        for ch in self._orig:
            setattr(sys, ch, self._orig[ch])

Utilisation:

with Hider() as h:
    spammy_function()
    result = h.autopsy()

(testé uniquement avec Python 3)

EDIT: permet maintenant de sélectionner stderr, stdout ou les deux, comme dans Hider([stdout, stderr])

ce doit être la accepté de répondre pour python 3 ! on pourrait également ajouter rare._stderr == sys.stderr; sys.stderr = auto <...>
généralisé un peu, merci pour la suggestion

InformationsquelleAutor Pietro Battiston

- Je utiliser un décorateur pour cela. Il enregistre sys.stdout et sys.stderr références et rend ces variables point à null. Puis, après l'exécution de la fonction de l'origine des références sont extraites. Il est important de noter le try/except bloc, qui permet la récupération des références d'origine, même si une exception est levée sur la fonction.

def suppress_std(func):
    def wrapper(*args, **kwargs):
        stderr_tmp = sys.stderr
        stdout_tmp = sys.stdout
        null = open(os.devnull, 'w')
        sys.stdout = null
        sys.stderr = null
        try:
            result = func(*args, **kwargs)
            sys.stderr = stderr_tmp
            sys.stdout = stdout_tmp
            return result
        except:
            sys.stderr = stderr_tmp
            sys.stdout = stdout_tmp
            raise
    return wrapper

À utiliser:

@suppress_std
def function_std_suppressed():
    # code here

InformationsquelleAutor Vítor Cézar

python 3.6 version de travail, testé avec des millions de suppressions sans erreurs

import os
import sys

class suppress_stdout_stderr(object):
    def __enter__(self):
        self.outnull_file = open(os.devnull, 'w')
        self.errnull_file = open(os.devnull, 'w')

        self.old_stdout_fileno_undup    = sys.stdout.fileno()
        self.old_stderr_fileno_undup    = sys.stderr.fileno()

        self.old_stdout_fileno = os.dup ( sys.stdout.fileno() )
        self.old_stderr_fileno = os.dup ( sys.stderr.fileno() )

        self.old_stdout = sys.stdout
        self.old_stderr = sys.stderr

        os.dup2 ( self.outnull_file.fileno(), self.old_stdout_fileno_undup )
        os.dup2 ( self.errnull_file.fileno(), self.old_stderr_fileno_undup )

        sys.stdout = self.outnull_file        
        sys.stderr = self.errnull_file
        return self

    def __exit__(self, *_):        
        sys.stdout = self.old_stdout
        sys.stderr = self.old_stderr

        os.dup2 ( self.old_stdout_fileno, self.old_stdout_fileno_undup )
        os.dup2 ( self.old_stderr_fileno, self.old_stderr_fileno_undup )

        os.close ( self.old_stdout_fileno )
        os.close ( self.old_stderr_fileno )

        self.outnull_file.close()
        self.errnull_file.close()

InformationsquelleAutor iperov

-2

Si vous exécutez ce script sur un linux en fonction de la machine, vous devriez être capable de:
```
$> ./runscript.py > output.txt
```
- Je ne veux pas supprimer toutes les données de sortie généré par le script, seule la sortie parasite généré par ces fonctions particulières. Sinon, ouais, ce serait la solution la plus simple ...
- Serait-ce de l'aide: Ajouter une impression avant et après ces fonction particulière. Analyser les données en sortie avec une regex pour se débarrasser de tout ce qui est entre les gravures ajoutées au-dessus de
InformationsquelleAutor GeneralBecos

Vous devez vous connecter pour publier un commentaire.