qase-python-commons 4.0.0__py3-none-any.whl → 4.1.0__py3-none-any.whl

qase/__init__.py

@@ -0,0 +1,3 @@
+"""
+Qase Python Commons package.
+"""

qase/commons/config.py

@@ -1,18 +1,28 @@
 import os
 import json
-from .logger import Logger
+from .logger import Logger, LoggingOptions
 from .models.config.qaseconfig import QaseConfig, Mode
+from .utils import QaseUtils
 
 
 class ConfigManager:
 
     def __init__(self, config_file='./qase.config.json'):
-        self.logger = Logger()
         self.__config_file = config_file
         self.config = QaseConfig()
 
+        # Initialize temporary logger for error handling during config loading
+        self.logger = Logger(debug=False)
+        
         self.__load_file_config()
         self.__load_env_config()
+        
+        # Re-initialize logger with proper logging options after config is loaded
+        logging_options = LoggingOptions(
+            console=self.config.logging.console if self.config.logging.console is not None else True,
+            file=self.config.logging.file if self.config.logging.file is not None else self.config.debug
+        )
+        self.logger = Logger(debug=self.config.debug, logging_options=logging_options)
 
     def validate_config(self):
         errors: list[str] = []
@@ -63,6 +73,11 @@ class ConfigManager:
                             config.get("excludeParams")
                         )
 
+                    if config.get("statusMapping"):
+                        self.config.set_status_mapping(
+                            config.get("statusMapping")
+                        )
+
                     if config.get("executionPlan"):
                         execution_plan = config.get("executionPlan")
                         if execution_plan.get("path"):
@@ -196,6 +211,9 @@ class ConfigManager:
                                         xfail_status.get("xpass")
                                     )
 
+                    if config.get("logging"):
+                        self.config.set_logging(config.get("logging"))
+
         except Exception as e:
             self.logger.log("Failed to load config from file", "error")
 
@@ -224,6 +242,19 @@ class ConfigManager:
                     self.config.set_exclude_params(
                         [param.strip() for param in value.split(',')])
 
+                if key == 'QASE_STATUS_MAPPING':
+                    # Parse status mapping from environment variable
+                    # Format: "source1=target1,source2=target2"
+                    if value:
+                        mapping_dict = {}
+                        pairs = value.split(',')
+                        for pair in pairs:
+                            pair = pair.strip()
+                            if pair and '=' in pair:
+                                source_status, target_status = pair.split('=', 1)
+                                mapping_dict[source_status.strip()] = target_status.strip()
+                        self.config.set_status_mapping(mapping_dict)
+
                 if key == 'QASE_EXECUTION_PLAN_PATH':
                     self.config.execution_plan.set_path(value)
 
@@ -308,5 +339,11 @@ class ConfigManager:
                 if key == 'QASE_PYTEST_XFAIL_STATUS_XPASS':
                     self.config.framework.pytest.xfail_status.set_xpass(value)
 
+                if key == 'QASE_LOGGING_CONSOLE':
+                    self.config.logging.set_console(QaseUtils.parse_bool(value))
+
+                if key == 'QASE_LOGGING_FILE':
+                    self.config.logging.set_file(QaseUtils.parse_bool(value))
+
         except Exception as e:
-            self.logger.log("Failed to load config from env vars {e}", "error")
+            self.logger.log(f"Failed to load config from env vars {e}", "error")

qase/commons/logger.py

@@ -1,14 +1,39 @@
 import os
 import datetime
 import threading
+from typing import Optional
+
+
+class LoggingOptions:
+    def __init__(self, console: bool = True, file: bool = False):
+        self.console = console
+        self.file = file
 
 
 class Logger:
     _log_file = None
 
-    def __init__(self, debug: bool = False, prefix: str = '', dir: str = os.path.join('.', 'logs')) -> None:
+    def __init__(self, debug: bool = False, prefix: str = '', dir: str = os.path.join('.', 'logs'), 
+                 logging_options: Optional[LoggingOptions] = None) -> None:
         self.debug = debug
