mirror of
https://github.com/Azornes/Comfyui-LayerForge.git
synced 2026-03-21 20:52:12 -03:00
Add logging system
This commit is contained in:
Dariusz L
316
README_LOGGER.md
Normal file
316
README_LOGGER.md
Normal file
@@ -0,0 +1,316 @@
|
||||
# System Logowania dla ComfyUI-LayerForge
|
||||
|
||||
Ten dokument opisuje system logowania zaimplementowany dla projektu ComfyUI-LayerForge, który umożliwia łatwe zarządzanie debugowaniem kodu zarówno w części JavaScript, jak i Python.
|
||||
|
||||
## Spis treści
|
||||
|
||||
1. [Wprowadzenie](#wprowadzenie)
|
||||
2. [Konfiguracja](#konfiguracja)
|
||||
3. [Użycie w JavaScript](#użycie-w-javascript)
|
||||
4. [Użycie w Python](#użycie-w-python)
|
||||
5. [Poziomy logowania](#poziomy-logowania)
|
||||
6. [Zarządzanie logami](#zarządzanie-logami)
|
||||
7. [Przykłady](#przykłady)
|
||||
|
||||
## Wprowadzenie
|
||||
|
||||
System logowania ComfyUI-LayerForge został zaprojektowany, aby zapewnić:
|
||||
|
||||
- Spójne logowanie w całym projekcie (JavaScript i Python)
|
||||
- Możliwość włączania/wyłączania logów globalnie lub per moduł
|
||||
- Różne poziomy logowania (DEBUG, INFO, WARN, ERROR)
|
||||
- Kolorowe logi w konsoli
|
||||
- Możliwość zapisywania logów do plików
|
||||
- Eksport logów do analizy
|
||||
|
||||
## Konfiguracja
|
||||
|
||||
### Konfiguracja JavaScript
|
||||
|
||||
```javascript
|
||||
// Importuj logger
|
||||
import {logger, LogLevel} from "./logger.js";
|
||||
|
||||
// Konfiguracja globalna
|
||||
logger.configure({
|
||||
globalLevel: LogLevel.INFO, // Domyślny poziom logowania
|
||||
useColors: true, // Kolorowe logi w konsoli
|
||||
saveToStorage: true, // Zapisywanie logów do localStorage
|
||||
maxStoredLogs: 1000 // Maksymalna liczba przechowywanych logów
|
||||
});
|
||||
|
||||
// Konfiguracja per moduł
|
||||
logger.setModuleLevel('Canvas', LogLevel.DEBUG);
|
||||
logger.setModuleLevel('API', LogLevel.WARN);
|
||||
|
||||
// Włączanie/wyłączanie globalnie
|
||||
logger.setEnabled(true); // Włącz wszystkie logi
|
||||
logger.setEnabled(false); // Wyłącz wszystkie logi
|
||||
```
|
||||
|
||||
### Konfiguracja Python
|
||||
|
||||
```python
|
||||
# Importuj logger
|
||||
from python.logger import logger, LogLevel, set_debug, set_file_logging
|
||||
|
||||
# Konfiguracja globalna
|
||||
logger.configure({
|
||||
'global_level': LogLevel.INFO,
|
||||
'use_colors': True,
|
||||
'log_to_file': True,
|
||||
'log_dir': 'logs',
|
||||
'max_file_size_mb': 10,
|
||||
'backup_count': 5
|
||||
})
|
||||
|
||||
# Konfiguracja per moduł
|
||||
logger.set_module_level('canvas_node', LogLevel.DEBUG)
|
||||
logger.set_module_level('api', LogLevel.WARN)
|
||||
|
||||
# Szybkie włączanie debugowania
|
||||
set_debug(True) # Ustawia globalny poziom na DEBUG
|
||||
set_debug(False) # Ustawia globalny poziom na INFO
|
||||
|
||||
# Włączanie/wyłączanie logowania do pliku
|
||||
set_file_logging(True, 'custom_logs')
|
||||
```
|
||||
|
||||
### Konfiguracja przez zmienne środowiskowe (Python)
|
||||
|
||||
Możesz również skonfigurować logger Python za pomocą zmiennych środowiskowych:
|
||||
|
||||
```bash
|
||||
# Poziom globalny (DEBUG, INFO, WARN, ERROR, NONE)
|
||||
export LAYERFORGE_LOG_LEVEL=DEBUG
|
||||
|
||||
# Ustawienia modułów (format JSON)
|
||||
export LAYERFORGE_MODULE_LEVELS='{"canvas_node": "DEBUG", "api": "WARN"}'
|
||||
|
||||
# Inne ustawienia
|
||||
export LAYERFORGE_USE_COLORS=true
|
||||
export LAYERFORGE_LOG_TO_FILE=true
|
||||
export LAYERFORGE_LOG_DIR=logs
|
||||
export LAYERFORGE_MAX_FILE_SIZE_MB=10
|
||||
export LAYERFORGE_BACKUP_COUNT=5
|
||||
```
|
||||
|
||||
## Użycie w JavaScript
|
||||
|
||||
### Podstawowe użycie
|
||||
|
||||
```javascript
|
||||
import {logger, LogLevel} from "./logger.js";
|
||||
|
||||
// Inicjalizacja loggera dla modułu
|
||||
const log = {
|
||||
debug: (...args) => logger.debug('MojModul', ...args),
|
||||
info: (...args) => logger.info('MojModul', ...args),
|
||||
warn: (...args) => logger.warn('MojModul', ...args),
|
||||
error: (...args) => logger.error('MojModul', ...args)
|
||||
};
|
||||
|
||||
// Używanie loggera
|
||||
log.debug("To jest wiadomość debugowania");
|
||||
log.info("To jest informacja");
|
||||
log.warn("To jest ostrzeżenie");
|
||||
log.error("To jest błąd");
|
||||
|
||||
// Logowanie obiektów
|
||||
log.debug("Dane użytkownika:", { id: 123, name: "Jan Kowalski" });
|
||||
|
||||
// Logowanie błędów
|
||||
try {
|
||||
// Kod, który może rzucić wyjątek
|
||||
} catch (error) {
|
||||
log.error("Wystąpił błąd:", error);
|
||||
}
|
||||
```
|
||||
|
||||
### Dostęp z konsoli przeglądarki
|
||||
|
||||
Logger jest dostępny globalnie w przeglądarce jako `window.LayerForgeLogger`, co umożliwia łatwe debugowanie:
|
||||
|
||||
```javascript
|
||||
// W konsoli przeglądarki
|
||||
LayerForgeLogger.setGlobalLevel(LayerForgeLogger.LogLevel.DEBUG);
|
||||
LayerForgeLogger.setModuleLevel('Canvas', LayerForgeLogger.LogLevel.DEBUG);
|
||||
LayerForgeLogger.exportLogs('json'); // Eksportuje logi do pliku JSON
|
||||
```
|
||||
|
||||
## Użycie w Python
|
||||
|
||||
### Podstawowe użycie
|
||||
|
||||
```python
|
||||
from python.logger import debug, info, warn, error, exception
|
||||
|
||||
# Używanie funkcji pomocniczych
|
||||
debug('canvas_node', 'To jest wiadomość debugowania')
|
||||
info('canvas_node', 'To jest informacja')
|
||||
warn('canvas_node', 'To jest ostrzeżenie')
|
||||
error('canvas_node', 'To jest błąd')
|
||||
|
||||
# Logowanie wyjątków
|
||||
try:
|
||||
# Kod, który może rzucić wyjątek
|
||||
except Exception as e:
|
||||
exception('canvas_node', f'Wystąpił błąd: {str(e)}')
|
||||
```
|
||||
|
||||
### Używanie funkcji pomocniczych w module
|
||||
|
||||
```python
|
||||
from python.logger import logger, LogLevel, debug, info, warn, error, exception
|
||||
|
||||
# Funkcje pomocnicze dla modułu
|
||||
log_debug = lambda *args, **kwargs: debug('moj_modul', *args, **kwargs)
|
||||
log_info = lambda *args, **kwargs: info('moj_modul', *args, **kwargs)
|
||||
log_warn = lambda *args, **kwargs: warn('moj_modul', *args, **kwargs)
|
||||
log_error = lambda *args, **kwargs: error('moj_modul', *args, **kwargs)
|
||||
log_exception = lambda *args: exception('moj_modul', *args)
|
||||
|
||||
# Używanie funkcji pomocniczych
|
||||
log_debug("To jest wiadomość debugowania")
|
||||
log_info("To jest informacja")
|
||||
log_warn("To jest ostrzeżenie")
|
||||
log_error("To jest błąd")
|
||||
```
|
||||
|
||||
## Poziomy logowania
|
||||
|
||||
System logowania obsługuje następujące poziomy:
|
||||
|
||||
- **DEBUG** - Szczegółowe informacje, przydatne podczas debugowania
|
||||
- **INFO** - Ogólne informacje o działaniu aplikacji
|
||||
- **WARN** - Ostrzeżenia, które nie powodują błędów, ale mogą prowadzić do problemów
|
||||
- **ERROR** - Błędy, które uniemożliwiają wykonanie operacji
|
||||
- **NONE** - Wyłącza wszystkie logi
|
||||
|
||||
## Zarządzanie logami
|
||||
|
||||
### JavaScript
|
||||
|
||||
```javascript
|
||||
// Eksport logów do pliku
|
||||
logger.exportLogs('json'); // Eksportuje logi do pliku JSON
|
||||
logger.exportLogs('txt'); // Eksportuje logi do pliku tekstowego
|
||||
|
||||
// Czyszczenie logów
|
||||
logger.clearLogs();
|
||||
```
|
||||
|
||||
### Python
|
||||
|
||||
Logi Python są automatycznie zapisywane do plików w katalogu `logs` (lub innym skonfigurowanym), jeśli włączono opcję `log_to_file`. Pliki logów są rotowane, gdy osiągną określony rozmiar.
|
||||
|
||||
## Przykłady
|
||||
|
||||
### Przykład użycia w JavaScript
|
||||
|
||||
```javascript
|
||||
import {logger, LogLevel} from "./logger.js";
|
||||
|
||||
// Inicjalizacja loggera dla modułu Canvas
|
||||
const log = {
|
||||
debug: (...args) => logger.debug('Canvas', ...args),
|
||||
info: (...args) => logger.info('Canvas', ...args),
|
||||
warn: (...args) => logger.warn('Canvas', ...args),
|
||||
error: (...args) => logger.error('Canvas', ...args)
|
||||
};
|
||||
|
||||
// Konfiguracja loggera dla modułu Canvas
|
||||
logger.setModuleLevel('Canvas', LogLevel.DEBUG);
|
||||
|
||||
class Canvas {
|
||||
constructor() {
|
||||
log.info("Inicjalizacja Canvas");
|
||||
this.width = 512;
|
||||
this.height = 512;
|
||||
}
|
||||
|
||||
render() {
|
||||
log.debug(`Renderowanie canvas o wymiarach ${this.width}x${this.height}`);
|
||||
// Kod renderowania...
|
||||
log.info("Renderowanie zakończone");
|
||||
}
|
||||
|
||||
saveToServer(fileName) {
|
||||
log.info(`Zapisywanie do serwera: ${fileName}`);
|
||||
try {
|
||||
// Kod zapisywania...
|
||||
log.debug("Zapisano pomyślnie");
|
||||
return true;
|
||||
} catch (error) {
|
||||
log.error("Błąd podczas zapisywania:", error);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Przykład użycia w Python
|
||||
|
||||
```python
|
||||
from python.logger import logger, LogLevel, debug, info, warn, error, exception
|
||||
|
||||
# Konfiguracja loggera dla modułu canvas_node
|
||||
logger.set_module_level('canvas_node', LogLevel.DEBUG)
|
||||
|
||||
# Funkcje pomocnicze dla modułu
|
||||
log_debug = lambda *args, **kwargs: debug('canvas_node', *args, **kwargs)
|
||||
log_info = lambda *args, **kwargs: info('canvas_node', *args, **kwargs)
|
||||
log_warn = lambda *args, **kwargs: warn('canvas_node', *args, **kwargs)
|
||||
log_error = lambda *args, **kwargs: error('canvas_node', *args, **kwargs)
|
||||
log_exception = lambda *args: exception('canvas_node', *args)
|
||||
|
||||
class CanvasNode:
|
||||
def __init__(self):
|
||||
log_info("Inicjalizacja CanvasNode")
|
||||
self.flow_id = "123456"
|
||||
|
||||
def process_canvas_image(self, canvas_image, trigger, output_switch, cache_enabled, input_image=None, input_mask=None):
|
||||
try:
|
||||
log_info(f"Przetwarzanie obrazu canvas - ID wykonania: {self.flow_id}, trigger: {trigger}")
|
||||
log_debug(f"Nazwa pliku canvas: {canvas_image}")
|
||||
log_debug(f"Output switch: {output_switch}, Cache enabled: {cache_enabled}")
|
||||
|
||||
# Kod przetwarzania...
|
||||
|
||||
log_info("Pomyślnie zwrócono przetworzony obraz i maskę")
|
||||
return (processed_image, processed_mask)
|
||||
except Exception as e:
|
||||
log_exception(f"Błąd w process_canvas_image: {str(e)}")
|
||||
return ()
|
||||
```
|
||||
|
||||
## Podsumowanie
|
||||
|
||||
System logowania ComfyUI-LayerForge zapewnia spójne i elastyczne rozwiązanie do debugowania i monitorowania aplikacji. Dzięki możliwości konfiguracji poziomów logowania per moduł, możesz skupić się na konkretnych częściach aplikacji bez zaśmiecania konsoli niepotrzebnymi informacjami.
|
||||
|
||||
Aby włączyć pełne debugowanie, ustaw poziom globalny na `DEBUG`:
|
||||
|
||||
```javascript
|
||||
// JavaScript
|
||||
logger.setGlobalLevel(LogLevel.DEBUG);
|
||||
```
|
||||
|
||||
```python
|
||||
# Python
|
||||
logger.set_global_level(LogLevel.DEBUG)
|
||||
# lub
|
||||
set_debug(True)
|
||||
```
|
||||
|
||||
Aby wyłączyć wszystkie logi:
|
||||
|
||||
```javascript
|
||||
// JavaScript
|
||||
logger.setEnabled(false);
|
||||
// lub
|
||||
logger.setGlobalLevel(LogLevel.NONE);
|
||||
```
|
||||
|
||||
```python
|
||||
# Python
|
||||
logger.set_global_level(LogLevel.NONE)
|
||||
184
canvas_node.py
184
canvas_node.py
@@ -16,6 +16,45 @@ import time
|
||||
import base64
|
||||
from PIL import Image
|
||||
import io
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Dodaj ścieżkę do katalogu python/ do sys.path
|
||||
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'python'))
|
||||
|
||||
# Importuj logger
|
||||
try:
|
||||
from python.logger import logger, LogLevel, debug, info, warn, error, exception
|
||||
|
||||
# Konfiguracja loggera dla modułu canvas_node
|
||||
logger.set_module_level('canvas_node', LogLevel.INFO) # Domyślnie INFO, można zmienić na DEBUG
|
||||
|
||||
# Włącz logowanie do pliku
|
||||
logger.configure({
|
||||
'log_to_file': True,
|
||||
'log_dir': os.path.join(os.path.dirname(os.path.abspath(__file__)), 'logs')
|
||||
})
|
||||
|
||||
# Funkcje pomocnicze dla modułu
|
||||
log_debug = lambda *args, **kwargs: debug('canvas_node', *args, **kwargs)
|
||||
log_info = lambda *args, **kwargs: info('canvas_node', *args, **kwargs)
|
||||
log_warn = lambda *args, **kwargs: warn('canvas_node', *args, **kwargs)
|
||||
log_error = lambda *args, **kwargs: error('canvas_node', *args, **kwargs)
|
||||
log_exception = lambda *args: exception('canvas_node', *args)
|
||||
|
||||
log_info("Logger initialized for canvas_node")
|
||||
except ImportError as e:
|
||||
# Fallback jeśli logger nie jest dostępny
|
||||
print(f"Warning: Logger module not available: {e}")
|
||||
|
||||
# Proste funkcje zastępcze
|
||||
def log_debug(*args): print("[DEBUG]", *args)
|
||||
def log_info(*args): print("[INFO]", *args)
|
||||
def log_warn(*args): print("[WARN]", *args)
|
||||
def log_error(*args): print("[ERROR]", *args)
|
||||
def log_exception(*args):
|
||||
print("[ERROR]", *args)
|
||||
traceback.print_exc()
|
||||
|
||||
torch.set_float32_matmul_precision('high')
|
||||
|
||||
@@ -74,7 +113,7 @@ class CanvasNode:
|
||||
current_execution = self.get_execution_id()
|
||||
|
||||
if current_execution != self.__class__._canvas_cache['last_execution_id']:
|
||||
print(f"New execution detected: {current_execution}")
|
||||
log_info(f"New execution detected: {current_execution}")
|
||||
self.__class__._canvas_cache['image'] = None
|
||||
self.__class__._canvas_cache['mask'] = None
|
||||
self.__class__._canvas_cache['last_execution_id'] = current_execution
|
||||
@@ -82,12 +121,12 @@ class CanvasNode:
|
||||
|
||||
if persistent.get('image') is not None:
|
||||
self.__class__._canvas_cache['image'] = persistent['image']
|
||||
print("Restored image from persistent cache")
|
||||
log_info("Restored image from persistent cache")
|
||||
if persistent.get('mask') is not None:
|
||||
self.__class__._canvas_cache['mask'] = persistent['mask']
|
||||
print("Restored mask from persistent cache")
|
||||
log_info("Restored mask from persistent cache")
|
||||
except Exception as e:
|
||||
print(f"Error restoring cache: {str(e)}")
|
||||
log_error(f"Error restoring cache: {str(e)}")
|
||||
|
||||
def get_execution_id(self):
|
||||
|
||||
@@ -95,7 +134,7 @@ class CanvasNode:
|
||||
|
||||
return str(int(time.time() * 1000))
|
||||
except Exception as e:
|
||||
print(f"Error getting execution ID: {str(e)}")
|
||||
log_error(f"Error getting execution ID: {str(e)}")
|
||||
return None
|
||||
|
||||
def update_persistent_cache(self):
|
||||
@@ -105,9 +144,9 @@ class CanvasNode:
|
||||
'image': self.__class__._canvas_cache['image'],
|
||||
'mask': self.__class__._canvas_cache['mask']
|
||||
}
|
||||
print("Updated persistent cache")
|
||||
log_debug("Updated persistent cache")
|
||||
except Exception as e:
|
||||
print(f"Error updating persistent cache: {str(e)}")
|
||||
log_error(f"Error updating persistent cache: {str(e)}")
|
||||
|
||||
def track_data_flow(self, stage, status, data_info=None):
|
||||
|
||||
@@ -117,9 +156,9 @@ class CanvasNode:
|
||||
'status': status,
|
||||
'data_info': data_info
|
||||
}
|
||||
print(f"Data Flow [{self.flow_id}] - Stage: {stage}, Status: {status}")
|
||||
log_debug(f"Data Flow [{self.flow_id}] - Stage: {stage}, Status: {status}")
|
||||
if data_info:
|
||||
print(f"Data Info: {data_info}")
|
||||
log_debug(f"Data Info: {data_info}")
|
||||
|
||||
self.__class__._canvas_cache['data_flow_status'][self.flow_id] = flow_status
|
||||
|
||||
@@ -159,7 +198,7 @@ class CanvasNode:
|
||||
return input_image
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error in add_image_to_canvas: {str(e)}")
|
||||
log_error(f"Error in add_image_to_canvas: {str(e)}")
|
||||
return None
|
||||
|
||||
def add_mask_to_canvas(self, input_mask, input_image):
|
||||
@@ -187,7 +226,7 @@ class CanvasNode:
|
||||
return input_mask
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error in add_mask_to_canvas: {str(e)}")
|
||||
log_error(f"Error in add_mask_to_canvas: {str(e)}")
|
||||
return None
|
||||
|
||||
# Zmienna blokująca równoczesne wykonania
|
||||
@@ -198,30 +237,30 @@ class CanvasNode:
|
||||
try:
|
||||
# Sprawdź czy już trwa przetwarzanie
|
||||
if self.__class__._processing_lock is not None:
|
||||
print(f"[OUTPUT_LOG] Process already in progress, waiting for completion...")
|
||||
log_warn(f"Process already in progress, waiting for completion...")
|
||||
return () # Zwróć pusty wynik, aby uniknąć równoczesnych przetworzeń
|
||||
|
||||
# Ustaw blokadę
|
||||
self.__class__._processing_lock = True
|
||||
|
||||
current_execution = self.get_execution_id()
|
||||
print(f"[OUTPUT_LOG] Starting process_canvas_image - execution ID: {current_execution}, trigger: {trigger}")
|
||||
print(f"[OUTPUT_LOG] Canvas image filename: {canvas_image}")
|
||||
print(f"[OUTPUT_LOG] Output switch: {output_switch}, Cache enabled: {cache_enabled}")
|
||||
print(f"[OUTPUT_LOG] Input image provided: {input_image is not None}")
|
||||
print(f"[OUTPUT_LOG] Input mask provided: {input_mask is not None}")
|
||||
log_info(f"Starting process_canvas_image - execution ID: {current_execution}, trigger: {trigger}")
|
||||
log_debug(f"Canvas image filename: {canvas_image}")
|
||||
log_debug(f"Output switch: {output_switch}, Cache enabled: {cache_enabled}")
|
||||
log_debug(f"Input image provided: {input_image is not None}")
|
||||
log_debug(f"Input mask provided: {input_mask is not None}")
|
||||
|
||||
if current_execution != self.__class__._canvas_cache['last_execution_id']:
|
||||
print(f"[OUTPUT_LOG] New execution detected: {current_execution} (previous: {self.__class__._canvas_cache['last_execution_id']})")
|
||||
log_info(f"New execution detected: {current_execution} (previous: {self.__class__._canvas_cache['last_execution_id']})")
|
||||
|
||||
self.__class__._canvas_cache['image'] = None
|
||||
self.__class__._canvas_cache['mask'] = None
|
||||
self.__class__._canvas_cache['last_execution_id'] = current_execution
|
||||
else:
|
||||
print(f"[OUTPUT_LOG] Same execution ID, using cached data")
|
||||
log_debug(f"Same execution ID, using cached data")
|
||||
|
||||
if input_image is not None:
|
||||
print("Input image received, converting to PIL Image...")
|
||||
log_info("Input image received, converting to PIL Image...")
|
||||
|
||||
if isinstance(input_image, torch.Tensor):
|
||||
if input_image.dim() == 4:
|
||||
@@ -240,17 +279,17 @@ class CanvasNode:
|
||||
try:
|
||||
|
||||
pil_image = Image.fromarray(image_array, 'RGB')
|
||||
print("Successfully converted to PIL Image")
|
||||
log_debug("Successfully converted to PIL Image")
|
||||
|
||||
self.__class__._canvas_cache['image'] = pil_image
|
||||
print(f"Image stored in cache with size: {pil_image.size}")
|
||||
log_debug(f"Image stored in cache with size: {pil_image.size}")
|
||||
except Exception as e:
|
||||
print(f"Error converting to PIL Image: {str(e)}")
|
||||
print(f"Array shape: {image_array.shape}, dtype: {image_array.dtype}")
|
||||
log_error(f"Error converting to PIL Image: {str(e)}")
|
||||
log_debug(f"Array shape: {image_array.shape}, dtype: {image_array.dtype}")
|
||||
raise
|
||||
|
||||
if input_mask is not None:
|
||||
print("Input mask received, converting to PIL Image...")
|
||||
log_info("Input mask received, converting to PIL Image...")
|
||||
if isinstance(input_mask, torch.Tensor):
|
||||
if input_mask.dim() == 4:
|
||||
input_mask = input_mask.squeeze(0)
|
||||
@@ -259,10 +298,10 @@ class CanvasNode:
|
||||
|
||||
mask_array = (input_mask.cpu().numpy() * 255).astype(np.uint8)
|
||||
pil_mask = Image.fromarray(mask_array, 'L')
|
||||
print("Successfully converted mask to PIL Image")
|
||||
log_debug("Successfully converted mask to PIL Image")
|
||||
|
||||
self.__class__._canvas_cache['mask'] = pil_mask
|
||||
print(f"Mask stored in cache with size: {pil_mask.size}")
|
||||
log_debug(f"Mask stored in cache with size: {pil_mask.size}")
|
||||
|
||||
self.__class__._canvas_cache['cache_enabled'] = cache_enabled
|
||||
|
||||
@@ -270,7 +309,7 @@ class CanvasNode:
|
||||
# Wczytaj obraz bez maski
|
||||
path_image_without_mask = folder_paths.get_annotated_filepath(
|
||||
canvas_image.replace('.png', '_without_mask.png'))
|
||||
print(f"[OUTPUT_LOG] Loading image without mask from: {path_image_without_mask}")
|
||||
log_debug(f"Loading image without mask from: {path_image_without_mask}")
|
||||
i = Image.open(path_image_without_mask)
|
||||
i = ImageOps.exif_transpose(i)
|
||||
if i.mode not in ['RGB', 'RGBA']:
|
||||
@@ -281,56 +320,55 @@ class CanvasNode:
|
||||
alpha = image[..., 3:]
|
||||
image = rgb * alpha + (1 - alpha) * 0.5
|
||||
processed_image = torch.from_numpy(image)[None,]
|
||||
print(f"[OUTPUT_LOG] Successfully loaded image without mask, shape: {processed_image.shape}")
|
||||
log_debug(f"Successfully loaded image without mask, shape: {processed_image.shape}")
|
||||
except Exception as e:
|
||||
print(f"[OUTPUT_LOG] Error loading image without mask: {str(e)}")
|
||||
log_error(f"Error loading image without mask: {str(e)}")
|
||||
processed_image = torch.ones((1, 512, 512, 3), dtype=torch.float32)
|
||||
print(f"[OUTPUT_LOG] Using default image, shape: {processed_image.shape}")
|
||||
log_debug(f"Using default image, shape: {processed_image.shape}")
|
||||
|
||||
try:
|
||||
# Wczytaj maskę
|
||||
path_image = folder_paths.get_annotated_filepath(canvas_image)
|
||||
path_mask = path_image.replace('.png', '_mask.png')
|
||||
print(f"[OUTPUT_LOG] Looking for mask at: {path_mask}")
|
||||
log_debug(f"Looking for mask at: {path_mask}")
|
||||
if os.path.exists(path_mask):
|
||||
print(f"[OUTPUT_LOG] Mask file exists, loading...")
|
||||
log_debug(f"Mask file exists, loading...")
|
||||
mask = Image.open(path_mask).convert('L')
|
||||
mask = np.array(mask).astype(np.float32) / 255.0
|
||||
processed_mask = torch.from_numpy(mask)[None,]
|
||||
print(f"[OUTPUT_LOG] Successfully loaded mask, shape: {processed_mask.shape}")
|
||||
log_debug(f"Successfully loaded mask, shape: {processed_mask.shape}")
|
||||
else:
|
||||
print(f"[OUTPUT_LOG] Mask file does not exist, creating default mask")
|
||||
log_debug(f"Mask file does not exist, creating default mask")
|
||||
processed_mask = torch.ones((1, processed_image.shape[1], processed_image.shape[2]),
|
||||
dtype=torch.float32)
|
||||
print(f"[OUTPUT_LOG] Default mask created, shape: {processed_mask.shape}")
|
||||
log_debug(f"Default mask created, shape: {processed_mask.shape}")
|
||||
except Exception as e:
|
||||
print(f"[OUTPUT_LOG] Error loading mask: {str(e)}")
|
||||
log_error(f"Error loading mask: {str(e)}")
|
||||
processed_mask = torch.ones((1, processed_image.shape[1], processed_image.shape[2]),
|
||||
dtype=torch.float32)
|
||||
print(f"[OUTPUT_LOG] Fallback mask created, shape: {processed_mask.shape}")
|
||||
log_debug(f"Fallback mask created, shape: {processed_mask.shape}")
|
||||
|
||||
if not output_switch:
|
||||
print(f"[OUTPUT_LOG] Output switch is OFF, returning empty tuple")
|
||||
log_debug(f"Output switch is OFF, returning empty tuple")
|
||||
return ()
|
||||
|
||||
print(f"[OUTPUT_LOG] About to return output - Image shape: {processed_image.shape}, Mask shape: {processed_mask.shape}")
|
||||
print(f"[OUTPUT_LOG] Image tensor info - dtype: {processed_image.dtype}, device: {processed_image.device}")
|
||||
print(f"[OUTPUT_LOG] Mask tensor info - dtype: {processed_mask.dtype}, device: {processed_mask.device}")
|
||||
log_debug(f"About to return output - Image shape: {processed_image.shape}, Mask shape: {processed_mask.shape}")
|
||||
log_debug(f"Image tensor info - dtype: {processed_image.dtype}, device: {processed_image.device}")
|
||||
log_debug(f"Mask tensor info - dtype: {processed_mask.dtype}, device: {processed_mask.device}")
|
||||
|
||||
self.update_persistent_cache()
|
||||
|
||||
print(f"[OUTPUT_LOG] Successfully returning processed image and mask")
|
||||
log_info(f"Successfully returning processed image and mask")
|
||||
return (processed_image, processed_mask)
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error in process_canvas_image: {str(e)}")
|
||||
traceback.print_exc()
|
||||
log_exception(f"Error in process_canvas_image: {str(e)}")
|
||||
return ()
|
||||
|
||||
finally:
|
||||
# Zwolnij blokadę
|
||||
self.__class__._processing_lock = None
|
||||
print(f"[OUTPUT_LOG] Process completed, lock released")
|
||||
log_debug(f"Process completed, lock released")
|
||||
|
||||
def get_cached_data(self):
|
||||
return {
|
||||
@@ -378,11 +416,11 @@ class CanvasNode:
|
||||
async def get_canvas_data(request):
|
||||
try:
|
||||
node_id = request.match_info["node_id"]
|
||||
print(f"Received request for node: {node_id}")
|
||||
log_debug(f"Received request for node: {node_id}")
|
||||
|
||||
cache_data = cls._canvas_cache
|
||||
print(f"Cache content: {cache_data}")
|
||||
print(f"Image in cache: {cache_data['image'] is not None}")
|
||||
log_debug(f"Cache content: {cache_data}")
|
||||
log_debug(f"Image in cache: {cache_data['image'] is not None}")
|
||||
|
||||
response_data = {
|
||||
'success': True,
|
||||
@@ -409,7 +447,7 @@ class CanvasNode:
|
||||
return web.json_response(response_data)
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error in get_canvas_data: {str(e)}")
|
||||
log_error(f"Error in get_canvas_data: {str(e)}")
|
||||
return web.json_response({
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
@@ -471,7 +509,7 @@ class BiRefNetMatting:
|
||||
|
||||
full_model_path = os.path.join(self.base_path, "BiRefNet")
|
||||
|
||||
print(f"Loading BiRefNet model from {full_model_path}...")
|
||||
log_info(f"Loading BiRefNet model from {full_model_path}...")
|
||||
|
||||
try:
|
||||
|
||||
@@ -486,23 +524,23 @@ class BiRefNetMatting:
|
||||
self.model = self.model.cuda()
|
||||
|
||||
self.model_cache[model_path] = self.model
|
||||
print("Model loaded successfully from Hugging Face")
|
||||
print(f"Model type: {type(self.model)}")
|
||||
print(f"Model device: {next(self.model.parameters()).device}")
|
||||
log_info("Model loaded successfully from Hugging Face")
|
||||
log_debug(f"Model type: {type(self.model)}")
|
||||
log_debug(f"Model device: {next(self.model.parameters()).device}")
|
||||
|
||||
except Exception as e:
|
||||
print(f"Failed to load model: {str(e)}")
|
||||
log_error(f"Failed to load model: {str(e)}")
|
||||
raise
|
||||
|
||||
else:
|
||||
self.model = self.model_cache[model_path]
|
||||
print("Using cached model")
|
||||
log_debug("Using cached model")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error loading model: {str(e)}")
|
||||
traceback.print_exc()
|
||||
log_error(f"Error loading model: {str(e)}")
|
||||
log_exception("Model loading failed")
|
||||
return False
|
||||
|
||||
def preprocess_image(self, image):
|
||||
@@ -528,7 +566,7 @@ class BiRefNetMatting:
|
||||
|
||||
return image_tensor
|
||||
except Exception as e:
|
||||
print(f"Error preprocessing image: {str(e)}")
|
||||
log_error(f"Error preprocessing image: {str(e)}")
|
||||
return None
|
||||
|
||||
def execute(self, image, model_path, threshold=0.5, refinement=1):
|
||||
@@ -544,25 +582,25 @@ class BiRefNetMatting:
|
||||
else:
|
||||
original_size = image.size[::-1]
|
||||
|
||||
print(f"Original size: {original_size}")
|
||||
log_debug(f"Original size: {original_size}")
|
||||
|
||||
processed_image = self.preprocess_image(image)
|
||||
if processed_image is None:
|
||||
raise Exception("Failed to preprocess image")
|
||||
|
||||
print(f"Processed image shape: {processed_image.shape}")
|
||||
log_debug(f"Processed image shape: {processed_image.shape}")
|
||||
|
||||
with torch.no_grad():
|
||||
outputs = self.model(processed_image)
|
||||
result = outputs[-1].sigmoid().cpu()
|
||||
print(f"Model output shape: {result.shape}")
|
||||
log_debug(f"Model output shape: {result.shape}")
|
||||
|
||||
if result.dim() == 3:
|
||||
result = result.unsqueeze(1) # 添加通道维度
|
||||
elif result.dim() == 2:
|
||||
result = result.unsqueeze(0).unsqueeze(0) # 添加batch和通道维度
|
||||
|
||||
print(f"Reshaped result shape: {result.shape}")
|
||||
log_debug(f"Reshaped result shape: {result.shape}")
|
||||
|
||||
result = F.interpolate(
|
||||
result,
|
||||
@@ -570,7 +608,7 @@ class BiRefNetMatting:
|
||||
mode='bilinear',
|
||||
align_corners=True
|
||||
)
|
||||
print(f"Resized result shape: {result.shape}")
|
||||
log_debug(f"Resized result shape: {result.shape}")
|
||||
|
||||
result = result.squeeze() # 移除多余的维度
|
||||
ma = torch.max(result)
|
||||
@@ -618,7 +656,7 @@ async def matting(request):
|
||||
|
||||
# Sprawdź czy już trwa przetwarzanie
|
||||
if _matting_lock is not None:
|
||||
print("Matting already in progress, rejecting request")
|
||||
log_warn("Matting already in progress, rejecting request")
|
||||
return web.json_response({
|
||||
"error": "Another matting operation is in progress",
|
||||
"details": "Please wait for the current operation to complete"
|
||||
@@ -628,13 +666,13 @@ async def matting(request):
|
||||
_matting_lock = True
|
||||
|
||||
try:
|
||||
print("Received matting request")
|
||||
log_info("Received matting request")
|
||||
data = await request.json()
|
||||
|
||||
matting = BiRefNetMatting()
|
||||
|
||||
image_tensor, original_alpha = convert_base64_to_tensor(data["image"])
|
||||
print(f"Input image shape: {image_tensor.shape}")
|
||||
log_debug(f"Input image shape: {image_tensor.shape}")
|
||||
|
||||
matted_image, alpha_mask = matting.execute(
|
||||
image_tensor,
|
||||
@@ -652,9 +690,7 @@ async def matting(request):
|
||||
})
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error in matting endpoint: {str(e)}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
log_exception(f"Error in matting endpoint: {str(e)}")
|
||||
return web.json_response({
|
||||
"error": str(e),
|
||||
"details": traceback.format_exc()
|
||||
@@ -662,7 +698,7 @@ async def matting(request):
|
||||
finally:
|
||||
# Zwolnij blokadę
|
||||
_matting_lock = None
|
||||
print("Matting lock released")
|
||||
log_debug("Matting lock released")
|
||||
|
||||
|
||||
def convert_base64_to_tensor(base64_str):
|
||||
@@ -695,7 +731,7 @@ def convert_base64_to_tensor(base64_str):
|
||||
return img_tensor, None
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error in convert_base64_to_tensor: {str(e)}")
|
||||
log_error(f"Error in convert_base64_to_tensor: {str(e)}")
|
||||
raise
|
||||
|
||||
|
||||
@@ -742,6 +778,6 @@ def convert_tensor_to_base64(tensor, alpha_mask=None, original_alpha=None):
|
||||
return f"data:image/png;base64,{img_str}"
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error in convert_tensor_to_base64: {str(e)}")
|
||||
print(f"Tensor shape: {tensor.shape}, dtype: {tensor.dtype}")
|
||||
log_error(f"Error in convert_tensor_to_base64: {str(e)}")
|
||||
log_debug(f"Tensor shape: {tensor.shape}, dtype: {tensor.dtype}")
|
||||
raise
|
||||
|
||||
211
js/Canvas.js
211
js/Canvas.js
@@ -1,5 +1,17 @@
|
||||
import {getCanvasState, setCanvasState, removeCanvasState, saveImage, getImage, removeImage} from "./db.js";
|
||||
import {MaskTool} from "./Mask_tool.js";
|
||||
import {logger, LogLevel} from "./logger.js";
|
||||
|
||||
// Inicjalizacja loggera dla modułu Canvas
|
||||
const log = {
|
||||
debug: (...args) => logger.debug('Canvas', ...args),
|
||||
info: (...args) => logger.info('Canvas', ...args),
|
||||
warn: (...args) => logger.warn('Canvas', ...args),
|
||||
error: (...args) => logger.error('Canvas', ...args)
|
||||
};
|
||||
|
||||
// Konfiguracja loggera dla modułu Canvas
|
||||
logger.setModuleLevel('Canvas', LogLevel.DEBUG); // Domyślnie INFO, można zmienić na DEBUG dla szczegółowych logów
|
||||
|
||||
// Prosta funkcja generująca UUID
|
||||
function generateUUID() {
|
||||
@@ -101,13 +113,13 @@ export class Canvas {
|
||||
async loadStateFromDB() {
|
||||
// Sprawdź czy już trwa ładowanie
|
||||
if (this._loadInProgress) {
|
||||
console.log("Load already in progress, waiting...");
|
||||
log.warn("Load already in progress, waiting...");
|
||||
return this._loadInProgress;
|
||||
}
|
||||
|
||||
console.log("Attempting to load state from IndexedDB for node:", this.node.id);
|
||||
log.info("Attempting to load state from IndexedDB for node:", this.node.id);
|
||||
if (!this.node.id) {
|
||||
console.error("Node ID is not available for loading state from DB.");
|
||||
log.error("Node ID is not available for loading state from DB.");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -125,35 +137,35 @@ export class Canvas {
|
||||
try {
|
||||
const savedState = await getCanvasState(this.node.id);
|
||||
if (!savedState) {
|
||||
console.log("No saved state found in IndexedDB for node:", this.node.id);
|
||||
log.info("No saved state found in IndexedDB for node:", this.node.id);
|
||||
return false;
|
||||
}
|
||||
console.log("Found saved state in IndexedDB.");
|
||||
log.info("Found saved state in IndexedDB.");
|
||||
|
||||
this.width = savedState.width || 512;
|
||||
this.height = savedState.height || 512;
|
||||
this.viewport = savedState.viewport || {x: -(this.width / 4), y: -(this.height / 4), zoom: 0.8};
|
||||
|
||||
this.updateCanvasSize(this.width, this.height, false);
|
||||
console.log(`Canvas resized to ${this.width}x${this.height} and viewport set.`);
|
||||
log.debug(`Canvas resized to ${this.width}x${this.height} and viewport set.`);
|
||||
|
||||
const imagePromises = savedState.layers.map((layerData, index) => {
|
||||
return new Promise((resolve) => {
|
||||
if (layerData.imageId) {
|
||||
console.log(`Layer ${index}: Loading image with id: ${layerData.imageId}`);
|
||||
log.debug(`Layer ${index}: Loading image with id: ${layerData.imageId}`);
|
||||
// Sprawdź, czy obraz jest już w pamięci podręcznej
|
||||
if (this.imageCache.has(layerData.imageId)) {
|
||||
console.log(`Layer ${index}: Image found in cache.`);
|
||||
log.debug(`Layer ${index}: Image found in cache.`);
|
||||
const imageSrc = this.imageCache.get(layerData.imageId);
|
||||
const img = new Image();
|
||||
img.onload = () => {
|
||||
console.log(`Layer ${index}: Image loaded successfully.`);
|
||||
log.debug(`Layer ${index}: Image loaded successfully.`);
|
||||
const newLayer = {...layerData, image: img};
|
||||
delete newLayer.imageId;
|
||||
resolve(newLayer);
|
||||
};
|
||||
img.onerror = () => {
|
||||
console.error(`Layer ${index}: Failed to load image from src.`);
|
||||
log.error(`Layer ${index}: Failed to load image from src.`);
|
||||
resolve(null);
|
||||
};
|
||||
img.src = imageSrc;
|
||||
@@ -161,54 +173,54 @@ export class Canvas {
|
||||
// Wczytaj obraz z IndexedDB
|
||||
getImage(layerData.imageId).then(imageSrc => {
|
||||
if (imageSrc) {
|
||||
console.log(`Layer ${index}: Loading image from data:URL...`);
|
||||
log.debug(`Layer ${index}: Loading image from data:URL...`);
|
||||
const img = new Image();
|
||||
img.onload = () => {
|
||||
console.log(`Layer ${index}: Image loaded successfully.`);
|
||||
log.debug(`Layer ${index}: Image loaded successfully.`);
|
||||
this.imageCache.set(layerData.imageId, imageSrc); // Zapisz w pamięci podręcznej jako imageSrc
|
||||
const newLayer = {...layerData, image: img};
|
||||
delete newLayer.imageId;
|
||||
resolve(newLayer);
|
||||
};
|
||||
img.onerror = () => {
|
||||
console.error(`Layer ${index}: Failed to load image from src.`);
|
||||
log.error(`Layer ${index}: Failed to load image from src.`);
|
||||
resolve(null);
|
||||
};
|
||||
img.src = imageSrc;
|
||||
} else {
|
||||
console.error(`Layer ${index}: Image not found in IndexedDB.`);
|
||||
log.error(`Layer ${index}: Image not found in IndexedDB.`);
|
||||
resolve(null);
|
||||
}
|
||||
}).catch(err => {
|
||||
console.error(`Layer ${index}: Error loading image from IndexedDB:`, err);
|
||||
log.error(`Layer ${index}: Error loading image from IndexedDB:`, err);
|
||||
resolve(null);
|
||||
});
|
||||
}
|
||||
} else if (layerData.imageSrc) {
|
||||
// Obsługa starego formatu z imageSrc
|
||||
console.log(`Layer ${index}: Found imageSrc, converting to new format with imageId.`);
|
||||
log.info(`Layer ${index}: Found imageSrc, converting to new format with imageId.`);
|
||||
const imageId = generateUUID();
|
||||
saveImage(imageId, layerData.imageSrc).then(() => {
|
||||
console.log(`Layer ${index}: Image saved to IndexedDB with id: ${imageId}`);
|
||||
log.info(`Layer ${index}: Image saved to IndexedDB with id: ${imageId}`);
|
||||
this.imageCache.set(imageId, layerData.imageSrc); // Zapisz w pamięci podręcznej jako imageSrc
|
||||
const img = new Image();
|
||||
img.onload = () => {
|
||||
console.log(`Layer ${index}: Image loaded successfully from imageSrc.`);
|
||||
log.debug(`Layer ${index}: Image loaded successfully from imageSrc.`);
|
||||
const newLayer = {...layerData, image: img, imageId};
|
||||
delete newLayer.imageSrc;
|
||||
resolve(newLayer);
|
||||
};
|
||||
img.onerror = () => {
|
||||
console.error(`Layer ${index}: Failed to load image from imageSrc.`);
|
||||
log.error(`Layer ${index}: Failed to load image from imageSrc.`);
|
||||
resolve(null);
|
||||
};
|
||||
img.src = layerData.imageSrc;
|
||||
}).catch(err => {
|
||||
console.error(`Layer ${index}: Error saving image to IndexedDB:`, err);
|
||||
log.error(`Layer ${index}: Error saving image to IndexedDB:`, err);
|
||||
resolve(null);
|
||||
});
|
||||
} else {
|
||||
console.error(`Layer ${index}: No imageId or imageSrc found, skipping layer.`);
|
||||
log.error(`Layer ${index}: No imageId or imageSrc found, skipping layer.`);
|
||||
resolve(null); // Pomiń warstwy bez obrazu
|
||||
}
|
||||
});
|
||||
@@ -216,35 +228,35 @@ export class Canvas {
|
||||
|
||||
const loadedLayers = await Promise.all(imagePromises);
|
||||
this.layers = loadedLayers.filter(l => l !== null);
|
||||
console.log(`Loaded ${this.layers.length} layers.`);
|
||||
log.info(`Loaded ${this.layers.length} layers.`);
|
||||
|
||||
if (this.layers.length === 0) {
|
||||
console.warn("No valid layers loaded, state may be corrupted.");
|
||||
log.warn("No valid layers loaded, state may be corrupted.");
|
||||
return false;
|
||||
}
|
||||
|
||||
this.updateSelectionAfterHistory();
|
||||
this.render();
|
||||
console.log("Canvas state loaded successfully from IndexedDB for node", this.node.id);
|
||||
log.info("Canvas state loaded successfully from IndexedDB for node", this.node.id);
|
||||
return true;
|
||||
} catch (e) {
|
||||
console.error("Error loading canvas state from IndexedDB:", e);
|
||||
await removeCanvasState(this.node.id).catch(err => console.error("Failed to remove corrupted state:", err));
|
||||
log.error("Error loading canvas state from IndexedDB:", e);
|
||||
await removeCanvasState(this.node.id).catch(err => log.error("Failed to remove corrupted state:", err));
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
async saveStateToDB(immediate = false) {
|
||||
console.log("Preparing to save state to IndexedDB for node:", this.node.id);
|
||||
log.info("Preparing to save state to IndexedDB for node:", this.node.id);
|
||||
if (!this.node.id) {
|
||||
console.error("Node ID is not available for saving state to DB.");
|
||||
log.error("Node ID is not available for saving state to DB.");
|
||||
return;
|
||||
}
|
||||
|
||||
// Oblicz sygnaturę obecnego stanu
|
||||
const currentStateSignature = this.getStateSignature(this.layers);
|
||||
if (this.lastSavedStateSignature === currentStateSignature) {
|
||||
console.log("State unchanged, skipping save to IndexedDB.");
|
||||
log.debug("State unchanged, skipping save to IndexedDB.");
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -259,7 +271,7 @@ export class Canvas {
|
||||
layers: await Promise.all(this.layers.map(async (layer, index) => {
|
||||
const newLayer = {...layer};
|
||||
if (layer.image instanceof HTMLImageElement) {
|
||||
console.log(`Layer ${index}: Using imageId instead of serializing image.`);
|
||||
log.debug(`Layer ${index}: Using imageId instead of serializing image.`);
|
||||
if (!layer.imageId) {
|
||||
// Jeśli obraz nie ma jeszcze imageId, zapisz go do IndexedDB
|
||||
layer.imageId = generateUUID();
|
||||
@@ -268,7 +280,7 @@ export class Canvas {
|
||||
}
|
||||
newLayer.imageId = layer.imageId;
|
||||
} else if (!layer.imageId) {
|
||||
console.error(`Layer ${index}: No image or imageId found, skipping layer.`);
|
||||
log.error(`Layer ${index}: No image or imageId found, skipping layer.`);
|
||||
return null; // Pomiń warstwy bez obrazu
|
||||
}
|
||||
delete newLayer.image;
|
||||
@@ -281,14 +293,14 @@ export class Canvas {
|
||||
// Filtruj warstwy, które nie mają obrazu
|
||||
state.layers = state.layers.filter(layer => layer !== null);
|
||||
if (state.layers.length === 0) {
|
||||
console.warn("No valid layers to save, skipping save to IndexedDB.");
|
||||
log.warn("No valid layers to save, skipping save to IndexedDB.");
|
||||
return;
|
||||
}
|
||||
await setCanvasState(this.node.id, state);
|
||||
console.log("Canvas state saved to IndexedDB.");
|
||||
log.info("Canvas state saved to IndexedDB.");
|
||||
this.lastSavedStateSignature = currentStateSignature; // Zaktualizuj sygnaturę zapisanego stanu
|
||||
} catch (e) {
|
||||
console.error("Error saving canvas state to IndexedDB:", e);
|
||||
log.error("Error saving canvas state to IndexedDB:", e);
|
||||
}
|
||||
};
|
||||
|
||||
@@ -302,10 +314,10 @@ export class Canvas {
|
||||
}
|
||||
|
||||
async loadInitialState() {
|
||||
console.log("Loading initial state for node:", this.node.id);
|
||||
log.info("Loading initial state for node:", this.node.id);
|
||||
const loaded = await this.loadStateFromDB();
|
||||
if (!loaded) {
|
||||
console.log("No saved state found, initializing from node data.");
|
||||
log.info("No saved state found, initializing from node data.");
|
||||
await this.initNodeData();
|
||||
}
|
||||
this.saveState(); // Save initial state to undo stack
|
||||
@@ -508,16 +520,16 @@ export class Canvas {
|
||||
async copySelectedLayers() {
|
||||
if (this.selectedLayers.length === 0) return;
|
||||
this.internalClipboard = this.selectedLayers.map(layer => ({...layer}));
|
||||
console.log(`Copied ${this.internalClipboard.length} layer(s) to internal clipboard.`);
|
||||
log.info(`Copied ${this.internalClipboard.length} layer(s) to internal clipboard.`);
|
||||
try {
|
||||
const blob = await this.getFlattenedSelectionAsBlob();
|
||||
if (blob) {
|
||||
const item = new ClipboardItem({'image/png': blob});
|
||||
await navigator.clipboard.write([item]);
|
||||
console.log("Flattened selection copied to the system clipboard.");
|
||||
log.info("Flattened selection copied to the system clipboard.");
|
||||
}
|
||||
} catch (error) {
|
||||
console.error("Failed to copy image to system clipboard:", error);
|
||||
log.error("Failed to copy image to system clipboard:", error);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -541,14 +553,14 @@ export class Canvas {
|
||||
|
||||
this.updateSelection(newLayers);
|
||||
this.render();
|
||||
console.log(`Pasted ${newLayers.length} layer(s).`);
|
||||
log.info(`Pasted ${newLayers.length} layer(s).`);
|
||||
}
|
||||
|
||||
|
||||
async handlePaste() {
|
||||
try {
|
||||
if (!navigator.clipboard?.read) {
|
||||
console.log("Browser does not support clipboard read API. Falling back to internal paste.");
|
||||
log.info("Browser does not support clipboard read API. Falling back to internal paste.");
|
||||
this.pasteLayers();
|
||||
return;
|
||||
}
|
||||
@@ -582,7 +594,7 @@ export class Canvas {
|
||||
}
|
||||
|
||||
} catch (err) {
|
||||
console.error("Paste operation failed, falling back to internal paste. Error:", err);
|
||||
log.error("Paste operation failed, falling back to internal paste. Error:", err);
|
||||
this.pasteLayers();
|
||||
}
|
||||
}
|
||||
@@ -1202,7 +1214,7 @@ export class Canvas {
|
||||
|
||||
async addLayerWithImage(image, layerProps = {}) {
|
||||
try {
|
||||
console.log("Adding layer with image:", image);
|
||||
log.debug("Adding layer with image:", image);
|
||||
|
||||
// Wygeneruj unikalny identyfikator dla obrazu i zapisz go do IndexedDB
|
||||
const imageId = generateUUID();
|
||||
@@ -1228,10 +1240,10 @@ export class Canvas {
|
||||
this.render();
|
||||
this.saveState();
|
||||
|
||||
console.log("Layer added successfully");
|
||||
log.info("Layer added successfully");
|
||||
return layer;
|
||||
} catch (error) {
|
||||
console.error("Error adding layer:", error);
|
||||
log.error("Error adding layer:", error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
@@ -1732,13 +1744,13 @@ export class Canvas {
|
||||
async saveToServer(fileName) {
|
||||
// Sprawdź czy już trwa zapis
|
||||
if (this._saveInProgress) {
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Save already in progress, waiting...`);
|
||||
log.warn(`Save already in progress, waiting...`);
|
||||
return this._saveInProgress;
|
||||
}
|
||||
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Starting saveToServer with fileName: ${fileName}`);
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Canvas dimensions: ${this.width}x${this.height}`);
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Number of layers: ${this.layers.length}`);
|
||||
log.info(`Starting saveToServer with fileName: ${fileName}`);
|
||||
log.debug(`Canvas dimensions: ${this.width}x${this.height}`);
|
||||
log.debug(`Number of layers: ${this.layers.length}`);
|
||||
|
||||
// Utwórz Promise dla aktualnego zapisu
|
||||
this._saveInProgress = this._performSave(fileName);
|
||||
@@ -1748,6 +1760,7 @@ export class Canvas {
|
||||
return result;
|
||||
} finally {
|
||||
this._saveInProgress = null;
|
||||
log.debug(`Save completed, lock released`);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1772,15 +1785,15 @@ export class Canvas {
|
||||
maskCtx.fillStyle = '#ffffff'; // Białe tło dla wolnych przestrzeni
|
||||
maskCtx.fillRect(0, 0, this.width, this.height);
|
||||
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Canvas contexts created, starting layer rendering`);
|
||||
log.debug(`Canvas contexts created, starting layer rendering`);
|
||||
|
||||
// Rysowanie warstw
|
||||
const sortedLayers = this.layers.sort((a, b) => a.zIndex - b.zIndex);
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Processing ${sortedLayers.length} layers in order`);
|
||||
log.debug(`Processing ${sortedLayers.length} layers in order`);
|
||||
|
||||
sortedLayers.forEach((layer, index) => {
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Processing layer ${index}: zIndex=${layer.zIndex}, size=${layer.width}x${layer.height}, pos=(${layer.x},${layer.y})`);
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Layer ${index}: blendMode=${layer.blendMode || 'normal'}, opacity=${layer.opacity !== undefined ? layer.opacity : 1}`);
|
||||
log.debug(`Processing layer ${index}: zIndex=${layer.zIndex}, size=${layer.width}x${layer.height}, pos=(${layer.x},${layer.y})`);
|
||||
log.debug(`Layer ${index}: blendMode=${layer.blendMode || 'normal'}, opacity=${layer.opacity !== undefined ? layer.opacity : 1}`);
|
||||
|
||||
tempCtx.save();
|
||||
tempCtx.globalCompositeOperation = layer.blendMode || 'normal';
|
||||
@@ -1790,7 +1803,7 @@ export class Canvas {
|
||||
tempCtx.drawImage(layer.image, -layer.width / 2, -layer.height / 2, layer.width, layer.height);
|
||||
tempCtx.restore();
|
||||
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Layer ${index} rendered successfully`);
|
||||
log.debug(`Layer ${index} rendered successfully`);
|
||||
|
||||
maskCtx.save();
|
||||
maskCtx.translate(layer.x + layer.width / 2, layer.y + layer.height / 2);
|
||||
@@ -1875,10 +1888,10 @@ export class Canvas {
|
||||
|
||||
// Zapisz obraz bez maski
|
||||
const fileNameWithoutMask = fileName.replace('.png', '_without_mask.png');
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Saving image without mask as: ${fileNameWithoutMask}`);
|
||||
log.info(`Saving image without mask as: ${fileNameWithoutMask}`);
|
||||
|
||||
tempCanvas.toBlob(async (blobWithoutMask) => {
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Created blob for image without mask, size: ${blobWithoutMask.size} bytes`);
|
||||
log.debug(`Created blob for image without mask, size: ${blobWithoutMask.size} bytes`);
|
||||
const formDataWithoutMask = new FormData();
|
||||
formDataWithoutMask.append("image", blobWithoutMask, fileNameWithoutMask);
|
||||
formDataWithoutMask.append("overwrite", "true");
|
||||
@@ -1888,16 +1901,16 @@ export class Canvas {
|
||||
method: "POST",
|
||||
body: formDataWithoutMask,
|
||||
});
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Image without mask upload response: ${response.status}`);
|
||||
log.debug(`Image without mask upload response: ${response.status}`);
|
||||
} catch (error) {
|
||||
console.error(`[CANVAS_OUTPUT_LOG] Error uploading image without mask:`, error);
|
||||
log.error(`Error uploading image without mask:`, error);
|
||||
}
|
||||
}, "image/png");
|
||||
|
||||
// Zapisz obraz z maską
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Saving main image as: ${fileName}`);
|
||||
log.info(`Saving main image as: ${fileName}`);
|
||||
tempCanvas.toBlob(async (blob) => {
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Created blob for main image, size: ${blob.size} bytes`);
|
||||
log.debug(`Created blob for main image, size: ${blob.size} bytes`);
|
||||
const formData = new FormData();
|
||||
formData.append("image", blob, fileName);
|
||||
formData.append("overwrite", "true");
|
||||
@@ -1907,14 +1920,14 @@ export class Canvas {
|
||||
method: "POST",
|
||||
body: formData,
|
||||
});
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Main image upload response: ${resp.status}`);
|
||||
log.debug(`Main image upload response: ${resp.status}`);
|
||||
|
||||
if (resp.status === 200) {
|
||||
const maskFileName = fileName.replace('.png', '_mask.png');
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Saving mask as: ${maskFileName}`);
|
||||
log.info(`Saving mask as: ${maskFileName}`);
|
||||
|
||||
maskCanvas.toBlob(async (maskBlob) => {
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Created blob for mask, size: ${maskBlob.size} bytes`);
|
||||
log.debug(`Created blob for mask, size: ${maskBlob.size} bytes`);
|
||||
const maskFormData = new FormData();
|
||||
maskFormData.append("image", maskBlob, maskFileName);
|
||||
maskFormData.append("overwrite", "true");
|
||||
@@ -1924,28 +1937,28 @@ export class Canvas {
|
||||
method: "POST",
|
||||
body: maskFormData,
|
||||
});
|
||||
console.log(`[CANVAS_OUTPUT_LOG] Mask upload response: ${maskResp.status}`);
|
||||
log.debug(`Mask upload response: ${maskResp.status}`);
|
||||
|
||||
if (maskResp.status === 200) {
|
||||
const data = await resp.json();
|
||||
this.widget.value = data.name;
|
||||
console.log(`[CANVAS_OUTPUT_LOG] All files saved successfully, widget value set to: ${data.name}`);
|
||||
log.info(`All files saved successfully, widget value set to: ${data.name}`);
|
||||
resolve(true);
|
||||
} else {
|
||||
console.error(`[CANVAS_OUTPUT_LOG] Error saving mask: ${maskResp.status}`);
|
||||
log.error(`Error saving mask: ${maskResp.status}`);
|
||||
resolve(false);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error(`[CANVAS_OUTPUT_LOG] Error saving mask:`, error);
|
||||
log.error(`Error saving mask:`, error);
|
||||
resolve(false);
|
||||
}
|
||||
}, "image/png");
|
||||
} else {
|
||||
console.error(`[CANVAS_OUTPUT_LOG] Main image upload failed: ${resp.status} - ${resp.statusText}`);
|
||||
log.error(`Main image upload failed: ${resp.status} - ${resp.statusText}`);
|
||||
resolve(false);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error(`[CANVAS_OUTPUT_LOG] Error uploading main image:`, error);
|
||||
log.error(`Error uploading main image:`, error);
|
||||
resolve(false);
|
||||
}
|
||||
}, "image/png");
|
||||
@@ -2241,7 +2254,7 @@ export class Canvas {
|
||||
|
||||
return dataUrl;
|
||||
} catch (error) {
|
||||
console.error("Error getting layer image data:", error);
|
||||
log.error("Error getting layer image data:", error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
@@ -2289,7 +2302,7 @@ export class Canvas {
|
||||
|
||||
async addInputToCanvas(inputImage, inputMask) {
|
||||
try {
|
||||
console.log("Adding input to canvas:", {inputImage});
|
||||
log.debug("Adding input to canvas:", {inputImage});
|
||||
|
||||
const tempCanvas = document.createElement('canvas');
|
||||
const tempCtx = tempCanvas.getContext('2d');
|
||||
@@ -2326,18 +2339,18 @@ export class Canvas {
|
||||
layer.mask = inputMask.data;
|
||||
}
|
||||
|
||||
console.log("Layer added successfully");
|
||||
log.info("Layer added successfully");
|
||||
return true;
|
||||
|
||||
} catch (error) {
|
||||
console.error("Error in addInputToCanvas:", error);
|
||||
log.error("Error in addInputToCanvas:", error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
async convertTensorToImage(tensor) {
|
||||
try {
|
||||
console.log("Converting tensor to image:", tensor);
|
||||
log.debug("Converting tensor to image:", tensor);
|
||||
|
||||
if (!tensor || !tensor.data || !tensor.width || !tensor.height) {
|
||||
throw new Error("Invalid tensor data");
|
||||
@@ -2363,7 +2376,7 @@ export class Canvas {
|
||||
img.src = canvas.toDataURL();
|
||||
});
|
||||
} catch (error) {
|
||||
console.error("Error converting tensor to image:", error);
|
||||
log.error("Error converting tensor to image:", error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
@@ -2383,10 +2396,10 @@ export class Canvas {
|
||||
|
||||
async initNodeData() {
|
||||
try {
|
||||
console.log("Starting node data initialization...");
|
||||
log.info("Starting node data initialization...");
|
||||
|
||||
if (!this.node || !this.node.inputs) {
|
||||
console.log("Node or inputs not ready");
|
||||
log.debug("Node or inputs not ready");
|
||||
return this.scheduleDataCheck();
|
||||
}
|
||||
|
||||
@@ -2395,11 +2408,11 @@ export class Canvas {
|
||||
const imageData = app.nodeOutputs[imageLinkId];
|
||||
|
||||
if (imageData) {
|
||||
console.log("Found image data:", imageData);
|
||||
log.debug("Found image data:", imageData);
|
||||
await this.processImageData(imageData);
|
||||
this.dataInitialized = true;
|
||||
} else {
|
||||
console.log("Image data not available yet");
|
||||
log.debug("Image data not available yet");
|
||||
return this.scheduleDataCheck();
|
||||
}
|
||||
}
|
||||
@@ -2409,13 +2422,13 @@ export class Canvas {
|
||||
const maskData = app.nodeOutputs[maskLinkId];
|
||||
|
||||
if (maskData) {
|
||||
console.log("Found mask data:", maskData);
|
||||
log.debug("Found mask data:", maskData);
|
||||
await this.processMaskData(maskData);
|
||||
}
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error("Error in initNodeData:", error);
|
||||
log.error("Error in initNodeData:", error);
|
||||
return this.scheduleDataCheck();
|
||||
}
|
||||
}
|
||||
@@ -2437,7 +2450,7 @@ export class Canvas {
|
||||
try {
|
||||
if (!imageData) return;
|
||||
|
||||
console.log("Processing image data:", {
|
||||
log.debug("Processing image data:", {
|
||||
type: typeof imageData,
|
||||
isArray: Array.isArray(imageData),
|
||||
shape: imageData.shape,
|
||||
@@ -2465,10 +2478,10 @@ export class Canvas {
|
||||
const image = await this.createImageFromData(convertedData);
|
||||
|
||||
this.addScaledLayer(image, scale);
|
||||
console.log("Image layer added successfully with scale:", scale);
|
||||
log.info("Image layer added successfully with scale:", scale);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error("Error processing image data:", error);
|
||||
log.error("Error processing image data:", error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
@@ -2494,13 +2507,13 @@ export class Canvas {
|
||||
this.selectedLayer = layer;
|
||||
this.render();
|
||||
|
||||
console.log("Scaled layer added:", {
|
||||
log.debug("Scaled layer added:", {
|
||||
originalSize: `${image.width}x${image.height}`,
|
||||
scaledSize: `${scaledWidth}x${scaledHeight}`,
|
||||
scale: scale
|
||||
});
|
||||
} catch (error) {
|
||||
console.error("Error adding scaled layer:", error);
|
||||
log.error("Error adding scaled layer:", error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
@@ -2512,7 +2525,7 @@ export class Canvas {
|
||||
const width = shape[2];
|
||||
const channels = shape[3];
|
||||
|
||||
console.log("Converting tensor:", {
|
||||
log.debug("Converting tensor:", {
|
||||
shape: shape,
|
||||
dataRange: {
|
||||
min: tensor.min_val,
|
||||
@@ -2543,7 +2556,7 @@ export class Canvas {
|
||||
imageData.data.set(data);
|
||||
return imageData;
|
||||
} catch (error) {
|
||||
console.error("Error converting tensor:", error);
|
||||
log.error("Error converting tensor:", error);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -2569,20 +2582,20 @@ export class Canvas {
|
||||
await this.initNodeData();
|
||||
return;
|
||||
} catch (error) {
|
||||
console.warn(`Retry ${i + 1}/${maxRetries} failed:`, error);
|
||||
log.warn(`Retry ${i + 1}/${maxRetries} failed:`, error);
|
||||
if (i < maxRetries - 1) {
|
||||
await new Promise(resolve => setTimeout(resolve, delay));
|
||||
}
|
||||
}
|
||||
}
|
||||
console.error("Failed to load data after", maxRetries, "retries");
|
||||
log.error("Failed to load data after", maxRetries, "retries");
|
||||
}
|
||||
|
||||
async processMaskData(maskData) {
|
||||
try {
|
||||
if (!maskData) return;
|
||||
|
||||
console.log("Processing mask data:", maskData);
|
||||
log.debug("Processing mask data:", maskData);
|
||||
|
||||
if (Array.isArray(maskData)) {
|
||||
maskData = maskData[0];
|
||||
@@ -2596,10 +2609,10 @@ export class Canvas {
|
||||
const maskTensor = await this.convertTensorToMask(maskData);
|
||||
this.selectedLayer.mask = maskTensor;
|
||||
this.render();
|
||||
console.log("Mask applied to selected layer");
|
||||
log.info("Mask applied to selected layer");
|
||||
}
|
||||
} catch (error) {
|
||||
console.error("Error processing mask data:", error);
|
||||
log.error("Error processing mask data:", error);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2614,7 +2627,7 @@ export class Canvas {
|
||||
|
||||
async importImage(cacheData) {
|
||||
try {
|
||||
console.log("Starting image import with cache data");
|
||||
log.info("Starting image import with cache data");
|
||||
const img = await this.loadImageFromCache(cacheData.image);
|
||||
const mask = cacheData.mask ? await this.loadImageFromCache(cacheData.mask) : null;
|
||||
|
||||
@@ -2667,18 +2680,18 @@ export class Canvas {
|
||||
this.render();
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error importing image:', error);
|
||||
log.error('Error importing image:', error);
|
||||
}
|
||||
}
|
||||
|
||||
async importLatestImage() {
|
||||
try {
|
||||
console.log("Fetching latest image from server...");
|
||||
log.info("Fetching latest image from server...");
|
||||
const response = await fetch('/ycnode/get_latest_image');
|
||||
const result = await response.json();
|
||||
|
||||
if (result.success && result.image_data) {
|
||||
console.log("Latest image received, adding to canvas.");
|
||||
log.info("Latest image received, adding to canvas.");
|
||||
const img = new Image();
|
||||
await new Promise((resolve, reject) => {
|
||||
img.onload = resolve;
|
||||
@@ -2692,13 +2705,13 @@ export class Canvas {
|
||||
width: this.width,
|
||||
height: this.height,
|
||||
});
|
||||
console.log("Latest image imported and placed on canvas successfully.");
|
||||
log.info("Latest image imported and placed on canvas successfully.");
|
||||
return true;
|
||||
} else {
|
||||
throw new Error(result.error || "Failed to fetch the latest image.");
|
||||
}
|
||||
} catch (error) {
|
||||
console.error("Error importing latest image:", error);
|
||||
log.error("Error importing latest image:", error);
|
||||
alert(`Failed to import latest image: ${error.message}`);
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -6,6 +6,18 @@ import {Canvas} from "./Canvas.js";
|
||||
import {clearAllCanvasStates} from "./db.js";
|
||||
import {ImageCache} from "./ImageCache.js";
|
||||
import {validateImageData, convertImageData, applyMaskToImageData, prepareImageForCanvas} from "./ImageUtils.js";
|
||||
import {logger, LogLevel} from "./logger.js";
|
||||
|
||||
// Inicjalizacja loggera dla modułu Canvas_view
|
||||
const log = {
|
||||
debug: (...args) => logger.debug('Canvas_view', ...args),
|
||||
info: (...args) => logger.info('Canvas_view', ...args),
|
||||
warn: (...args) => logger.warn('Canvas_view', ...args),
|
||||
error: (...args) => logger.error('Canvas_view', ...args)
|
||||
};
|
||||
|
||||
// Konfiguracja loggera dla modułu Canvas_view
|
||||
logger.setModuleLevel('Canvas_view', LogLevel.INFO); // Domyślnie INFO, można zmienić na DEBUG dla szczegółowych logów
|
||||
|
||||
async function createCanvasWidget(node, widget, app) {
|
||||
const canvas = new Canvas(node, widget);
|
||||
@@ -580,7 +592,7 @@ async function createCanvasWidget(node, widget, app) {
|
||||
await canvas.saveToServer(widget.value);
|
||||
app.graph.runStep();
|
||||
} catch (error) {
|
||||
console.error("Matting error:", error);
|
||||
log.error("Matting error:", error);
|
||||
alert(`Error during matting process: ${error.message}`);
|
||||
} finally {
|
||||
button.classList.remove('loading');
|
||||
@@ -683,7 +695,7 @@ async function createCanvasWidget(node, widget, app) {
|
||||
await clearAllCanvasStates();
|
||||
alert("Canvas cache cleared successfully!");
|
||||
} catch (e) {
|
||||
console.error("Failed to clear canvas cache:", e);
|
||||
log.error("Failed to clear canvas cache:", e);
|
||||
alert("Error clearing canvas cache. Check the console for details.");
|
||||
}
|
||||
}
|
||||
@@ -788,18 +800,18 @@ async function createCanvasWidget(node, widget, app) {
|
||||
}
|
||||
}, [controlPanel, canvasContainer]);
|
||||
const handleFileLoad = async (file) => {
|
||||
console.log("File dropped:", file.name);
|
||||
log.info("File dropped:", file.name);
|
||||
if (!file.type.startsWith('image/')) {
|
||||
console.log("Dropped file is not an image.");
|
||||
log.info("Dropped file is not an image.");
|
||||
return;
|
||||
}
|
||||
|
||||
const reader = new FileReader();
|
||||
reader.onload = async (event) => {
|
||||
console.log("FileReader finished loading dropped file as data:URL.");
|
||||
log.debug("FileReader finished loading dropped file as data:URL.");
|
||||
const img = new Image();
|
||||
img.onload = async () => {
|
||||
console.log("Image object loaded from dropped data:URL.");
|
||||
log.debug("Image object loaded from dropped data:URL.");
|
||||
const scale = Math.min(
|
||||
canvas.width / img.width,
|
||||
canvas.height / img.height
|
||||
@@ -821,7 +833,7 @@ async function createCanvasWidget(node, widget, app) {
|
||||
canvas.updateSelection([layer]);
|
||||
canvas.render();
|
||||
canvas.saveState();
|
||||
console.log("Dropped layer added and state saved.");
|
||||
log.info("Dropped layer added and state saved.");
|
||||
await updateOutput();
|
||||
};
|
||||
img.src = event.target.result;
|
||||
@@ -885,7 +897,7 @@ async function createCanvasWidget(node, widget, app) {
|
||||
|
||||
originalParent = mainContainer.parentNode;
|
||||
if (!originalParent) {
|
||||
console.error("Could not find original parent of the canvas container!");
|
||||
log.error("Could not find original parent of the canvas container!");
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -910,13 +922,13 @@ async function createCanvasWidget(node, widget, app) {
|
||||
let executionInProgress = false;
|
||||
|
||||
api.addEventListener("execution_start", async () => {
|
||||
console.log(`[CANVAS_VIEW_LOG] Execution start event for node ${node.id}`);
|
||||
console.log(`[CANVAS_VIEW_LOG] Widget value: ${widget.value}`);
|
||||
console.log(`[CANVAS_VIEW_LOG] Node inputs: ${node.inputs?.length || 0}`);
|
||||
log.info(`Execution start event for node ${node.id}`);
|
||||
log.debug(`Widget value: ${widget.value}`);
|
||||
log.debug(`Node inputs: ${node.inputs?.length || 0}`);
|
||||
|
||||
// Sprawdź czy już trwa wykonanie
|
||||
if (executionInProgress) {
|
||||
console.log(`[CANVAS_VIEW_LOG] Execution already in progress, skipping...`);
|
||||
log.warn(`Execution already in progress, skipping...`);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -925,34 +937,34 @@ async function createCanvasWidget(node, widget, app) {
|
||||
|
||||
try {
|
||||
await canvas.saveToServer(widget.value);
|
||||
console.log(`[CANVAS_VIEW_LOG] Canvas saved to server`);
|
||||
log.info(`Canvas saved to server`);
|
||||
|
||||
if (node.inputs[0]?.link) {
|
||||
const linkId = node.inputs[0].link;
|
||||
const inputData = app.nodeOutputs[linkId];
|
||||
console.log(`[CANVAS_VIEW_LOG] Input link ${linkId} has data: ${!!inputData}`);
|
||||
log.debug(`Input link ${linkId} has data: ${!!inputData}`);
|
||||
if (inputData) {
|
||||
imageCache.set(linkId, inputData);
|
||||
console.log(`[CANVAS_VIEW_LOG] Input data cached for link ${linkId}`);
|
||||
log.debug(`Input data cached for link ${linkId}`);
|
||||
}
|
||||
} else {
|
||||
console.log(`[CANVAS_VIEW_LOG] No input link found`);
|
||||
log.debug(`No input link found`);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error(`[CANVAS_VIEW_LOG] Error during execution:`, error);
|
||||
log.error(`Error during execution:`, error);
|
||||
} finally {
|
||||
// Zwolnij flagę wykonania
|
||||
executionInProgress = false;
|
||||
console.log(`[CANVAS_VIEW_LOG] Execution completed, flag released`);
|
||||
log.debug(`Execution completed, flag released`);
|
||||
}
|
||||
});
|
||||
|
||||
const originalSaveToServer = canvas.saveToServer;
|
||||
canvas.saveToServer = async function (fileName) {
|
||||
console.log(`[CANVAS_VIEW_LOG] saveToServer called with fileName: ${fileName}`);
|
||||
console.log(`[CANVAS_VIEW_LOG] Current execution context - node ID: ${node.id}`);
|
||||
log.debug(`saveToServer called with fileName: ${fileName}`);
|
||||
log.debug(`Current execution context - node ID: ${node.id}`);
|
||||
const result = await originalSaveToServer.call(this, fileName);
|
||||
console.log(`[CANVAS_VIEW_LOG] saveToServer completed, result: ${result}`);
|
||||
log.debug(`saveToServer completed, result: ${result}`);
|
||||
return result;
|
||||
};
|
||||
|
||||
@@ -975,11 +987,11 @@ app.registerExtension({
|
||||
if (nodeType.comfyClass === "CanvasNode") {
|
||||
const onNodeCreated = nodeType.prototype.onNodeCreated;
|
||||
nodeType.prototype.onNodeCreated = async function () {
|
||||
console.log("CanvasNode created, ID:", this.id);
|
||||
log.info("CanvasNode created, ID:", this.id);
|
||||
const r = onNodeCreated?.apply(this, arguments);
|
||||
|
||||
const widget = this.widgets.find(w => w.name === "canvas_image");
|
||||
console.log("Found canvas_image widget:", widget);
|
||||
log.debug("Found canvas_image widget:", widget);
|
||||
await createCanvasWidget(this, widget, app);
|
||||
|
||||
return r;
|
||||
@@ -1017,7 +1029,7 @@ app.registerExtension({
|
||||
window.open(url, '_blank');
|
||||
setTimeout(() => URL.revokeObjectURL(url), 1000);
|
||||
} catch (e) {
|
||||
console.error("Error opening image:", e);
|
||||
log.error("Error opening image:", e);
|
||||
}
|
||||
},
|
||||
},
|
||||
@@ -1028,9 +1040,9 @@ app.registerExtension({
|
||||
const blob = await self.canvasWidget.getFlattenedCanvasAsBlob();
|
||||
const item = new ClipboardItem({'image/png': blob});
|
||||
await navigator.clipboard.write([item]);
|
||||
console.log("Image copied to clipboard.");
|
||||
log.info("Image copied to clipboard.");
|
||||
} catch (e) {
|
||||
console.error("Error copying image:", e);
|
||||
log.error("Error copying image:", e);
|
||||
alert("Failed to copy image to clipboard.");
|
||||
}
|
||||
},
|
||||
@@ -1049,7 +1061,7 @@ app.registerExtension({
|
||||
document.body.removeChild(a);
|
||||
setTimeout(() => URL.revokeObjectURL(url), 1000);
|
||||
} catch (e) {
|
||||
console.error("Error saving image:", e);
|
||||
log.error("Error saving image:", e);
|
||||
}
|
||||
},
|
||||
},
|
||||
|
||||
@@ -1,16 +1,29 @@
|
||||
import {logger, LogLevel} from "./logger.js";
|
||||
|
||||
// Inicjalizacja loggera dla modułu ImageCache
|
||||
const log = {
|
||||
debug: (...args) => logger.debug('ImageCache', ...args),
|
||||
info: (...args) => logger.info('ImageCache', ...args),
|
||||
warn: (...args) => logger.warn('ImageCache', ...args),
|
||||
error: (...args) => logger.error('ImageCache', ...args)
|
||||
};
|
||||
|
||||
// Konfiguracja loggera dla modułu ImageCache
|
||||
logger.setModuleLevel('ImageCache', LogLevel.INFO);
|
||||
|
||||
export class ImageCache {
|
||||
constructor() {
|
||||
this.cache = new Map();
|
||||
}
|
||||
|
||||
set(key, imageData) {
|
||||
console.log("Caching image data for key:", key);
|
||||
log.info("Caching image data for key:", key);
|
||||
this.cache.set(key, imageData);
|
||||
}
|
||||
|
||||
get(key) {
|
||||
const data = this.cache.get(key);
|
||||
console.log("Retrieved cached data for key:", key, !!data);
|
||||
log.debug("Retrieved cached data for key:", key, !!data);
|
||||
return data;
|
||||
}
|
||||
|
||||
@@ -19,7 +32,7 @@ export class ImageCache {
|
||||
}
|
||||
|
||||
clear() {
|
||||
console.log("Clearing image cache");
|
||||
log.info("Clearing image cache");
|
||||
this.cache.clear();
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,18 @@
|
||||
import {logger, LogLevel} from "./logger.js";
|
||||
|
||||
// Inicjalizacja loggera dla modułu ImageUtils
|
||||
const log = {
|
||||
debug: (...args) => logger.debug('ImageUtils', ...args),
|
||||
info: (...args) => logger.info('ImageUtils', ...args),
|
||||
warn: (...args) => logger.warn('ImageUtils', ...args),
|
||||
error: (...args) => logger.error('ImageUtils', ...args)
|
||||
};
|
||||
|
||||
// Konfiguracja loggera dla modułu ImageUtils
|
||||
logger.setModuleLevel('ImageUtils', LogLevel.INFO);
|
||||
|
||||
export function validateImageData(data) {
|
||||
console.log("Validating data structure:", {
|
||||
log.debug("Validating data structure:", {
|
||||
hasData: !!data,
|
||||
type: typeof data,
|
||||
isArray: Array.isArray(data),
|
||||
@@ -10,22 +23,22 @@ export function validateImageData(data) {
|
||||
});
|
||||
|
||||
if (!data) {
|
||||
console.log("Data is null or undefined");
|
||||
log.info("Data is null or undefined");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (Array.isArray(data)) {
|
||||
console.log("Data is array, getting first element");
|
||||
log.debug("Data is array, getting first element");
|
||||
data = data[0];
|
||||
}
|
||||
|
||||
if (!data || typeof data !== 'object') {
|
||||
console.log("Invalid data type");
|
||||
log.info("Invalid data type");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!data.data) {
|
||||
console.log("Missing data property");
|
||||
log.info("Missing data property");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -33,7 +46,7 @@ export function validateImageData(data) {
|
||||
try {
|
||||
data.data = new Float32Array(data.data);
|
||||
} catch (e) {
|
||||
console.log("Failed to convert data to Float32Array:", e);
|
||||
log.error("Failed to convert data to Float32Array:", e);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -42,7 +55,7 @@ export function validateImageData(data) {
|
||||
}
|
||||
|
||||
export function convertImageData(data) {
|
||||
console.log("Converting image data:", data);
|
||||
log.info("Converting image data:", data);
|
||||
|
||||
if (Array.isArray(data)) {
|
||||
data = data[0];
|
||||
@@ -54,7 +67,7 @@ export function convertImageData(data) {
|
||||
const channels = shape[3];
|
||||
const floatData = new Float32Array(data.data);
|
||||
|
||||
console.log("Processing dimensions:", {height, width, channels});
|
||||
log.debug("Processing dimensions:", {height, width, channels});
|
||||
|
||||
const rgbaData = new Uint8ClampedArray(width * height * 4);
|
||||
|
||||
@@ -80,7 +93,7 @@ export function convertImageData(data) {
|
||||
}
|
||||
|
||||
export function applyMaskToImageData(imageData, maskData) {
|
||||
console.log("Applying mask to image data");
|
||||
log.info("Applying mask to image data");
|
||||
|
||||
const rgbaData = new Uint8ClampedArray(imageData.data);
|
||||
const width = imageData.width;
|
||||
@@ -89,7 +102,7 @@ export function applyMaskToImageData(imageData, maskData) {
|
||||
const maskShape = maskData.shape;
|
||||
const maskFloatData = new Float32Array(maskData.data);
|
||||
|
||||
console.log(`Applying mask of shape: ${maskShape}`);
|
||||
log.debug(`Applying mask of shape: ${maskShape}`);
|
||||
|
||||
for (let h = 0; h < height; h++) {
|
||||
for (let w = 0; w < width; w++) {
|
||||
@@ -101,7 +114,7 @@ export function applyMaskToImageData(imageData, maskData) {
|
||||
}
|
||||
}
|
||||
|
||||
console.log("Mask application completed");
|
||||
log.info("Mask application completed");
|
||||
|
||||
return {
|
||||
data: rgbaData,
|
||||
@@ -111,7 +124,7 @@ export function applyMaskToImageData(imageData, maskData) {
|
||||
}
|
||||
|
||||
export function prepareImageForCanvas(inputImage) {
|
||||
console.log("Preparing image for canvas:", inputImage);
|
||||
log.info("Preparing image for canvas:", inputImage);
|
||||
|
||||
try {
|
||||
if (Array.isArray(inputImage)) {
|
||||
@@ -128,7 +141,7 @@ export function prepareImageForCanvas(inputImage) {
|
||||
const channels = shape[3];
|
||||
const floatData = new Float32Array(inputImage.data);
|
||||
|
||||
console.log("Image dimensions:", {height, width, channels});
|
||||
log.debug("Image dimensions:", {height, width, channels});
|
||||
|
||||
const rgbaData = new Uint8ClampedArray(width * height * 4);
|
||||
|
||||
@@ -152,7 +165,7 @@ export function prepareImageForCanvas(inputImage) {
|
||||
height: height
|
||||
};
|
||||
} catch (error) {
|
||||
console.error("Error preparing image:", error);
|
||||
log.error("Error preparing image:", error);
|
||||
throw new Error(`Failed to prepare image: ${error.message}`);
|
||||
}
|
||||
}
|
||||
@@ -1,3 +1,16 @@
|
||||
import {logger, LogLevel} from "./logger.js";
|
||||
|
||||
// Inicjalizacja loggera dla modułu Mask_tool
|
||||
const log = {
|
||||
debug: (...args) => logger.debug('Mask_tool', ...args),
|
||||
info: (...args) => logger.info('Mask_tool', ...args),
|
||||
warn: (...args) => logger.warn('Mask_tool', ...args),
|
||||
error: (...args) => logger.error('Mask_tool', ...args)
|
||||
};
|
||||
|
||||
// Konfiguracja loggera dla modułu Mask_tool
|
||||
logger.setModuleLevel('Mask_tool', LogLevel.INFO);
|
||||
|
||||
export class MaskTool {
|
||||
constructor(canvasInstance) {
|
||||
this.canvasInstance = canvasInstance;
|
||||
@@ -28,13 +41,13 @@ export class MaskTool {
|
||||
activate() {
|
||||
this.isActive = true;
|
||||
this.canvasInstance.interaction.mode = 'drawingMask';
|
||||
console.log("Mask tool activated");
|
||||
log.info("Mask tool activated");
|
||||
}
|
||||
|
||||
deactivate() {
|
||||
this.isActive = false;
|
||||
this.canvasInstance.interaction.mode = 'none';
|
||||
console.log("Mask tool deactivated");
|
||||
log.info("Mask tool deactivated");
|
||||
}
|
||||
|
||||
setBrushSize(size) {
|
||||
|
||||
67
js/db.js
67
js/db.js
@@ -1,3 +1,16 @@
|
||||
import {logger, LogLevel} from "./logger.js";
|
||||
|
||||
// Inicjalizacja loggera dla modułu db
|
||||
const log = {
|
||||
debug: (...args) => logger.debug('db', ...args),
|
||||
info: (...args) => logger.info('db', ...args),
|
||||
warn: (...args) => logger.warn('db', ...args),
|
||||
error: (...args) => logger.error('db', ...args)
|
||||
};
|
||||
|
||||
// Konfiguracja loggera dla modułu db
|
||||
logger.setModuleLevel('db', LogLevel.INFO);
|
||||
|
||||
const DB_NAME = 'CanvasNodeDB';
|
||||
const STATE_STORE_NAME = 'CanvasState';
|
||||
const IMAGE_STORE_NAME = 'CanvasImages';
|
||||
@@ -12,37 +25,37 @@ function openDB() {
|
||||
return;
|
||||
}
|
||||
|
||||
console.log("Opening IndexedDB...");
|
||||
log.info("Opening IndexedDB...");
|
||||
const request = indexedDB.open(DB_NAME, DB_VERSION);
|
||||
|
||||
request.onerror = (event) => {
|
||||
console.error("IndexedDB error:", event.target.error);
|
||||
log.error("IndexedDB error:", event.target.error);
|
||||
reject("Error opening IndexedDB.");
|
||||
};
|
||||
|
||||
request.onsuccess = (event) => {
|
||||
db = event.target.result;
|
||||
console.log("IndexedDB opened successfully.");
|
||||
log.info("IndexedDB opened successfully.");
|
||||
resolve(db);
|
||||
};
|
||||
|
||||
request.onupgradeneeded = (event) => {
|
||||
console.log("Upgrading IndexedDB...");
|
||||
log.info("Upgrading IndexedDB...");
|
||||
const db = event.target.result;
|
||||
if (!db.objectStoreNames.contains(STATE_STORE_NAME)) {
|
||||
db.createObjectStore(STATE_STORE_NAME, {keyPath: 'id'});
|
||||
console.log("Object store created:", STATE_STORE_NAME);
|
||||
log.info("Object store created:", STATE_STORE_NAME);
|
||||
}
|
||||
if (!db.objectStoreNames.contains(IMAGE_STORE_NAME)) {
|
||||
db.createObjectStore(IMAGE_STORE_NAME, {keyPath: 'imageId'});
|
||||
console.log("Object store created:", IMAGE_STORE_NAME);
|
||||
log.info("Object store created:", IMAGE_STORE_NAME);
|
||||
}
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export async function getCanvasState(id) {
|
||||
console.log(`DB: Getting state for id: ${id}`);
|
||||
log.info(`Getting state for id: ${id}`);
|
||||
const db = await openDB();
|
||||
return new Promise((resolve, reject) => {
|
||||
const transaction = db.transaction([STATE_STORE_NAME], 'readonly');
|
||||
@@ -50,19 +63,19 @@ export async function getCanvasState(id) {
|
||||
const request = store.get(id);
|
||||
|
||||
request.onerror = (event) => {
|
||||
console.error("DB: Error getting canvas state:", event.target.error);
|
||||
log.error("Error getting canvas state:", event.target.error);
|
||||
reject("Error getting state.");
|
||||
};
|
||||
|
||||
request.onsuccess = (event) => {
|
||||
console.log(`DB: Get success for id: ${id}`, event.target.result ? 'found' : 'not found');
|
||||
log.debug(`Get success for id: ${id}`, event.target.result ? 'found' : 'not found');
|
||||
resolve(event.target.result ? event.target.result.state : null);
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export async function setCanvasState(id, state) {
|
||||
console.log(`DB: Setting state for id: ${id}`);
|
||||
log.info(`Setting state for id: ${id}`);
|
||||
const db = await openDB();
|
||||
return new Promise((resolve, reject) => {
|
||||
const transaction = db.transaction([STATE_STORE_NAME], 'readwrite');
|
||||
@@ -70,19 +83,19 @@ export async function setCanvasState(id, state) {
|
||||
const request = store.put({id, state});
|
||||
|
||||
request.onerror = (event) => {
|
||||
console.error("DB: Error setting canvas state:", event.target.error);
|
||||
log.error("Error setting canvas state:", event.target.error);
|
||||
reject("Error setting state.");
|
||||
};
|
||||
|
||||
request.onsuccess = () => {
|
||||
console.log(`DB: Set success for id: ${id}`);
|
||||
log.debug(`Set success for id: ${id}`);
|
||||
resolve();
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export async function removeCanvasState(id) {
|
||||
console.log(`DB: Removing state for id: ${id}`);
|
||||
log.info(`Removing state for id: ${id}`);
|
||||
const db = await openDB();
|
||||
return new Promise((resolve, reject) => {
|
||||
const transaction = db.transaction([STATE_STORE_NAME], 'readwrite');
|
||||
@@ -90,19 +103,19 @@ export async function removeCanvasState(id) {
|
||||
const request = store.delete(id);
|
||||
|
||||
request.onerror = (event) => {
|
||||
console.error("DB: Error removing canvas state:", event.target.error);
|
||||
log.error("Error removing canvas state:", event.target.error);
|
||||
reject("Error removing state.");
|
||||
};
|
||||
|
||||
request.onsuccess = () => {
|
||||
console.log(`DB: Remove success for id: ${id}`);
|
||||
log.debug(`Remove success for id: ${id}`);
|
||||
resolve();
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export async function saveImage(imageId, imageSrc) {
|
||||
console.log(`DB: Saving image with id: ${imageId}`);
|
||||
log.info(`Saving image with id: ${imageId}`);
|
||||
const db = await openDB();
|
||||
return new Promise((resolve, reject) => {
|
||||
const transaction = db.transaction([IMAGE_STORE_NAME], 'readwrite');
|
||||
@@ -110,19 +123,19 @@ export async function saveImage(imageId, imageSrc) {
|
||||
const request = store.put({imageId, imageSrc});
|
||||
|
||||
request.onerror = (event) => {
|
||||
console.error("DB: Error saving image:", event.target.error);
|
||||
log.error("Error saving image:", event.target.error);
|
||||
reject("Error saving image.");
|
||||
};
|
||||
|
||||
request.onsuccess = () => {
|
||||
console.log(`DB: Image saved successfully for id: ${imageId}`);
|
||||
log.debug(`Image saved successfully for id: ${imageId}`);
|
||||
resolve();
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export async function getImage(imageId) {
|
||||
console.log(`DB: Getting image with id: ${imageId}`);
|
||||
log.info(`Getting image with id: ${imageId}`);
|
||||
const db = await openDB();
|
||||
return new Promise((resolve, reject) => {
|
||||
const transaction = db.transaction([IMAGE_STORE_NAME], 'readonly');
|
||||
@@ -130,19 +143,19 @@ export async function getImage(imageId) {
|
||||
const request = store.get(imageId);
|
||||
|
||||
request.onerror = (event) => {
|
||||
console.error("DB: Error getting image:", event.target.error);
|
||||
log.error("Error getting image:", event.target.error);
|
||||
reject("Error getting image.");
|
||||
};
|
||||
|
||||
request.onsuccess = (event) => {
|
||||
console.log(`DB: Get image success for id: ${imageId}`, event.target.result ? 'found' : 'not found');
|
||||
log.debug(`Get image success for id: ${imageId}`, event.target.result ? 'found' : 'not found');
|
||||
resolve(event.target.result ? event.target.result.imageSrc : null);
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export async function removeImage(imageId) {
|
||||
console.log(`DB: Removing image with id: ${imageId}`);
|
||||
log.info(`Removing image with id: ${imageId}`);
|
||||
const db = await openDB();
|
||||
return new Promise((resolve, reject) => {
|
||||
const transaction = db.transaction([IMAGE_STORE_NAME], 'readwrite');
|
||||
@@ -150,19 +163,19 @@ export async function removeImage(imageId) {
|
||||
const request = store.delete(imageId);
|
||||
|
||||
request.onerror = (event) => {
|
||||
console.error("DB: Error removing image:", event.target.error);
|
||||
log.error("Error removing image:", event.target.error);
|
||||
reject("Error removing image.");
|
||||
};
|
||||
|
||||
request.onsuccess = () => {
|
||||
console.log(`DB: Remove image success for id: ${imageId}`);
|
||||
log.debug(`Remove image success for id: ${imageId}`);
|
||||
resolve();
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export async function clearAllCanvasStates() {
|
||||
console.log("DB: Clearing all canvas states...");
|
||||
log.info("Clearing all canvas states...");
|
||||
const db = await openDB();
|
||||
return new Promise((resolve, reject) => {
|
||||
const transaction = db.transaction([STATE_STORE_NAME], 'readwrite');
|
||||
@@ -170,12 +183,12 @@ export async function clearAllCanvasStates() {
|
||||
const request = store.clear();
|
||||
|
||||
request.onerror = (event) => {
|
||||
console.error("DB: Error clearing canvas states:", event.target.error);
|
||||
log.error("Error clearing canvas states:", event.target.error);
|
||||
reject("Error clearing states.");
|
||||
};
|
||||
|
||||
request.onsuccess = () => {
|
||||
console.log("DB: All canvas states cleared successfully.");
|
||||
log.info("All canvas states cleared successfully.");
|
||||
resolve();
|
||||
};
|
||||
});
|
||||
|
||||
371
js/logger.js
Normal file
371
js/logger.js
Normal file
@@ -0,0 +1,371 @@
|
||||
/**
|
||||
* Logger - Centralny system logowania dla ComfyUI-LayerForge
|
||||
*
|
||||
* Funkcje:
|
||||
* - Różne poziomy logowania (DEBUG, INFO, WARN, ERROR)
|
||||
* - Możliwość włączania/wyłączania logów globalnie lub per moduł
|
||||
* - Kolorowe logi w konsoli
|
||||
* - Możliwość zapisywania logów do localStorage
|
||||
* - Możliwość eksportu logów
|
||||
*/
|
||||
|
||||
// Poziomy logowania
|
||||
export const LogLevel = {
|
||||
DEBUG: 0,
|
||||
INFO: 1,
|
||||
WARN: 2,
|
||||
ERROR: 3,
|
||||
NONE: 4
|
||||
};
|
||||
|
||||
// Konfiguracja domyślna
|
||||
const DEFAULT_CONFIG = {
|
||||
globalLevel: LogLevel.INFO, // Domyślny poziom logowania
|
||||
moduleSettings: {}, // Ustawienia per moduł
|
||||
useColors: true, // Kolorowe logi w konsoli
|
||||
saveToStorage: false, // Zapisywanie logów do localStorage
|
||||
maxStoredLogs: 1000, // Maksymalna liczba przechowywanych logów
|
||||
timestampFormat: 'HH:mm:ss', // Format znacznika czasu
|
||||
storageKey: 'layerforge_logs' // Klucz localStorage
|
||||
};
|
||||
|
||||
// Kolory dla różnych poziomów logowania
|
||||
const COLORS = {
|
||||
[LogLevel.DEBUG]: '#9e9e9e', // Szary
|
||||
[LogLevel.INFO]: '#2196f3', // Niebieski
|
||||
[LogLevel.WARN]: '#ff9800', // Pomarańczowy
|
||||
[LogLevel.ERROR]: '#f44336', // Czerwony
|
||||
};
|
||||
|
||||
// Nazwy poziomów logowania
|
||||
const LEVEL_NAMES = {
|
||||
[LogLevel.DEBUG]: 'DEBUG',
|
||||
[LogLevel.INFO]: 'INFO',
|
||||
[LogLevel.WARN]: 'WARN',
|
||||
[LogLevel.ERROR]: 'ERROR',
|
||||
};
|
||||
|
||||
class Logger {
|
||||
constructor() {
|
||||
this.config = { ...DEFAULT_CONFIG };
|
||||
this.logs = [];
|
||||
this.enabled = true;
|
||||
|
||||
// Załaduj konfigurację z localStorage, jeśli istnieje
|
||||
this.loadConfig();
|
||||
}
|
||||
|
||||
/**
|
||||
* Konfiguracja loggera
|
||||
* @param {Object} config - Obiekt konfiguracyjny
|
||||
*/
|
||||
configure(config) {
|
||||
this.config = { ...this.config, ...config };
|
||||
this.saveConfig();
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Włącz/wyłącz logger globalnie
|
||||
* @param {boolean} enabled - Czy logger ma być włączony
|
||||
*/
|
||||
setEnabled(enabled) {
|
||||
this.enabled = enabled;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ustaw globalny poziom logowania
|
||||
* @param {LogLevel} level - Poziom logowania
|
||||
*/
|
||||
setGlobalLevel(level) {
|
||||
this.config.globalLevel = level;
|
||||
this.saveConfig();
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ustaw poziom logowania dla konkretnego modułu
|
||||
* @param {string} module - Nazwa modułu
|
||||
* @param {LogLevel} level - Poziom logowania
|
||||
*/
|
||||
setModuleLevel(module, level) {
|
||||
this.config.moduleSettings[module] = level;
|
||||
this.saveConfig();
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sprawdź, czy dany poziom logowania jest aktywny dla modułu
|
||||
* @param {string} module - Nazwa modułu
|
||||
* @param {LogLevel} level - Poziom logowania do sprawdzenia
|
||||
* @returns {boolean} - Czy poziom jest aktywny
|
||||
*/
|
||||
isLevelEnabled(module, level) {
|
||||
if (!this.enabled) return false;
|
||||
|
||||
// Sprawdź ustawienia modułu, jeśli istnieją
|
||||
if (this.config.moduleSettings[module] !== undefined) {
|
||||
return level >= this.config.moduleSettings[module];
|
||||
}
|
||||
|
||||
// W przeciwnym razie użyj globalnego poziomu
|
||||
return level >= this.config.globalLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Formatuj znacznik czasu
|
||||
* @returns {string} - Sformatowany znacznik czasu
|
||||
*/
|
||||
formatTimestamp() {
|
||||
const now = new Date();
|
||||
const format = this.config.timestampFormat;
|
||||
|
||||
// Prosty formatter - można rozszerzyć o więcej opcji
|
||||
return format
|
||||
.replace('HH', String(now.getHours()).padStart(2, '0'))
|
||||
.replace('mm', String(now.getMinutes()).padStart(2, '0'))
|
||||
.replace('ss', String(now.getSeconds()).padStart(2, '0'))
|
||||
.replace('SSS', String(now.getMilliseconds()).padStart(3, '0'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Zapisz log
|
||||
* @param {string} module - Nazwa modułu
|
||||
* @param {LogLevel} level - Poziom logowania
|
||||
* @param {Array} args - Argumenty do zalogowania
|
||||
*/
|
||||
log(module, level, ...args) {
|
||||
if (!this.isLevelEnabled(module, level)) return;
|
||||
|
||||
const timestamp = this.formatTimestamp();
|
||||
const levelName = LEVEL_NAMES[level];
|
||||
|
||||
// Przygotuj dane logu
|
||||
const logData = {
|
||||
timestamp,
|
||||
module,
|
||||
level,
|
||||
levelName,
|
||||
args,
|
||||
time: new Date()
|
||||
};
|
||||
|
||||
// Dodaj do pamięci, jeśli zapisywanie jest włączone
|
||||
if (this.config.saveToStorage) {
|
||||
this.logs.push(logData);
|
||||
|
||||
// Ogranicz liczbę przechowywanych logów
|
||||
if (this.logs.length > this.config.maxStoredLogs) {
|
||||
this.logs.shift();
|
||||
}
|
||||
|
||||
// Zapisz do localStorage
|
||||
this.saveLogs();
|
||||
}
|
||||
|
||||
// Wyświetl w konsoli
|
||||
this.printToConsole(logData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wyświetl log w konsoli
|
||||
* @param {Object} logData - Dane logu
|
||||
*/
|
||||
printToConsole(logData) {
|
||||
const { timestamp, module, level, levelName, args } = logData;
|
||||
|
||||
// Przygotuj prefix logu
|
||||
const prefix = `[${timestamp}] [${module}] [${levelName}]`;
|
||||
|
||||
// Użyj kolorów, jeśli są włączone
|
||||
if (this.config.useColors && typeof console.log === 'function') {
|
||||
const color = COLORS[level] || '#000000';
|
||||
console.log(`%c${prefix}`, `color: ${color}; font-weight: bold;`, ...args);
|
||||
return;
|
||||
}
|
||||
|
||||
// Fallback bez kolorów
|
||||
console.log(prefix, ...args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Zapisz logi do localStorage
|
||||
*/
|
||||
saveLogs() {
|
||||
if (typeof localStorage !== 'undefined' && this.config.saveToStorage) {
|
||||
try {
|
||||
// Zapisz tylko niezbędne informacje
|
||||
const simplifiedLogs = this.logs.map(log => ({
|
||||
t: log.timestamp,
|
||||
m: log.module,
|
||||
l: log.level,
|
||||
a: log.args.map(arg => {
|
||||
// Konwertuj obiekty na stringi
|
||||
if (typeof arg === 'object') {
|
||||
try {
|
||||
return JSON.stringify(arg);
|
||||
} catch (e) {
|
||||
return String(arg);
|
||||
}
|
||||
}
|
||||
return arg;
|
||||
})
|
||||
}));
|
||||
|
||||
localStorage.setItem(this.config.storageKey, JSON.stringify(simplifiedLogs));
|
||||
} catch (e) {
|
||||
console.error('Failed to save logs to localStorage:', e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Załaduj logi z localStorage
|
||||
*/
|
||||
loadLogs() {
|
||||
if (typeof localStorage !== 'undefined' && this.config.saveToStorage) {
|
||||
try {
|
||||
const storedLogs = localStorage.getItem(this.config.storageKey);
|
||||
if (storedLogs) {
|
||||
this.logs = JSON.parse(storedLogs);
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('Failed to load logs from localStorage:', e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Zapisz konfigurację do localStorage
|
||||
*/
|
||||
saveConfig() {
|
||||
if (typeof localStorage !== 'undefined') {
|
||||
try {
|
||||
localStorage.setItem('layerforge_logger_config', JSON.stringify(this.config));
|
||||
} catch (e) {
|
||||
console.error('Failed to save logger config to localStorage:', e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Załaduj konfigurację z localStorage
|
||||
*/
|
||||
loadConfig() {
|
||||
if (typeof localStorage !== 'undefined') {
|
||||
try {
|
||||
const storedConfig = localStorage.getItem('layerforge_logger_config');
|
||||
if (storedConfig) {
|
||||
this.config = { ...this.config, ...JSON.parse(storedConfig) };
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('Failed to load logger config from localStorage:', e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Wyczyść wszystkie logi
|
||||
*/
|
||||
clearLogs() {
|
||||
this.logs = [];
|
||||
if (typeof localStorage !== 'undefined') {
|
||||
localStorage.removeItem(this.config.storageKey);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Eksportuj logi do pliku
|
||||
* @param {string} format - Format eksportu ('json' lub 'txt')
|
||||
*/
|
||||
exportLogs(format = 'json') {
|
||||
if (this.logs.length === 0) {
|
||||
console.warn('No logs to export');
|
||||
return;
|
||||
}
|
||||
|
||||
let content;
|
||||
let mimeType;
|
||||
let extension;
|
||||
|
||||
if (format === 'json') {
|
||||
content = JSON.stringify(this.logs, null, 2);
|
||||
mimeType = 'application/json';
|
||||
extension = 'json';
|
||||
} else {
|
||||
// Format tekstowy
|
||||
content = this.logs.map(log =>
|
||||
`[${log.timestamp}] [${log.module}] [${log.levelName}] ${log.args.join(' ')}`
|
||||
).join('\n');
|
||||
mimeType = 'text/plain';
|
||||
extension = 'txt';
|
||||
}
|
||||
|
||||
// Utwórz link do pobrania
|
||||
const blob = new Blob([content], { type: mimeType });
|
||||
const url = URL.createObjectURL(blob);
|
||||
const a = document.createElement('a');
|
||||
a.href = url;
|
||||
a.download = `layerforge_logs_${new Date().toISOString().replace(/[:.]/g, '-')}.${extension}`;
|
||||
document.body.appendChild(a);
|
||||
a.click();
|
||||
document.body.removeChild(a);
|
||||
URL.revokeObjectURL(url);
|
||||
}
|
||||
|
||||
// Metody pomocnicze dla różnych poziomów logowania
|
||||
|
||||
/**
|
||||
* Log na poziomie DEBUG
|
||||
* @param {string} module - Nazwa modułu
|
||||
* @param {...any} args - Argumenty do zalogowania
|
||||
*/
|
||||
debug(module, ...args) {
|
||||
this.log(module, LogLevel.DEBUG, ...args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Log na poziomie INFO
|
||||
* @param {string} module - Nazwa modułu
|
||||
* @param {...any} args - Argumenty do zalogowania
|
||||
*/
|
||||
info(module, ...args) {
|
||||
this.log(module, LogLevel.INFO, ...args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Log na poziomie WARN
|
||||
* @param {string} module - Nazwa modułu
|
||||
* @param {...any} args - Argumenty do zalogowania
|
||||
*/
|
||||
warn(module, ...args) {
|
||||
this.log(module, LogLevel.WARN, ...args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Log na poziomie ERROR
|
||||
* @param {string} module - Nazwa modułu
|
||||
* @param {...any} args - Argumenty do zalogowania
|
||||
*/
|
||||
error(module, ...args) {
|
||||
this.log(module, LogLevel.ERROR, ...args);
|
||||
}
|
||||
}
|
||||
|
||||
// Eksportuj singleton
|
||||
export const logger = new Logger();
|
||||
|
||||
// Eksportuj funkcje pomocnicze
|
||||
export const debug = (module, ...args) => logger.debug(module, ...args);
|
||||
export const info = (module, ...args) => logger.info(module, ...args);
|
||||
export const warn = (module, ...args) => logger.warn(module, ...args);
|
||||
export const error = (module, ...args) => logger.error(module, ...args);
|
||||
|
||||
// Dodaj do window dla łatwego dostępu z konsoli
|
||||
if (typeof window !== 'undefined') {
|
||||
window.LayerForgeLogger = logger;
|
||||
}
|
||||
|
||||
export default logger;
|
||||
299
python/logger.py
Normal file
299
python/logger.py
Normal file
@@ -0,0 +1,299 @@
|
||||
"""
|
||||
Logger - Centralny system logowania dla ComfyUI-LayerForge (Python)
|
||||
|
||||
Funkcje:
|
||||
- Różne poziomy logowania (DEBUG, INFO, WARN, ERROR)
|
||||
- Możliwość włączania/wyłączania logów globalnie lub per moduł
|
||||
- Kolorowe logi w konsoli
|
||||
- Rotacja plików logów
|
||||
- Konfiguracja przez zmienne środowiskowe
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import json
|
||||
import logging
|
||||
import datetime
|
||||
from enum import IntEnum
|
||||
from logging.handlers import RotatingFileHandler
|
||||
import traceback
|
||||
|
||||
# Poziomy logowania
|
||||
class LogLevel(IntEnum):
|
||||
DEBUG = 10
|
||||
INFO = 20
|
||||
WARN = 30
|
||||
ERROR = 40
|
||||
NONE = 100
|
||||
|
||||
# Mapowanie poziomów logowania
|
||||
LEVEL_MAP = {
|
||||
LogLevel.DEBUG: logging.DEBUG,
|
||||
LogLevel.INFO: logging.INFO,
|
||||
LogLevel.WARN: logging.WARNING,
|
||||
LogLevel.ERROR: logging.ERROR,
|
||||
LogLevel.NONE: logging.CRITICAL + 1
|
||||
}
|
||||
|
||||
# Kolory ANSI dla różnych poziomów logowania
|
||||
COLORS = {
|
||||
LogLevel.DEBUG: '\033[90m', # Szary
|
||||
LogLevel.INFO: '\033[94m', # Niebieski
|
||||
LogLevel.WARN: '\033[93m', # Żółty
|
||||
LogLevel.ERROR: '\033[91m', # Czerwony
|
||||
'RESET': '\033[0m' # Reset
|
||||
}
|
||||
|
||||
# Konfiguracja domyślna
|
||||
DEFAULT_CONFIG = {
|
||||
'global_level': LogLevel.INFO,
|
||||
'module_settings': {},
|
||||
'use_colors': True,
|
||||
'log_to_file': False,
|
||||
'log_dir': 'logs',
|
||||
'max_file_size_mb': 10,
|
||||
'backup_count': 5,
|
||||
'timestamp_format': '%H:%M:%S',
|
||||
}
|
||||
|
||||
class ColoredFormatter(logging.Formatter):
|
||||
"""Formatter dodający kolory do logów w konsoli"""
|
||||
|
||||
def __init__(self, fmt=None, datefmt=None, use_colors=True):
|
||||
super().__init__(fmt, datefmt)
|
||||
self.use_colors = use_colors
|
||||
|
||||
def format(self, record):
|
||||
levelname = record.levelname
|
||||
message = super().format(record)
|
||||
|
||||
if self.use_colors and hasattr(LogLevel, levelname):
|
||||
level = getattr(LogLevel, levelname)
|
||||
color = COLORS.get(level, '')
|
||||
reset = COLORS['RESET']
|
||||
return f"{color}{message}{reset}"
|
||||
|
||||
return message
|
||||
|
||||
class LayerForgeLogger:
|
||||
"""Główna klasa loggera dla LayerForge"""
|
||||
|
||||
_instance = None
|
||||
|
||||
def __new__(cls):
|
||||
if cls._instance is None:
|
||||
cls._instance = super(LayerForgeLogger, cls).__new__(cls)
|
||||
cls._instance._initialized = False
|
||||
return cls._instance
|
||||
|
||||
def __init__(self):
|
||||
if self._initialized:
|
||||
return
|
||||
|
||||
self.config = DEFAULT_CONFIG.copy()
|
||||
self.enabled = True
|
||||
self.loggers = {}
|
||||
|
||||
# Załaduj konfigurację ze zmiennych środowiskowych
|
||||
self._load_config_from_env()
|
||||
|
||||
# Utwórz katalog logów, jeśli nie istnieje
|
||||
if self.config['log_to_file']:
|
||||
os.makedirs(self.config['log_dir'], exist_ok=True)
|
||||
|
||||
self._initialized = True
|
||||
|
||||
def _load_config_from_env(self):
|
||||
"""Załaduj konfigurację ze zmiennych środowiskowych"""
|
||||
|
||||
# Poziom globalny
|
||||
if 'LAYERFORGE_LOG_LEVEL' in os.environ:
|
||||
level_name = os.environ['LAYERFORGE_LOG_LEVEL'].upper()
|
||||
if hasattr(LogLevel, level_name):
|
||||
self.config['global_level'] = getattr(LogLevel, level_name)
|
||||
|
||||
# Ustawienia modułów
|
||||
if 'LAYERFORGE_MODULE_LEVELS' in os.environ:
|
||||
try:
|
||||
module_settings = json.loads(os.environ['LAYERFORGE_MODULE_LEVELS'])
|
||||
for module, level_name in module_settings.items():
|
||||
if hasattr(LogLevel, level_name.upper()):
|
||||
self.config['module_settings'][module] = getattr(LogLevel, level_name.upper())
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
|
||||
# Inne ustawienia
|
||||
if 'LAYERFORGE_USE_COLORS' in os.environ:
|
||||
self.config['use_colors'] = os.environ['LAYERFORGE_USE_COLORS'].lower() == 'true'
|
||||
|
||||
if 'LAYERFORGE_LOG_TO_FILE' in os.environ:
|
||||
self.config['log_to_file'] = os.environ['LAYERFORGE_LOG_TO_FILE'].lower() == 'true'
|
||||
|
||||
if 'LAYERFORGE_LOG_DIR' in os.environ:
|
||||
self.config['log_dir'] = os.environ['LAYERFORGE_LOG_DIR']
|
||||
|
||||
if 'LAYERFORGE_MAX_FILE_SIZE_MB' in os.environ:
|
||||
try:
|
||||
self.config['max_file_size_mb'] = int(os.environ['LAYERFORGE_MAX_FILE_SIZE_MB'])
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
if 'LAYERFORGE_BACKUP_COUNT' in os.environ:
|
||||
try:
|
||||
self.config['backup_count'] = int(os.environ['LAYERFORGE_BACKUP_COUNT'])
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
def configure(self, config):
|
||||
"""Konfiguracja loggera"""
|
||||
self.config.update(config)
|
||||
return self
|
||||
|
||||
def set_enabled(self, enabled):
|
||||
"""Włącz/wyłącz logger globalnie"""
|
||||
self.enabled = enabled
|
||||
return self
|
||||
|
||||
def set_global_level(self, level):
|
||||
"""Ustaw globalny poziom logowania"""
|
||||
self.config['global_level'] = level
|
||||
return self
|
||||
|
||||
def set_module_level(self, module, level):
|
||||
"""Ustaw poziom logowania dla konkretnego modułu"""
|
||||
self.config['module_settings'][module] = level
|
||||
return self
|
||||
|
||||
def is_level_enabled(self, module, level):
|
||||
"""Sprawdź, czy dany poziom logowania jest aktywny dla modułu"""
|
||||
if not self.enabled:
|
||||
return False
|
||||
|
||||
# Sprawdź ustawienia modułu, jeśli istnieją
|
||||
if module in self.config['module_settings']:
|
||||
return level >= self.config['module_settings'][module]
|
||||
|
||||
# W przeciwnym razie użyj globalnego poziomu
|
||||
return level >= self.config['global_level']
|
||||
|
||||
def _get_logger(self, module):
|
||||
"""Pobierz lub utwórz logger dla modułu"""
|
||||
if module in self.loggers:
|
||||
return self.loggers[module]
|
||||
|
||||
# Utwórz nowy logger
|
||||
logger = logging.getLogger(f"layerforge.{module}")
|
||||
logger.setLevel(logging.DEBUG) # Ustaw najniższy poziom, filtrowanie będzie później
|
||||
logger.propagate = False
|
||||
|
||||
# Dodaj handler dla konsoli
|
||||
console_handler = logging.StreamHandler(sys.stdout)
|
||||
console_formatter = ColoredFormatter(
|
||||
fmt='[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s',
|
||||
datefmt=self.config['timestamp_format'],
|
||||
use_colors=self.config['use_colors']
|
||||
)
|
||||
console_handler.setFormatter(console_formatter)
|
||||
logger.addHandler(console_handler)
|
||||
|
||||
# Dodaj handler dla pliku, jeśli włączono logowanie do pliku
|
||||
if self.config['log_to_file']:
|
||||
log_file = os.path.join(self.config['log_dir'], f"layerforge_{module}.log")
|
||||
file_handler = RotatingFileHandler(
|
||||
log_file,
|
||||
maxBytes=self.config['max_file_size_mb'] * 1024 * 1024,
|
||||
backupCount=self.config['backup_count']
|
||||
)
|
||||
file_formatter = logging.Formatter(
|
||||
fmt='[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s',
|
||||
datefmt='%Y-%m-%d %H:%M:%S'
|
||||
)
|
||||
file_handler.setFormatter(file_formatter)
|
||||
logger.addHandler(file_handler)
|
||||
|
||||
self.loggers[module] = logger
|
||||
return logger
|
||||
|
||||
def log(self, module, level, *args, **kwargs):
|
||||
"""Zapisz log"""
|
||||
if not self.is_level_enabled(module, level):
|
||||
return
|
||||
|
||||
logger = self._get_logger(module)
|
||||
|
||||
# Konwertuj argumenty na string
|
||||
message = " ".join(str(arg) for arg in args)
|
||||
|
||||
# Dodaj informacje o wyjątku, jeśli podano
|
||||
exc_info = kwargs.get('exc_info', None)
|
||||
|
||||
# Mapuj poziom LogLevel na poziom logging
|
||||
log_level = LEVEL_MAP.get(level, logging.INFO)
|
||||
|
||||
# Zapisz log
|
||||
logger.log(log_level, message, exc_info=exc_info)
|
||||
|
||||
def debug(self, module, *args, **kwargs):
|
||||
"""Log na poziomie DEBUG"""
|
||||
self.log(module, LogLevel.DEBUG, *args, **kwargs)
|
||||
|
||||
def info(self, module, *args, **kwargs):
|
||||
"""Log na poziomie INFO"""
|
||||
self.log(module, LogLevel.INFO, *args, **kwargs)
|
||||
|
||||
def warn(self, module, *args, **kwargs):
|
||||
"""Log na poziomie WARN"""
|
||||
self.log(module, LogLevel.WARN, *args, **kwargs)
|
||||
|
||||
def error(self, module, *args, **kwargs):
|
||||
"""Log na poziomie ERROR"""
|
||||
self.log(module, LogLevel.ERROR, *args, **kwargs)
|
||||
|
||||
def exception(self, module, *args):
|
||||
"""Log wyjątku na poziomie ERROR"""
|
||||
self.log(module, LogLevel.ERROR, *args, exc_info=True)
|
||||
|
||||
# Singleton
|
||||
logger = LayerForgeLogger()
|
||||
|
||||
# Funkcje pomocnicze
|
||||
def debug(module, *args, **kwargs):
|
||||
"""Log na poziomie DEBUG"""
|
||||
logger.debug(module, *args, **kwargs)
|
||||
|
||||
def info(module, *args, **kwargs):
|
||||
"""Log na poziomie INFO"""
|
||||
logger.info(module, *args, **kwargs)
|
||||
|
||||
def warn(module, *args, **kwargs):
|
||||
"""Log na poziomie WARN"""
|
||||
logger.warn(module, *args, **kwargs)
|
||||
|
||||
def error(module, *args, **kwargs):
|
||||
"""Log na poziomie ERROR"""
|
||||
logger.error(module, *args, **kwargs)
|
||||
|
||||
def exception(module, *args):
|
||||
"""Log wyjątku na poziomie ERROR"""
|
||||
logger.exception(module, *args)
|
||||
|
||||
# Funkcja do szybkiego włączania/wyłączania debugowania
|
||||
def set_debug(enabled=True):
|
||||
"""Włącz/wyłącz debugowanie globalnie"""
|
||||
if enabled:
|
||||
logger.set_global_level(LogLevel.DEBUG)
|
||||
else:
|
||||
logger.set_global_level(LogLevel.INFO)
|
||||
return logger
|
||||
|
||||
# Funkcja do włączania/wyłączania logowania do pliku
|
||||
def set_file_logging(enabled=True, log_dir=None):
|
||||
"""Włącz/wyłącz logowanie do pliku"""
|
||||
logger.config['log_to_file'] = enabled
|
||||
if log_dir:
|
||||
logger.config['log_dir'] = log_dir
|
||||
os.makedirs(log_dir, exist_ok=True)
|
||||
|
||||
# Zresetuj loggery, aby zastosować nowe ustawienia
|
||||
logger.loggers = {}
|
||||
return logger
|
||||
Reference in New Issue
Block a user