Skip to content

registry

Feature registry for tracking and managing features.

FeatureRegistry

Global registry for feature definitions and generators.

Provides registration and lookup of: - Feature transformation functions - Feature generator classes - Custom feature definitions

Source code in featcopilot/core/registry.py 
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
class FeatureRegistry:
    """
    Global registry for feature definitions and generators.

    Provides registration and lookup of:
    - Feature transformation functions
    - Feature generator classes
    - Custom feature definitions
    """

    _instance: Optional["FeatureRegistry"] = None
    _transformations: dict[str, Callable] = {}
    _generators: dict[str, type] = {}

    def __new__(cls) -> "FeatureRegistry":
        """Singleton pattern for global registry."""
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._init_default_transformations()
        return cls._instance

    def _init_default_transformations(self) -> None:
        """Initialize default transformation functions."""
        import numpy as np

        self._transformations = {
            "log": lambda x: np.log1p(np.abs(x)),
            "log10": lambda x: np.log10(np.abs(x) + 1),
            "sqrt": lambda x: np.sqrt(np.abs(x)),
            "square": lambda x: x**2,
            "cube": lambda x: x**3,
            "reciprocal": lambda x: 1 / (x + 1e-8),
            "abs": lambda x: np.abs(x),
            "sign": lambda x: np.sign(x),
            "exp": lambda x: np.exp(np.clip(x, -50, 50)),
            "sin": lambda x: np.sin(x),
            "cos": lambda x: np.cos(x),
            "tanh": lambda x: np.tanh(x),
        }

    def register_transformation(self, name: str, func: Callable) -> None:
        """
        Register a transformation function.

        Parameters
        ----------
        name : str
            Name of transformation
        func : callable
            Function that takes array and returns transformed array
        """
        self._transformations[name] = func

    def get_transformation(self, name: str) -> Optional[Callable]:
        """Get a registered transformation by name."""
        return self._transformations.get(name)

    def list_transformations(self) -> list[str]:
        """List all registered transformation names."""
        return list(self._transformations.keys())

    def register_generator(self, name: str, generator_class: type) -> None:
        """
        Register a feature generator class.

        Parameters
        ----------
        name : str
            Name of generator
        generator_class : type
            Class that generates features
        """
        self._generators[name] = generator_class

    def get_generator(self, name: str) -> Optional[type]:
        """Get a registered generator by name."""
        return self._generators.get(name)

    def list_generators(self) -> list[str]:
        """List all registered generator names."""
        return list(self._generators.keys())

    def create_feature(self, name: str, transformation: str, source_columns: list[str], **kwargs) -> Feature:
        """
        Create a feature using a registered transformation.

        Parameters
        ----------
        name : str
            Feature name
        transformation : str
            Name of registered transformation
        source_columns : list
            Columns used in transformation
        **kwargs : dict
            Additional feature attributes

        Returns
        -------
        Feature
            Created feature object
        """
        func = self.get_transformation(transformation)
        if func is None:
            raise ValueError(f"Unknown transformation: {transformation}")

        # Generate code string for the transformation
        code = f"result = {transformation}(df['{source_columns[0]}'])"

        return Feature(
            name=name,
            source_columns=source_columns,
            transformation=transformation,
            code=code,
            origin=FeatureOrigin.POLYNOMIAL,
            **kwargs,
        )

__new__()

Singleton pattern for global registry.

Source code in featcopilot/core/registry.py 
22
23
24
25
26
27
def __new__(cls) -> "FeatureRegistry":
    """Singleton pattern for global registry."""
    if cls._instance is None:
        cls._instance = super().__new__(cls)
        cls._instance._init_default_transformations()
    return cls._instance

create_feature(name, transformation, source_columns, **kwargs)

Create a feature using a registered transformation.

Parameters:

Name Type Description Default
name str

Feature name

 required
transformation str

Name of registered transformation

 required
source_columns list

Columns used in transformation

 required
**kwargs dict

Additional feature attributes

 {}

Returns:

Type Description
Feature

Created feature object
Source code in featcopilot/core/registry.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
def create_feature(self, name: str, transformation: str, source_columns: list[str], **kwargs) -> Feature:
    """
    Create a feature using a registered transformation.

    Parameters
    ----------
    name : str
        Feature name
    transformation : str
        Name of registered transformation
    source_columns : list
        Columns used in transformation
    **kwargs : dict
        Additional feature attributes

    Returns
    -------
    Feature
        Created feature object
    """
    func = self.get_transformation(transformation)
    if func is None:
        raise ValueError(f"Unknown transformation: {transformation}")

    # Generate code string for the transformation
    code = f"result = {transformation}(df['{source_columns[0]}'])"

    return Feature(
        name=name,
        source_columns=source_columns,
        transformation=transformation,
        code=code,
        origin=FeatureOrigin.POLYNOMIAL,
        **kwargs,
    )

get_generator(name)

Get a registered generator by name.

Source code in featcopilot/core/registry.py 
82
83
84
def get_generator(self, name: str) -> Optional[type]:
    """Get a registered generator by name."""
    return self._generators.get(name)

get_transformation(name)

Get a registered transformation by name.

Source code in featcopilot/core/registry.py 
61
62
63
def get_transformation(self, name: str) -> Optional[Callable]:
    """Get a registered transformation by name."""
    return self._transformations.get(name)

list_generators()

List all registered generator names.

Source code in featcopilot/core/registry.py 
86
87
88
def list_generators(self) -> list[str]:
    """List all registered generator names."""
    return list(self._generators.keys())

list_transformations()

List all registered transformation names.

Source code in featcopilot/core/registry.py 
65
66
67
def list_transformations(self) -> list[str]:
    """List all registered transformation names."""
    return list(self._transformations.keys())

register_generator(name, generator_class)

Register a feature generator class.

Parameters:

Name Type Description Default
name str

Name of generator

 required
generator_class type

Class that generates features

 required
Source code in featcopilot/core/registry.py 
69
70
71
72
73
74
75
76
77
78
79
80
def register_generator(self, name: str, generator_class: type) -> None:
    """
    Register a feature generator class.

    Parameters
    ----------
    name : str
        Name of generator
    generator_class : type
        Class that generates features
    """
    self._generators[name] = generator_class

register_transformation(name, func)

Register a transformation function.

Parameters:

Name Type Description Default
name str

Name of transformation

 required
func callable

Function that takes array and returns transformed array

 required
Source code in featcopilot/core/registry.py 
48
49
50
51
52
53
54
55
56
57
58
59
def register_transformation(self, name: str, func: Callable) -> None:
    """
    Register a transformation function.

    Parameters
    ----------
    name : str
        Name of transformation
    func : callable
        Function that takes array and returns transformed array
    """
    self._transformations[name] = func