Przekazywanie danych między skryptami

Zadałem pytanie na SO, ale zero odzewu - wiem, zapowiada się bardzo źle.
Daję link do pytania na SO: https://stackoverflow.com/questions/71202469/python-output-from-another-python-script

W każdym razie problem polega na tym, że gdy przekazuję dane pomiędzy skryptami debugując/uruchamiając skrypt w PyCharmie wszystko działa super. Puszczam skrypt osobno poza PyCharm intepreterem pythona z takimi samymi argumentami i nie dostaję na outpucie konsoli żadnych danych z drugiego skryptu.
Może mi ktoś wskazać gdzie w ogóle szukać rozwiązania? W linku jest kawałek kodu od tego w jaki sposób wołam skrypty i co drukuję z drugiego skryptu.

Ok, a jakieś logi z Jenkinsa, co tam się dzieje?
A w ogóle to to, jak opisałeś problem na SO, trza sobie głowę połamać, żeby to zrozumieć; koniec końców wydaje się, że Masz problem z logami:D

Zdziwiłbym sie jakby ci ktoś odpowiedział. Błędy zgłasza się tak:

1. Co zrobiłeś (kompletne reproduction steps)
2. Co wg ciebie powinno się stać
3. Co się faktycznie stało

Z twojego opisu w sumie nie wiadomo z czym konkretnie jest problem.
A teraz co mówi dokumentacja:

https://docs.python.org/3/library/subprocess.html#subprocess.check_call

Code needing to capture stdout or stderr should use run() instead

hmm

As you can see I write stderr and stdout to temporary files (error and output)

Ja nic takiego nie widzę. Piszesz do jakiegoś loggera, nie wiadomo skąd i nie wiadomo jak. Potem nie wiadomo jak otwierasz ten plik z logami i co w ogóle przekazujesz do tej swojej funkcji printCheckOutput i nie pokazałe też co robi to twoje collectLogFromOutAndErr.
Warto moze byłoby tez napisać na którym etapie coś się sypie -> czy ten twój logger nie tworzy w ogóle pliku z logami (może nie jest flushnięty?), czy pliki z logami się tworzą, ale twoje collectLogFromOutAndErr nie potrafi ich poskładać w jeden wynikowy plik (znów: może nie flushujesz albo nie zamykasz pliku?), czy może te pliki się tworzą ok, ale twoja funkcja printCheckOutput nie wyłapuje tego co powinna wyłapać (może kodowanie jest zrypane?).

Mam nadzieje że wiesz ze jak wołasz jeden skrypt z drugiego przez subprocess.call to odpala sie nowy interpreter i te skrypty niczego nie "współdzielą"?
Mam nadzieje ze wiesz też, że jeśli próbujesz przepchać jakieś dane między tymi procesami przez stdin/stdout to trzeba uważać na to, zeby nie trafić na wypełnienie bufora systemowego. Może się tak łatwo zdarzyc że proces pisze na stdout ale drugi proces który ma to czytać czeka aż ten pierwszy się zakończy zanim odczyta, a to nigdy nie następuje, bo pierwszy się blokuje jak bufor na stdout jest pełny, bo nikt z niego nie czyta. W efekcie trzeba generalnie czytać periodycznie a nie czekać aż drugi proces się skończy.

Moja rada: zrób mały alekompletny przykład kodu który po uruchomieniu nie działa i pokazuje konkretnie twój problem.

Stosując się do części rad @Shalom edytowałem mój post na SO. W każdym razie spróbuję zrobić mniejszy przykład, aczkolwiek problem rozbija się o to że w konsoli PyCharma działa wszystko dobrze a w systemowej już nie. Pogrzebię w sieci jeszcze może ta konsola zupełnie inaczej działa niż ta systemowa, na przykład jest o wiele większa. Pliki tymczasowe się tworzą.

Pliki tymczasowe się tworzą.

Ale co dalej? Zawierają jakiś content? Nie zawierają? Nie widzę u ciebie w kodzie __exit__ i zamykania tych plików, więc mogą sie w ogóle nie flushować. Nadal nie potrafisz jasno napisać w którym miejscu ci coś nie działa. Twój opis to nadal dramat i nikt ci nie odpowie, bo nie wiadomo z czym masz problem.

Przesyłam wyciętą na potrzeby wytłumaczenia przykładu część skryptów. Przy czym te tutaj przykłady działają tak jak chcę to znaczy jest wymiana danych między tymi skryptami.
script_A.py. Pliki tymczasowe oraz z logiem się tworzy i jest w nim pełna oczekiwana zawartość.

import tempfile
import os
import sys
import subprocess

LOG_FILE_PATH_DEF = "log_file.txt"


def append_file_to_file(out_file, in_file):
    for line in in_file:
        out_file.write(line)


class CompilationLogger:

    def __init__(self, log_file_path=LOG_FILE_PATH_DEF):
        self._log_file_path = log_file_path
        self._tmp_err = None
        self._tmp_out = None
        self._log_file = None

    def __enter__(self):
        self._log_file = open(self._log_file_path, 'w+')
        self._tmp_err = tempfile.TemporaryFile(mode='w+', dir=os.path.dirname(os.path.abspath(self._log_file_path)),
                                               encoding="UTF-8")
        self._tmp_out = tempfile.TemporaryFile(mode='w+', dir=os.path.dirname(os.path.abspath(self._log_file_path)),
                                               encoding="UTF-8")
        return self

    def __exit__(self, *args):
        self._tmp_err.close()
        self._tmp_out.close()
        self._log_file.close()

    def get_err_file_handler(self):
        return self._tmp_err

    def get_out_file_handler(self):
        return self._tmp_out

    def collect_log_from_out_and_err(self):
        self._tmp_out.seek(0)
        append_file_to_file(self._tmp_err, self._tmp_out)
        self._tmp_err.seek(0)
        self.print_summary_messages(self._tmp_err)
        self._tmp_err.seek(0)
        append_file_to_file(self._log_file, self._tmp_err)
        self._tmp_err.seek(0)
        string = self._tmp_err.read()
        if string.__contains__("warning"):
            raise

    def print_and_log(self, msg):
        print(msg)
        self._log_file.write(msg + '\n')
        sys.stdout.flush()

    @staticmethod
    def print_summary_messages(messages_file):
        for line in messages_file:
            if 'warning' in line or 'error:' in line:
                print(line, end='')
        sys.stdout.flush()


if __name__ == '__main__':
    with CompilationLogger() as comp_logger:
        command = "python " + "script_B.py"

        try:
            subprocess.check_call(command, stdin=subprocess.PIPE, stdout=comp_logger.get_out_file_handler(),
                                  stderr=comp_logger.get_err_file_handler())
        except subprocess.CalledProcessError:
            failed = 1

        try:
            comp_logger.collect_log_from_out_and_err()
        except:
            failed = 1

    if failed:
        sys.exit(1)

script_B.py

import sys

if __name__ == '__main__':
    print("I sent something to stdout, ok?")
    for i in range(100000):
        print("{} warning".format(i))
    sys.exit(1)

python script_A.py by wywołać test mając oba skrypty w jednej lokalizacji.

Nie ma żadej pewności ze to co pisał skrypt B do twoich loggerów się flushowało, a ty potem robisz jakieś seek i czytasz.