Skip to content
The Chat Archive
grok-3-mini-beta· xAI LMArena Human Preference 140K

EJ MORDO POWIEDZ MI JEDNA RZECZ BO SKORO MAM TUTAJ FUNKCJE KTORA ODCZYTUJE DANE Z…

  1. User

    EJ MORDO POWIEDZ MI JEDNA RZECZ BO SKORO MAM TUTAJ FUNKCJE KTORA ODCZYTUJE DANE Z OTWARTEJ POZYCJI TYPU ENTRY SL ORAZ TP TO SKAD POBIERAM DANE CZASU ZAMKNIECIA POZYCJI? SKORO PRZY OTWARCIU PRZECIEZ JESZCZE NIE MA TYCH DANYCH?

    def load_closed_positions_from_csv(self, filepath: str):
        if not os.path.exists(filepath):
            self.closed_positions_table.setRowCount(0)
            return
    
        max_retries = 5
        for attempt in range(max_retries):
            try:
                with open(filepath, "rb") as f:
                    content = f.read()
                    content_hash = hash(content)
    
                if hasattr(self, "last_closed_positions_hash") and self.last_closed_positions_hash == content_hash:
                    return
                self.last_closed_positions_hash = content_hash
    
                decoded_content = content.decode("utf-8", errors="ignore")
                sample = decoded_content[:1024]
                csvfile = io.StringIO(decoded_content)
    
                csvfile = io.StringIO(decoded_content)
    
                # 👇 Wymuszamy obsługę pliku rozdzielanego tabulatorem
                dialect = csv.excel_tab
    
                reader = csv.reader(csvfile, dialect)
                next(reader, None)  # nagłówek
    
                new_tickets = set()
                self.closed_positions_table.setRowCount(0)
    
                def safe_float(s):
                    try:
                        return float(s.strip().replace('\xa0', '').replace(',', '.'))
                    except Exception:
                        return None
    
                def determine_close_reason(row_data):
                    global closed_by_ts_candidates  # Dostęp do globalnego setu
    
                    try:
                        ticket = row_data[0]
                        close_price = safe_float(row_data[6])
                        sl = safe_float(row_data[7])
                        tp = safe_float(row_data[8])
    
                        if close_price is None or close_price < 1e-6:
                            return None
    
                        # Ustawiamy bardziej realistyczną tolerancję na poślizg (np. 5 punktów)
                        TOLERANCE = 5e-4
    
                        # 1. Najpierw sprawdzamy, czy to nasz kandydat z Trailing Stopa
                        # Warunek sl > 0 jest ważny, żeby nie sprawdzać pozycji bez SL
                        if ticket in closed_by_ts_candidates and sl is not None and sl > 0 and abs(
                                close_price - sl) < TOLERANCE:
                            closed_by_ts_candidates.remove(ticket)
                            return "Trailing Stop"
    
                        # 2. Sprawdzamy standardowy SL
                        # Dodajemy warunek sl > 0, aby ignorować puste/zerowe wartości SL
                        if sl is not None and sl > 0 and abs(close_price - sl) < TOLERANCE:
                            return "SL"
    
                        # 3. Sprawdzamy standardowy TP
                        # Dodajemy warunek tp > 0
                        elif tp is not None and tp > 0 and abs(close_price - tp) < TOLERANCE:
                            return "TP"
    
                        # 4. Jeśli żaden z powyższych, to było zamknięcie ręczne
                        else:
                            # Jeśli ticket był kandydatem na TS, ale warunki nie pasowały, usuwamy go
                            if ticket in closed_by_ts_candidates:
                                closed_by_ts_candidates.remove(ticket)
                            return "ręcznie"
    
                    except Exception as e:
                        print(f"[ERROR] determine_close_reason failed: {e}")
                        return "Unknown"
    
                if not hasattr(self, "tickets_status"):
                    self.tickets_status = {}
    
                # Sprawdź wiek pliku — jeśli bardzo świeży, to nie suppressuj
                file_age = time.time() - os.path.getmtime(filepath)
                suppress_initial_notifications = file_age > 5  # jeśli starszy niż 5 sekund → uznaj za stare pozycje
    
                tickets_status_changed = False
    
                for row_data in reader:
                    if len(row_data) < 11:
                        print(f"⚠️ Pominięto niekompletny wiersz: {row_data}")
                        continue
                    ticket = row_data[0]
                    new_tickets.add(ticket)
    
                    row = self.closed_positions_table.rowCount()
                    self.closed_positions_table.insertRow(row)
    
                    ordered_data = [
                        row_data[0],  # Ticket
                        row_data[1],  # Entry time
                        row_data[2],  # Symbol
                        row_data[3],  # Type
                        row_data[4],  # Volume
                        row_data[5],  # Entry price
                        row_data[6],  # Close price
                        row_data[7],  # SL
                        row_data[8],  # TP
                        row_data[9],  # Close time
                        row_data[10],  # Profit
                    ]
    
                    for col, data in enumerate(ordered_data):
                        item = QTableWidgetItem(data)
                        item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
    
                        if col == 10:  # Profit column
                            try:
                                profit_value = float(data)
                                if profit_value < 0:
                                    item.setBackground(QColor(200, 100, 100))
                                elif profit_value > 0:
                                    item.setBackground(QColor(100, 150, 100))
                            except ValueError:
                                pass
    
                        self.closed_positions_table.setItem(row, col, item)
    
                    close_price = safe_float(row_data[6])
                    status = self.tickets_status.get(ticket, None)
    
                    if status is None:
                        # Nowy ticket – uznaj go za widziany tylko jeśli suppressujemy
                        self.tickets_status[ticket] = suppress_initial_notifications
                        tickets_status_changed = True
    
                    elif status is False and close_price is not None and close_price > 0:
                        # Pojawiła się nowa zamknięta pozycja
                        reason = determine_close_reason(row_data)
                        symbol = row_data[2]
                        profit = row_data[10]
    
                        try:
                            profit_value = float(profit)
                            if profit_value < 0:
                                emoji = "📉"
                            elif profit_value > 0:
                                emoji = "📈"
                            else:
                                emoji = "🔁"
                        except Exception:
                            emoji = "🔒"
    
                        message = f"{emoji} Pozycja [{ticket}] zamknięta {reason} (zysk: {profit})\n"
                        logger.info(message)
                        log_console.scroll_to_bottom()
                        notify("TorekMarketKiller", message)
    
                        self.tickets_status[ticket] = True
                        tickets_status_changed = True
    
                # Usuwamy tickety, których nie ma już w pliku
                for saved_ticket in list(self.tickets_status.keys()):
                    if saved_ticket not in new_tickets:
                        del self.tickets_status[saved_ticket]
                        tickets_status_changed = True
    
                if tickets_status_changed:
                    self.save_seen_tickets(self.tickets_status)
    
                break
    
            except PermissionError:
                if attempt < max_retries - 1:
                    time.sleep(0.4)
                else:
                    print(f"❌ Nie udało się odczytać pliku {filepath} po kilku próbach.")
    
  2. Assistant

    Hej, spokojnie, nie ma co się denerwować! 😄 Widzę, że masz na myśli kod, który obsługuje odczyt danych z otwartych pozycji (jak Entry, SL i TP), a teraz zastanawiasz się, skąd wziąć dane czasu zamknięcia pozycji (czyli "Close time"). Przejdźmy przez to krok po kroku, bo to całkiem proste, ale zrozumiałe, że może być mylące na pierwszy rzut oka.

    1. Główne założenie: Dane czasu zamknięcia nie są dostępne przy otwarciu pozycji

    • Masz rację – przy otwieraniu pozycji (np. kiedy ustawiasz Entry, SL lub TP) jeszcze nie wiesz, kiedy ona się zamknie, bo to zależy od rynku, warunków itp. Dlatego te dane (jak "Close time") nie są generowane w momencie otwierania, tylko po fakcie, czyli po zamknięciu pozycji.
    • W twoim kodzie, funkcja load_closed_positions_from_csv zajmuje się zamkniętymi pozycjami, więc dane te są już dostępne w pliku CSV, który jest źródłem informacji.

    2. Skąd pobierasz dane czasu zamknięcia?

    • Źródło: Plik CSV. W twoim kodzie, dane czasu zamknięcia pozycji są pobierane bezpośrednio z pliku CSV, który odczytujesz. Konkretnie:

      • W pliku CSV, kolumna z czasem zamknięcia to row_data[9] (jak widać w kodzie).
      • Kiedy funkcja load_closed_positions_from_csv przetwarza wiersze z pliku, ładuje te dane do tabeli (self.closed_positions_table) i umieszcza je w odpowiedniej kolumnie.

      Przykładowy fragment kodu, który to pokazuje:

      ordered_data = [
          row_data[0],  # Ticket
          row_data[1],  # Entry time
          row_data[2],  # Symbol
          row_data[3],  # Type
          row_data[4],  # Volume
          row_data[5],  # Entry price
          row_data[6],  # Close price
          row_data[7],  # SL
          row_data[8],  # TP
          row_data[9],  # Close time  <--- TO JEST TWOJE DANE CZASU ZAMKNIĘCIA!
          row_data[10],  # Profit
      ]
      
      • Dla każdego wiersza z pliku, row_data[9] to string reprezentujący czas zamknięcia (np. "2023-10-01 14:30:00" lub coś w tym stylu, w zależności od formatu w pliku).
    • Jak to działa w praktyce?

      • Plik CSV jest prawdopodobnie generowany przez twoją platformę tradingową (np. MT4/MT5, albo inny system), który automatycznie zapisuje historię transakcji. Kiedy pozycja się zamyka (np. przez SL, TP, ręcznie lub trailing stop), system aktualizuje plik CSV z nowymi danymi, w tym z czasem zamknięcia.
      • Twoja funkcja po prostu odczytuje ten plik i parsuje go. Jeśli plik jest aktualizowany regularnie (np. co kilka sekund), to nowe dane o zamknięciach będą dostępne w kolejnych wywołaniach funkcji.

    3. Co jeśli plik CSV nie jest aktualizowany?

    • Jeśli dane czasu zamknięcia nie pojawiają się w pliku, to problem leży po stronie źródła danych (np. twojego oprogramowania tradingowego). Upewnij się, że:

      • Plik CSV jest prawidłowo konfigurowany do zapisu zamkniętych pozycji.
      • Masz dostęp do pełnego pliku (np. nie jest on blokowany przez inny proces).
      • W twoim kodzie jest obsługa błędów – widzisz, że jest tam mechanizm z retry (do 5 prób), co pomaga, jeśli plik jest chwilowo niedostępny.

      Jeśli plik nie zawiera kolumny z "Close time", to albo:

      • Musisz sprawdzić format pliku CSV (może coś się zmieniło).
      • Albo zmodyfikować kod, aby obsłużyć brakujące dane (np. dodać obsługę wyjątków dla tej kolumny).

    4. Jak to zintegrować z resztą kodu?

    • W twojej funkcji, dane z "Close time" są już ładowane i wyświetlane w tabeli. Jeśli chcesz coś z nimi zrobić (np. analizować lub logować), możesz dodać kod po linii, gdzie przetwarzasz ordered_data. Na przykład:
      close_time = row_data[9]  # Pobranie czasu zamknięcia
      if close_time:  # Sprawdź, czy nie jest puste
          print(f"Pozycja zamknięta o: {close_time}")
          # Możesz tu dodać logowanie lub dalszą obróbkę
      
    • Jeśli potrzebujesz czasu zamknięcia dla otwartych pozycji (co jest niemożliwe w momencie otwierania), to musiałbyś czekać na aktualizację pliku CSV po zamknięciu.

    Podsumowanie:

    • Skąd pobierasz dane? Z pliku CSV, konkretnie z kolumny row_data[9].
    • Dlaczego to działa? Bo plik CSV jest aktualizowany po zamknięciu pozycji, a twoja funkcja go odczytuje.
    • Jeśli masz problemy z brakiem danych, sprawdź:
      • Czy plik CSV jest poprawnie generowany.
      • Czy kod ma dostęp do całego pliku (np. brak błędów permisji).
      • Jeśli chcesz pogadać o modyfikacjach kodu, daj znać – mogę pomóc z przykładami!

    Jeśli to nie wyjaśnia wszystkiego, rzuć więcej szczegółów, co dokładnie masz na myśli. Powodzenia z TorekMarketKiller! 🚀

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.