-        if self.debug:
+        self.prefix = prefix
+        self.dir = dir
+        
+        # Initialize logging options
+        if logging_options is None:
+            # Default behavior: console always enabled, file enabled only in debug mode
+            self.logging_options = LoggingOptions(
+                console=True,
+                file=debug
+            )
+        else:
+            self.logging_options = logging_options
+        
+        # Override with environment variables if set
+        self._load_env_logging_options()
+        
+        # Setup file logging if enabled
+        if self.logging_options.file:
             if Logger._log_file is None:
                 timestamp = self._get_timestamp()
                 filename = f'{prefix}_{timestamp}.log'
@@ -21,16 +46,38 @@ class Logger:
 
             self.lock = threading.Lock()
 
+    def _load_env_logging_options(self):
+        """Load logging options from environment variables"""
+        # QASE_LOGGING_CONSOLE
+        console_env = os.environ.get('QASE_LOGGING_CONSOLE')
+        if console_env is not None:
+            self.logging_options.console = console_env.lower() in ('true', '1', 'yes', 'on')
+        
+        # QASE_LOGGING_FILE
+        file_env = os.environ.get('QASE_LOGGING_FILE')
+        if file_env is not None:
+            self.logging_options.file = file_env.lower() in ('true', '1', 'yes', 'on')
+        
+        # Legacy QASE_DEBUG support
+        debug_env = os.environ.get('QASE_DEBUG')
+        if debug_env is not None and debug_env.lower() in ('true', '1', 'yes', 'on'):
+            # When debug is enabled via env, enable file logging if not explicitly disabled
+            if not hasattr(self.logging_options, 'file') or self.logging_options.file is None:
+                self.logging_options.file = True
+
     def log(self, message: str, level: str = 'info'):
         time_str = self._get_timestamp("%H:%M:%S")
         log = f"[Qase][{time_str}][{level}] {message}\n"
 
-        try:
-            print(log, end='')
-        except (OSError, IOError):
-            pass
+        # Console output
+        if self.logging_options.console:
+            try:
+                print(log, end='')
+            except (OSError, IOError):
+                pass
 
-        if self.debug:
+        # File output
+        if self.logging_options.file:
             with self.lock:
                 with open(Logger._log_file, 'a', encoding='utf-8') as f:
                     f.write(log)
@@ -39,6 +86,15 @@ class Logger:
         if self.debug:
             self.log(message, 'debug')
 
+    def log_error(self, message: str):
+        self.log(message, 'error')
+
+    def log_warning(self, message: str):
+        self.log(message, 'warning')
+
+    def log_info(self, message: str):
+        self.log(message, 'info')
+
     @staticmethod
     def _get_timestamp(fmt: str = "%Y%m%d"):
         now = datetime.datetime.now()

qase/commons/models/config/qaseconfig.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import List
+from typing import List, Dict, Optional
 
 from .framework import Framework
 from .report import ReportConfig
@@ -14,6 +14,21 @@ class Mode(Enum):
     off = "off"
 
 
+class LoggingConfig(BaseModel):
+    console: Optional[bool] = None
+    file: Optional[bool] = None
+
+    def __init__(self):
+        self.console = None
+        self.file = None
+
+    def set_console(self, console: bool):
+        self.console = console
+
+    def set_file(self, file: bool):
+        self.file = file
+
+
 class ExecutionPlan(BaseModel):
     path: str = None
 
@@ -36,6 +51,8 @@ class QaseConfig(BaseModel):
     profilers: list = None
     framework: Framework = None
     exclude_params: list = None
+    status_mapping: Dict[str, str] = None
+    logging: LoggingConfig = None
 
     def __init__(self):
         self.mode = Mode.off
@@ -47,6 +64,8 @@ class QaseConfig(BaseModel):
         self.framework = Framework()
         self.profilers = []
         self.exclude_params = []
+        self.status_mapping = {}
+        self.logging = LoggingConfig()
 
     def set_mode(self, mode: str):
         if any(mode == e.value for e in Mode.__members__.values()):
