phenotypic.abc_.BaseOperation#

class phenotypic.abc_.BaseOperation[source]#

Bases: ABC

Root abstract base class for all operations in PhenoTypic.

BaseOperation is the foundation of PhenoTypic’s operation system. It provides automatic memory tracking, logging integration, and utilities for parallel execution. All operations in PhenoTypic inherit from BaseOperation (either directly or through intermediate ABCs like ImageOperation and MeasureFeatures).

This class is a blueprint for extending the framework: when you create a new operation, BaseOperation automatically handles memory profiling and logging so you can focus on the algorithm implementation.

What it provides automatically:

  • Memory Tracking: BaseOperation automatically initiates tracemalloc when the logger is enabled for INFO level or higher. This enables per-operation memory usage monitoring without explicit instrumentation. Three levels of memory tracking are available:

    1. Object memory (via pympler if available): Detailed breakdown of memory used by Python objects in your operation.

    2. Process memory (via psutil if available): System-level memory usage (RSS - resident set size).

    3. Tracemalloc snapshots: Python’s built-in memory tracking showing current and peak allocations.

  • Logging Integration: A logger is created automatically for each operation class with the name format: module.ClassName. Subclasses can log messages and memory usage without additional setup.

  • Parallel Execution Support: The _get_matched_operation_args() method enables serialization of operation state for parallel execution by extracting operation attributes that match the _operate() method’s parameters.

Inheritance hierarchy:

BaseOperation (this class) ├── ImageOperation │ ├── ImageEnhancer (preprocessing filters, noise reduction) │ ├── ImageCorrector (rotation, alignment, quality fixes) │ └── ObjectDetector (colony detection algorithms) │ ├── MeasureFeatures (feature extraction from detected objects) │ └── GridOperation (grid detection and refinement)

How to subclass BaseOperation:

When extending BaseOperation, you typically implement one of its subclasses (ImageOperation, MeasureFeatures, etc.) which provides the specific interface for your operation type. All the memory tracking and logging happens automatically in the parent class.

Example: Creating a custom operation (without image details):

from phenotypic.abc_ import BaseOperation import logging

class MyCustomOperation(BaseOperation):
def __init__(self, param1, param2=5):

# Always call parent __init__ first super().__init__()

# Store your parameters as attributes self.param1 = param1 self.param2 = param2

def _operate(self, data):

# Your algorithm here # Logger available as self._logger self._logger.info(f”Processing with param1={self.param1}”)

# Log memory usage after expensive operations self._log_memory_usage(“after processing”)

return result

_logger#

Logger instance created automatically with the format module.ClassName. Use _logger.info(), _logger.debug() to log messages during operation execution.

Type:

logging.Logger

_tracemalloc_started#

Internal flag indicating whether tracemalloc was started. Set to True automatically if logger is enabled for INFO level or higher.

Type:

bool

Notes

  • Memory tracking is only enabled if the logger is configured to handle INFO level messages or higher. If you want to disable memory tracking, set the logger level to WARNING or higher.

  • Tracemalloc is automatically stopped when the operation object is deleted (in __del__), even if an exception occurs.

  • The _get_matched_operation_args() method is used internally by the pipeline system for parallel execution. It extracts operation attributes that match the _operate() method signature, enabling operations to be serialized and executed in worker processes.

  • On Windows, pympler may not be available, so object memory tracking will fall back gracefully. psutil is available on all platforms.

Examples

Enabling memory tracking for an operation
import logging
from phenotypic.detect import OtsuDetector

# Set up logging to see memory usage
logging.basicConfig(level=logging.INFO)

# Create detector instance
detector = OtsuDetector()

# Apply operation - memory usage is logged automatically
result = detector.apply(image)

# Console output shows:
# INFO: Memory usage after <step>: XX.XX MB (objects), YY.YY MB (process)
Accessing memory information programmatically
import logging
from phenotypic.enhance import GaussianBlur

# Create custom logger to capture memory messages
logger = logging.getLogger('phenotypic.enhance.GaussianBlur')
logger.setLevel(logging.INFO)

handler = logging.StreamHandler()
handler.setLevel(logging.INFO)
logger.addHandler(handler)

# Use operation
blur = GaussianBlur(sigma=2)
enhanced = blur.apply(image)

# Memory tracking happens automatically during operation
Custom operation with parameter matching for parallel execution
from phenotypic.abc_ import ImageOperation
from phenotypic import Image

class CustomThreshold(ImageOperation):
    def __init__(self, threshold_value: int):
        super().__init__()
        self.threshold_value = threshold_value

    @staticmethod
    def _operate(image: Image, threshold_value: int = 128) -> Image:
        # Apply threshold algorithm
        image.enh_gray[:] = image.enh_gray[:] > threshold_value
        return image

# When operation is applied via pipeline:
operation = CustomThreshold(threshold_value=100)

# _get_matched_operation_args() automatically extracts:
# {'threshold_value': 100}
# This enables parallel execution in pipelines

Methods

__init__

__del__()[source]#

Automatically stop tracemalloc when the object is deleted.