experimentation-toolkit 0.1.0__py3-none-any.whl

experimentation_toolkit/models/core.py

@@ -0,0 +1,51 @@
+"""Experiment metadata models."""
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from experimentation_toolkit.models.enums import MetricType
+
+
+class ToolkitModel(BaseModel):
+    """Strict, immutable base model with standards-compliant JSON output."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True, allow_inf_nan=False)
+
+
+class Variant(ToolkitModel):
+    """A named experiment arm."""
+
+    name: str = Field(min_length=1)
+
+
+class Metric(ToolkitModel):
+    """Metadata for one experiment outcome."""
+
+    name: str = Field(min_length=1)
+    metric_type: MetricType
+    primary: bool = False
+    description: str | None = None
+
+
+class Experiment(ToolkitModel):
+    """Metadata for a two-arm controlled experiment."""
+
+    name: str = "A/B experiment"
+    control: Variant | str
+    treatment: Variant | str
+    metrics: tuple[Metric, ...] = ()
+
+    @model_validator(mode="after")
+    def validate_distinct_variants(self) -> "Experiment":
+        """Require distinct non-empty arm names and unique metric names."""
+        control_name = self.control.name if isinstance(self.control, Variant) else self.control
+        treatment_name = (
+            self.treatment.name if isinstance(self.treatment, Variant) else self.treatment
+        )
+        if not control_name.strip() or not treatment_name.strip():
+            raise ValueError("variant names must be non-empty")
+        if control_name == treatment_name:
+            raise ValueError("control and treatment must have different names")
+        metric_names = [metric.name for metric in self.metrics]
+        if len(metric_names) != len(set(metric_names)):
+            raise ValueError("metric names must be unique within an experiment")
+        return self

experimentation_toolkit/models/enums.py

@@ -0,0 +1,41 @@
+"""Enumerations shared by the public API."""
+
+from enum import StrEnum
+
+
+class AlternativeHypothesis(StrEnum):
+    """Direction of the treatment-minus-control hypothesis test."""
+
+    TWO_SIDED = "two-sided"
+    GREATER = "greater"
+    LESS = "less"
+
+
+class MetricType(StrEnum):
+    """Supported metric families."""
+
+    PROPORTION = "proportion"
+    CONTINUOUS = "continuous"
+
+
+class DiagnosticStatus(StrEnum):
+    """Status of a factual diagnostic check."""
+
+    PASS = "PASS"
+    WARN = "WARN"
+    FAIL = "FAIL"
+
+
+class CorrectionMethod(StrEnum):
+    """Supported multiple-testing procedures."""
+
+    BONFERRONI = "bonferroni"
+    HOLM = "holm"
+    BENJAMINI_HOCHBERG = "benjamini-hochberg"
+
+
+class MDEType(StrEnum):
+    """Scale on which a minimum detectable effect is supplied."""
+
+    ABSOLUTE = "absolute"
+    RELATIVE = "relative"

experimentation_toolkit/models/results.py

@@ -0,0 +1,211 @@
+"""Serializable analysis, diagnostic, power, and report models."""
+
+from math import isclose
+from typing import Any
+
+from pydantic import Field, field_validator, model_validator
+
+from experimentation_toolkit.models.core import Experiment, ToolkitModel
+from experimentation_toolkit.models.enums import (
+    AlternativeHypothesis,
+    CorrectionMethod,
+    DiagnosticStatus,
+    MDEType,
+    MetricType,
+)
+
+
+class ConfidenceInterval(ToolkitModel):
+    """An interval whose ``None`` endpoint represents an unbounded side."""
+
+    lower: float | None
+    upper: float | None
+    confidence_level: float = Field(gt=0.0, lt=1.0)
+
+    @field_validator("upper")
+    @classmethod
+    def validate_order(cls, upper: float | None, info: Any) -> float | None:
+        lower = info.data.get("lower")
+        if lower is not None and upper is not None and lower > upper:
+            raise ValueError("confidence interval lower bound must not exceed upper bound")
+        return upper
+
+    @model_validator(mode="after")
+    def validate_bounded_side(self) -> "ConfidenceInterval":
+        if self.lower is None and self.upper is None:
+            raise ValueError("at least one confidence interval endpoint must be bounded")
+        return self
+
+
+class DiagnosticResult(ToolkitModel):
+    """A factual diagnostic emitted by an analysis."""
+
+    code: str
+    status: DiagnosticStatus
+    message: str
+    details: dict[str, int | float | str | bool | None] = Field(default_factory=dict)
+
+
+class AnalysisResult(ToolkitModel):
+    """Common result schema for treatment-minus-control analyses."""
+
+    metric_name: str | None = None
+    metric_type: MetricType
+    control_estimate: float
+    treatment_estimate: float
+    absolute_effect: float
+    relative_effect: float | None
+    relative_effect_definition: str | None
+    confidence_interval: ConfidenceInterval
+    test_statistic: float | None
+    p_value: float | None = Field(default=None, ge=0.0, le=1.0)
+    confidence_level: float = Field(gt=0.0, lt=1.0)
+    alternative: AlternativeHypothesis
+    control_sample_size: int = Field(gt=0)
+    treatment_sample_size: int = Field(gt=0)
+    control_standard_deviation: float | None = Field(default=None, ge=0.0)
+    treatment_standard_deviation: float | None = Field(default=None, ge=0.0)
+    degrees_of_freedom: float | None = Field(default=None, gt=0.0)
+    method: str
+    null_hypothesis: str
+    alternative_hypothesis: str
+    diagnostics: tuple[DiagnosticResult, ...] = ()
+
+    @model_validator(mode="after")
+    def validate_result_coherence(self) -> "AnalysisResult":
+        if self.confidence_interval.confidence_level != self.confidence_level:
+            raise ValueError("analysis and interval confidence levels must match")
+        expected_effect = self.treatment_estimate - self.control_estimate
+        if not isclose(self.absolute_effect, expected_effect, rel_tol=1e-12, abs_tol=0.0):
+            raise ValueError("absolute effect must equal treatment estimate minus control estimate")
+        if (self.relative_effect is None) != (self.relative_effect_definition is None):
+            raise ValueError(
+                "relative effect and its definition must either both be set or both be null"
+            )
+        if self.alternative is AlternativeHypothesis.TWO_SIDED and (
+            self.confidence_interval.lower is None or self.confidence_interval.upper is None
+        ):
+            raise ValueError("a two-sided analysis requires two bounded interval endpoints")
+        if self.alternative is AlternativeHypothesis.GREATER and (
+            self.confidence_interval.lower is None or self.confidence_interval.upper is not None
+        ):
+            raise ValueError("a greater alternative requires a lower-bounded interval")
+        if self.alternative is AlternativeHypothesis.LESS and (
+            self.confidence_interval.lower is not None or self.confidence_interval.upper is None
+        ):
+            raise ValueError("a less alternative requires an upper-bounded interval")
+        return self
+
+
+class SRMResult(ToolkitModel):
+    """Chi-square goodness-of-fit sample-ratio-mismatch result."""
+
+    observed_counts: dict[str, int]
+    expected_counts: dict[str, float]
+    chi_square_statistic: float = Field(ge=0.0)
+    p_value: float = Field(ge=0.0, le=1.0)
+    significance_level: float = Field(gt=0.0, lt=1.0)
+    degrees_of_freedom: int = Field(ge=1)
+    status: DiagnosticStatus
+    method: str = "Pearson chi-square goodness-of-fit test"
+    message: str
+    diagnostics: tuple[DiagnosticResult, ...] = ()
+
+    @model_validator(mode="after")
+    def validate_srm_structure(self) -> "SRMResult":
+        if set(self.observed_counts) != set(self.expected_counts):
+            raise ValueError("observed and expected SRM counts must have identical keys")
+        if any(value < 0 for value in self.observed_counts.values()):
+            raise ValueError("observed SRM counts must be non-negative")
+        if any(value <= 0.0 for value in self.expected_counts.values()):
+            raise ValueError("expected SRM counts must be positive")
+        if self.degrees_of_freedom != len(self.observed_counts) - 1:
+            raise ValueError("SRM degrees of freedom must equal the number of groups minus one")
+        if self.status not in (DiagnosticStatus.PASS, DiagnosticStatus.FAIL):
+            raise ValueError("SRM status must be PASS or FAIL")
+        return self
+
+
+class MultipleTestingResult(ToolkitModel):
+    """Adjusted p-values in the same order as the input hypotheses."""
+
+    original_p_values: tuple[float, ...]
+    adjusted_p_values: tuple[float, ...]
+    rejected: tuple[bool, ...]
+    alpha: float = Field(gt=0.0, lt=1.0)
+    method: CorrectionMethod
+    hypothesis_labels: tuple[str, ...] | None = None
+    error_rate_control: str
+
+    @model_validator(mode="after")
+    def validate_parallel_results(self) -> "MultipleTestingResult":
+        size = len(self.original_p_values)
+        if size == 0:
+            raise ValueError("multiple-testing results must contain at least one hypothesis")
+        if len(self.adjusted_p_values) != size or len(self.rejected) != size:
+            raise ValueError("multiple-testing result arrays must have equal lengths")
+        if self.hypothesis_labels is not None and len(self.hypothesis_labels) != size:
+            raise ValueError("hypothesis labels must match the number of p-values")
+        if any(value < 0.0 or value > 1.0 for value in self.original_p_values):
+            raise ValueError("original p-values must be in [0, 1]")
+        if any(value < 0.0 or value > 1.0 for value in self.adjusted_p_values):
+            raise ValueError("adjusted p-values must be in [0, 1]")
+        if self.rejected != tuple(value <= self.alpha for value in self.adjusted_p_values):
+            raise ValueError("rejection decisions must correspond to adjusted p-values and alpha")
+        expected_error_rate = (
+            "false discovery rate"
+            if self.method is CorrectionMethod.BENJAMINI_HOCHBERG
+            else "family-wise error rate"
+        )
+        if self.error_rate_control != expected_error_rate:
+            raise ValueError("error-rate description must correspond to the correction method")
+        return self
+
+
+class ProportionSampleSizeResult(ToolkitModel):
+    """Normal-approximation sample-size planning result."""
+
+    baseline_rate: float = Field(gt=0.0, lt=1.0)
+    treatment_rate: float = Field(gt=0.0, lt=1.0)
+    minimum_detectable_effect: float = Field(gt=0.0)
+    mde_type: MDEType
+    alpha: float = Field(gt=0.0, lt=1.0)
+    target_power: float = Field(gt=0.0, lt=1.0)
+    achieved_power: float = Field(ge=0.0, le=1.0)
+    allocation_ratio: float = Field(gt=0.0)
+    alternative: AlternativeHypothesis
+    control_sample_size: int = Field(gt=0)
+    treatment_sample_size: int = Field(gt=0)
+    total_sample_size: int = Field(gt=0)
+    method: str
+
+    @model_validator(mode="after")
+    def validate_total_sample_size(self) -> "ProportionSampleSizeResult":
+        if self.total_sample_size != self.control_sample_size + self.treatment_sample_size:
+            raise ValueError("total sample size must equal control plus treatment sample sizes")
+        if self.achieved_power < self.target_power:
+            raise ValueError("achieved power must meet or exceed target power")
+        return self
+
+
+class AchievedPowerResult(ToolkitModel):
+    """Approximate achieved power for fixed group sizes and rates."""
+
+    baseline_rate: float = Field(gt=0.0, lt=1.0)
+    treatment_rate: float = Field(gt=0.0, lt=1.0)
+    control_sample_size: int = Field(gt=0)
+    treatment_sample_size: int = Field(gt=0)
+    alpha: float = Field(gt=0.0, lt=1.0)
+    power: float = Field(ge=0.0, le=1.0)
+    alternative: AlternativeHypothesis
+    method: str
+
+
+class ExperimentReport(ToolkitModel):
+    """Serializable collection of experiment analyses and diagnostics."""
+
+    experiment: Experiment
+    analyses: tuple[AnalysisResult, ...]
+    diagnostics: tuple[SRMResult | DiagnosticResult, ...] = ()
+    multiple_testing: MultipleTestingResult | None = None
+    metadata: dict[str, int | float | str | bool | None] = Field(default_factory=dict)

experimentation_toolkit/multiple_testing/__init__.py

@@ -0,0 +1,5 @@
+"""Multiple-testing procedures."""
+
+from experimentation_toolkit.multiple_testing.corrections import adjust_p_values
+
+__all__ = ["adjust_p_values"]

experimentation_toolkit/multiple_testing/corrections.py

@@ -0,0 +1,65 @@
+"""Multiple-testing corrections with stable input-order mapping."""
+
+from collections.abc import Iterable, Sequence
+
+import numpy as np
+
+from experimentation_toolkit.models.enums import CorrectionMethod
+from experimentation_toolkit.models.results import MultipleTestingResult
+from experimentation_toolkit.validation.inputs import validate_p_values, validate_probability
+
+
+def adjust_p_values(
+    p_values: Iterable[float],
+    *,
+    method: CorrectionMethod | str,
+    alpha: float = 0.05,
+    hypothesis_labels: Sequence[str] | None = None,
+) -> MultipleTestingResult:
+    """Adjust p-values with Bonferroni, Holm, or Benjamini-Hochberg.
+
+    Bonferroni and Holm control family-wise error rate. Benjamini-Hochberg
+    controls false discovery rate under independence or positive dependence;
+    it does not generally control family-wise error rate.
+    """
+    p_values = validate_p_values(p_values)
+    alpha = validate_probability(alpha, "alpha", open_interval=True)
+    try:
+        method = CorrectionMethod(method)
+    except ValueError as error:
+        allowed = ", ".join(item.value for item in CorrectionMethod)
+        raise ValueError(f"method must be one of: {allowed}") from error
+    labels = tuple(hypothesis_labels) if hypothesis_labels is not None else None
+    if labels is not None and len(labels) != len(p_values):
+        raise ValueError("hypothesis_labels must have the same length as p_values")
+    if labels is not None and any(not label for label in labels):
+        raise ValueError("hypothesis labels must be non-empty")
+
+    values = np.asarray(p_values, dtype=np.float64)
+    count = values.size
+    if method is CorrectionMethod.BONFERRONI:
+        adjusted = np.minimum(values * count, 1.0)
+        error_rate_control = "family-wise error rate"
+    else:
+        order = np.argsort(values, kind="stable")
+        sorted_values = values[order]
+        if method is CorrectionMethod.HOLM:
+            scaled = (count - np.arange(count)) * sorted_values
+            sorted_adjusted = np.minimum(np.maximum.accumulate(scaled), 1.0)
+            error_rate_control = "family-wise error rate"
+        else:
+            scaled = count * sorted_values / np.arange(1, count + 1)
+            sorted_adjusted = np.minimum(np.minimum.accumulate(scaled[::-1])[::-1], 1.0)
+            error_rate_control = "false discovery rate"
+        adjusted = np.empty(count, dtype=np.float64)
+        adjusted[order] = sorted_adjusted
+    rejected = adjusted <= alpha
+    return MultipleTestingResult(
+        original_p_values=p_values,
+        adjusted_p_values=tuple(float(value) for value in adjusted),
+        rejected=tuple(bool(value) for value in rejected),
+        alpha=alpha,
+        method=method,
+        hypothesis_labels=labels,
+        error_rate_control=error_rate_control,
+    )

experimentation_toolkit/power/__init__.py

@@ -0,0 +1,8 @@
+"""Power and sample-size planning."""
+
+from experimentation_toolkit.power.proportion import (
+    proportion_achieved_power,
+    proportion_sample_size,
+)
+
+__all__ = ["proportion_achieved_power", "proportion_sample_size"]

experimentation_toolkit/power/proportion.py

@@ -0,0 +1,238 @@
+"""Normal-approximation power and sample size for independent proportions."""
+
+from math import ceil, sqrt
+
+import numpy as np
+from scipy import stats
+
+from experimentation_toolkit.models.enums import AlternativeHypothesis, MDEType
+from experimentation_toolkit.models.results import AchievedPowerResult, ProportionSampleSizeResult
+from experimentation_toolkit.validation.inputs import (
+    normalize_alternative,
+    validate_positive_integer,
+    validate_probability,
+)
+
+_METHOD = "Normal approximation for a pooled-null two-sample proportion score test"
+_MAX_EXACT_SAMPLE_SIZE = 2**53
+
+
+def _normal_approximation_power(
+    baseline_rate: float,
+    treatment_rate: float,
+    control_size: int,
+    treatment_size: int,
+    alpha: float,
+    alternative: AlternativeHypothesis,
+) -> float:
+    control_weight = control_size / (control_size + treatment_size)
+    pooled_rate = control_weight * baseline_rate + (1.0 - control_weight) * treatment_rate
+    inverse_root_control = 1.0 / sqrt(control_size)
+    inverse_root_treatment = 1.0 / sqrt(treatment_size)
+    null_standard_error = sqrt(pooled_rate * (1.0 - pooled_rate)) * np.hypot(
+        inverse_root_control, inverse_root_treatment
+    )
+    alternative_standard_error = np.hypot(
+        sqrt(baseline_rate * (1.0 - baseline_rate)) * inverse_root_control,
+        sqrt(treatment_rate * (1.0 - treatment_rate)) * inverse_root_treatment,
+    )
+    if null_standard_error == 0.0 or alternative_standard_error == 0.0:
+        raise ValueError("power approximation is undefined at degenerate boundary rates")
+    mean = (treatment_rate - baseline_rate) / null_standard_error
+    scale = alternative_standard_error / null_standard_error
+    if alternative is AlternativeHypothesis.TWO_SIDED:
+        critical = float(stats.norm.ppf(1.0 - alpha / 2.0))
+        power = stats.norm.sf((critical - mean) / scale) + stats.norm.cdf(
+            (-critical - mean) / scale
+        )
+    elif alternative is AlternativeHypothesis.GREATER:
+        critical = float(stats.norm.ppf(1.0 - alpha))
+        power = stats.norm.sf((critical - mean) / scale)
+    else:
+        critical = float(stats.norm.ppf(alpha))
+        power = stats.norm.cdf((critical - mean) / scale)
+    return float(np.clip(power, 0.0, 1.0))
+
+
+def proportion_achieved_power(
+    *,
+    baseline_rate: float,
+    treatment_rate: float,
+    control_sample_size: int,
+    treatment_sample_size: int,
+    alpha: float = 0.05,
+    alternative: AlternativeHypothesis | str = AlternativeHypothesis.TWO_SIDED,
+) -> AchievedPowerResult:
+    """Estimate achieved power for a fixed two-proportion design."""
+    baseline_rate = validate_probability(baseline_rate, "baseline_rate", open_interval=True)
+    treatment_rate = validate_probability(treatment_rate, "treatment_rate", open_interval=True)
+    control_sample_size = validate_positive_integer(control_sample_size, "control_sample_size")
+    treatment_sample_size = validate_positive_integer(
+        treatment_sample_size, "treatment_sample_size"
+    )
+    alpha = validate_probability(alpha, "alpha", open_interval=True)
+    alternative = normalize_alternative(alternative)
+    power = _normal_approximation_power(
+        baseline_rate,
+        treatment_rate,
+        control_sample_size,
+        treatment_sample_size,
+        alpha,
+        alternative,
+    )
+    return AchievedPowerResult(
+        baseline_rate=baseline_rate,
+        treatment_rate=treatment_rate,
+        control_sample_size=control_sample_size,
+        treatment_sample_size=treatment_sample_size,
+        alpha=alpha,
+        power=power,
+        alternative=alternative,
+        method=_METHOD,
+    )
+
+
+def proportion_sample_size(
+    *,
+    baseline_rate: float,
+    minimum_detectable_effect: float,
+    mde_type: MDEType | str,
+    alpha: float = 0.05,
+    power: float = 0.8,
+    allocation_ratio: float = 1.0,
+    alternative: AlternativeHypothesis | str = AlternativeHypothesis.TWO_SIDED,
+) -> ProportionSampleSizeResult:
+    """Plan group sizes for a two-proportion experiment.
+
+    ``allocation_ratio`` is treatment/control. The MDE is a positive magnitude:
+    it is added to the baseline for two-sided/greater alternatives and subtracted
+    for a less alternative. A relative MDE is a fraction of the baseline (``0.1``
+    means a 10% relative change), never percentage points.
+    """
+    baseline_rate = validate_probability(baseline_rate, "baseline_rate", open_interval=True)
+    effect = float(minimum_detectable_effect)
+    if not np.isfinite(effect) or effect <= 0.0:
+        raise ValueError("minimum_detectable_effect must be finite and greater than zero")
+    try:
+        mde_type = MDEType(mde_type)
+    except ValueError as error:
+        raise ValueError("mde_type must be 'absolute' or 'relative'") from error
+    alpha = validate_probability(alpha, "alpha", open_interval=True)
+    power = validate_probability(power, "power", open_interval=True)
+    allocation_ratio = float(allocation_ratio)
+    if not np.isfinite(allocation_ratio) or allocation_ratio <= 0.0:
+        raise ValueError("allocation_ratio must be finite and greater than zero")
+    alternative = normalize_alternative(alternative)
+
+    absolute_effect = effect if mde_type is MDEType.ABSOLUTE else baseline_rate * effect
+    sign = -1.0 if alternative is AlternativeHypothesis.LESS else 1.0
+    treatment_rate = baseline_rate + sign * absolute_effect
+    if treatment_rate == baseline_rate:
+        raise ValueError("the MDE is too small to resolve at float64 precision")
+    if not 0.0 < treatment_rate < 1.0:
+        raise ValueError("the MDE implies a treatment rate outside the open interval (0, 1)")
+
+    pooled_rate = (baseline_rate + allocation_ratio * treatment_rate) / (1.0 + allocation_ratio)
+    null_variance_factor = pooled_rate * (1.0 - pooled_rate) * (1.0 + 1.0 / allocation_ratio)
+    alternative_variance_factor = baseline_rate * (1.0 - baseline_rate) + (
+        treatment_rate * (1.0 - treatment_rate) / allocation_ratio
+    )
+    alpha_quantile = float(
+        stats.norm.ppf(
+            1.0 - alpha / 2.0 if alternative is AlternativeHypothesis.TWO_SIDED else 1.0 - alpha
+        )
+    )
+    power_quantile = float(stats.norm.ppf(power))
+    standardized_distance = (
+        alpha_quantile * sqrt(null_variance_factor)
+        + power_quantile * sqrt(alternative_variance_factor)
+    ) / absolute_effect
+    if not np.isfinite(standardized_distance) or abs(standardized_distance) > sqrt(
+        _MAX_EXACT_SAMPLE_SIZE
+    ):
+        raise ValueError(
+            "the requested design exceeds the sample-size range supported by float64 precision"
+        )
+    raw_control_size = standardized_distance**2
+    if not np.isfinite(raw_control_size) or raw_control_size > _MAX_EXACT_SAMPLE_SIZE:
+        raise ValueError(
+            "the requested design exceeds the sample-size range supported by float64 precision"
+        )
+
+    def treatment_size_for(control_size: int) -> int:
+        treatment_size = max(2, ceil(allocation_ratio * control_size))
+        if treatment_size > _MAX_EXACT_SAMPLE_SIZE:
+            raise ValueError(
+                "the requested design exceeds the sample-size range supported by float64 precision"
+            )
+        return treatment_size
+
+    upper_control_size = max(2, ceil(raw_control_size))
+    upper_treatment_size = treatment_size_for(upper_control_size)
+    upper_power = _normal_approximation_power(
+        baseline_rate,
+        treatment_rate,
+        upper_control_size,
+        upper_treatment_size,
+        alpha,
+        alternative,
+    )
+    while upper_power < power:
+        upper_control_size *= 2
+        if upper_control_size > _MAX_EXACT_SAMPLE_SIZE:
+            raise ValueError(
+                "the requested design exceeds the sample-size range supported by float64 precision"
+            )
+        upper_treatment_size = treatment_size_for(upper_control_size)
+        upper_power = _normal_approximation_power(
+            baseline_rate,
+            treatment_rate,
+            upper_control_size,
+            upper_treatment_size,
+            alpha,
+            alternative,
+        )
+
+    lower_control_size = 2
+    while lower_control_size < upper_control_size:
+        candidate_control_size = (lower_control_size + upper_control_size) // 2
+        candidate_treatment_size = treatment_size_for(candidate_control_size)
+        candidate_power = _normal_approximation_power(
+            baseline_rate,
+            treatment_rate,
+            candidate_control_size,
+            candidate_treatment_size,
+            alpha,
+            alternative,
+        )
+        if candidate_power >= power:
+            upper_control_size = candidate_control_size
+        else:
+            lower_control_size = candidate_control_size + 1
+
+    control_size = lower_control_size
+    treatment_size = treatment_size_for(control_size)
+    achieved = _normal_approximation_power(
+        baseline_rate,
+        treatment_rate,
+        control_size,
+        treatment_size,
+        alpha,
+        alternative,
+    )
+
+    return ProportionSampleSizeResult(
+        baseline_rate=baseline_rate,
+        treatment_rate=treatment_rate,
+        minimum_detectable_effect=effect,
+        mde_type=mde_type,
+        alpha=alpha,
+        target_power=power,
+        achieved_power=achieved,
+        allocation_ratio=allocation_ratio,
+        alternative=alternative,
+        control_sample_size=control_size,
+        treatment_sample_size=treatment_size,
+        total_sample_size=control_size + treatment_size,
+        method=_METHOD,
+    )

experimentation_toolkit/py.typed

@@ -0,0 +1 @@
+

experimentation_toolkit/validation/__init__.py

@@ -0,0 +1 @@
+"""Input validation utilities."""