@@ -70,3 +89,12 @@ class QaseConfig(BaseModel):
 
     def set_exclude_params(self, exclude_params: List[str]):
         self.exclude_params = exclude_params
+
+    def set_status_mapping(self, status_mapping: Dict[str, str]):
+        self.status_mapping = status_mapping
+
+    def set_logging(self, logging_config: dict):
+        if logging_config.get("console") is not None:
+            self.logging.set_console(QaseUtils.parse_bool(logging_config.get("console")))
+        if logging_config.get("file") is not None:
+            self.logging.set_file(QaseUtils.parse_bool(logging_config.get("file")))

qase/commons/models/result.py

@@ -33,10 +33,16 @@ class Execution(BaseModel):
         self.thread = thread
 
     def set_status(self, status: Optional[str]):
-        if status in ['passed', 'failed', 'skipped', 'untested', 'invalid']:
+        if status is None:
             self.status = status
+            return
+        
+        # Convert to lowercase for validation
+        status_lower = status.lower()
+        if status_lower in ['passed', 'failed', 'skipped', 'untested', 'invalid', 'disabled', 'blocked']:
+            self.status = status_lower
         else:
-            raise ValueError('Step status must be one of: passed, failed, skipped, untested, invalid')
+            raise ValueError('Step status must be one of: passed, failed, skipped, untested, invalid, disabled, blocked')
 
     def get_status(self):
         return self.status

qase/commons/reporters/core.py

@@ -11,6 +11,7 @@ from ..models.config.qaseconfig import Mode
 from typing import Union, List
 
 from ..util import get_host_info
+from ..status_mapping.status_mapping import StatusMapping
 
 """
     CoreReporter is a facade for all reporters and it is used to initialize and manage them.
@@ -23,11 +24,17 @@ class QaseCoreReporter:
                  reporter_name: Union[str, None] = None):
         config.validate_config()
         self.config = config.config
-        self.logger = Logger(self.config.debug)
+        # Use the logger from ConfigManager instead of creating a new one
+        self.logger = config.logger
         self._execution_plan = None
         self.profilers = []
         self.overhead = 0
 
+        # Initialize status mapping
+        self.status_mapping = StatusMapping.from_dict(self.config.status_mapping)
+        if not self.status_mapping.is_empty():
+            self.logger.log_debug(f"Status mapping initialized: {self.status_mapping}")
+
         # self._selective_execution_setup()
         self.fallback = self._fallback_setup()
 
@@ -87,6 +94,9 @@ class QaseCoreReporter:
                 ts = time.time()
                 self.logger.log_debug(f"Adding result {result}")
 
+                # Apply status mapping before adding result
+                self._apply_status_mapping(result)
+
                 self.reporter.add_result(result)
 
                 self.logger.log_debug(f"Result {result.get_title()} added")
@@ -208,3 +218,26 @@ class QaseCoreReporter:
         if self.config.fallback == Mode.report:
             return QaseReport(config=self.config, logger=self.logger)
         return None
+
+    def _apply_status_mapping(self, result: Result) -> None:
+        """
+        Apply status mapping to a test result.
+        
+        This method applies the configured status mapping to the result's execution status.
+        The mapping is applied before the result is sent to the reporter.
+        
+        Args:
+            result: Test result to apply status mapping to
+        """
+        if self.status_mapping.is_empty():
+            return
+        
+        original_status = result.get_status()
+        if not original_status:
+            return
+        
+        mapped_status = self.status_mapping.apply_mapping(original_status)
+        
+        if mapped_status != original_status:
+            result.execution.set_status(mapped_status)
+            self.logger.log_debug(f"Status mapped for '{result.get_title()}': {original_status} -> {mapped_status}")

qase/commons/status_mapping/__init__.py

@@ -0,0 +1,12 @@
+"""
+Utilities package for Qase Python Commons.
+"""
+
+from .status_mapping import StatusMapping, StatusMappingError, create_status_mapping_from_config, create_status_mapping_from_env
+
+__all__ = [
+    'StatusMapping',
+    'StatusMappingError', 
+    'create_status_mapping_from_config',
+    'create_status_mapping_from_env'
+]

qase/commons/status_mapping/status_mapping.py

@@ -0,0 +1,237 @@
+"""
+Status mapping utilities for Qase Python Commons.
+
+This module provides functionality to map test result statuses from one value to another
+based on configuration. This is useful for standardizing status values across different
+testing frameworks or for custom status transformations.
+"""
+
+from typing import Dict, Optional, List
+import os
+import logging
+
+
+class StatusMappingError(Exception):
+    """Exception raised when status mapping encounters an error."""
+    pass
+
+
+class StatusMapping:
+    """
+    Handles mapping of test result statuses.
+    
+    This class provides functionality to:
+    - Parse status mapping from configuration
+    - Validate status mappings
+    - Apply status mappings to test results
+    - Support both JSON configuration and environment variables
+    """
+    
+    # Valid statuses that can be mapped
+    VALID_STATUSES = {
+        'passed', 'failed', 'skipped', 'disabled', 'blocked', 'invalid'
+    }
+    
+    def __init__(self, mapping: Optional[Dict[str, str]] = None):
+        """
+        Initialize StatusMapping with optional mapping dictionary.
+        
+        Args:
+            mapping: Dictionary mapping source status to target status
+        """
+        self.mapping = mapping or {}
+        self.logger = logging.getLogger(__name__)
+    
+    @classmethod
+    def from_dict(cls, mapping_dict: Dict[str, str]) -> 'StatusMapping':
+        """
+        Create StatusMapping from dictionary.
+        
+        Args:
+            mapping_dict: Dictionary with status mappings
+            
+        Returns:
+            StatusMapping instance
+            
+        Raises:
+            StatusMappingError: If mapping contains invalid statuses
+        """
+        instance = cls()
+        instance.set_mapping(mapping_dict)
+        return instance
+    
+    @classmethod
+    def from_env_string(cls, env_string: str) -> 'StatusMapping':
+        """
+        Create StatusMapping from environment variable string.
+        
+        Expected format: "source1=target1,source2=target2"
+        
+        Args:
+            env_string: Environment variable string
+            
+        Returns:
+            StatusMapping instance
+            
+        Raises:
+            StatusMappingError: If string format is invalid
+        """
+        instance = cls()
+        instance.parse_env_string(env_string)
+        return instance
+    
+    def set_mapping(self, mapping_dict: Dict[str, str]) -> None:
+        """
+        Set status mapping from dictionary.
+        
+        Args:
+            mapping_dict: Dictionary with status mappings
+            
+        Raises:
+            StatusMappingError: If mapping contains invalid statuses
+        """
+        if not isinstance(mapping_dict, dict):
+            raise StatusMappingError("Mapping must be a dictionary")
+        
+        # Validate all statuses in the mapping
+        for source_status, target_status in mapping_dict.items():
+            if source_status not in self.VALID_STATUSES:
+                raise StatusMappingError(f"Invalid source status: {source_status}")
+            if target_status not in self.VALID_STATUSES:
+                raise StatusMappingError(f"Invalid target status: {target_status}")
+        
+        self.mapping = mapping_dict.copy()
+        self.logger.debug(f"Status mapping set: {self.mapping}")
+    
+    def parse_env_string(self, env_string: str) -> None:
+        """
+        Parse status mapping from environment variable string.
+        
+        Expected format: "source1=target1,source2=target2"
+        
+        Args:
+            env_string: Environment variable string
+            
+        Raises:
+            StatusMappingError: If string format is invalid
+        """
+        if not env_string or not env_string.strip():
+            self.mapping = {}
+            return
+        
+        mapping_dict = {}
+        pairs = env_string.split(',')
+        
+        for pair in pairs:
+            pair = pair.strip()
+            if not pair:
+                continue
+                
+            if '=' not in pair:
+                raise StatusMappingError(f"Invalid mapping format: {pair}. Expected 'source=target'")
+            
+            source_status, target_status = pair.split('=', 1)
+            source_status = source_status.strip()
+            target_status = target_status.strip()
+            
+            if not source_status or not target_status:
+                raise StatusMappingError(f"Empty status in mapping: {pair}")
+            
+            mapping_dict[source_status] = target_status
+        
+        self.set_mapping(mapping_dict)
+    
+    def apply_mapping(self, status: str) -> str:
+        """
+        Apply status mapping to a given status.
+        
+        Args:
+            status: Original status
+            
+        Returns:
+            Mapped status if mapping exists, otherwise original status
+        """
+        if not status:
+            return status
+        
+        if status in self.mapping:
+            mapped_status = self.mapping[status]
+            self.logger.debug(f"Status mapped: {status} -> {mapped_status}")
+            return mapped_status
+        
+        return status
+    
+    def get_mapping(self) -> Dict[str, str]:
+        """
+        Get current status mapping.
+        
+        Returns:
+            Dictionary with current status mappings
+        """
+        return self.mapping.copy()
+    
+    def is_empty(self) -> bool:
+        """
+        Check if mapping is empty.
+        
+        Returns:
+            True if no mappings are defined
+        """
+        return len(self.mapping) == 0
+    
+    def validate(self) -> List[str]:
+        """
+        Validate current mapping and return any issues.
+        
+        Returns:
+            List of validation error messages
+        """
+        errors = []
+        
+        for source_status, target_status in self.mapping.items():
+            if source_status not in self.VALID_STATUSES:
+                errors.append(f"Invalid source status: {source_status}")
+            if target_status not in self.VALID_STATUSES:
+                errors.append(f"Invalid target status: {target_status}")
+        
+        return errors
+    
+    def __str__(self) -> str:
+        """String representation of the mapping."""
+        return str(self.mapping)
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"StatusMapping({self.mapping})"
+
+
+def create_status_mapping_from_config(config_value: Optional[Dict[str, str]]) -> StatusMapping:
+    """
+    Create StatusMapping from configuration value.
+    
+    Args:
+        config_value: Configuration dictionary or None
+        
+    Returns:
+        StatusMapping instance
+    """
+    if config_value is None:
+        return StatusMapping()
+    
+    return StatusMapping.from_dict(config_value)
+
+
+def create_status_mapping_from_env(env_var_name: str = 'STATUS_MAPPING') -> StatusMapping:
+    """
+    Create StatusMapping from environment variable.
+    
+    Args:
+        env_var_name: Name of environment variable
+        
+    Returns:
+        StatusMapping instance
+    """
+    env_value = os.getenv(env_var_name)
+    if env_value:
+        return StatusMapping.from_env_string(env_value)
+    return StatusMapping()

{qase_python_commons-4.0.0.dist-info → qase_python_commons-4.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qase-python-commons
-Version: 4.0.0
+Version: 4.1.0
 Summary: A library for Qase TestOps and Qase Report
 Author-email: Qase Team <support@qase.io>
 Project-URL: Homepage, https://github.com/qase-tms/qase-python/tree/main/qase-python-commons
@@ -21,7 +21,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: certifi>=2024.2.2
 Requires-Dist: attrs>=23.2.0
-Requires-Dist: qase-api-client~=2.0.0
+Requires-Dist: qase-api-client~=2.0.1
 Requires-Dist: qase-api-v2-client~=2.0.0
 Requires-Dist: more_itertools
 Provides-Extra: testing
@@ -36,7 +36,12 @@ Requires-Dist: urllib3; extra == "testing"
 
 ## Description
 
-This package contains reporters for Qase TestOps and Qase Report that are used in [qase-pytest](https://github.com/qase-tms/qase-python/tree/master/qase-pytest) and [qase-robotframework](https://github.com/qase-tms/qase-python/tree/master/qase-robotframework).
+This package contains reporters for Qase TestOps and Qase Report that are used in following projects:
+
+- [qase-pytest](https://github.com/qase-tms/qase-python/tree/main/qase-pytest)
+- [qase-robotframework](https://github.com/qase-tms/qase-python/tree/main/qase-robotframework)
+- [qase-behave](https://github.com/qase-tms/qase-python/tree/main/qase-behave)
+- [qase-tavern](https://github.com/qase-tms/qase-python/tree/main/qase-tavern)
 
 ## How to install
 

{qase_python_commons-4.0.0.dist-info → qase_python_commons-4.1.0.dist-info}/RECORD

@@ -1,7 +1,8 @@
+qase/__init__.py,sha256=FLefSJnT6MTsTfZSDjMbMImI6674fAoJ5ZT3PNWGcRo,37
 qase/commons/__init__.py,sha256=3HI65PJES4Q6YvtkSuRPh6tZboTETJo8wbdHlNYaePU,323
-qase/commons/config.py,sha256=yqV8I4rtQz5siOcP1gWXNwWw7RXDRDWLB_Hk0C2yEug,13322
+qase/commons/config.py,sha256=ivunk-6IBfsXyRf-_Y_Je_K8boD4gDupv8v2Yf3nm2M,15162
 qase/commons/loader.py,sha256=-MMY4HgSI6q1xq3NaJoq_w4liM73qdFKjYLVCT1E7Pc,1064
-qase/commons/logger.py,sha256=KEQr8G0eFZxlI3LJIaaNWOKD8o3NhKsZD06swXFn3FI,1313
+qase/commons/logger.py,sha256=V_QTSDWNnUgd0j58rydYYN1AYOu3wa9T2fWjpOyxyuA,3430
 qase/commons/utils.py,sha256=utPRoYyThLs2tgD1lmjkwJ9KZuE7ZjliUiZkJJWFca0,3330
 qase/commons/client/api_v1_client.py,sha256=_dpvldRonALKubInPU03hYhyGJqxeq3DiIuyjDeOngg,11543
 qase/commons/client/api_v2_client.py,sha256=GsIrXJcBw6GtzvJjbjMYa0tvUIxEEe4pALRN2LBMKPM,9043
@@ -12,7 +13,7 @@ qase/commons/models/attachment.py,sha256=cGfB0BaTDVfA7euJubKvi2cXXNvlSm_dy5x-ak3
 qase/commons/models/basemodel.py,sha256=0j8E-LE6hxAKQPYLNM9qThor9s2ZndZys_kibeoLImo,426
 qase/commons/models/external_link.py,sha256=bdXj7pNHHkfb3dcYtXN8sNp-HFxHvZeYz8QIPGcvX0w,1317
 qase/commons/models/relation.py,sha256=HymHeh1uBcoQnTs4Vra7WJ_KFkhryj5o7cShjoGQImI,511
-qase/commons/models/result.py,sha256=8dES10mjBx7SdltAlKDB39bO3k1-xGQVKrHWn19gXK0,3793
+qase/commons/models/result.py,sha256=8Tp-R34vxZhxmgqQErr2vH8ie-ZidDNqxZy6Xty4uqg,4019
 qase/commons/models/run.py,sha256=ANbljW1mgua4JF1wGZG9S-jnUpI7FC4F15sAQOoNnko,3096
 qase/commons/models/runtime.py,sha256=h0kJcPYRo8dglIQVFyzh-cFpWb3bAaQaIq5wV8VfClM,1508
 qase/commons/models/step.py,sha256=svH2jvxiJRBugCjKdifXzOKli9OzQQvn8lsPhzd20yY,5433
@@ -21,7 +22,7 @@ qase/commons/models/config/batch.py,sha256=X0H8SVOCCD2pV6LSMqjI-tIjRcLifnrM5Mare
 qase/commons/models/config/connection.py,sha256=wK2fGjc0G0rMVVhPnjw_t_M1YWZwANlhwl-awmI7XSo,516
 qase/commons/models/config/framework.py,sha256=sSWKQp18zxiS_79_XDH2hkHLpYEQnyH3bRquaT8XYYY,1803
 qase/commons/models/config/plan.py,sha256=JbAY7qfGXYreXOLa32OLxw6z0paeCCf87-2b1m8xkks,137
-qase/commons/models/config/qaseconfig.py,sha256=ho_22bcouoJb1f68EGffeBs_ovK3DVyfbFrYXwQFrWs,1918
+qase/commons/models/config/qaseconfig.py,sha256=oWc03PKV8-jb3JNgs_tqQP-22wsKZW25eSaAacYl4no,2838
 qase/commons/models/config/report.py,sha256=g3Z2B3Tewaasjc1TMj2mkXxz0Zc1C39sHeTXH0MRM2Y,497
 qase/commons/models/config/run.py,sha256=UGE5PA_EyiFpfIev-TOob1BocxT1vdUdWW3ELMD58zQ,1239
 qase/commons/models/config/testops.py,sha256=rJ9wW-VMt-5XaoPdRUKeM9rlV0eTiRINEhEulFVczv0,1893
@@ -30,13 +31,15 @@ qase/commons/profilers/db.py,sha256=Am1tvvLgJq4_A8JsuSeBGf47BD2lnSX-5KiMjSgr-Ko,
 qase/commons/profilers/network.py,sha256=zKNBnTQG4BMg8dn8O--tQzQLpu-qs5ADhHEnqIas0gM,4950
 qase/commons/profilers/sleep.py,sha256=HT6h0R-2XHZAoBYRxS2T_KC8RrnEoVjP7MXusaE4Nec,1624
 qase/commons/reporters/__init__.py,sha256=J0aNLzb_MPPT_zF8BtX_w9nj_U7Ad06RGpyWK5Pxq1o,169
-qase/commons/reporters/core.py,sha256=JyFMGhcDOr3nBlhh0Ca8Dx6BmvNBoG8m1Y4hpC0qIog,8185
+qase/commons/reporters/core.py,sha256=FJx1kxXkUz9vwkSAXapkNS3vF97Igvlq7Yyjp-4BpeI,9539
 qase/commons/reporters/report.py,sha256=ZLwtVn5gjwgJFtfbpLUO-vW3M3skEq3AhKJwtmM0nUw,4810
 qase/commons/reporters/testops.py,sha256=uph_8upIt5bu4ncqyK7ehXR9NqtpZ34wGUBFLVJKOpE,7481
+qase/commons/status_mapping/__init__.py,sha256=NPsWKDC7rGSCYfVunnGnHxL0_HmKWH7RBaMjWTH_Mtk,322
+qase/commons/status_mapping/status_mapping.py,sha256=kohSLNK6_qbMSP-M8gxHTTmOECgzDE3XvLqOzidPlYI,7213
 qase/commons/util/__init__.py,sha256=0sRRfrMOIPCHpk9tXM94Pj10qrk18B61qEcbLpRjw_I,74
 qase/commons/util/host_data.py,sha256=n8o5PDs8kELCZZ5GR7Jug6LsgZHWJudU7iRmZHRdrlw,5264
 qase/commons/validators/base.py,sha256=wwSn-4YiuXtfGMGnSKgo9Vm5hAKevVmmfd2Ro6Q7MYQ,173
-qase_python_commons-4.0.0.dist-info/METADATA,sha256=i3e1yWuvsf7RkNj4zWPVbER7RikCOgaPsBirjLVhVqo,1808
-qase_python_commons-4.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-qase_python_commons-4.0.0.dist-info/top_level.txt,sha256=Mn5aFk7H7Uia4s1NRDsvebu8vCrFy9nOuRIBfkIY5kQ,5
-qase_python_commons-4.0.0.dist-info/RECORD,,
+qase_python_commons-4.1.0.dist-info/METADATA,sha256=JcshiFrQAEhDrqLCi3QflCIJcPMfDF4qLsEqLt-ansE,1982
+qase_python_commons-4.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qase_python_commons-4.1.0.dist-info/top_level.txt,sha256=Mn5aFk7H7Uia4s1NRDsvebu8vCrFy9nOuRIBfkIY5kQ,5
+qase_python_commons-4.1.0.dist-info/RECORD,,