Full Code of openeemeter/eemeter for AI

gitextract_3_jyodj_/

├── .coveragerc
├── .dockerignore
├── .gitattributes
├── .gitignore
├── CHANGELOG.md
├── CHARTER.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Dockerfile
├── LICENSE
├── MAINTAINERS.md
├── MANIFEST.in
├── README.md
├── bump_version.sh
├── data/
│   ├── attribution.txt
│   ├── features.csv
│   ├── hourly_data_2.parquet
│   ├── month_loadshape.csv
│   ├── seasonal_day_of_week_loadshape.csv
│   └── seasonal_hourly_day_of_week_loadshape.csv
├── docker-compose.yml
├── docs/
│   └── gridmeter/
│       ├── gridmeter.__version__.rst
│       ├── gridmeter.bin_selection.rst
│       ├── gridmeter.bins.rst
│       ├── gridmeter.diagnostics.rst
│       ├── gridmeter.distance_calc_selection.rst
│       ├── gridmeter.equivalence.rst
│       ├── gridmeter.model.rst
│       ├── gridmeter.param_selection.rst
│       ├── gridmeter.rst
│       └── gridmeter.synthetic_data.rst
├── opendsm/
│   ├── __init__.py
│   ├── common/
│   │   ├── __init__.py
│   │   ├── base_settings.py
│   │   ├── clustering/
│   │   │   ├── __init__.py
│   │   │   ├── algorithms/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── birch.py
│   │   │   │   ├── bisect_k_means.py
│   │   │   │   ├── dbscan.py
│   │   │   │   ├── hdbscan.py
│   │   │   │   ├── sklearn_bisect_k_means.py
│   │   │   │   └── spectral.py
│   │   │   ├── cluster.py
│   │   │   ├── metrics/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── cluster_metrics.py
│   │   │   │   └── density_based_clustering_validation.py
│   │   │   ├── scoring.py
│   │   │   ├── settings.py
│   │   │   ├── transform.py
│   │   │   └── voting.py
│   │   ├── const.py
│   │   ├── hourly_interpolation.py
│   │   ├── metrics.py
│   │   ├── pydantic_utils.py
│   │   ├── stats/
│   │   │   ├── __init__.py
│   │   │   ├── adaptive_loss.py
│   │   │   ├── adaptive_loss_Z.py
│   │   │   ├── basic.py
│   │   │   ├── distribution_transform/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── bisymlog.py
│   │   │   │   ├── mu_sigma.py
│   │   │   │   ├── raymaekers_robust_yeo_johnson.py
│   │   │   │   ├── scipy_yeo_johnson.py
│   │   │   │   └── standardize.py
│   │   │   ├── outliers.py
│   │   │   └── outliers_transformed.py
│   │   ├── test_data.py
│   │   └── utils.py
│   ├── comparison_groups/
│   │   ├── __init__.py
│   │   ├── archived_gridmeter_changelog.md
│   │   ├── cg_clustering/
│   │   │   ├── __init__.py
│   │   │   ├── bounds.py
│   │   │   ├── create_comparison_groups.py
│   │   │   ├── settings.py
│   │   │   └── treatment_fit.py
│   │   ├── common/
│   │   │   ├── __init__.py
│   │   │   ├── base_comparison_group.py
│   │   │   ├── const.py
│   │   │   ├── data.py
│   │   │   ├── data_settings.py
│   │   │   └── tutorial_data.py
│   │   ├── individual_meter_matching/
│   │   │   ├── __init__.py
│   │   │   ├── create_comparison_groups.py
│   │   │   ├── distance_calc_selection.py
│   │   │   ├── highs_settings.py
│   │   │   └── settings.py
│   │   ├── random_sampling/
│   │   │   ├── __init__.py
│   │   │   ├── create_comparison_groups.py
│   │   │   └── settings.py
│   │   ├── savings/
│   │   │   ├── __init__.py
│   │   │   ├── archived_dev.py
│   │   │   ├── cg_correction_testing.py
│   │   │   ├── model_correction.py
│   │   │   ├── scratch.ipynb
│   │   │   └── settings.py
│   │   └── stratified_sampling/
│   │       ├── __init__.py
│   │       ├── bin_selection.py
│   │       ├── bins.py
│   │       ├── const.py
│   │       ├── create_comparison_groups.py
│   │       ├── diagnostics.py
│   │       ├── equivalence.py
│   │       ├── model.py
│   │       ├── param_selection.py
│   │       └── settings.py
│   ├── drmeter/
│   │   ├── __init__.py
│   │   └── models/
│   │       ├── __init__.py
│   │       └── caltrack/
│   │           ├── __init__.py
│   │           ├── data.py
│   │           └── model.py
│   └── eemeter/
│       ├── __init__.py
│       ├── common/
│       │   ├── __init__.py
│       │   ├── data_processor_utilities.py
│       │   ├── data_settings.py
│       │   ├── exceptions.py
│       │   ├── features.py
│       │   ├── sufficiency_criteria.py
│       │   ├── transform.py
│       │   └── warnings.py
│       ├── models/
│       │   ├── __init__.py
│       │   ├── billing/
│       │   │   ├── __init__.py
│       │   │   ├── data.py
│       │   │   ├── model.py
│       │   │   ├── plot.py
│       │   │   ├── settings.py
│       │   │   └── weighted_model.py
│       │   ├── daily/
│       │   │   ├── __init__.py
│       │   │   ├── base_models/
│       │   │   │   ├── __init__.py
│       │   │   │   ├── c_hdd_tidd.py
│       │   │   │   ├── full_model.py
│       │   │   │   ├── hdd_tidd_cdd.py
│       │   │   │   └── tidd.py
│       │   │   ├── data.py
│       │   │   ├── fit_base_models.py
│       │   │   ├── model.py
│       │   │   ├── objective_function.py
│       │   │   ├── optimize.py
│       │   │   ├── optimize_results.py
│       │   │   ├── parameters.py
│       │   │   ├── plot.py
│       │   │   └── utilities/
│       │   │       ├── __init__.py
│       │   │       ├── base_model.py
│       │   │       ├── const.py
│       │   │       ├── ellipsoid_test.py
│       │   │       ├── opt_settings.py
│       │   │       ├── selection_criteria.py
│       │   │       └── settings.py
│       │   ├── hourly/
│       │   │   ├── __init__.py
│       │   │   ├── data.py
│       │   │   ├── model.py
│       │   │   └── settings.py
│       │   └── hourly_caltrack/
│       │       ├── __init__.py
│       │       ├── data.py
│       │       ├── derivatives.py
│       │       ├── design_matrices.py
│       │       ├── metrics.py
│       │       ├── model.py
│       │       ├── segmentation.py
│       │       ├── usage_per_day.py
│       │       └── wrapper.py
│       ├── samples/
│       │   ├── __init__.py
│       │   ├── load.py
│       │   └── metadata.json
│       └── utilities/
│           ├── __init__.py
│           └── io.py
├── pyproject.toml
├── pytest.ini
├── setup.cfg
├── tests/
│   ├── common/
│   │   ├── clustering/
│   │   │   ├── test_bisect_k_means.py
│   │   │   ├── test_cluster.py
│   │   │   ├── test_cluster_transform.py
│   │   │   ├── test_spectral.py
│   │   │   └── test_voting.py
│   │   ├── metrics.py
│   │   ├── test_basic_stats.py
│   │   └── test_utils.py
│   ├── comparison_groups/
│   │   ├── conftest.py
│   │   ├── imm/
│   │   │   └── test_distance_calc_selection.py
│   │   └── stratified_sampling/
│   │       ├── test_bin.py
│   │       ├── test_bin_selection.py
│   │       ├── test_diagnostics.py
│   │       ├── test_equivalence.py
│   │       └── test_model.py
│   ├── conftest.py
│   ├── eemeter/
│   │   ├── daily_model/
│   │   │   ├── base_models/
│   │   │   │   ├── test_c_hdd_tidd_smooth.py
│   │   │   │   └── test_full_model_finder.py
│   │   │   ├── test_billing_data.py
│   │   │   ├── test_daily_data.py
│   │   │   ├── test_daily_model.py
│   │   │   ├── test_data.csv
│   │   │   ├── test_fit_base_models.py
│   │   │   ├── test_fit_model.py
│   │   │   ├── test_objective_function.py
│   │   │   ├── test_optimize.py
│   │   │   ├── test_optimize_results.py
│   │   │   └── utilities/
│   │   │       ├── test_adaptive_loss.py
│   │   │       ├── test_base_model.py
│   │   │       ├── test_config.py
│   │   │       ├── test_ellipsoid_test.py
│   │   │       └── test_selection_criteria.py
│   │   └── hourly_model/
│   │       ├── conftest.py
│   │       └── test_hourly_model.py
│   ├── legacy_hourly.json
│   ├── snapshots/
│   │   ├── __init__.py
│   │   └── snap_test_features.py
│   ├── test_caltrack_design_matrices.py
│   ├── test_caltrack_hourly.py
│   ├── test_derivatives.py
│   ├── test_exceptions.py
│   ├── test_features.py
│   ├── test_io.py
│   ├── test_json_serialization.py
│   ├── test_samples.py
│   ├── test_segmentation.py
│   ├── test_transform.py
│   ├── test_version.py
│   └── test_warnings.py
└── tox.ini

SYMBOL INDEX (1711 symbols across 146 files)

FILE: opendsm/__init__.py
  function __dir__ (line 77) | def __dir__():

FILE: opendsm/common/base_settings.py
  class BaseSettings (line 22) | class BaseSettings(pydantic.BaseModel):
    method __lowercase_property_keys__ (line 32) | def __lowercase_property_keys__(cls, values: Any) -> Any:
    method lowercase_values (line 42) | def lowercase_values(cls, v):
  class MutableBaseSettings (line 48) | class MutableBaseSettings(BaseSettings):
  function CustomField (line 58) | def CustomField(developer=False, *args, **kwargs):

FILE: opendsm/common/clustering/algorithms/birch.py
  function birch (line 29) | def birch(

FILE: opendsm/common/clustering/algorithms/bisect_k_means.py
  function bisect_k_means (line 28) | def bisect_k_means(

FILE: opendsm/common/clustering/algorithms/dbscan.py
  function dbscan (line 25) | def dbscan(

FILE: opendsm/common/clustering/algorithms/hdbscan.py
  function hdbscan (line 25) | def hdbscan(

FILE: opendsm/common/clustering/algorithms/sklearn_bisect_k_means.py
  class BisectingKMeans (line 49) | class BisectingKMeans(_sklearn_BisectingKMeans):
    method fit (line 65) | def fit(self, X, y=None, sample_weight=None):

FILE: opendsm/common/clustering/algorithms/spectral.py
  function eigenDecomposition (line 36) | def eigenDecomposition(A, topK = 5):
  function eigendecomp_cluster_count (line 72) | def eigendecomp_cluster_count(
  function _affinity_matrix (line 91) | def _affinity_matrix(
  function _single_spectral_clustering (line 113) | def _single_spectral_clustering(
  function _local_affinity_matrix (line 191) | def _local_affinity_matrix(X):
  class RobustSpectralClustering (line 220) | class RobustSpectralClustering:
    method __init__ (line 238) | def __init__(self, k, nn=15, theta=20, m=0.5, laplacian=1, n_iter=50, ...
    method __affinity_matrix (line 271) | def __affinity_matrix(self, X):
    method __local_affinity_matrix (line 278) | def __local_affinity_matrix(self, X):
    method __latent_decomposition (line 305) | def __latent_decomposition(self, X):
    method fit_predict (line 383) | def fit_predict(self, X):
  function spectral (line 406) | def spectral(

FILE: opendsm/common/clustering/cluster.py
  function _cluster_merge (line 38) | def _cluster_merge(
  function cluster_reorder (line 96) | def cluster_reorder(
  function _cluster_features (line 176) | def _cluster_features(
  function cluster_features (line 215) | def cluster_features(

FILE: opendsm/common/clustering/metrics/cluster_metrics.py
  class DistanceMetric (line 39) | class DistanceMetric(str, Enum):
  class ClusterPairDistanceMetrics (line 50) | class ClusterPairDistanceMetrics(ArbitraryPydanticModel):
    method n (line 66) | def n(self) -> int:
    method sum_of_squares (line 70) | def sum_of_squares(self) -> float:
    method mean (line 74) | def mean(self) -> float:
    method median (line 78) | def median(self) -> float:
    method var (line 82) | def var(self) -> float:
    method std (line 86) | def std(self) -> float:
    method mad (line 90) | def mad(self) -> float:
    method lower_quantile (line 94) | def lower_quantile(self) -> float:
    method upper_quantile (line 98) | def upper_quantile(self) -> float:
    method min (line 102) | def min(self) -> float:
    method max (line 106) | def max(self) -> float:
  class SingleClusterMetrics (line 110) | class SingleClusterMetrics(ArbitraryPydanticModel):
    method var_norm (line 159) | def var_norm(self) -> float | None:
    method within_pairwise_distances (line 167) | def within_pairwise_distances(self) -> np.ndarray | None:
    method between_pairwise_distances (line 176) | def between_pairwise_distances(self) -> np.ndarray | None:
    method mean_silhouette_coefficient (line 189) | def mean_silhouette_coefficient(self) -> np.ndarray:
    method median_silhouette_coefficient (line 199) | def median_silhouette_coefficient(self) -> np.ndarray:
  class ClusterMetrics (line 209) | class ClusterMetrics(ArbitraryPydanticModel):
    method _validate_data (line 235) | def _validate_data(self) -> 'ClusterMetrics':
    method n_total (line 259) | def n_total(self) -> int:
    method unique_labels (line 263) | def unique_labels(self) -> np.ndarray:
    method label_count (line 267) | def label_count(self) -> int:
    method _label_indices (line 271) | def _label_indices(self) -> dict[int, np.ndarray]:
    method _n (line 276) | def _n(self) -> np.ndarray:
    method _mean (line 281) | def _mean(self) -> np.ndarray:
    method _median (line 289) | def _median(self) -> np.ndarray:
    method _var (line 297) | def _var(self) -> np.ndarray:
    method _distance (line 305) | def _distance(self) -> np.ndarray:
    method _distance_to_mean (line 309) | def _distance_to_mean(self) -> np.ndarray:
    method _distance_to_median (line 313) | def _distance_to_median(self) -> np.ndarray:
    method _labeled_distance (line 317) | def _labeled_distance(self) -> dict[tuple[int, int], np.ndarray]:
    method _labeled_distance_to_centroid (line 328) | def _labeled_distance_to_centroid(self, distance_matrix: np.ndarray) -...
    method _labeled_distance_to_mean (line 342) | def _labeled_distance_to_mean(self) -> dict[tuple[int, int], np.ndarray]:
    method _labeled_distance_to_median (line 346) | def _labeled_distance_to_median(self) -> dict[tuple[int, int], np.ndar...
    method _labeled_distance_to_nearest_cluster (line 349) | def _labeled_distance_to_nearest_cluster(self, agg: str = "mean") -> d...
    method _labeled_mean_distance_to_nearest_cluster (line 370) | def _labeled_mean_distance_to_nearest_cluster(self) -> dict[int, np.nd...
    method _labeled_median_distance_to_nearest_cluster (line 374) | def _labeled_median_distance_to_nearest_cluster(self) -> dict[int, np....
    method _labeled_distance_intra_cluster (line 377) | def _labeled_distance_intra_cluster(self, agg: str = "mean") -> dict[i...
    method _labeled_mean_distance_intra_cluster (line 395) | def _labeled_mean_distance_intra_cluster(self) -> dict[int, np.ndarray]:
    method _labeled_median_distance_intra_cluster (line 399) | def _labeled_median_distance_intra_cluster(self) -> dict[int, np.ndarr...
    method all (line 403) | def all(self) -> SingleClusterMetrics:
    method cluster (line 430) | def cluster(self) -> dict[int, SingleClusterMetrics]:
    method _WCSM (line 495) | def _WCSM(self) -> dict[int, np.ndarray]:
    method _sum_WCSM (line 513) | def _sum_WCSM(self) -> np.ndarray:
    method _TSM (line 521) | def _TSM(self) -> np.ndarray:
    method _WCSS (line 529) | def _WCSS(self) -> float:
    method _BCSS (line 537) | def _BCSS(self) -> float:
    method _WC_pairwise_distances (line 548) | def _WC_pairwise_distances(self) -> np.ndarray:
    method _BC_pairwise_distances (line 558) | def _BC_pairwise_distances(self) -> np.ndarray:
    method _mean_scatter (line 568) | def _mean_scatter(self) -> float:
    method sum_of_squared_errors_index (line 585) | def sum_of_squared_errors_index(self) -> float:
    method mean_squared_error_index (line 600) | def mean_squared_error_index(self) -> float:
    method ball_hall_index (line 618) | def ball_hall_index(self) -> float:
    method banfeld_raftery_index (line 633) | def banfeld_raftery_index(self) -> float:
    method scott_symons_index (line 653) | def scott_symons_index(self) -> float:
    method trace_w_index (line 679) | def trace_w_index(self) -> float:
    method _silhouette_coefficients (line 697) | def _silhouette_coefficients(self, variant: str = "mean") -> np.ndarray:
    method silhouette_index (line 718) | def silhouette_index(self) -> float:
    method silhouette_median_index (line 728) | def silhouette_median_index(self) -> float:
    method davies_bouldin_index (line 738) | def davies_bouldin_index(self) -> float:
    method calinski_harabasz_index (line 765) | def calinski_harabasz_index(self) -> float:
    method variance_ratio_criterion (line 784) | def variance_ratio_criterion(self) -> float:
    method dunn_index (line 788) | def dunn_index(self) -> float:
    method xie_beni_index (line 835) | def xie_beni_index(self) -> float:
    method duda_hart_index (line 885) | def duda_hart_index(self) -> float:
    method c_index (line 907) | def c_index(self) -> float:
    method mcclain_rao_index (line 942) | def mcclain_rao_index(self) -> float:
    method i_index (line 967) | def i_index(self) -> float:
    method log_ss_ratio_index (line 1005) | def log_ss_ratio_index(self) -> float:
    method gamma_index (line 1034) | def gamma_index(self) -> float:
    method point_biserial_index (line 1069) | def point_biserial_index(self) -> float:
    method _det_ratio (line 1109) | def _det_ratio(self) -> float:
    method ksq_detw_index (line 1126) | def ksq_detw_index(self) -> float:
    method det_ratio_index (line 1162) | def det_ratio_index(self) -> float:
    method log_det_ratio_index (line 1177) | def log_det_ratio_index(self) -> float:
    method trace_wb_index (line 1194) | def trace_wb_index(self) -> float:
    method s_dbw_index (line 1220) | def s_dbw_index(self) -> float:
    method sd_validity_index (line 1295) | def sd_validity_index(self) -> float:
    method density_based_clustering_validation_index (line 1340) | def density_based_clustering_validation_index(self) -> float:

FILE: opendsm/common/clustering/metrics/density_based_clustering_validation.py
  function prim_mst (line 45) | def prim_mst(
  function compute_pair_to_pair_dists (line 103) | def compute_pair_to_pair_dists(
  function get_subarray (line 113) | def get_subarray(
  function get_internal_objects (line 127) | def get_internal_objects(
  function compute_cluster_core_distance (line 160) | def compute_cluster_core_distance(
  function compute_mutual_reach_dists (line 182) | def compute_mutual_reach_dists(
  function fn_density_sparseness (line 196) | def fn_density_sparseness(
  function fn_density_separation (line 216) | def fn_density_separation(
  function _check_duplicated_samples (line 230) | def _check_duplicated_samples(X: npt.NDArray[np.float64], threshold: flo...
  function _convert_singleton_clusters_to_noise (line 242) | def _convert_singleton_clusters_to_noise(
  function dbcv (line 255) | def dbcv(

FILE: opendsm/common/clustering/scoring.py
  function get_max_score_from_system_size (line 29) | def get_max_score_from_system_size() -> float:
  function renumber_clusters (line 42) | def renumber_clusters(clusters: np.ndarray, reorder: bool):
  function merge_small_clusters (line 74) | def merge_small_clusters(clusters: np.ndarray, min_cluster_size: int):
  class LabelResult (line 99) | class LabelResult(BaseModel):
  function _score_clusters (line 122) | def _score_clusters(
  function score_council (line 203) | def score_council(settings: _settings.ClusteringSettings):
  function score_clusters (line 224) | def score_clusters(

FILE: opendsm/common/clustering/settings.py
  class NormalizeChoice (line 15) | class NormalizeChoice(str, Enum):
  class NormalizeSettings (line 21) | class NormalizeSettings(BaseSettings):
    method _check_quantile (line 46) | def _check_quantile(self):
    method _check_enable (line 61) | def _check_enable(self):
  class TransformChoice (line 76) | class TransformChoice(str, Enum):
  class fPCATransformSettings (line 81) | class fPCATransformSettings(BaseSettings):
  class PCASelection (line 90) | class PCASelection(str, Enum):
  class WaveletSelection (line 95) | class WaveletSelection(str, Enum):
  class WaveletTransformSettings (line 108) | class WaveletTransformSettings(BaseSettings):
    method _check_seed (line 156) | def _check_seed(self):
    method _check_wavelet (line 165) | def _check_wavelet(self):
    method _check_pca_settings (line 181) | def _check_pca_settings(self):
  class DistanceMetric (line 212) | class DistanceMetric(str, Enum):
  class ScoreSettings (line 221) | class ScoreSettings(BaseSettings):
    method _check_weights (line 281) | def _check_weights(self):
  class ClusterRangeSettings (line 298) | class ClusterRangeSettings(BaseSettings):
    method _check_n_cluster_range (line 312) | def _check_n_cluster_range(self):
  class BiKmeansInnerAlgorithms (line 321) | class BiKmeansInnerAlgorithms(str, Enum):
  class BiKmeansBisectingStrategies (line 326) | class BiKmeansBisectingStrategies(str, Enum):
  class BisectingKMeansSettings (line 331) | class BisectingKMeansSettings(BaseSettings):
  class BirchSettings (line 363) | class BirchSettings(BaseSettings):
  class DbscanDistanceAlgorithm (line 385) | class DbscanDistanceAlgorithm(str, Enum):
  class DBSCANSettings (line 391) | class DBSCANSettings(BaseSettings):
  class HdbscanClusterSelectionMethod (line 426) | class HdbscanClusterSelectionMethod(str, Enum):
  class HDBSCANSettings (line 431) | class HDBSCANSettings(BaseSettings):
  class SpectralEigenSolver (line 486) | class SpectralEigenSolver(str, Enum):
  class AffinityMatrixOptions (line 491) | class AffinityMatrixOptions(str, Enum):
  class SpectralAssignLabels (line 504) | class SpectralAssignLabels(str, Enum):
  class SpectralSettings (line 509) | class SpectralSettings(BaseSettings):
    method _check_eigen_tol (line 562) | def _check_eigen_tol(self):
  class SortMethod (line 572) | class SortMethod(str, Enum):
  class AggregateMethod (line 578) | class AggregateMethod(str, Enum):
  class ClusterSortSettings (line 583) | class ClusterSortSettings(BaseSettings):
  class ClusterAlgorithms (line 605) | class ClusterAlgorithms(str, Enum):
  class ClusteringSettings (line 613) | class ClusteringSettings(BaseSettings):
    method _check_seed (line 680) | def _check_seed(self):
    method _remove_unselected_algorithms (line 694) | def _remove_unselected_algorithms(self):
    method _remove_unselected_transform (line 714) | def _remove_unselected_transform(self):

FILE: opendsm/common/clustering/transform.py
  function _safe_standardize (line 36) | def _safe_standardize(
  function normalize (line 92) | def normalize(
  class FpcaError (line 159) | class FpcaError(Exception):
  function _fpca_base (line 162) | def _fpca_base(
  function fpca_transform (line 217) | def fpca_transform(
  function wavelet_transform (line 236) | def wavelet_transform(
  function transform_features (line 338) | def transform_features(

FILE: opendsm/common/clustering/voting.py
  function construct_voting_df (line 29) | def construct_voting_df(results):
  function _shulze_pairwise_preference (line 60) | def _shulze_pairwise_preference(df, voter_weights=None):
  function _shulze_path_strength (line 107) | def _shulze_path_strength(Pd, pred):
  function _shulze_rank_strength (line 142) | def _shulze_rank_strength(Pd, pred):
  function shulze_voting (line 160) | def shulze_voting(df, voter_weights=None, window_size=0, return_preferen...

FILE: opendsm/common/const.py
  class CAlgoChoice (line 49) | class CAlgoChoice(str, Enum):
  class TutorialDataChoice (line 56) | class TutorialDataChoice(str, Enum):

FILE: opendsm/common/hourly_interpolation.py
  function autocorr_fcn (line 30) | def autocorr_fcn(x, lags, exclude_0=True):
  function autocorr_fcn2 (line 55) | def autocorr_fcn2(x, lags):
  function autocorr_fcn3 (line 68) | def autocorr_fcn3(x, lags):
  function multiple_imputation (line 91) | def multiple_imputation(df, columns=None, **kwargs):
  function shift_array (line 130) | def shift_array(arr, num, fill_value=np.nan):
  function _interpolate_col (line 155) | def _interpolate_col(x, lags):
  function interpolate (line 221) | def interpolate(df, columns=None):

FILE: opendsm/common/metrics.py
  class ColumnMetrics (line 41) | class ColumnMetrics(ArbitraryPydanticModel):
    method sum (line 58) | def sum(self) -> float:
    method mean (line 69) | def mean(self) -> float:
    method variance (line 83) | def variance(self) -> float:
    method std (line 96) | def std(self) -> float:
    method cvstd (line 107) | def cvstd(self) -> float:
    method sum_squared (line 122) | def sum_squared(self) -> float:
    method median (line 135) | def median(self) -> float:
    method MAD_scaled (line 148) | def MAD_scaled(self) -> float:
    method iqr (line 163) | def iqr(self) -> float:
    method skew (line 177) | def skew(self) -> float:
    method kurtosis (line 191) | def kurtosis(self) -> float:
  function A_n (line 205) | def A_n(x: np.ndarray, n: float) -> float:
  class BaselineMetrics (line 222) | class BaselineMetrics(ArbitraryPydanticModel):
    method _df (line 357) | def _df(self) -> pd.DataFrame:
    method n (line 390) | def n(self) -> float:
    method n_prime (line 403) | def n_prime(self) -> float:
    method ddof (line 431) | def ddof(self) -> float:
    method ddof_autocorr (line 451) | def ddof_autocorr(self) -> float:
    method observed (line 471) | def observed(self) -> ColumnMetrics:
    method predicted (line 482) | def predicted(self) -> ColumnMetrics:
    method residuals (line 493) | def residuals(self) -> ColumnMetrics:
    method max_error (line 504) | def max_error(self) -> float:
    method mae (line 518) | def mae(self) -> float:
    method nmae (line 532) | def nmae(self) -> float:
    method pnmae (line 547) | def pnmae(self) -> float:
    method medae (line 561) | def medae(self) -> float:
    method mbe (line 575) | def mbe(self) -> float:
    method nmbe (line 590) | def nmbe(self) -> float:
    method pnmbe (line 606) | def pnmbe(self) -> float:
    method sse (line 621) | def sse(self) -> float:
    method mse (line 635) | def mse(self) -> float:
    method rmse (line 649) | def rmse(self) -> float:
    method rmse_autocorr (line 663) | def rmse_autocorr(self) -> float:
    method rmse_adj (line 677) | def rmse_adj(self) -> float:
    method rmse_autocorr_adj (line 691) | def rmse_autocorr_adj(self) -> float:
    method cvrmse (line 705) | def cvrmse(self) -> float:
    method cvrmse_autocorr (line 721) | def cvrmse_autocorr(self) -> float:
    method cvrmse_adj (line 735) | def cvrmse_adj(self) -> float:
    method cvrmse_autocorr_adj (line 749) | def cvrmse_autocorr_adj(self) -> float:
    method pnrmse (line 765) | def pnrmse(self) -> float:
    method pnrmse_autocorr (line 780) | def pnrmse_autocorr(self) -> float:
    method pnrmse_adj (line 794) | def pnrmse_adj(self) -> float:
    method pnrmse_autocorr_adj (line 808) | def pnrmse_autocorr_adj(self) -> float:
    method r_squared (line 824) | def r_squared(self) -> float:
    method r_squared_adj (line 839) | def r_squared_adj(self) -> float:
    method mape (line 862) | def mape(self) -> float:
    method smape (line 884) | def smape(self) -> float:
    method wape (line 908) | def wape(self) -> float:
    method swape (line 927) | def swape(self) -> float:
    method maape (line 949) | def maape(self) -> float:
    method nse (line 972) | def nse(self) -> float:
    method nnse (line 993) | def nnse(self) -> float:
    method kge (line 1008) | def kge(self) -> Optional[float]:
    method _relative_errors (line 1036) | def _relative_errors(self) -> np.ndarray:
    method a10 (line 1044) | def a10(self) -> float:
    method a20 (line 1058) | def a20(self) -> float:
    method a30 (line 1072) | def a30(self) -> float:
    method wi (line 1086) | def wi(self) -> float:
    method index_of_agreement (line 1109) | def index_of_agreement(self) -> float:
    method pearson_r (line 1134) | def pearson_r(self) -> float:
    method pi (line 1149) | def pi(self) -> float:
    method pi_rating (line 1166) | def pi_rating(self) -> str:
    method explained_variance_score (line 1196) | def explained_variance_score(self) -> float:
  function BaselineMetricsFromDict (line 1214) | def BaselineMetricsFromDict(input_dict: dict) -> BaselineMetrics:
  class ModelChoice (line 1235) | class ModelChoice(str, Enum):
  class ReportingMetrics (line 1258) | class ReportingMetrics(pydantic.BaseModel):
    method _baseline (line 1299) | def _baseline(self) -> BaselineMetrics:
    method _df (line 1304) | def _df(self) -> pd.DataFrame:
    method n (line 1334) | def n(self) -> float:
    method observed_sum (line 1347) | def observed_sum(self) -> float:
    method predicted_sum (line 1360) | def predicted_sum(self) -> float:
    method t_stat (line 1373) | def t_stat(self) -> float:
    method savings (line 1387) | def savings(self) -> float:
    method total_savings_uncertainty (line 1401) | def total_savings_uncertainty(self) -> Optional[float]:
    method fsu (line 1451) | def fsu(self) -> float:
    method predicted_data_point_unc (line 1465) | def predicted_data_point_unc(self) -> Optional[float]:
  class AutocorrelationMethod (line 1482) | class AutocorrelationMethod(Enum):
  function acf (line 1499) | def acf(

FILE: opendsm/common/pydantic_utils.py
  class PydanticDf (line 25) | class PydanticDf(pydantic.BaseModel):
    method _check_columns (line 34) | def _check_columns(self):
  class ArbitraryPydanticModel (line 59) | class ArbitraryPydanticModel(pydantic.BaseModel):
    method _serialize_special_floats (line 63) | def _serialize_special_floats(self, serializer, info):
    method _convert_special_floats_to_str (line 73) | def _convert_special_floats_to_str(obj):
    method _parse_special_floats (line 88) | def _parse_special_floats(cls, data):
    method _convert_str_to_special_floats (line 97) | def _convert_str_to_special_floats(obj):
  function PydanticFromDict (line 115) | def PydanticFromDict(input_dict, name="PydanticModel"):
  function computed_field_cached_property (line 135) | def computed_field_cached_property():

FILE: opendsm/common/stats/adaptive_loss.py
  function sliding_window (line 35) | def sliding_window(
  function rolling_IQR_outlier (line 83) | def rolling_IQR_outlier(
  function get_C (line 146) | def get_C(
  function rolling_C (line 199) | def rolling_C(
  function generalized_loss_fcn (line 229) | def generalized_loss_fcn(
  function generalized_loss_derivative (line 276) | def generalized_loss_derivative(
  function generalized_loss_weights (line 319) | def generalized_loss_weights(
  function penalized_loss_fcn (line 362) | def penalized_loss_fcn(
  function alpha_scaled (line 400) | def alpha_scaled(
  function adaptive_loss_fcn (line 452) | def adaptive_loss_fcn(
  function adaptive_weights (line 504) | def adaptive_weights(

FILE: opendsm/common/stats/adaptive_loss_Z.py
  function ln_Z (line 225) | def ln_Z(alpha, alpha_min=-100):

FILE: opendsm/common/stats/basic.py
  function t_stat (line 40) | def t_stat(alpha: float, n: int, tail: Union[int, str] = 2) -> float:
  function z_stat (line 65) | def z_stat(alpha: float, tail: Union[int, str] = 2) -> float:
  function unc_factor (line 88) | def unc_factor(
  function weighted_std (line 113) | def weighted_std(
  function fast_std (line 144) | def fast_std(
  function _weighted_quantile (line 180) | def _weighted_quantile(
  function weighted_quantile (line 232) | def weighted_quantile(
  function _median_absolute_deviation (line 278) | def _median_absolute_deviation(
  function median_absolute_deviation (line 314) | def median_absolute_deviation(

FILE: opendsm/common/stats/distribution_transform/bisymlog.py
  class Bisymlog (line 32) | class Bisymlog:
    method __init__ (line 33) | def __init__(self, C=C_base, heuristic_scaling_factor=0.5, base=10, re...
    method set_C_heuristically (line 45) | def set_C_heuristically(self, y, scaling_factor=None): # scaling facto...
    method transform (line 86) | def transform(self, y):
    method invTransform (line 117) | def invTransform(self, y):
  function bisymlog (line 133) | def bisymlog(x, rescale_quantile=None):

FILE: opendsm/common/stats/distribution_transform/mu_sigma.py
  function adaptive_weighted_mu_sigma (line 27) | def adaptive_weighted_mu_sigma(x, use_mean=False, rel_err=1E-4, abs_err=...
  function ransac_mu_sigma (line 55) | def ransac_mu_sigma(x, n_iter=100, n_sample=100, seed=None):
  function robust_mu_sigma (line 74) | def robust_mu_sigma(x, robust_type="huber_m_estimate", **kwargs):

FILE: opendsm/common/stats/distribution_transform/raymaekers_robust_yeo_johnson.py
  function _yeo_johnson_base (line 42) | def _yeo_johnson_base(x, lam, deriv):
  function _box_cox_base (line 69) | def _box_cox_base(x, lam, deriv):
  function rectified_transform (line 88) | def rectified_transform(x, lam, Q, tr_type="Yeo-Johnson"):
  function unrectified_transform (line 111) | def unrectified_transform(x, lam, tr_type="Yeo-Johnson"):
  function loss_fcn (line 124) | def loss_fcn(x, mu=0, c=1, loss_type="adaptive"):
  function _robust_standardize (line 136) | def _robust_standardize(x, robust_type, c_huber):
  function initial_lam_obj_fcn_dec (line 143) | def initial_lam_obj_fcn_dec(x, Q, transform_type="Yeo-Johnson", c=0.5, r...
  function lam_obj_fcn_dec (line 162) | def lam_obj_fcn_dec(
  function normal_transformation (line 197) | def normal_transformation(
  function raymaekers_robust_YJ (line 242) | def raymaekers_robust_YJ(x, Q_perc=0.25, c=0.5, outlier_alpha=0.005, c_h...

FILE: opendsm/common/stats/distribution_transform/scipy_yeo_johnson.py
  function scipy_YJ (line 24) | def scipy_YJ(x, robust_type="huber_m_estimate"):
  function obj_fcn_dec (line 31) | def obj_fcn_dec(x):
  function robust_scipy_YJ (line 42) | def robust_scipy_YJ(x, robust_type="huber_m_estimate", method="trim", **...

FILE: opendsm/common/stats/distribution_transform/standardize.py
  function robust_standardize (line 18) | def robust_standardize(x, robust_type="iqr", **kwargs):

FILE: opendsm/common/stats/outliers.py
  function IQR_outlier (line 28) | def IQR_outlier(data, weights=None, sigma_threshold=3, quantile=0.25):
  function _IQR_outlier (line 38) | def _IQR_outlier(data, weights=None, sigma_threshold=3, quantile=0.25):
  function remove_outliers (line 56) | def remove_outliers(x, weights=None, sigma_threshold=3, quantile=0.25):

FILE: opendsm/common/stats/outliers_transformed.py
  function remove_outliers (line 31) | def remove_outliers(x, weights=None, sigma_threshold=3, quantile=0.25, t...

FILE: opendsm/common/test_data.py
  function load_test_data (line 51) | def load_test_data(data_type: str):
  function _load_time_series_data (line 87) | def _load_time_series_data(data_type):
  function _aggregate_hourly_data (line 125) | def _aggregate_hourly_data(df, agg):
  function _load_other_data (line 139) | def _load_other_data(data_type):
  function _load_file (line 157) | def _load_file(file: Path | str):

FILE: opendsm/common/utils.py
  function np_clip (line 30) | def np_clip(a, a_min, a_max):
  function to_np_array (line 90) | def to_np_array(x):
  function safe_divide (line 116) | def safe_divide(num, den, min_denominator=1e-3, return_all=True):
  function OoM (line 186) | def OoM(x, method="round"):
  function OoM_numba (line 194) | def OoM_numba(x, method="round"):
  function RoundToSigFigs (line 230) | def RoundToSigFigs(x, p):
  function sigmoid (line 248) | def sigmoid(x, x0=0, k=1):
  function log_cosh (line 283) | def log_cosh(x):

FILE: opendsm/comparison_groups/cg_clustering/bounds.py
  function _get_num_cluster_min (line 20) | def _get_num_cluster_min(
  function _get_num_cluster_max (line 50) | def _get_num_cluster_max(
  function get_cluster_bounds (line 94) | def get_cluster_bounds(

FILE: opendsm/comparison_groups/cg_clustering/create_comparison_groups.py
  class CG_Clustering (line 27) | class CG_Clustering(Comparison_Group_Algorithm):
    method __init__ (line 32) | def __init__(self, settings: Optional[_settings.CG_Clustering_Settings...
    method get_labels (line 38) | def get_labels(self, comparison_pool_data):
    method match_treatment_to_clusters (line 72) | def match_treatment_to_clusters(self, treatment_data):
    method get_comparison_group (line 91) | def get_comparison_group(self, treatment_data, comparison_pool_data):

FILE: opendsm/comparison_groups/cg_clustering/settings.py
  class AdaptiveLossChoice (line 30) | class AdaptiveLossChoice(str, Enum):
  class TreatmentMatchSettings (line 38) | class TreatmentMatchSettings(BaseSettings):
    method _check_treatment_match_loss (line 65) | def _check_treatment_match_loss(self):
  class _CG_Clustering_Settings (line 91) | class _CG_Clustering_Settings(_settings.ClusteringSettings):
  class ClusteringSettings (line 97) | class ClusteringSettings(BaseSettings):
  function CG_Clustering_Settings (line 101) | def CG_Clustering_Settings(**kwargs) -> _CG_Clustering_Settings:

FILE: opendsm/comparison_groups/cg_clustering/treatment_fit.py
  function _get_cluster_ls (line 33) | def _get_cluster_ls(df_cp_ls: pd.DataFrame, cluster_df: pd.DataFrame, ag...
  function fit_to_clusters (line 49) | def fit_to_clusters(
  class ClusterTreatmentMatchError (line 128) | class ClusterTreatmentMatchError(Exception):
  function _match_treatment_to_cluster (line 132) | def _match_treatment_to_cluster(
  function match_treatment_to_clusters (line 190) | def match_treatment_to_clusters(

FILE: opendsm/comparison_groups/common/base_comparison_group.py
  class Comparison_Group_Algorithm (line 22) | class Comparison_Group_Algorithm:
    method _get_treatment_loadshape (line 35) | def _get_treatment_loadshape(self, id):
    method _set_treatment_match_loadshape (line 47) | def _set_treatment_match_loadshape(self):
    method _get_treatment_match_loadshape (line 57) | def _get_treatment_match_loadshape(self, id):
    method get_comparison_pool_loadshape (line 68) | def get_comparison_pool_loadshape(self):
    method get_loadshapes (line 76) | def get_loadshapes(self, id=None):
    method _validate_ls_weights (line 92) | def _validate_ls_weights(self, weights):
    method plot_loadshapes (line 108) | def plot_loadshapes(self, id=None):

FILE: opendsm/comparison_groups/common/const.py
  class DistanceMetric (line 25) | class DistanceMetric(str, Enum):
  class AggType (line 36) | class AggType(str, Enum):
  class LoadshapeType (line 44) | class LoadshapeType(str, Enum):
  class TimePeriod (line 51) | class TimePeriod(str, Enum):

FILE: opendsm/comparison_groups/common/data.py
  function is_datetime (line 24) | def is_datetime(x: pd.Series) -> bool:
  class Data (line 35) | class Data:
    method __init__ (line 36) | def __init__(self,
    method extend (line 77) | def extend(self, other):
    method _find_groupby_columns (line 97) | def _find_groupby_columns(self) -> list:
    method _add_index_columns_from_datetime (line 118) | def _add_index_columns_from_datetime(self, df: pd.DataFrame) -> pd.Dat...
    method _create_values_for_interpolation (line 155) | def _create_values_for_interpolation(self, df: pd.DataFrame) -> pd.Dat...
    method _validate_unstacked_loadshape (line 190) | def _validate_unstacked_loadshape(self, df: pd.DataFrame) -> pd.DataFr...
    method _validate_format_loadshape (line 216) | def _validate_format_loadshape(self, df: pd.DataFrame) -> pd.DataFrame:
    method _validate_format_features (line 344) | def _validate_format_features(self, df: pd.DataFrame) -> pd.DataFrame:
    method _convert_timeseries_to_loadshape (line 379) | def _convert_timeseries_to_loadshape(
    method _trim_data (line 481) | def _trim_data(self) -> None:
    method _set_data (line 510) | def _set_data(
    method settings (line 583) | def settings(self):
    method loadshape (line 587) | def loadshape(self):
    method features (line 594) | def features(self):
    method ids (line 601) | def ids(self):
    method excluded_ids (line 610) | def excluded_ids(self):

FILE: opendsm/comparison_groups/common/data_settings.py
  class Season_Definition (line 29) | class Season_Definition(BaseSettings):
    method set_numeric_dict (line 47) | def set_numeric_dict(self) -> Season_Definition:
  class Weekday_Weekend_Definition (line 62) | class Weekday_Weekend_Definition(BaseSettings):
    method set_numeric_dict (line 75) | def set_numeric_dict(self) -> Weekday_Weekend_Definition:
  class Data_Settings (line 90) | class Data_Settings(BaseSettings):
    method validate_min_data_pct_required (line 130) | def validate_min_data_pct_required(cls, value):
    method _set_nested_classes (line 151) | def _set_nested_classes(self):
    method _validate_loadshape_time_series_settings (line 166) | def _validate_loadshape_time_series_settings(self):
    method _set_min_data_pct_on_interpolate (line 178) | def _set_min_data_pct_on_interpolate(self):

FILE: opendsm/comparison_groups/common/tutorial_data.py
  function load_tutorial_data (line 22) | def load_tutorial_data(data_type: str):

FILE: opendsm/comparison_groups/individual_meter_matching/create_comparison_groups.py
  class Individual_Meter_Matching (line 28) | class Individual_Meter_Matching(Comparison_Group_Algorithm):
    method __init__ (line 29) | def __init__(self, settings: Optional[Settings] = None):
    method _create_clusters_df (line 35) | def _create_clusters_df(self, df_raw):
    method _create_treatment_weights_df (line 62) | def _create_treatment_weights_df(self, ids):
    method get_comparison_group (line 71) | def get_comparison_group(self, treatment_data, comparison_pool_data, w...
    method add_treatment_meters (line 100) | def add_treatment_meters(self, treatment_data):

FILE: opendsm/comparison_groups/individual_meter_matching/distance_calc_selection.py
  function cp_chunks (line 30) | def cp_chunks(lst, n):
  function _distances (line 35) | def _distances(ls_t, ls_cp, weights=None, dist_metric="euclidean", n_met...
  function highs_fit_comparison_group_loadshape (line 59) | def highs_fit_comparison_group_loadshape(t_ls, cp_ls, coef_sum=1, solver...
  class DistanceMatchingError (line 100) | class DistanceMatchingError(Exception):
  class DistanceMatching (line 104) | class DistanceMatching:
    method __init__ (line 118) | def __init__(
    method _closest_idx_duplicates_allowed (line 135) | def _closest_idx_duplicates_allowed(self, distances, n_match=None):
    method _closest_idx_duplicates_not_allowed (line 148) | def _closest_idx_duplicates_not_allowed(self, ls_t, ls_cp, distances):
    method get_comparison_group (line 196) | def get_comparison_group(

FILE: opendsm/comparison_groups/individual_meter_matching/highs_settings.py
  class HiGHS_Settings (line 30) | class HiGHS_Settings(BaseSettings):
    method _random_seed (line 478) | def _random_seed(self):

FILE: opendsm/comparison_groups/individual_meter_matching/settings.py
  class SelectionMethod (line 26) | class SelectionMethod(str, Enum):
  class Settings (line 31) | class Settings(BaseSettings):
    method _check_allow_duplicates (line 75) | def _check_allow_duplicates(self):

FILE: opendsm/comparison_groups/random_sampling/create_comparison_groups.py
  class Random_Sampling (line 26) | class Random_Sampling(Comparison_Group_Algorithm):
    method __init__ (line 27) | def __init__(self, settings: Optional[Settings] = None):
    method _create_clusters_df (line 33) | def _create_clusters_df(self, df_raw):
    method _create_treatment_weights_df (line 45) | def _create_treatment_weights_df(self, ids):
    method get_comparison_group (line 54) | def get_comparison_group(self, treatment_data, comparison_pool_data, w...

FILE: opendsm/comparison_groups/random_sampling/settings.py
  class Settings (line 23) | class Settings(BaseSettings):
    method _check_n_meters_choice (line 45) | def _check_n_meters_choice(self):

FILE: opendsm/comparison_groups/savings/cg_correction_testing.py
  function get_t_cg_df (line 29) | def get_t_cg_df(data, num_treatment=None, num_control=None, seed=21):
  function get_comparison_groups (line 67) | def get_comparison_groups(df_t, df_cp, agg, cg_type="cluster", multiproc...
  function add_datetime_loadshape_mapping_col (line 92) | def add_datetime_loadshape_mapping_col(df, data_settings):
  class Savings (line 117) | class Savings:
    method __init__ (line 118) | def __init__(self, df_t, df_cp, df_cluster_id, df_t_coeffs, agg_type="...
    method _initialize_df (line 138) | def _initialize_df(self, df, is_treatment=False):
    method _agg_cluster_data (line 173) | def _agg_cluster_data(self):
    method _get_treatment_cg_data (line 225) | def _get_treatment_cg_data(self):
    method add_pct_did (line 271) | def add_pct_did(self, simplified_eqn=False):
    method add_abs_pct_did (line 284) | def add_abs_pct_did(self, simplified_eqn=False):
    method add_sig_pct_did (line 301) | def add_sig_pct_did(self, k=0.01, m_0=0.1):
    method add_scaled_ordinary_did (line 324) | def add_scaled_ordinary_did(self):
    method add_modeled_scaled_ordinary_did (line 359) | def add_modeled_scaled_ordinary_did(self):
    method _get_did_cols (line 393) | def _get_did_cols(self):
    method df (line 400) | def df(self):
    method df_agg (line 418) | def df_agg(self, period="reporting"):
    method df_stats (line 441) | def df_stats(self, period="reporting"):

FILE: opendsm/comparison_groups/savings/model_correction.py
  function _unit_correction_unc (line 28) | def _unit_correction_unc(
  function _unit_correction (line 96) | def _unit_correction(
  function _update_mask (line 171) | def _update_mask(global_mask, mask=None, idx_valid=None, idx_invalid=None):
  function _apply_mask (line 189) | def _apply_mask(mask, *arrays):
  function _effective_sample_size (line 207) | def _effective_sample_size(weight):
  function _cluster_correction (line 214) | def _cluster_correction(
  function model_correction (line 321) | def model_correction(

FILE: opendsm/comparison_groups/savings/settings.py
  class TransformChoice (line 26) | class TransformChoice(str, Enum):
  class OutlierRejectionSettings (line 34) | class OutlierRejectionSettings(BaseSettings):
  class CorrectionCapChoice (line 61) | class CorrectionCapChoice(str, Enum):
  class CorrectionCapSettings (line 66) | class CorrectionCapSettings(BaseSettings):
    method _check_solar_cap (line 90) | def _check_solar_cap(self):
  class CorrectionAlgorithm (line 105) | class CorrectionAlgorithm(str, Enum):
  class WeightClusterAggChoice (line 111) | class WeightClusterAggChoice(str, Enum):
  class CGCorrectionSettings (line 115) | class CGCorrectionSettings(BaseSettings):

FILE: opendsm/comparison_groups/stratified_sampling/bin_selection.py
  class StratifiedSamplingBinSelector (line 28) | class StratifiedSamplingBinSelector(object):
    method __init__ (line 29) | def __init__(
    method kwargs_as_json (line 331) | def kwargs_as_json(self):
    method results_as_json (line 343) | def results_as_json(self):
    method plot_records_based_equiv_average (line 372) | def plot_records_based_equiv_average(self, plot=True):

FILE: opendsm/comparison_groups/stratified_sampling/bins.py
  class ModelSamplingException (line 24) | class ModelSamplingException(Exception):
  class BinnedData (line 28) | class BinnedData:
    method __init__ (line 29) | def __init__(self, df, binning, min_n_treatment_per_bin=0):
    method _map_bins (line 36) | def _map_bins(self, df):
    method count_bins_1d (line 45) | def count_bins_1d(self, column):
    method count_bins (line 64) | def count_bins(self, skip_outliers=False):
    method _outlier_bins (line 77) | def _outlier_bins(self):
    method _flag_outliers (line 86) | def _flag_outliers(self):
  class Binning (line 94) | class Binning(object):
    method __init__ (line 97) | def __init__(self):
    method edges (line 102) | def edges(self):
    method edges_xy (line 105) | def edges_xy(self, col_x, col_y):
    method bin (line 117) | def bin(self, values, column_name, n_bins, fixed_width):
    method _add_column (line 130) | def _add_column(self, column, edges):
    method _update_multibins (line 140) | def _update_multibins(self):
  class Bin (line 146) | class Bin:
    method __init__ (line 149) | def __init__(self, column, min, max, index):
    method filter_expr (line 155) | def filter_expr(self):
    method __str__ (line 160) | def __str__(self):
    method __repr__ (line 163) | def __repr__(self):
  class MultiBin (line 167) | class MultiBin:
    method __init__ (line 170) | def __init__(self, bins):
    method filter_expr (line 176) | def filter_expr(self):
    method get_max_n_target (line 181) | def get_max_n_target(self, df):
    method sample (line 184) | def sample(self, df, n_target, min_n_treatment_per_bin, random_seed=1):
    method edges (line 201) | def edges(self):
    method __str__ (line 215) | def __str__(self):
    method __repr__ (line 218) | def __repr__(self):
  function sample_bins (line 222) | def sample_bins(
  function get_counts_and_update_n_samples_approx (line 251) | def get_counts_and_update_n_samples_approx(

FILE: opendsm/comparison_groups/stratified_sampling/const.py
  class DistanceMetric (line 20) | class DistanceMetric(str, Enum):

FILE: opendsm/comparison_groups/stratified_sampling/create_comparison_groups.py
  class Stratified_Sampling (line 31) | class Stratified_Sampling(Comparison_Group_Algorithm):
    method __init__ (line 32) | def __init__(self, settings: Optional[Settings] = None):
    method _create_clusters_df (line 55) | def _create_clusters_df(self, ids):
    method _create_treatment_weights_df (line 66) | def _create_treatment_weights_df(self, ids):
    method _create_output_dfs (line 74) | def _create_output_dfs(self, t_ids):
    method get_comparison_group (line 92) | def get_comparison_group(self, treatment_data, comparison_pool_data):
    method diagnostics (line 150) | def diagnostics(self):

FILE: opendsm/comparison_groups/stratified_sampling/diagnostics.py
  function t_and_ks_test (line 33) | def t_and_ks_test(x, y, thresh=0.05):
  class DiagnosticPlotter (line 56) | class DiagnosticPlotter:
    method quantile (line 57) | def quantile(self, df, df_equiv, cols=None):
    method scatter (line 124) | def scatter(self, df, cols=None):
    method _scatter (line 132) | def _scatter(self, df, col_x, col_y):
    method histogram (line 173) | def histogram(self, df, cols=None):
    method _histogram (line 179) | def _histogram(self, df, col):
  class StratifiedSamplingDiagnostics (line 210) | class StratifiedSamplingDiagnostics(DiagnosticPlotter):
    method __init__ (line 242) | def __init__(self, model):
    method histogram (line 285) | def histogram(self, cols=None):
    method scatter (line 288) | def scatter(self, cols=None):
    method quantile_equivalence (line 291) | def quantile_equivalence(self, cols=None):
    method _check_equiv_labels (line 295) | def _check_equiv_labels(self, equiv_label_x, equiv_label_y):
    method equivalence (line 318) | def equivalence(self, cols=None, equiv_label_x=None, equiv_label_y=None):
    method equivalence_passed (line 365) | def equivalence_passed(self, cols=None):
    method count_bins (line 369) | def count_bins(self):
    method n_sampled_to_n_treatment_ratio (line 394) | def n_sampled_to_n_treatment_ratio(self):

FILE: opendsm/comparison_groups/stratified_sampling/equivalence.py
  function ids_to_index (line 21) | def ids_to_index(subset_ids, all_ids):
  class Equivalence (line 35) | class Equivalence:
    method __init__ (line 55) | def __init__(self, ix_x, ix_y, features_matrix, n_quantiles=1, how='eu...
    method compute (line 73) | def compute(self):
  function reshape_outputs (line 82) | def reshape_outputs(means, quantiles):
  function get_quantile_indexes (line 93) | def get_quantile_indexes(n_quantiles):
  function get_quantiles (line 96) | def get_quantiles(col, n_quantiles):
  function cut_column (line 99) | def cut_column(col, q_this, q_next):
  function quantile_means_array (line 105) | def quantile_means_array(col, n_quantiles):
  function quantile_means_population (line 116) | def quantile_means_population(X, Y, n_quantiles):
  function chisquare_dist (line 135) | def chisquare_dist(X,Y):
  function get_distance_func (line 141) | def get_distance_func(how="euclidean"):
  function sum_column_distance (line 150) | def sum_column_distance(means_x, means_y, how="euclidean"):

FILE: opendsm/comparison_groups/stratified_sampling/model.py
  class StratifiedSampling (line 34) | class StratifiedSampling(object):
    method __init__ (line 71) | def __init__(
    method _chop_outliers (line 84) | def _chop_outliers(self, df):
    method _perturb (line 92) | def _perturb(self, df_orig, col_names=None, random_seed=1):
    method add_column (line 104) | def add_column(
    method _check_columns_present (line 149) | def _check_columns_present(self, df):
    method fit_and_sample (line 160) | def fit_and_sample(
    method print_n_bins (line 264) | def print_n_bins(self):
    method get_all_n_bins_as_str (line 267) | def get_all_n_bins_as_str(self):
    method get_n_bins (line 272) | def get_n_bins(self, col_name):
    method set_n_bins (line 276) | def set_n_bins(self, col_name, n_bins):
    method fit (line 281) | def fit(self, df_treatment, min_n_treatment_per_bin=0, random_seed=1):
    method diagnostics (line 327) | def diagnostics(self):
    method sample (line 330) | def sample(

FILE: opendsm/comparison_groups/stratified_sampling/param_selection.py
  function get_prob_bins (line 19) | def get_prob_bins(df, df_comparison, col, bins=20, fixed_count=True):
  function get_kl_divs (line 38) | def get_kl_divs(df_treat, df_compare, **kwargs):
  function choose_params (line 64) | def choose_params(difs, corr_matrix, thresh=0.75, num_params=3):
  function get_params (line 78) | def get_params(treatment, comparison, thresh=0.75, num_params=3, **kwargs):

FILE: opendsm/comparison_groups/stratified_sampling/settings.py
  class StratificationColumnSettings (line 25) | class StratificationColumnSettings(BaseSettings):
  class DSS_StratificationColumnSettings (line 59) | class DSS_StratificationColumnSettings(StratificationColumnSettings):
  class Settings (line 67) | class Settings(BaseSettings):
  class StratifiedSamplingSettings (line 88) | class StratifiedSamplingSettings(Settings):
    method _set_nested_classes (line 138) | def _set_nested_classes(self):
  class DistanceStratifiedSamplingSettings (line 161) | class DistanceStratifiedSamplingSettings(Settings):
    method _set_nested_classes (line 225) | def _set_nested_classes(self):

FILE: opendsm/drmeter/models/caltrack/model.py
  class Model (line 18) | class Model(HourlyModel):
    method __init__ (line 19) | def __init__(self, settings=None):

FILE: opendsm/eemeter/common/data_processor_utilities.py
  function remove_duplicates (line 26) | def remove_duplicates(df_or_series):
  function day_counts (line 43) | def day_counts(index):
  function clean_billing_data (line 69) | def clean_billing_data(data, source_interval, warnings):
  function as_freq (line 179) | def as_freq(
  function downsample_and_clean_daily_data (line 298) | def downsample_and_clean_daily_data(dataset, warnings):
  function clean_billing_daily_data (line 323) | def clean_billing_daily_data(data, source_interval, warnings):
  function compute_minimum_granularity (line 338) | def compute_minimum_granularity(index: pd.Series, default_granularity: O...

FILE: opendsm/eemeter/common/data_settings.py
  class ColumnSufficiencySettings (line 29) | class ColumnSufficiencySettings(MutableBaseSettings):
  class TemperatureSufficiencySettings (line 59) | class TemperatureSufficiencySettings(ColumnSufficiencySettings):
  class GhiSufficiencySettings (line 63) | class GhiSufficiencySettings(MutableBaseSettings):
  class ObservedSufficiencySettings (line 72) | class ObservedSufficiencySettings(MutableBaseSettings):
  class JointSufficiencySettings (line 95) | class JointSufficiencySettings(MutableBaseSettings):
  class BaseSufficiencySettings (line 104) | class BaseSufficiencySettings(MutableBaseSettings):
    method convert_float_to_int (line 145) | def convert_float_to_int(cls, v):
    method check_baseline_lengths (line 151) | def check_baseline_lengths(self):
  class DailyDataSufficiencySettings (line 162) | class DailyDataSufficiencySettings(BaseSufficiencySettings):
  class BillingDataSufficiencySettings (line 166) | class BillingDataSufficiencySettings(BaseSufficiencySettings):
    method convert_float_to_int (line 189) | def convert_float_to_int(cls, v):
  class HourlyTemperatureSufficiencySettings (line 195) | class HourlyTemperatureSufficiencySettings(TemperatureSufficiencySettings):
    method convert_float_to_int (line 204) | def convert_float_to_int(cls, v):
  class HourlyDataSufficiencySettings (line 209) | class HourlyDataSufficiencySettings(BaseSufficiencySettings):
  class BaseDataSettings (line 215) | class BaseDataSettings(MutableBaseSettings):
  class DailyDataSettings (line 227) | class DailyDataSettings(BaseDataSettings):
  class BillingDataSettings (line 232) | class BillingDataSettings(BaseDataSettings):
  class HourlyDataSettings (line 237) | class HourlyDataSettings(BaseDataSettings):

FILE: opendsm/eemeter/common/exceptions.py
  class EEMeterError (line 26) | class EEMeterError(Exception):
  class NoBaselineDataError (line 32) | class NoBaselineDataError(EEMeterError):
  class NoReportingDataError (line 38) | class NoReportingDataError(EEMeterError):
  class MissingModelParameterError (line 44) | class MissingModelParameterError(EEMeterError):
  class UnrecognizedModelTypeError (line 50) | class UnrecognizedModelTypeError(EEMeterError):
  class DataSufficiencyError (line 56) | class DataSufficiencyError(EEMeterError):
  class DisqualifiedModelError (line 62) | class DisqualifiedModelError(EEMeterError):

FILE: opendsm/eemeter/common/features.py
  function merge_features (line 36) | def merge_features(features, keep_partial_nan_rows=False):
  function compute_usage_per_day_feature (line 67) | def compute_usage_per_day_feature(meter_data, series_name="usage_per_day"):
  function get_missing_hours_of_week_warning (line 88) | def get_missing_hours_of_week_warning(hours_of_week):
  function compute_time_features (line 114) | def compute_time_features(index, hour_of_week=True, day_of_week=True, ho...
  function _matching_groups (line 168) | def _matching_groups(index, df, tolerance):
  function _degree_day_columns (line 183) | def _degree_day_columns(
  function compute_temperature_features (line 294) | def compute_temperature_features(
  function _estimate_hour_of_week_occupancy (line 546) | def _estimate_hour_of_week_occupancy(model_data, threshold):
  function estimate_hour_of_week_occupancy (line 582) | def estimate_hour_of_week_occupancy(data, segmentation=None, threshold=0...
  function _fit_temperature_bins (line 624) | def _fit_temperature_bins(temperature_data, default_bins, min_temperatur...
  function fit_temperature_bins (line 681) | def fit_temperature_bins(
  function compute_temperature_bin_features (line 813) | def compute_temperature_bin_features(temperatures, bin_endpoints):
  function compute_occupancy_feature (line 865) | def compute_occupancy_feature(hour_of_week, occupancy):

FILE: opendsm/eemeter/common/sufficiency_criteria.py
  class SufficiencyCriteria (line 38) | class SufficiencyCriteria(BaseSettings):
    method _has_ghi (line 59) | def _has_ghi(self) -> bool:
    method n_days_total (line 63) | def n_days_total(self) -> int:
    method _compute_valid_day_counts (line 91) | def _compute_valid_day_counts(self):
    method n_valid_temperature_days (line 117) | def n_valid_temperature_days(self) -> int:
    method n_valid_observed_days (line 124) | def n_valid_observed_days(self) -> int:
    method n_valid_days (line 131) | def n_valid_days(self) -> int:
    method _check_no_data (line 137) | def _check_no_data(self):
    method _check_n_days_boundary_gap (line 149) | def _check_n_days_boundary_gap(self, gap_type: Literal["start", "end"]):
    method _check_baseline_day_length (line 183) | def _check_baseline_day_length(self):
    method _check_negative_observed_values (line 203) | def _check_negative_observed_values(self):
    method _check_valid_days_percentage (line 223) | def _check_valid_days_percentage(self, col: Literal["temperature", "gh...
    method _check_valid_monthly_coverage (line 270) | def _check_valid_monthly_coverage(self, col: Literal["temperature", "g...
    method _check_season_weekday_weekend_availability (line 309) | def _check_season_weekday_weekend_availability(self):
    method _check_extreme_values (line 314) | def _check_extreme_values(self):
    method _check_high_frequency_temperature_values (line 356) | def _check_high_frequency_temperature_values(self):
    method _check_high_frequency_observed_values (line 392) | def _check_high_frequency_observed_values(self):
    method check_sufficiency_baseline (line 411) | def check_sufficiency_baseline(self):
    method check_sufficiency_reporting (line 423) | def check_sufficiency_reporting(self):
  class DailySufficiencyCriteria (line 432) | class DailySufficiencyCriteria(SufficiencyCriteria):
    method __init__ (line 437) | def __init__(self, *args, **kwargs):
    method check_sufficiency_baseline (line 440) | def check_sufficiency_baseline(self):
    method check_sufficiency_reporting (line 449) | def check_sufficiency_reporting(self):
  class BillingSufficiencyCriteria (line 453) | class BillingSufficiencyCriteria(SufficiencyCriteria):
    method __init__ (line 458) | def __init__(self, *args, **kwargs):
    method _check_observed_data_billing_monthly (line 461) | def _check_observed_data_billing_monthly(self):
    method _check_observed_data_billing_bimonthly (line 488) | def _check_observed_data_billing_bimonthly(self):
    method _check_estimated_observed_values (line 514) | def _check_estimated_observed_values(self):
    method check_sufficiency_baseline (line 569) | def check_sufficiency_baseline(self):
    method check_sufficiency_reporting (line 581) | def check_sufficiency_reporting(self):
  class HourlySufficiencyCriteria (line 585) | class HourlySufficiencyCriteria(SufficiencyCriteria):
    method __init__ (line 590) | def __init__(self, *args, **kwargs):
    method _check_baseline_length_hourly_model (line 593) | def _check_baseline_length_hourly_model(self):
    method _check_hourly_consecutive_temperature_data (line 596) | def _check_hourly_consecutive_temperature_data(self):
    method check_sufficiency_baseline (line 615) | def check_sufficiency_baseline(self):
    method check_sufficiency_reporting (line 628) | def check_sufficiency_reporting(self):

FILE: opendsm/eemeter/common/transform.py
  function overwrite_partial_rows_with_nan (line 43) | def overwrite_partial_rows_with_nan(df):
  function remove_duplicates (line 47) | def remove_duplicates(df_or_series):
  function as_freq (line 64) | def as_freq(
  function day_counts (line 161) | def day_counts(index):
  function _make_baseline_warnings (line 187) | def _make_baseline_warnings(
  function get_baseline_data (line 222) | def get_baseline_data(
  function _make_reporting_warnings (line 353) | def _make_reporting_warnings(
  function get_reporting_data (line 388) | def get_reporting_data(
  class Term (line 507) | class Term(object):
    method __init__ (line 537) | def __init__(
    method __repr__ (line 559) | def __repr__(self):
  function get_terms (line 571) | def get_terms(index, term_lengths, term_labels=None, start=None, method=...
  function clean_caltrack_billing_data (line 683) | def clean_caltrack_billing_data(data, source_interval):
  function downsample_and_clean_caltrack_daily_data (line 765) | def downsample_and_clean_caltrack_daily_data(data):
  function clean_caltrack_billing_daily_data (line 777) | def clean_caltrack_billing_daily_data(data, source_interval):
  function add_freq (line 791) | def add_freq(idx, freq=None):
  function trim (line 829) | def trim(*args, freq="h", tz="UTC"):
  function _check_input_formatting (line 887) | def _check_input_formatting(input, tz="UTC"):
  function _format_data_for_caltrack_hourly (line 915) | def _format_data_for_caltrack_hourly(df, tz="UTC"):
  function format_energy_data_for_caltrack (line 925) | def format_energy_data_for_caltrack(*args, method="hourly", tz="UTC"):
  function format_temperature_data_for_caltrack (line 975) | def format_temperature_data_for_caltrack(temperature_data, tz="UTC"):

FILE: opendsm/eemeter/common/warnings.py
  class EEMeterWarning (line 22) | class EEMeterWarning(pydantic.BaseModel):
    method __repr__ (line 40) | def __repr__(self):
    method __str__ (line 43) | def __str__(self):
    method json (line 46) | def json(self) -> dict:
    method warn (line 58) | def warn(self):

FILE: opendsm/eemeter/models/billing/data.py
  class _BillingData (line 45) | class _BillingData(_DailyData):
    method _compute_meter_value_df (line 57) | def _compute_meter_value_df(self, df: pd.DataFrame):
    method _compute_temperature_features (line 139) | def _compute_temperature_features(
    method billing_df (line 285) | def billing_df(self) -> pd.DataFrame | None:
  class BillingBaselineData (line 339) | class BillingBaselineData(_BillingData):
    method _check_data_sufficiency (line 361) | def _check_data_sufficiency(self, sufficiency_df):
  class BillingReportingData (line 393) | class BillingReportingData(_BillingData):
    method __init__ (line 414) | def __init__(
    method from_series (line 427) | def from_series(
    method _check_data_sufficiency (line 466) | def _check_data_sufficiency(self, sufficiency_df):

FILE: opendsm/eemeter/models/billing/model.py
  class BillingModel (line 32) | class BillingModel(DailyModel):
    method __init__ (line 58) | def __init__(self, settings=None, verbose: bool = False,):
    method fit (line 61) | def fit(
    method predict (line 68) | def predict(
    method plot (line 149) | def plot(
    method to_dict (line 169) | def to_dict(self) -> dict:

FILE: opendsm/eemeter/models/billing/plot.py
  function adjust_lightness (line 28) | def adjust_lightness(color, amount=1.0):
  function plot (line 39) | def plot(

FILE: opendsm/eemeter/models/billing/settings.py
  class BillingSettings (line 23) | class BillingSettings(DailyLegacySettings):

FILE: opendsm/eemeter/models/billing/weighted_model.py
  class BillingWeightedModel (line 33) | class BillingWeightedModel(DailyModel):
    method __init__ (line 61) | def __init__(
    method _initialize_settings (line 70) | def _initialize_settings(
    method fit (line 84) | def fit(
    method predict (line 91) | def predict(
    method plot (line 172) | def plot(
    method to_dict (line 192) | def to_dict(self) -> dict:

FILE: opendsm/eemeter/models/daily/base_models/c_hdd_tidd.py
  function fit_c_hdd_tidd (line 37) | def fit_c_hdd_tidd(
  function set_full_model_coeffs_smooth (line 151) | def set_full_model_coeffs_smooth(c_hdd_bp, c_hdd_beta, c_hdd_k, intercept):
  function set_full_model_coeffs (line 178) | def set_full_model_coeffs(c_hdd_bp, c_hdd_beta, intercept):
  function _c_hdd_tidd_update_bnds (line 192) | def _c_hdd_tidd_update_bnds(new_bnds, bnds, smooth):
  function _tdd_coefficients (line 225) | def _tdd_coefficients(
  function _c_hdd_tidd_x0 (line 267) | def _c_hdd_tidd_x0(T, obs, alpha, settings, smooth):
  function _c_hdd_tidd_x0_final (line 307) | def _c_hdd_tidd_x0_final(T, obs, x0, alpha, settings):
  function _c_hdd_tidd_bp0 (line 331) | def _c_hdd_tidd_bp0(T, obs, alpha, settings, min_weight=0.0):
  function _c_hdd_tidd (line 403) | def _c_hdd_tidd(
  function _c_hdd_tidd_smooth (line 410) | def _c_hdd_tidd_smooth(
  function _c_hdd_tidd_weight (line 417) | def _c_hdd_tidd_weight(
  function _c_hdd_tidd_smooth_weight (line 434) | def _c_hdd_tidd_smooth_weight(
  function _c_hdd_tidd_total_sum_of_squares (line 469) | def _c_hdd_tidd_total_sum_of_squares(c_hdd_bp, c_hdd_beta, intercept, T,...

FILE: opendsm/eemeter/models/daily/base_models/full_model.py
  function full_model (line 23) | def full_model(
  function get_full_model_x (line 102) | def get_full_model_x(model_key, x, T_min, T_max, T_min_seg, T_max_seg):
  function fix_full_model_x (line 165) | def fix_full_model_x(x, T_min_seg, T_max_seg):
  function full_model_weight (line 204) | def full_model_weight(

FILE: opendsm/eemeter/models/daily/base_models/hdd_tidd_cdd.py
  function fit_hdd_tidd_cdd (line 37) | def fit_hdd_tidd_cdd(
  function _hdd_tidd_cdd (line 129) | def _hdd_tidd_cdd(
  function _hdd_tidd_cdd_smooth (line 146) | def _hdd_tidd_cdd_smooth(*args):
  function evaluate_hdd_tidd_cdd_smooth (line 150) | def evaluate_hdd_tidd_cdd_smooth(
  function _hdd_tidd_cdd_smooth_x0 (line 170) | def _hdd_tidd_cdd_smooth_x0(T, obs, alpha, settings, smooth, min_weight=...
  function estimate_betas_and_intercept (line 302) | def estimate_betas_and_intercept(T, obs, hdd_bp, cdd_bp, min_T_idx, alpha):
  function _hdd_tidd_cdd_smooth_update_bnds (line 333) | def _hdd_tidd_cdd_smooth_update_bnds(new_bnds, bnds, smooth):
  function _hdd_tidd_cdd_weight (line 365) | def _hdd_tidd_cdd_weight(
  function _hdd_tidd_cdd_smooth_weight (line 386) | def _hdd_tidd_cdd_smooth_weight(
  function _hdd_tidd_cdd_total_sum_of_squares (line 408) | def _hdd_tidd_cdd_total_sum_of_squares(

FILE: opendsm/eemeter/models/daily/base_models/tidd.py
  function fit_tidd (line 30) | def fit_tidd(
  function _tidd_x0 (line 72) | def _tidd_x0(T, obs):
  function set_full_model_coeffs (line 78) | def set_full_model_coeffs(intercept):
  function _tidd (line 84) | def _tidd(intercept, T_fit_bnds=np.array([]), T=np.array([])):
  function _tidd_total_sum_of_squares (line 90) | def _tidd_total_sum_of_squares(intercept, T, obs):
  function _tidd_update_bnds (line 96) | def _tidd_update_bnds(new_bnds, bnds):
  function _tidd_weight (line 105) | def _tidd_weight(

FILE: opendsm/eemeter/models/daily/data.py
  class _DailyData (line 37) | class _DailyData:
    method __init__ (line 50) | def __init__(
    method df (line 85) | def df(self) -> pd.DataFrame | None:
    method from_series (line 94) | def from_series(
    method log_warnings (line 225) | def log_warnings(self) -> None:
    method _compute_meter_value_df (line 236) | def _compute_meter_value_df(self, df: pd.DataFrame):
    method _compute_temperature_features (line 299) | def _compute_temperature_features(
    method _merge_meter_temp (line 434) | def _merge_meter_temp(self, meter, temp):
    method _check_data_sufficiency (line 468) | def _check_data_sufficiency(self, sufficiency_df):
    method _set_data (line 473) | def _set_data(self, data: pd.DataFrame):
  class DailyBaselineData (line 553) | class DailyBaselineData(_DailyData):
    method _check_data_sufficiency (line 573) | def _check_data_sufficiency(self, sufficiency_df):
  class DailyReportingData (line 601) | class DailyReportingData(_DailyData):
    method __init__ (line 622) | def __init__(
    method from_series (line 635) | def from_series(
    method _check_data_sufficiency (line 678) | def _check_data_sufficiency(self, sufficiency_df):

FILE: opendsm/eemeter/models/daily/fit_base_models.py
  function _get_opt_settings (line 27) | def _get_opt_settings(settings):
  function fit_initial_models_from_full_model (line 47) | def fit_initial_models_from_full_model(df_meter, settings, print_res=Fal...
  function fit_model (line 93) | def fit_model(model_key, fit_input, x0: ModelCoefficients, bnds):
  function fit_final_model (line 133) | def fit_final_model(df_meter, HoF: OptimizedResult, settings, print_res=...

FILE: opendsm/eemeter/models/daily/model.py
  class DailyModel (line 52) | class DailyModel:
    method __init__ (line 78) | def __init__(
    method _initialize_settings (line 117) | def _initialize_settings(
    method fit (line 138) | def fit(
    method _fit (line 170) | def _fit(self, meter_data):
    method predict (line 194) | def predict(
    method _predict (line 241) | def _predict(self, df_eval, mask_observed_with_missing_temperature=True):
    method _check_model_fit (line 295) | def _check_model_fit(self):
    method to_dict (line 329) | def to_dict(self) -> dict:
    method to_json (line 337) | def to_json(self) -> str:
    method from_dict (line 346) | def from_dict(cls, data) -> DailyModel:
    method from_json (line 400) | def from_json(cls, str_data: str) -> DailyModel:
    method from_2_0_dict (line 413) | def from_2_0_dict(cls, data) -> DailyModel:
    method from_2_0_json (line 432) | def from_2_0_json(cls, str_data: str) -> DailyModel:
    method plot (line 444) | def plot(
    method _create_params_from_fit_model (line 462) | def _create_params_from_fit_model(self):
    method _initialize_data (line 489) | def _initialize_data(self, meter_data):
    method _combinations (line 545) | def _combinations(self):
    method _meter_segment (line 770) | def _meter_segment(self, component, meter=None):
    method _components (line 797) | def _components(self):
    method _fit_components (line 809) | def _fit_components(self):
    method _combination_selection_criteria (line 844) | def _combination_selection_criteria(self, combination):
    method _best_combination (line 880) | def _best_combination(self, print_out=False):
    method _final_fit (line 907) | def _final_fit(self, combination):
    method _get_error_metrics (line 952) | def _get_error_metrics(self, combination):
    method _predict_submodel (line 999) | def _predict_submodel(self, submodel, T):

FILE: opendsm/eemeter/models/daily/objective_function.py
  function get_idx (line 21) | def get_idx(A, B):
  function no_weights_obj_fcn (line 45) | def no_weights_obj_fcn(X, aux_inputs):
  function model_fcn_dec (line 71) | def model_fcn_dec(model_fcn_full, T_fit_bnds, T):
  function obj_fcn_decorator (line 94) | def obj_fcn_decorator(

FILE: opendsm/eemeter/models/daily/optimize.py
  function obj_fcn_dec (line 81) | def obj_fcn_dec(obj_fcn, x0, bnds):
  class BaseOptimizedResult (line 107) | class BaseOptimizedResult:
  class BaseOptimizer (line 124) | class BaseOptimizer:
    method __init__ (line 125) | def __init__(self, obj_fcn, x0, bnds, settings):
  class SciPyOptimizer (line 147) | class SciPyOptimizer(BaseOptimizer):
    method run (line 148) | def run(self):
  class NLoptOptimizer (line 210) | class NLoptOptimizer(BaseOptimizer):
    method run (line 211) | def run(self):
  class InitialGuessOptimizer (line 314) | class InitialGuessOptimizer:
    method __init__ (line 315) | def __init__(self, obj_fcn, x0, bnds, settings):
    method run (line 332) | def run(self):
  class Optimizer (line 363) | class Optimizer:
    method __init__ (line 378) | def __init__(self, obj_fcn, x0, bnds, coef_id, settings, opt_settings):
    method run (line 399) | def run(self):

FILE: opendsm/eemeter/models/daily/optimize_results.py
  function get_k (line 32) | def get_k(X, T_min_seg, T_max_seg):
  function reduce_model (line 72) | def reduce_model(
  class OptimizedResult (line 189) | class OptimizedResult:
    method __init__ (line 190) | def __init__(
    method _prediction_uncertainty (line 316) | def _prediction_uncertainty(self):  # based on std
    method _set_model_key (line 329) | def _set_model_key(self):
    method _refine_model (line 362) | def _refine_model(self):
    method eval (line 384) | def eval(self, T):

FILE: opendsm/eemeter/models/daily/parameters.py
  class ModelType (line 22) | class ModelType(str, Enum):
  class ModelCoefficients (line 39) | class ModelCoefficients(BaseModel):
    method is_smooth (line 113) | def is_smooth(self):
    method model_key (line 121) | def model_key(self):
    method from_np_arrays (line 135) | def from_np_arrays(cls, coefficients, coefficient_ids):
    method to_np_array (line 267) | def to_np_array(self):
  class DailySubmodelParameters (line 318) | class DailySubmodelParameters(BaseModel):
    method model_type (line 324) | def model_type(self):
  class DailyModelParameters (line 328) | class DailyModelParameters(BaseModel):
    method from_2_0_params (line 334) | def from_2_0_params(cls, data):

FILE: opendsm/eemeter/models/daily/plot.py
  function adjust_lightness (line 32) | def adjust_lightness(color, amount=1.0):
  function plot (line 43) | def plot(

FILE: opendsm/eemeter/models/daily/utilities/base_model.py
  function get_intercept (line 24) | def get_intercept(y, alpha=2):
  function get_slope (line 49) | def get_slope(x, y, x_bp, intercept, alpha=2):
  function linear_fit (line 72) | def linear_fit(x, y, alpha):
  function get_smooth_coeffs (line 89) | def get_smooth_coeffs(hdd_bp, pct_hdd_k, cdd_bp, pct_cdd_k, min_pct_k=0....
  function fix_identical_bnds (line 117) | def fix_identical_bnds(bnds):
  function get_T_bnds (line 126) | def get_T_bnds(T, settings):

FILE: opendsm/eemeter/models/daily/utilities/ellipsoid_test.py
  function ellipsoid_intersection_test (line 20) | def ellipsoid_intersection_test(mu_A, mu_B, cov_A, cov_B):
  function ellipsoid_K_function (line 59) | def ellipsoid_K_function(ss, lambdas, v_squared):
  function confidence_ellipse (line 80) | def confidence_ellipse(x, y, var=np.ones([2, 2]) * 1.96):
  function robust_confidence_ellipse (line 112) | def robust_confidence_ellipse(x, y, var=np.ones([2, 2]) * 1.96, outlier_...
  function ellipsoid_split_filter (line 171) | def ellipsoid_split_filter(meter, n_std=[1.4, 1.4]):

FILE: opendsm/eemeter/models/daily/utilities/opt_settings.py
  class AlgorithmChoice (line 24) | class AlgorithmChoice(str, Enum):
  class StopCriteriaChoice (line 79) | class StopCriteriaChoice(str, Enum):
  class OptimizationSettings (line 84) | class OptimizationSettings(BaseSettings):
    method _check_population_multiplier (line 125) | def _check_population_multiplier(self):

FILE: opendsm/eemeter/models/daily/utilities/selection_criteria.py
  function neg_log_likelihood (line 19) | def neg_log_likelihood(loss, N):
  function selection_criteria (line 44) | def selection_criteria(

FILE: opendsm/eemeter/models/daily/utilities/settings.py
  class AlphaFinalType (line 27) | class AlphaFinalType(str, Enum):
  class ModelSelectionCriteria (line 32) | class ModelSelectionCriteria(str, Enum):
  class FullModelSelection (line 50) | class FullModelSelection(str, Enum):
  class Season_Definition (line 58) | class Season_Definition(BaseSettings):
    method set_numeric_dict (line 76) | def set_numeric_dict(self) -> Season_Definition:
  class Weekday_Weekend_Definition (line 92) | class Weekday_Weekend_Definition(BaseSettings):
    method set_numeric_dict (line 105) | def set_numeric_dict(self) -> Weekday_Weekend_Definition:
  class Split_Selection_Definition (line 121) | class Split_Selection_Definition(BaseSettings):
    method _check_reduce_splits_num_std (line 179) | def _check_reduce_splits_num_std(self):
  function _check_developer_mode (line 190) | def _check_developer_mode(cls):
  class DailySettings (line 201) | class DailySettings(BaseSettings):
    method _check_developer_mode (line 387) | def _check_developer_mode(self):
    method _check_alpha_final (line 400) | def _check_alpha_final(self):
    method _check_final_bounds_scalar (line 420) | def _check_final_bounds_scalar(self):
    method _check_initial_step_percentage (line 436) | def _check_initial_step_percentage(self):
    method __repr__ (line 448) | def __repr__(self):
  class Split_Selection_Legacy_Definition (line 490) | class Split_Selection_Legacy_Definition(Split_Selection_Definition):
  class DailyLegacySettings (line 528) | class DailyLegacySettings(DailySettings):
  function update_daily_settings (line 555) | def update_daily_settings(settings, update_dict):
  function default_settings (line 570) | def default_settings(**kwargs) -> DailySettings:
  function caltrack_legacy_settings (line 577) | def caltrack_legacy_settings(**kwargs) -> DailyLegacySettings:

FILE: opendsm/eemeter/models/hourly/data.py
  class NREL_Weather_API (line 35) | class NREL_Weather_API:
    method __init__ (line 57) | def __init__(self, **kwargs):
    method get_data (line 61) | def get_data(self, lat, lon, years=[2017, 2021]):
    method query_API (line 87) | def query_API(self, lat, lon, years):
    method _generate_url (line 120) | def _generate_url(
  class _HourlyData (line 140) | class _HourlyData:
    method __init__ (line 148) | def __init__(
    method df (line 194) | def df(self):
    method log_warnings (line 201) | def log_warnings(self):
    method _get_contiguous_datetime (line 208) | def _get_contiguous_datetime(self, df):
    method _interpolate (line 231) | def _interpolate(self, df):
    method _add_pv_start_date (line 258) | def _add_pv_start_date(self, df, model_type="TS"):
    method _merge_meter_temp (line 271) | def _merge_meter_temp(self, meter, temp):
    method _check_data_sufficiency (line 277) | def _check_data_sufficiency(self):
    method _set_data (line 282) | def _set_data(self, data: pd.DataFrame):
  class HourlyBaselineData (line 343) | class HourlyBaselineData(_HourlyData):
    method _check_data_sufficiency (line 365) | def _check_data_sufficiency(self):
  class HourlyReportingData (line 380) | class HourlyReportingData(_HourlyData):
    method __init__ (line 403) | def __init__(
    method _check_data_sufficiency (line 417) | def _check_data_sufficiency(self):
  function _create_sufficiency_df (line 432) | def _create_sufficiency_df(df: pd.DataFrame):

FILE: opendsm/eemeter/models/hourly/model.py
  class AdaptiveElasticNetRegressor (line 65) | class AdaptiveElasticNetRegressor:
    method __init__ (line 66) | def __init__(self, base_model, settings):
    method fit (line 75) | def fit(self, X, y, sample_weight=None):
    method is_fit (line 191) | def is_fit(self):
    method predict (line 203) | def predict(self, X):
    method coef_ (line 225) | def coef_(self):
    method coef_ (line 233) | def coef_(self, val):
    method intercept_ (line 237) | def intercept_(self):
    method intercept_ (line 245) | def intercept_(self, val):
  class HourlyModel (line 250) | class HourlyModel:
    method __init__ (line 279) | def __init__(
    method _set_scalers (line 330) | def _set_scalers(self):
    method _set_model (line 340) | def _set_model(self):
    method fit (line 386) | def fit(
    method _fit (line 435) | def _fit(self, meter_data):
    method predict (line 458) | def predict(
    method _predict (line 515) | def _predict(self, eval_data, X=None):
    method _prepare_features (line 554) | def _prepare_features(self, meter_data):
    method _add_temperature_bins (line 599) | def _add_temperature_bins(self, df):
    method _add_categorical_features (line 732) | def _add_categorical_features(self, df):
    method _add_supplemental_features (line 920) | def _add_supplemental_features(self, df):
    method _sort_features (line 936) | def _sort_features(self, ts_features=None, cat_features=None):
    method _daily_fitting_sufficiency (line 959) | def _daily_fitting_sufficiency(self, df):
    method _normalize_features (line 983) | def _normalize_features(self, df):
    method _add_extreme_temperature_bins (line 1010) | def _add_extreme_temperature_bins(self, df, bin_range):
    method _add_temperature_interactions (line 1124) | def _add_temperature_interactions(self, df):
    method _get_feature_matrices (line 1177) | def _get_feature_matrices(self, df, dst_indices):
    method _set_baseline_metrics (line 1234) | def _set_baseline_metrics(self, df_meter):
    method _check_model_fit (line 1273) | def _check_model_fit(self):
    method _calculate_predicted_uncertianty (line 1307) | def _calculate_predicted_uncertianty(self, df_eval):
    method to_dict (line 1350) | def to_dict(self) -> dict:
    method to_json (line 1406) | def to_json(self) -> str:
    method from_dict (line 1415) | def from_dict(cls, data) -> HourlyModel:
    method from_json (line 1490) | def from_json(cls, str_data) -> HourlyModel:
    method plot (line 1502) | def plot(
  function _fit_exp_growth_decay (line 1514) | def _fit_exp_growth_decay(x, y, k_only=True, is_x_sorted=False):
  function _get_dst_indices (line 1568) | def _get_dst_indices(df):
  function _transform_dst (line 1604) | def _transform_dst(prediction, dst_indices):

FILE: opendsm/eemeter/models/hourly/settings.py
  class SelectionChoice (line 37) | class SelectionChoice(str, Enum):
  class ScalingChoice (line 42) | class ScalingChoice(str, Enum):
  class BinningChoice (line 47) | class BinningChoice(str, Enum):
  class DefaultTrainingFeatures (line 54) | class DefaultTrainingFeatures(str, Enum):
  class AggregationMethod (line 59) | class AggregationMethod(str, Enum):
  class BaseModel (line 64) | class BaseModel(str, Enum):
  class TemperatureBinSettings (line 69) | class TemperatureBinSettings(BaseSettings):
    method _check_temperature_bins (line 122) | def _check_temperature_bins(self):
    method _check_edge_bins (line 159) | def _check_edge_bins(self):
  class ElasticNetSettings (line 191) | class ElasticNetSettings(BaseSettings):
  class KernelRidgeSettings (line 245) | class KernelRidgeSettings(BaseSettings):
  class AdaptiveWeightsSettings (line 264) | class AdaptiveWeightsSettings(BaseSettings):
    method _check_adaptive_weights (line 301) | def _check_adaptive_weights(self):
  class Criterion (line 314) | class Criterion(str, Enum):
  class BaseHourlySettings (line 320) | class BaseHourlySettings(BaseSettings):
    method _check_seed (line 419) | def _check_seed(self):
    method _remove_unselected_model_settings (line 431) | def _remove_unselected_model_settings(self):
    method add_default_features (line 443) | def add_default_features(self, incoming_columns: list[str]):
  class HourlySolarSettings (line 452) | class HourlySolarSettings(BaseHourlySettings):
    method _add_required_features (line 460) | def _add_required_features(cls, v):
  class HourlyNonSolarSettings (line 468) | class HourlyNonSolarSettings(BaseHourlySettings):
    method _add_required_features (line 480) | def _add_required_features(cls, v):
  class ModelInfo (line 486) | class ModelInfo(pydantic.BaseModel):
  class SerializeModel (line 495) | class SerializeModel(BaseSettings):

FILE: opendsm/eemeter/models/hourly_caltrack/data.py
  class HourlyReportingData (line 27) | class HourlyReportingData:
    method __init__ (line 28) | def __init__(self, df: pd.DataFrame, is_electricity_data: bool):
    method _correct_frequency (line 41) | def _correct_frequency(self, df: pd.DataFrame):
    method from_series (line 64) | def from_series(
  class HourlyBaselineData (line 84) | class HourlyBaselineData(HourlyReportingData):
    method __init__ (line 85) | def __init__(self, df: pd.DataFrame, is_electricity_data: bool):
    method _check_data_sufficiency (line 95) | def _check_data_sufficiency(self):
    method from_series (line 112) | def from_series(

FILE: opendsm/eemeter/models/hourly_caltrack/derivatives.py
  function _compute_ols_error (line 22) | def _compute_ols_error(
  function _compute_fsu_error (line 47) | def _compute_fsu_error(
  function _compute_error_bands_metered_savings (line 78) | def _compute_error_bands_metered_savings(
  function metered_savings (line 148) | def metered_savings(
  function _compute_error_bands_modeled_savings (line 252) | def _compute_error_bands_modeled_savings(
  function modeled_savings (line 358) | def modeled_savings(

FILE: opendsm/eemeter/models/hourly_caltrack/design_matrices.py
  function create_caltrack_hourly_preliminary_design_matrix (line 38) | def create_caltrack_hourly_preliminary_design_matrix(
  function create_caltrack_billing_design_matrix (line 80) | def create_caltrack_billing_design_matrix(
  function create_caltrack_daily_design_matrix (line 117) | def create_caltrack_daily_design_matrix(
  function create_caltrack_hourly_segmented_design_matrices (line 150) | def create_caltrack_hourly_segmented_design_matrices(

FILE: opendsm/eemeter/models/hourly_caltrack/metrics.py
  function _compute_r_squared (line 24) | def _compute_r_squared(combined):
  function _compute_r_squared_adj (line 28) | def _compute_r_squared_adj(r_squared, length, num_parameters):
  function _compute_rmse (line 32) | def _compute_rmse(combined):
  function _compute_rmse_adj (line 36) | def _compute_rmse_adj(combined, length, num_parameters):
  function _compute_cvrmse (line 45) | def _compute_cvrmse(rmse, observed_mean):
  function _compute_cvrmse_adj (line 49) | def _compute_cvrmse_adj(rmse_adj, observed_mean):
  function _compute_mape (line 53) | def _compute_mape(combined):
  function _compute_nmae (line 57) | def _compute_nmae(combined):
  function _compute_nmbe (line 63) | def _compute_nmbe(combined):
  function _compute_autocorr_resid (line 67) | def _compute_autocorr_resid(combined, autocorr_lags):
  function _json_safe_float (line 71) | def _json_safe_float(number):
  class ModelMetricsFromJson (line 89) | class ModelMetricsFromJson(object):
    method __init__ (line 90) | def __init__(
  class ModelMetrics (line 163) | class ModelMetrics(object):
    method __init__ (line 259) | def __init__(
    method __repr__ (line 409) | def __repr__(self):
    method json (line 424) | def json(self):
    method from_json (line 474) | def from_json(cls, data):

FILE: opendsm/eemeter/models/hourly_caltrack/model.py
  class CalTRACKHourlyModelResults (line 43) | class CalTRACKHourlyModelResults(object):
    method __init__ (line 84) | def __init__(
    method __repr__ (line 105) | def __repr__(self):
    method json (line 110) | def json(self, with_candidates=False):
    method from_json (line 140) | def from_json(cls, data):
    method predict (line 180) | def predict(self, prediction_index, temperature_data, **kwargs):
  class _PredictionSegmentInfo (line 201) | class _PredictionSegmentInfo:
    method __init__ (line 207) | def __init__(self, segment_type: str):
  class CalTRACKHourlyModel (line 235) | class CalTRACKHourlyModel(SegmentedModel):
    method __init__ (line 254) | def __init__(
    method json (line 280) | def json(self):
    method from_json (line 302) | def from_json(cls, data):
  function caltrack_hourly_fit_feature_processor (line 333) | def caltrack_hourly_fit_feature_processor(
  function caltrack_hourly_prediction_feature_processor (line 420) | def caltrack_hourly_prediction_feature_processor(
  function fit_caltrack_hourly_model_segment (line 512) | def fit_caltrack_hourly_model_segment(segment_name, segment_data):
  function fit_caltrack_hourly_model (line 585) | def fit_caltrack_hourly_model(

FILE: opendsm/eemeter/models/hourly_caltrack/segmentation.py
  class CalTRACKSegmentModel (line 32) | class CalTRACKSegmentModel(object):
    method __init__ (line 49) | def __init__(self, segment_name, model, formula, model_params, warning...
    method predict (line 59) | def predict(self, data):
    method json (line 96) | def json(self):
    method from_json (line 112) | def from_json(cls, data):
  class SegmentedModel (line 130) | class SegmentedModel(object):
    method __init__ (line 154) | def __init__(
    method predict (line 180) | def predict(
    method json (line 222) | def json(self):
  function filter_zero_weights_feature_processor (line 244) | def filter_zero_weights_feature_processor(segment_name, segment_data):
  function iterate_segmented_dataset (line 249) | def iterate_segmented_dataset(
  function _get_calendar_year_coverage_warning (line 317) | def _get_calendar_year_coverage_warning(index):
  function _get_hourly_coverage_warning (line 321) | def _get_hourly_coverage_warning(index, min_fraction_daily_coverage=0.9):
  function _segment_weights_single (line 325) | def _segment_weights_single(index):
  function _segment_weights_one_month (line 329) | def _segment_weights_one_month(index):
  function _segment_weights_three_month (line 366) | def _segment_weights_three_month(index):
  function _segment_weights_three_month_weighted (line 403) | def _segment_weights_three_month_weighted(index):
  function segment_time_series (line 442) | def segment_time_series(index, segment_type="single", drop_zero_weight_s...
  function fit_model_segments (line 494) | def fit_model_segments(segmented_dataset_dict, fit_segment):

FILE: opendsm/eemeter/models/hourly_caltrack/usage_per_day.py
  class DataSufficiency (line 26) | class DataSufficiency(object):
    method __init__ (line 47) | def __init__(self, status, criteria_name, warnings=None, data=None, se...
    method __repr__ (line 63) | def __repr__(self):
    method json (line 71) | def json(self):
  function caltrack_sufficiency_criteria (line 86) | def caltrack_sufficiency_criteria(

FILE: opendsm/eemeter/models/hourly_caltrack/wrapper.py
  class IntermediateModelVariables (line 51) | class IntermediateModelVariables:
  class HourlyModel (line 60) | class HourlyModel:
    method __init__ (line 61) | def __init__(self, settings=None):
    method fit (line 65) | def fit(self, data):
    method predict (line 161) | def predict(self, reporting_data):
    method to_dict (line 204) | def to_dict(self):
    method to_json (line 209) | def to_json(self):
    method from_dict (line 213) | def from_dict(cls, data):
    method from_json (line 221) | def from_json(cls, str_data):
    method from_2_0_dict (line 225) | def from_2_0_dict(cls, data):
    method from_2_0_json (line 235) | def from_2_0_json(cls, str_data):
    method plot (line 238) | def plot(

FILE: opendsm/eemeter/samples/load.py
  function _load_sample_metadata (line 26) | def _load_sample_metadata():
  function samples (line 34) | def samples():
  function load_sample (line 46) | def load_sample(sample, tempF=True):

FILE: opendsm/eemeter/utilities/io.py
  function meter_data_from_csv (line 43) | def meter_data_from_csv(
  function temperature_data_from_csv (line 103) | def temperature_data_from_csv(
  function meter_data_from_json (line 160) | def meter_data_from_json(data: list, orient: str = "list") -> pd.DataFrame:
  function temperature_data_from_json (line 234) | def temperature_data_from_json(data: list, orient: str = "list") -> pd.S...
  function meter_data_to_csv (line 266) | def meter_data_to_csv(
  function temperature_data_to_csv (line 282) | def temperature_data_to_csv(

FILE: tests/common/clustering/test_bisect_k_means.py
  function get_default_settings_dict (line 23) | def get_default_settings_dict():
  function simple_2d_data (line 32) | def simple_2d_data():
  function default_settings (line 43) | def default_settings():
  function custom_bisect_settings (line 50) | def custom_bisect_settings():
  class TestBasicFunctionality (line 64) | class TestBasicFunctionality:
    method test_simple_clustering (line 67) | def test_simple_clustering(self, simple_2d_data, default_settings):
    method test_reproducibility (line 80) | def test_reproducibility(self, simple_2d_data, default_settings):
    method test_different_seeds (line 87) | def test_different_seeds(self, simple_2d_data):
  class TestClusterRangeConfiguration (line 104) | class TestClusterRangeConfiguration:
    method test_single_cluster_specification (line 107) | def test_single_cluster_specification(self, simple_2d_data):
    method test_cluster_range (line 120) | def test_cluster_range(self, simple_2d_data, custom_bisect_settings):
    method test_two_clusters (line 128) | def test_two_clusters(self, simple_2d_data):
    method test_many_clusters (line 139) | def test_many_clusters(self, simple_2d_data):
  class TestAlgorithmSettings (line 151) | class TestAlgorithmSettings:
    method test_lloyd_inner_algorithm (line 154) | def test_lloyd_inner_algorithm(self, simple_2d_data):
    method test_elkan_inner_algorithm (line 166) | def test_elkan_inner_algorithm(self, simple_2d_data):
    method test_largest_cluster_strategy (line 178) | def test_largest_cluster_strategy(self, simple_2d_data):
    method test_biggest_inertia_strategy (line 190) | def test_biggest_inertia_strategy(self, simple_2d_data):
    method test_recluster_count (line 202) | def test_recluster_count(self, simple_2d_data):
  class TestDataShapes (line 216) | class TestDataShapes:
    method test_small_dataset (line 219) | def test_small_dataset(self):
    method test_large_dataset (line 234) | def test_large_dataset(self):
    method test_high_dimensional_data (line 249) | def test_high_dimensional_data(self):
    method test_low_dimensional_data (line 264) | def test_low_dimensional_data(self):
  class TestEdgeCases (line 280) | class TestEdgeCases:
    method test_more_clusters_than_samples (line 283) | def test_more_clusters_than_samples(self):
    method test_uniform_data (line 299) | def test_uniform_data(self):
    method test_identical_samples (line 315) | def test_identical_samples(self):
    method test_negative_values (line 330) | def test_negative_values(self):
    method test_mixed_scale_features (line 345) | def test_mixed_scale_features(self):
  class TestClusterQuality (line 366) | class TestClusterQuality:
    method test_well_separated_clusters (line 369) | def test_well_separated_clusters(self):
  class TestBaselineConsistency (line 403) | class TestBaselineConsistency:
    method test_expected_baseline_output (line 406) | def test_expected_baseline_output(self):

FILE: tests/common/clustering/test_cluster.py
  function simple_data (line 39) | def simple_data():
  function simple_dataframe (line 52) | def simple_dataframe():
  function time_series_dataframe (line 61) | def time_series_dataframe():
  function cluster_labels_simple (line 85) | def cluster_labels_simple():
  function cluster_labels_with_outliers (line 92) | def cluster_labels_with_outliers():
  class TestClusterMerge (line 104) | class TestClusterMerge:
    method test_merge_two_similar_clusters (line 107) | def test_merge_two_similar_clusters(self):
    method test_keep_two_distinct_clusters (line 128) | def test_keep_two_distinct_clusters(self):
    method test_merge_with_different_W_values (line 147) | def test_merge_with_different_W_values(self):
    method test_merge_multiple_clusters (line 171) | def test_merge_multiple_clusters(self, simple_data):
  class TestClusterReorder (line 192) | class TestClusterReorder:
    method test_reorder_by_size_ascending (line 195) | def test_reorder_by_size_ascending(self, simple_dataframe, cluster_lab...
    method test_reorder_by_size_descending (line 246) | def test_reorder_by_size_descending(self, simple_dataframe, cluster_la...
    method test_reorder_by_peak (line 286) | def test_reorder_by_peak(self, time_series_dataframe):
    method test_reorder_with_outliers (line 310) | def test_reorder_with_outliers(self, simple_dataframe, cluster_labels_...
    method test_reorder_different_aggregations (line 329) | def test_reorder_different_aggregations(self, time_series_dataframe):
  class TestClusterFeaturesInternal (line 355) | class TestClusterFeaturesInternal:
    method test_bisecting_kmeans_clustering (line 358) | def test_bisecting_kmeans_clustering(self, simple_data):
    method test_spectral_clustering (line 374) | def test_spectral_clustering(self, simple_data):
    method test_adjust_cluster_count_for_small_data (line 389) | def test_adjust_cluster_count_for_small_data(self):
    method test_birch_clustering (line 409) | def test_birch_clustering(self, simple_data):
  class TestClusterFeatures (line 429) | class TestClusterFeatures:
    method test_basic_clustering (line 432) | def test_basic_clustering(self, simple_dataframe):
    method test_clustering_with_sorting (line 453) | def test_clustering_with_sorting(self, time_series_dataframe):
    method test_clustering_bypass_for_many_clusters (line 479) | def test_clustering_bypass_for_many_clusters(self):
    method test_clustering_with_normalization (line 497) | def test_clustering_with_normalization(self, simple_dataframe):
    method test_clustering_different_algorithms (line 522) | def test_clustering_different_algorithms(self, simple_dataframe):
    method test_clustering_with_fpca_transform (line 553) | def test_clustering_with_fpca_transform(self, time_series_dataframe):
    method test_reproducibility_with_seed (line 575) | def test_reproducibility_with_seed(self, simple_dataframe):
    method test_clustering_small_dataset (line 597) | def test_clustering_small_dataset(self):
    method test_clustering_preserves_index_order (line 621) | def test_clustering_preserves_index_order(self, simple_dataframe):
  class TestClusteringIntegration (line 649) | class TestClusteringIntegration:
    method test_full_pipeline_with_all_options (line 652) | def test_full_pipeline_with_all_options(self, time_series_dataframe):
    method test_pipeline_consistency_across_runs (line 690) | def test_pipeline_consistency_across_runs(self, simple_dataframe):
    method test_exact_output_spectral_baseline (line 715) | def test_exact_output_spectral_baseline(self):
    method test_exact_output_bisecting_kmeans_baseline (line 762) | def test_exact_output_bisecting_kmeans_baseline(self):

FILE: tests/common/clustering/test_cluster_transform.py
  function simple_time_series_data (line 43) | def simple_time_series_data():
  function small_dataset (line 71) | def small_dataset():
  function large_dataset (line 78) | def large_dataset():
  function constant_data (line 85) | def constant_data():
  function mixed_scale_data (line 91) | def mixed_scale_data():
  class TestSafeStandardize (line 106) | class TestSafeStandardize:
    method test_basic_standardization_scalar_scale (line 109) | def test_basic_standardization_scalar_scale(self):
    method test_basic_standardization_array_scale (line 120) | def test_basic_standardization_array_scale(self):
    method test_zero_scale_scalar (line 133) | def test_zero_scale_scalar(self):
    method test_zero_scale_array_single_column (line 144) | def test_zero_scale_array_single_column(self):
    method test_zero_scale_array_all_columns (line 160) | def test_zero_scale_array_all_columns(self):
    method test_2d_data_1d_scale_axis_0 (line 173) | def test_2d_data_1d_scale_axis_0(self):
    method test_negative_values (line 186) | def test_negative_values(self):
    method test_all_zeros (line 197) | def test_all_zeros(self):
    method test_custom_threshold (line 208) | def test_custom_threshold(self):
    method test_scalar_scale_zero_ndim (line 222) | def test_scalar_scale_zero_ndim(self):
    method test_mixed_scale_threshold_boundary (line 233) | def test_mixed_scale_threshold_boundary(self):
  class TestNormalize (line 251) | class TestNormalize:
    method test_standardize_axis_0 (line 256) | def test_standardize_axis_0(self, simple_time_series_data):
    method test_standardize_axis_none (line 269) | def test_standardize_axis_none(self, simple_time_series_data):
    method test_standardize_constant_data_axis_0 (line 279) | def test_standardize_constant_data_axis_0(self):
    method test_med_mad_axis_0 (line 291) | def test_med_mad_axis_0(self, simple_time_series_data):
    method test_med_mad_axis_none (line 301) | def test_med_mad_axis_none(self, simple_time_series_data):
    method test_med_mad_robust_to_outliers_axis_0 (line 310) | def test_med_mad_robust_to_outliers_axis_0(self):
    method test_min_max_quantile_axis_1 (line 326) | def test_min_max_quantile_axis_1(self, simple_time_series_data):
    method test_min_max_quantile_axis_0 (line 340) | def test_min_max_quantile_axis_0(self, simple_time_series_data):
    method test_min_max_quantile_different_quantiles (line 390) | def test_min_max_quantile_different_quantiles(self, simple_time_series...
    method test_min_max_quantile_constant_rows (line 403) | def test_min_max_quantile_constant_rows(self):
    method test_normalize_single_column (line 423) | def test_normalize_single_column(self):
    method test_normalize_small_values_axis_0 (line 432) | def test_normalize_small_values_axis_0(self):
  class TestFpcaError (line 446) | class TestFpcaError:
    method test_fpca_error_instantiation (line 449) | def test_fpca_error_instantiation(self):
  class TestFpcaBase (line 456) | class TestFpcaBase:
    method test_fpca_base_valid_input (line 459) | def test_fpca_base_valid_input(self, simple_time_series_data):
    method test_fpca_base_invalid_min_var_ratio_too_low (line 473) | def test_fpca_base_invalid_min_var_ratio_too_low(self, simple_time_ser...
    method test_fpca_base_invalid_min_var_ratio_too_high (line 483) | def test_fpca_base_invalid_min_var_ratio_too_high(self, simple_time_se...
    method test_fpca_base_non_finite_x (line 493) | def test_fpca_base_non_finite_x(self, simple_time_series_data):
    method test_fpca_base_non_finite_y (line 501) | def test_fpca_base_non_finite_y(self, simple_time_series_data):
    method test_fpca_base_empty_x (line 510) | def test_fpca_base_empty_x(self, simple_time_series_data):
    method test_fpca_base_empty_y (line 517) | def test_fpca_base_empty_y(self):
    method test_fpca_base_different_var_ratios (line 525) | def test_fpca_base_different_var_ratios(self, simple_time_series_data):
    method test_fpca_base_small_dataset (line 540) | def test_fpca_base_small_dataset(self, small_dataset):
  class TestFpcaTransform (line 552) | class TestFpcaTransform:
    method test_fpca_transform_basic (line 555) | def test_fpca_transform_basic(self, simple_time_series_data):
    method test_fpca_transform_different_var_ratios (line 573) | def test_fpca_transform_different_var_ratios(self, simple_time_series_...
    method test_fpca_transform_small_dataset (line 592) | def test_fpca_transform_small_dataset(self, small_dataset):
    method test_fpca_transform_propagates_error (line 608) | def test_fpca_transform_propagates_error(self, simple_time_series_data):
    method test_fpca_transform_deterministic (line 624) | def test_fpca_transform_deterministic(self, simple_time_series_data):
  class TestWaveletTransform (line 646) | class TestWaveletTransform:
    method test_wavelet_basic (line 649) | def test_wavelet_basic(self, simple_time_series_data):
    method test_wavelet_without_scale_feature (line 664) | def test_wavelet_without_scale_feature(self, simple_time_series_data):
    method test_wavelet_different_wavelets (line 683) | def test_wavelet_different_wavelets(self, simple_time_series_data):
    method test_wavelet_with_variance_ratio (line 702) | def test_wavelet_with_variance_ratio(self, simple_time_series_data):
    method test_wavelet_with_mle (line 721) | def test_wavelet_with_mle(self, simple_time_series_data):
    method test_wavelet_with_post_normalization (line 739) | def test_wavelet_with_post_normalization(self, simple_time_series_data):
    method test_wavelet_different_n_levels (line 760) | def test_wavelet_different_n_levels(self, simple_time_series_data):
    method test_wavelet_different_modes (line 779) | def test_wavelet_different_modes(self, simple_time_series_data):
    method test_wavelet_small_dataset (line 800) | def test_wavelet_small_dataset(self, small_dataset):
    method test_wavelet_large_dataset (line 817) | def test_wavelet_large_dataset(self, large_dataset):
    method test_wavelet_deterministic_with_seed (line 834) | def test_wavelet_deterministic_with_seed(self, simple_time_series_data):
    method test_wavelet_scale_feature_is_median (line 863) | def test_wavelet_scale_feature_is_median(self, simple_time_series_data):
  class TestTransformFeatures (line 887) | class TestTransformFeatures:
    method test_transform_features_fpca_no_normalization (line 892) | def test_transform_features_fpca_no_normalization(self, simple_time_se...
    method test_transform_features_fpca_with_pre_normalization (line 909) | def test_transform_features_fpca_with_pre_normalization(self, simple_t...
    method test_transform_features_wavelet_no_normalization (line 933) | def test_transform_features_wavelet_no_normalization(self, simple_time...
    method test_transform_features_wavelet_with_pre_normalization (line 951) | def test_transform_features_wavelet_with_pre_normalization(self, simpl...
    method test_transform_features_wavelet_with_post_normalization (line 975) | def test_transform_features_wavelet_with_post_normalization(self, simp...
    method test_transform_features_reduces_dimensionality (line 1001) | def test_transform_features_reduces_dimensionality(self, large_dataset):
    method test_transform_features_reproducible (line 1020) | def test_transform_features_reproducible(self, simple_time_series_data):
  class TestParametrizedTransforms (line 1049) | class TestParametrizedTransforms:
    method test_wavelet_combinations (line 1054) | def test_wavelet_combinations(self, simple_time_series_data, wavelet, ...

FILE: tests/common/clustering/test_spectral.py
  function get_default_settings_dict (line 23) | def get_default_settings_dict():
  function simple_2d_data (line 32) | def simple_2d_data():
  function default_settings (line 43) | def default_settings():
  function custom_spectral_settings (line 50) | def custom_spectral_settings():
  class TestBasicFunctionality (line 63) | class TestBasicFunctionality:
    method test_simple_clustering (line 66) | def test_simple_clustering(self, simple_2d_data, default_settings):
    method test_reproducibility (line 79) | def test_reproducibility(self, simple_2d_data, default_settings):
    method test_different_seeds (line 86) | def test_different_seeds(self, simple_2d_data):
  class TestClusterRangeConfiguration (line 103) | class TestClusterRangeConfiguration:
    method test_single_cluster_specification (line 106) | def test_single_cluster_specification(self, simple_2d_data):
    method test_cluster_range (line 119) | def test_cluster_range(self, simple_2d_data, custom_spectral_settings):
    method test_two_clusters (line 127) | def test_two_clusters(self, simple_2d_data):
    method test_many_clusters (line 138) | def test_many_clusters(self, simple_2d_data):
  class TestAlgorithmSettings (line 150) | class TestAlgorithmSettings:
    method test_arpack_eigen_solver (line 153) | def test_arpack_eigen_solver(self, simple_2d_data):
    method test_lobpcg_eigen_solver (line 165) | def test_lobpcg_eigen_solver(self, simple_2d_data):
    method test_kmeans_assign_labels (line 177) | def test_kmeans_assign_labels(self, simple_2d_data):
    method test_discretize_assign_labels (line 189) | def test_discretize_assign_labels(self, simple_2d_data):
    method test_cluster_qr_assign_labels (line 201) | def test_cluster_qr_assign_labels(self, simple_2d_data):
    method test_rbf_affinity (line 213) | def test_rbf_affinity(self, simple_2d_data):
    method test_nearest_neighbors_affinity (line 225) | def test_nearest_neighbors_affinity(self, simple_2d_data):
    method test_different_gamma_values (line 238) | def test_different_gamma_values(self, simple_2d_data):
    method test_recluster_count (line 252) | def test_recluster_count(self, simple_2d_data):
  class TestAffinityMatrixOptions (line 266) | class TestAffinityMatrixOptions:
    method test_laplacian_affinity (line 269) | def test_laplacian_affinity(self, simple_2d_data):
    method test_chi2_affinity (line 281) | def test_chi2_affinity(self, simple_2d_data):
  class TestDataShapes (line 297) | class TestDataShapes:
    method test_small_dataset (line 300) | def test_small_dataset(self):
    method test_large_dataset (line 315) | def test_large_dataset(self):
    method test_high_dimensional_data (line 330) | def test_high_dimensional_data(self):
    method test_low_dimensional_data (line 345) | def test_low_dimensional_data(self):
  class TestEdgeCases (line 361) | class TestEdgeCases:
    method test_uniform_data (line 364) | def test_uniform_data(self):
    method test_identical_samples (line 380) | def test_identical_samples(self):
    method test_negative_values (line 395) | def test_negative_values(self):
    method test_mixed_scale_features (line 410) | def test_mixed_scale_features(self):
    method test_sparse_data (line 430) | def test_sparse_data(self):
  class TestClusterQuality (line 449) | class TestClusterQuality:
    method test_well_separated_clusters (line 452) | def test_well_separated_clusters(self):
  class TestComponentSettings (line 485) | class TestComponentSettings:
    method test_custom_n_components (line 488) | def test_custom_n_components(self, simple_2d_data):
    method test_none_n_components (line 500) | def test_none_n_components(self, simple_2d_data):
  class TestBaselineConsistency (line 514) | class TestBaselineConsistency:
    method test_expected_baseline_output (line 517) | def test_expected_baseline_output(self):

FILE: tests/common/clustering/test_voting.py
  class TestShulzePairwisePreference (line 29) | class TestShulzePairwisePreference:
    method test_basic_pairwise (line 32) | def test_basic_pairwise(self):
    method test_pairwise_with_weights (line 50) | def test_pairwise_with_weights(self):
    method test_pairwise_tie (line 63) | def test_pairwise_tie(self):
  class TestShulzePathStrength (line 75) | class TestShulzePathStrength:
    method test_path_strength_preserves_shape (line 78) | def test_path_strength_preserves_shape(self):
    method test_path_strength_basic (line 89) | def test_path_strength_basic(self):
  class TestShulzeRankStrength (line 124) | class TestShulzeRankStrength:
    method test_rank_strength_basic (line 127) | def test_rank_strength_basic(self):
    method test_rank_strength_all_lose (line 148) | def test_rank_strength_all_lose(self):
  class TestConstructVotingDF (line 166) | class TestConstructVotingDF:
    method test_construct_basic (line 169) | def test_construct_basic(self):
    method test_construct_with_nan (line 188) | def test_construct_with_nan(self):
    method test_construct_with_inf (line 205) | def test_construct_with_inf(self):
  class TestShulzeVoting (line 222) | class TestShulzeVoting:
    method test_simple_majority (line 225) | def test_simple_majority(self):
    method test_condorcet_winner (line 238) | def test_condorcet_winner(self):
    method test_unanimous_vote (line 250) | def test_unanimous_vote(self):
    method test_weighted_voting (line 263) | def test_weighted_voting(self):
    method test_tie_breaking (line 276) | def test_tie_breaking(self):
    method test_single_candidate (line 290) | def test_single_candidate(self):
    method test_two_candidates (line 301) | def test_two_candidates(self):
    method test_two_strong_candidates (line 313) | def test_two_strong_candidates(self):
    method test_return_preference_df (line 327) | def test_return_preference_df(self):
    method test_window_smoothing (line 344) | def test_window_smoothing(self):
    method test_empty_voter_weights (line 365) | def test_empty_voter_weights(self):
    method test_weight_normalization (line 379) | def test_weight_normalization(self):
    method test_large_number_of_candidates (line 395) | def test_large_number_of_candidates(self):
  class TestShulzeVotingEdgeCases (line 409) | class TestShulzeVotingEdgeCases:
    method test_single_voter (line 412) | def test_single_voter(self):
    method test_zero_weights (line 422) | def test_zero_weights(self):
    method test_negative_window_size (line 436) | def test_negative_window_size(self):
    method test_missing_voter_weights (line 447) | def test_missing_voter_weights(self):
    method test_extreme_weight_differences (line 463) | def test_extreme_weight_differences(self):
    method test_cyclic_preferences (line 478) | def test_cyclic_preferences(self):
    method test_large_window_size (line 492) | def test_large_window_size(self):
    method test_weighted_voting_normalization (line 506) | def test_weighted_voting_normalization(self):
    method test_very_large_number_of_candidates (line 523) | def test_very_large_number_of_candidates(self):
    method test_empty_dataframe_no_rows_no_cols (line 537) | def test_empty_dataframe_no_rows_no_cols(self):
    method test_empty_dataframe_no_rows (line 544) | def test_empty_dataframe_no_rows(self):
    method test_empty_dataframe_no_columns (line 551) | def test_empty_dataframe_no_columns(self):

FILE: tests/common/metrics.py
  function test_acf (line 21) | def test_acf():

FILE: tests/common/test_basic_stats.py
  function test_t_stat (line 26) | def test_t_stat():
  function test_unc_factor (line 60) | def test_unc_factor():
  function test_median_absolute_deviation (line 94) | def test_median_absolute_deviation():
  function test_fast_std (line 120) | def test_fast_std():

FILE: tests/common/test_utils.py
  function test_np_clip (line 25) | def test_np_clip():
  function test_OoM (line 67) | def test_OoM():
  function test_RoundToSigFigs (line 108) | def test_RoundToSigFigs():

FILE: tests/comparison_groups/conftest.py
  function col_name (line 21) | def col_name():
  function df_treatment (line 26) | def df_treatment(col_name):
  function df_pool (line 41) | def df_pool(col_name):
  function df_equiv (line 52) | def df_equiv(df_treatment, df_pool):
  function equivalence_feature_matrix (line 79) | def equivalence_feature_matrix(df_equiv):
  function equivalence_feature_ids (line 85) | def equivalence_feature_ids(df_equiv):

FILE: tests/comparison_groups/imm/test_distance_calc_selection.py
  function generate_group (line 23) | def generate_group(n_entries, make_random=True, non_random_value=5, id_p...
  function test_distance_match (line 37) | def test_distance_match():
  function test_distance_match_duplicates_allowed (line 74) | def test_distance_match_duplicates_allowed():
  function test_distance_match_duplicates_forbidden (line 100) | def test_distance_match_duplicates_forbidden():
  function test_distance_match_large_treatments (line 129) | def test_distance_match_large_treatments():
  function test_distance_duplicate_best_match (line 157) | def test_distance_duplicate_best_match():
  function test_multiple_meter_matches (line 189) | def test_multiple_meter_matches():

FILE: tests/comparison_groups/stratified_sampling/test_bin.py
  function test_bin_filtering (line 21) | def test_bin_filtering():
  function test_binned_data_bin_label_label_leading_zeroes (line 31) | def test_binned_data_bin_label_label_leading_zeroes():

FILE: tests/comparison_groups/stratified_sampling/test_bin_selection.py
  function test_stratified_sampling_fit_and_sample_records_equivalence (line 23) | def test_stratified_sampling_fit_and_sample_records_equivalence(
  function test_stratified_sampling_fit_and_sample_records_equivalence_too_many_bins (line 47) | def test_stratified_sampling_fit_and_sample_records_equivalence_too_many...
  function test_stratified_sampling_fit_and_sample_records_equivalence_idempotent_check (line 69) | def test_stratified_sampling_fit_and_sample_records_equivalence_idempote...
  function test_stratified_sampling_fit_and_sample_records_equivalence_euclidean_idempotent_check (line 113) | def test_stratified_sampling_fit_and_sample_records_equivalence_euclidea...
  function test_stratified_sampling_fit_and_sample_records_equivalence_euclidean_idempotent_check (line 158) | def test_stratified_sampling_fit_and_sample_records_equivalence_euclidea...
  function test_plot_records_based_equiv_average (line 202) | def test_plot_records_based_equiv_average(
  function test_plot_records_based_equiv_average_chisquare (line 230) | def test_plot_records_based_equiv_average_chisquare(

FILE: tests/comparison_groups/stratified_sampling/test_diagnostics.py
  function diagnostics_obj (line 23) | def diagnostics_obj(df_treatment, df_pool, col_name):
  function test_equivalence (line 32) | def test_equivalence(diagnostics_obj):

FILE: tests/comparison_groups/stratified_sampling/test_equivalence.py
  function equiv_X (line 25) | def equiv_X():
  function equiv_Y (line 34) | def equiv_Y():
  function feature_matrix (line 44) | def feature_matrix(equiv_X, equiv_Y):
  function test_reshape_outputs (line 51) | def test_reshape_outputs():
  function test_equivalene_distance (line 62) | def test_equivalene_distance(feature_matrix):
  function test_get_quantiles (line 78) | def test_get_quantiles():
  function test_quantile_means_array (line 86) | def test_quantile_means_array(equiv_X, equiv_Y):
  function test_quantile_distance (line 102) | def test_quantile_distance(equiv_X, equiv_Y):
  function test_equivalence_inputs (line 108) | def test_equivalence_inputs(feature_matrix):
  function test_index_to_ids (line 122) | def test_index_to_ids():

FILE: tests/comparison_groups/stratified_sampling/test_model.py
  function test_stratified_sampling_fit_and_sample (line 24) | def test_stratified_sampling_fit_and_sample():
  function test_stratified_sampling_fit_and_sample_random_seed_check (line 69) | def test_stratified_sampling_fit_and_sample_random_seed_check():
  function stratified_sampling_obj (line 129) | def stratified_sampling_obj():
  function test_stratified_sampling_fit_and_sample_min_allowed_max_allowed (line 133) | def test_stratified_sampling_fit_and_sample_min_allowed_max_allowed(
  function test_stratified_sampling_fit_and_sample_n_samples_approx_limit (line 161) | def test_stratified_sampling_fit_and_sample_n_samples_approx_limit(
  function test_stratified_sampling_fit_and_sample_n_samples_approx_limit (line 177) | def test_stratified_sampling_fit_and_sample_n_samples_approx_limit(
  function test_stratified_sampling_fit_and_sample_n_samples_approx_variations (line 212) | def test_stratified_sampling_fit_and_sample_n_samples_approx_variations(
  function test_stratified_sampling_fit_and_sample_too_many_bins (line 254) | def test_stratified_sampling_fit_and_sample_too_many_bins(df_treatment, ...
  function test_stratified_sampling_fit_and_sample_dont_require_equivalence (line 268) | def test_stratified_sampling_fit_and_sample_dont_require_equivalence(
  function test_stratified_sampling_fit_and_sample_upper_limit_n_samples_approx (line 286) | def test_stratified_sampling_fit_and_sample_upper_limit_n_samples_approx(

FILE: tests/conftest.py
  function sample_metadata (line 24) | def sample_metadata():
  function _from_sample (line 32) | def _from_sample(sample, tempF=True):
  function il_electricity_cdd_hdd_hourly (line 43) | def il_electricity_cdd_hdd_hourly():
  function il_electricity_cdd_hdd_daily (line 48) | def il_electricity_cdd_hdd_daily():
  function il_electricity_cdd_hdd_billing_monthly (line 53) | def il_electricity_cdd_hdd_billing_monthly():
  function il_electricity_cdd_hdd_billing_bimonthly (line 58) | def il_electricity_cdd_hdd_billing_bimonthly():
  function il_gas_hdd_only_hourly (line 63) | def il_gas_hdd_only_hourly():
  function uk_electricity_hdd_only_hourly_sample_1 (line 68) | def uk_electricity_hdd_only_hourly_sample_1():
  function uk_electricity_hdd_only_hourly_sample_2 (line 73) | def uk_electricity_hdd_only_hourly_sample_2():

FILE: tests/eemeter/daily_model/base_models/test_c_hdd_tidd_smooth.py
  function test_fit_c_hdd_tidd_smooth (line 22) | def test_fit_c_hdd_tidd_smooth():

FILE: tests/eemeter/daily_model/base_models/test_full_model_finder.py
  function test_full_model_import (line 18) | def test_full_model_import():

FILE: tests/eemeter/daily_model/test_billing_data.py
  function get_datetime_index (line 30) | def get_datetime_index(request):
  function get_datetime_index_half_hourly_with_timezone (line 47) | def get_datetime_index_half_hourly_with_timezone():
  function get_datetime_index_hourly_with_timezone (line 61) | def get_datetime_index_hourly_with_timezone():
  function get_datetime_index_daily_with_timezone (line 75) | def get_datetime_index_daily_with_timezone():
  function get_datetime_index_monthly_with_timezone (line 89) | def get_datetime_index_monthly_with_timezone():
  function get_datetime_index_bimonthly_with_timezone (line 103) | def get_datetime_index_bimonthly_with_timezone():
  function get_datetime_index_daily_without_timezone (line 117) | def get_datetime_index_daily_without_timezone():
  function get_temperature_data_half_hourly (line 127) | def get_temperature_data_half_hourly(get_datetime_index_half_hourly_with...
  function get_temperature_data_hourly (line 141) | def get_temperature_data_hourly(get_datetime_index_hourly_with_timezone):
  function get_temperature_data_daily (line 155) | def get_temperature_data_daily(get_datetime_index_daily_with_timezone):
  function get_meter_data_daily (line 169) | def get_meter_data_daily(get_datetime_index_daily_with_timezone):
  function get_meter_data_monthly (line 183) | def get_meter_data_monthly(get_datetime_index_monthly_with_timezone):
  function get_meter_data_bimonthly (line 198) | def get_meter_data_bimonthly(get_datetime_index_bimonthly_with_timezone):
  function test_billing_baseline_data_with_missing_timezone (line 214) | def test_billing_baseline_data_with_missing_timezone(get_datetime_index):
  function test_billing_baseline_data_with_missing_datetime_index_and_column (line 235) | def test_billing_baseline_data_with_missing_datetime_index_and_column():
  function test_billing_baseline_data_with_monthly_frequencies (line 251) | def test_billing_baseline_data_with_monthly_frequencies(get_datetime_ind...
  function test_billing_baseline_data_with_bimonthly_frequencies (line 288) | def test_billing_baseline_data_with_bimonthly_frequencies(get_datetime_i...
  function test_billing_baseline_data_with_monthly_hourly_frequencies (line 327) | def test_billing_baseline_data_with_monthly_hourly_frequencies(
  function test_billing_baseline_data_with_bimonthly_hourly_frequencies (line 349) | def test_billing_baseline_data_with_bimonthly_hourly_frequencies(
  function test_billing_baseline_data_with_monthly_daily_frequencies (line 370) | def test_billing_baseline_data_with_monthly_daily_frequencies(
  function test_billing_baseline_data_with_bimonthly_daily_frequencies (line 396) | def test_billing_baseline_data_with_bimonthly_daily_frequencies(
  function test_billing_baseline_data_with_specific_hourly_input (line 423) | def test_billing_baseline_data_with_specific_hourly_input():
  function test_billing_baseline_data_with_specific_daily_input (line 454) | def test_billing_baseline_data_with_specific_daily_input():
  function test_billing_baseline_data_with_specific_missing_daily_input (line 484) | def test_billing_baseline_data_with_specific_missing_daily_input():
  function test_billing_baseline_data_with_specific_monthly_input (line 517) | def test_billing_baseline_data_with_specific_monthly_input():
  function test_billing_reporting_data_with_missing_half_hourly_frequencies (line 543) | def test_billing_reporting_data_with_missing_half_hourly_frequencies(
  function test_billing_reporting_data_with_missing_daily_frequencies (line 591) | def test_billing_reporting_data_with_missing_daily_frequencies(get_datet...
  function test_dst_handling (line 631) | def test_dst_handling():

FILE: tests/eemeter/daily_model/test_daily_data.py
  function get_datetime_index (line 30) | def get_datetime_index(request):
  function get_datetime_index_half_hourly_with_timezone (line 46) | def get_datetime_index_half_hourly_with_timezone():
  function get_datetime_index_hourly_with_timezone (line 60) | def get_datetime_index_hourly_with_timezone():
  function get_datetime_index_daily_with_timezone (line 74) | def get_datetime_index_daily_with_timezone():
  function get_datetime_index_daily_without_timezone (line 88) | def get_datetime_index_daily_without_timezone():
  function get_temperature_data_half_hourly (line 98) | def get_temperature_data_half_hourly(get_datetime_index_half_hourly_with...
  function get_temperature_data_hourly (line 112) | def get_temperature_data_hourly(get_datetime_index_hourly_with_timezone):
  function get_meter_data_daily (line 126) | def get_meter_data_daily(get_datetime_index_daily_with_timezone):
  function get_meter_data_daily_with_extreme_values_and_negative_values (line 140) | def get_meter_data_daily_with_extreme_values_and_negative_values(
  function get_temperature_data_daily (line 172) | def get_temperature_data_daily(get_datetime_index_daily_with_timezone):
  function test_daily_baseline_data_with_missing_timezone (line 187) | def test_daily_baseline_data_with_missing_timezone(get_datetime_index):
  function test_daily_baseline_data_with_missing_datetime_index_and_column (line 208) | def test_daily_baseline_data_with_missing_datetime_index_and_column():
  function test_daily_baseline_data_with_datetime_column (line 224) | def test_daily_baseline_data_with_datetime_column(get_datetime_index):
  function test_daily_baseline_data_with_same_daily_frequencies (line 246) | def test_daily_baseline_data_with_same_daily_frequencies(get_datetime_in...
  function test_daily_baseline_data_with_same_hourly_frequencies (line 278) | def test_daily_baseline_data_with_same_hourly_frequencies(get_datetime_i...
  function test_daily_baseline_data_with_daily_and_half_hourly_frequencies (line 304) | def test_daily_baseline_data_with_daily_and_half_hourly_frequencies(
  function test_daily_baseline_data_with_daily_and_hourly_frequencies (line 325) | def test_daily_baseline_data_with_daily_and_hourly_frequencies(
  function test_daily_baseline_data_with_extreme_values_in_daily_and_hourly_frequencies (line 345) | def test_daily_baseline_data_with_extreme_values_in_daily_and_hourly_fre...
  function test_daily_baseline_data_with_extreme_and_negative_values_in_daily_and_hourly_frequencies (line 370) | def test_daily_baseline_data_with_extreme_and_negative_values_in_daily_a...
  function test_daily_baseline_data_with_specific_hourly_input (line 399) | def test_daily_baseline_data_with_specific_hourly_input():
  function test_daily_baseline_data_with_specific_daily_input (line 417) | def test_daily_baseline_data_with_specific_daily_input():
  function test_daily_baseline_data_with_missing_specific_daily_input (line 434) | def test_daily_baseline_data_with_missing_specific_daily_input():
  function test_daily_baseline_data_with_missing_hourly_temperature_data (line 453) | def test_daily_baseline_data_with_missing_hourly_temperature_data(
  function test_daily_baseline_data_with_missing_half_hourly_temperature_data (line 492) | def test_daily_baseline_data_with_missing_half_hourly_temperature_data(
  function test_daily_baseline_data_with_missing_daily_temperature_data (line 532) | def test_daily_baseline_data_with_missing_daily_temperature_data(
  function test_daily_baseline_data_with_missing_meter_data (line 569) | def test_daily_baseline_data_with_missing_meter_data(
  function test_daily_baseline_data_with_missing_meter_data_37_days (line 601) | def test_daily_baseline_data_with_missing_meter_data_37_days(
  function test_duplicate_datetime_index_values (line 633) | def test_duplicate_datetime_index_values():
  function test_daily_reporting_data_with_half_hourly_and_hourly_frequencies (line 658) | def test_daily_reporting_data_with_half_hourly_and_hourly_frequencies(
  function test_daily_reporting_data_with_missing_half_hourly_and_hourly_frequencies (line 681) | def test_daily_reporting_data_with_missing_half_hourly_and_hourly_freque...
  function test_daily_reporting_data_high_frequency_temperature_warning_gives_proper_results (line 726) | def test_daily_reporting_data_high_frequency_temperature_warning_gives_p...
  function test_daily_reporting_data_with_missing_daily_frequencies (line 753) | def test_daily_reporting_data_with_missing_daily_frequencies(get_datetim...
  function baseline_data_daily_params (line 792) | def baseline_data_daily_params(il_electricity_cdd_hdd_daily):
  function test_offset_temperature_aggregations (line 812) | def test_offset_temperature_aggregations(baseline_data_daily_params, tz,...
  function test_non_ns_datetime_index (line 828) | def test_non_ns_datetime_index():
  function test_offset_aggregations_hourly (line 842) | def test_offset_aggregations_hourly(il_electricity_cdd_hdd_hourly):
  function test_dst_handling (line 857) | def test_dst_handling():

FILE: tests/eemeter/daily_model/test_daily_model.py
  function daily_series (line 28) | def daily_series():
  function bad_daily_series (line 43) | def bad_daily_series(daily_series):
  function missing_daily_data (line 50) | def missing_daily_data(bad_daily_series) -> DailyBaselineData:
  function bad_daily_data (line 58) | def bad_daily_data(bad_daily_series) -> DailyBaselineData:
  function test_disqualified_data_error (line 64) | def test_disqualified_data_error(missing_daily_data):
  function test_model_cvrmse_error (line 73) | def test_model_cvrmse_error(bad_daily_data):
  function test_timezone_behavior (line 80) | def test_timezone_behavior(daily_series):
  function test_predict_df_matches_input_index (line 117) | def test_predict_df_matches_input_index(daily_series):

FILE: tests/eemeter/daily_model/test_fit_base_models.py
  function meter_data (line 32) | def meter_data():
  function get_settings (line 106) | def get_settings():
  function get_optimized_result (line 111) | def get_optimized_result(get_settings):
  function test_fit_initial_models_from_full_model (line 144) | def test_fit_initial_models_from_full_model(meter_data, get_settings):
  function test_fit_model (line 162) | def test_fit_model(meter_data, get_settings):
  function test_fit_final_model (line 201) | def test_fit_final_model(meter_data, get_settings, get_optimized_result):

FILE: tests/eemeter/daily_model/test_fit_model.py
  class TestFitModel (line 28) | class TestFitModel:
    method setup_class (line 30) | def setup_class(cls):
    method test_fit_model (line 37) | def test_fit_model(self):

FILE: tests/eemeter/daily_model/test_objective_function.py
  function test_get_idx (line 31) | def test_get_idx():
  function test_no_weights_obj_fcn (line 58) | def test_no_weights_obj_fcn():
  function obj_fcn_test (line 94) | def obj_fcn_test(self):
  function test_obj_fcn_decorator (line 115) | def test_obj_fcn_decorator():

FILE: tests/eemeter/daily_model/test_optimize.py
  function test_obj_fcn_dec (line 29) | def test_obj_fcn_dec():
  function get_obj_fcn (line 44) | def get_obj_fcn(settings):
  function get_x0 (line 78) | def get_x0():
  function get_bnds (line 83) | def get_bnds():
  function test_optimizer_run (line 97) | def test_optimizer_run(get_x0, get_bnds):

FILE: tests/eemeter/daily_model/test_optimize_results.py
  function test_get_k (line 27) | def test_get_k():
  function test_reduce_model (line 143) | def test_reduce_model(
  class TestOptimizeResult (line 178) | class TestOptimizeResult:
    method optimize_result (line 180) | def optimize_result(self):
    method test_named_coeffs (line 227) | def test_named_coeffs(self, optimize_result):
    method test_prediction_uncertainty (line 231) | def test_prediction_uncertainty(self, optimize_result):
    method test_set_model_key (line 236) | def test_set_model_key(self, optimize_result):
    method test_refine_model (line 242) | def test_refine_model(self, optimize_result):
    method test_eval (line 248) | def test_eval(self, optimize_result):

FILE: tests/eemeter/daily_model/utilities/test_adaptive_loss.py
  function test_remove_outliers (line 23) | def test_remove_outliers():
  function test_adaptive_loss_fcn (line 44) | def test_adaptive_loss_fcn():
  function test_adaptive_weights (line 70) | def test_adaptive_weights():

FILE: tests/eemeter/daily_model/utilities/test_base_model.py
  function get_settings (line 30) | def get_settings():
  function test_get_intercept (line 35) | def test_get_intercept():
  function test_get_slope (line 61) | def test_get_slope():
  function test_linear_fit (line 107) | def test_linear_fit():
  function test_get_smooth_coeffs (line 137) | def test_get_smooth_coeffs():
  function test_fix_identical_bnds (line 165) | def test_fix_identical_bnds():

FILE: tests/eemeter/daily_model/utilities/test_config.py
  function test_default_settings (line 21) | def test_default_settings():
  function test_custom_settings (line 40) | def test_custom_settings():
  function test_invalid_settings (line 79) | def test_invalid_settings():

FILE: tests/eemeter/daily_model/utilities/test_ellipsoid_test.py
  function test_ellipsoid_intersection_test (line 25) | def test_ellipsoid_intersection_test():
  function test_ellipsoid_K_function (line 48) | def test_ellipsoid_K_function():
  function test_robust_confidence_ellipse (line 68) | def test_robust_confidence_ellipse():
  function test_ellipsoid_split_filter (line 92) | def test_ellipsoid_split_filter():

FILE: tests/eemeter/daily_model/utilities/test_selection_criteria.py
  function test_neg_log_likelihood (line 21) | def test_neg_log_likelihood():
  function test_selection_criteria (line 60) | def test_selection_criteria():

FILE: tests/eemeter/hourly_model/conftest.py
  function hourly_data (line 23) | def hourly_data():
  function baseline (line 29) | def baseline(hourly_data):
  function reporting (line 38) | def reporting(hourly_data):

FILE: tests/eemeter/hourly_model/test_hourly_model.py
  function test_good_data (line 34) | def test_good_data(baseline, reporting):
  function test_misaligned_data (line 48) | def test_misaligned_data(baseline, reporting):
  function test_tz_naive (line 56) | def test_tz_naive(baseline):
  function test_tz_mismatch (line 62) | def test_tz_mismatch(baseline):
  function test_predict_missing_fit_features (line 74) | def test_predict_missing_fit_features(baseline, reporting):
  function test_nonsolar_predict_with_ghi (line 83) | def test_nonsolar_predict_with_ghi(baseline, reporting, caplog):
  function test_forced_solar_model_fit_no_ghi (line 93) | def test_forced_solar_model_fit_no_ghi(baseline):
  function test_forced_nonsolar_model_fit_with_ghi (line 100) | def test_forced_nonsolar_model_fit_with_ghi(baseline):
  function test_no_data (line 108) | def test_no_data(baseline):
  function test_negative_meter_values (line 115) | def test_negative_meter_values(baseline):
  function test_invalid_baseline_lengths (line 128) | def test_invalid_baseline_lengths(baseline):
  function test_low_freq_temp (line 148) | def test_low_freq_temp(baseline):
  function test_low_freq_meter (line 159) | def test_low_freq_meter(baseline):
  function test_monthly_percentage (line 170) | def test_monthly_percentage(baseline):
  function test_monthly_ghi_percentage (line 221) | def test_monthly_ghi_percentage(baseline):
  function test_hourly_fit_daily_threshold (line 242) | def test_hourly_fit_daily_threshold(baseline):
  function test_hourly_error_metric_dq (line 262) | def test_hourly_error_metric_dq(baseline):
  function assert_dq (line 271) | def assert_dq(data, expected_disqualifications):
  function test_hourly_dict_settings (line 279) | def test_hourly_dict_settings():

FILE: tests/test_caltrack_design_matrices.py
  function test_create_caltrack_hourly_preliminary_design_matrix (line 30) | def test_create_caltrack_hourly_preliminary_design_matrix(
  function test_create_caltrack_daily_design_matrix (line 53) | def test_create_caltrack_daily_design_matrix(il_electricity_cdd_hdd_daily):
  function test_create_caltrack_billing_design_matrix (line 71) | def test_create_caltrack_billing_design_matrix(il_electricity_cdd_hdd_bi...
  function preliminary_hourly_design_matrix (line 90) | def preliminary_hourly_design_matrix(il_electricity_cdd_hdd_hourly):
  function segmentation (line 99) | def segmentation(preliminary_hourly_design_matrix):
  function occupancy_lookup (line 106) | def occupancy_lookup(preliminary_hourly_design_matrix, segmentation):
  function temperature_bins (line 113) | def temperature_bins(preliminary_hourly_design_matrix, segmentation, occ...
  function test_create_caltrack_hourly_segmented_design_matrices (line 121) | def test_create_caltrack_hourly_segmented_design_matrices(
  function test_create_caltrack_billing_design_matrix_empty_temp (line 161) | def test_create_caltrack_billing_design_matrix_empty_temp(
  function test_create_caltrack_billing_design_matrix_partial_empty_temp (line 172) | def test_create_caltrack_billing_design_matrix_partial_empty_temp(

FILE: tests/test_caltrack_hourly.py
  function segmented_data (line 32) | def segmented_data():
  function occupancy_lookup (line 48) | def occupancy_lookup():
  function occupied_temperature_bins (line 57) | def occupied_temperature_bins():
  function unoccupied_temperature_bins (line 63) | def unoccupied_temperature_bins():
  function test_caltrack_hourly_fit_feature_processor (line 68) | def test_caltrack_hourly_fit_feature_processor(
  function test_caltrack_hourly_prediction_feature_processor (line 98) | def test_caltrack_hourly_prediction_feature_processor(
  function segmented_design_matrices (line 128) | def segmented_design_matrices(
  function test_fit_caltrack_hourly_model_segment (line 145) | def test_fit_caltrack_hourly_model_segment(segmented_design_matrices):
  function temps (line 163) | def temps():
  function test_fit_caltrack_hourly_model (line 170) | def test_fit_caltrack_hourly_model(
  function test_serialize_caltrack_hourly_model (line 192) | def test_serialize_caltrack_hourly_model(
  function segmented_data_nans (line 211) | def segmented_data_nans():
  function occupancy_lookup_nans (line 228) | def occupancy_lookup_nans():
  function temperature_bins_nans (line 242) | def temperature_bins_nans():
  function segmented_design_matrices_nans (line 255) | def segmented_design_matrices_nans(
  function test_fit_caltrack_hourly_model_nans_less_than_week_predict (line 277) | def test_fit_caltrack_hourly_model_nans_less_than_week_predict(
  function segmented_data_nans_less_than_week (line 303) | def segmented_data_nans_less_than_week():
  function occupancy_lookup_nans_less_than_week (line 320) | def occupancy_lookup_nans_less_than_week():
  function temperature_bins_nans_less_than_week (line 334) | def temperature_bins_nans_less_than_week():
  function segmented_design_matrices_nans_less_than_week (line 347) | def segmented_design_matrices_nans_less_than_week(
  function temps_extended (line 371) | def temps_extended():
  function test_fit_caltrack_hourly_model_nans_less_than_week_fit (line 378) | def test_fit_caltrack_hourly_model_nans_less_than_week_fit(
  function segmented_design_matrices_empty_models (line 402) | def segmented_design_matrices_empty_models(
  function test_predict_caltrack_hourly_model_empty_models (line 420) | def test_predict_caltrack_hourly_model_empty_models(
  function occupancy_lookup_zeroes (line 443) | def occupancy_lookup_zeroes():
  function segmented_design_matrices_single_mode (line 452) | def segmented_design_matrices_single_mode(
  function test_fit_caltrack_hourly_model_segment_single_mode (line 469) | def test_fit_caltrack_hourly_model_segment_single_mode(

FILE: tests/test_derivatives.py
  function baseline_data_daily (line 45) | def baseline_data_daily(il_electricity_cdd_hdd_daily):
  function baseline_model_daily (line 60) | def baseline_model_daily(baseline_data_daily):
  function reporting_data_daily (line 66) | def reporting_data_daily(il_electricity_cdd_hdd_daily):
  function reporting_model_daily (line 80) | def reporting_model_daily(reporting_data_daily):
  function reporting_meter_data_daily (line 86) | def reporting_meter_data_daily():
  function reporting_temperature_data (line 92) | def reporting_temperature_data():
  function test_metered_savings_cdd_hdd_daily (line 97) | def test_metered_savings_cdd_hdd_daily(
  function baseline_model_billing (line 111) | def baseline_model_billing(il_electricity_cdd_hdd_billing_monthly):
  function reporting_model_billing (line 126) | def reporting_model_billing(il_electricity_cdd_hdd_billing_monthly):
  function reporting_meter_data_billing (line 142) | def reporting_meter_data_billing():
  function test_metered_savings_cdd_hdd_billing (line 147) | def test_metered_savings_cdd_hdd_billing(
  function test_metered_savings_cdd_hdd_billing_no_reporting_data (line 160) | def test_metered_savings_cdd_hdd_billing_no_reporting_data(
  function test_metered_savings_cdd_hdd_billing_single_record_reporting_data (line 185) | def test_metered_savings_cdd_hdd_billing_single_record_reporting_data(
  function baseline_model_billing_single_record_baseline_data (line 217) | def baseline_model_billing_single_record_baseline_data(
  function test_metered_savings_cdd_hdd_billing_single_record_baseline_data (line 238) | def test_metered_savings_cdd_hdd_billing_single_record_baseline_data(
  function reporting_meter_data_billing_wrong_timestamp (line 275) | def reporting_meter_data_billing_wrong_timestamp():
  function test_metered_savings_cdd_hdd_billing_reporting_data_wrong_timestamp (line 280) | def test_metered_savings_cdd_hdd_billing_reporting_data_wrong_timestamp(
  function test_modeled_savings_cdd_hdd_daily (line 292) | def test_modeled_savings_cdd_hdd_daily(
  function test_modeled_savings_daily_empty_temperature_data (line 310) | def test_modeled_savings_daily_empty_temperature_data(
  function baseline_model_hourly (line 321) | def baseline_model_hourly(il_electricity_cdd_hdd_hourly):
  function reporting_model_hourly (line 360) | def reporting_model_hourly(il_electricity_cdd_hdd_hourly):
  function reporting_meter_data_hourly (line 399) | def reporting_meter_data_hourly():
  function test_metered_savings_cdd_hdd_hourly (line 404) | def test_metered_savings_cdd_hdd_hourly(
  function test_modeled_savings_cdd_hdd_hourly (line 419) | def test_modeled_savings_cdd_hdd_hourly(
  function normal_year_temperature_data (line 442) | def normal_year_temperature_data():
  function test_modeled_savings_cdd_hdd_billing (line 448) | def test_modeled_savings_cdd_hdd_billing(
  function reporting_meter_data_billing_not_aligned (line 483) | def reporting_meter_data_billing_not_aligned():
  function test_metered_savings_not_aligned_reporting_data (line 488) | def test_metered_savings_not_aligned_reporting_data(
  function baseline_model_billing_single_record (line 501) | def baseline_model_billing_single_record(il_electricity_cdd_hdd_billing_...
  function test_metered_savings_model_single_record (line 516) | def test_metered_savings_model_single_record(
  function baseline_model_hourly_single_segment (line 554) | def baseline_model_hourly_single_segment(il_electricity_cdd_hdd_hourly):

FILE: tests/test_exceptions.py
  function test_eemeter_error (line 26) | def test_eemeter_error():
  function test_no_baseline_data_error (line 31) | def test_no_baseline_data_error():
  function test_no_reporting_data_error (line 37) | def test_no_reporting_data_error():
  function test_missing_model_parameter_error (line 43) | def test_missing_model_parameter_error():
  function test_unrecognized_model_type_error (line 49) | def test_unrecognized_model_type_error():

FILE: tests/test_features.py
  function test_compute_temperature_features_no_freq_index (line 33) | def test_compute_temperature_features_no_freq_index(
  function test_compute_temperature_features_no_meter_data_tz (line 44) | def test_compute_temperature_features_no_meter_data_tz(
  function test_compute_temperature_features_no_temp_data_tz (line 54) | def test_compute_temperature_features_no_temp_data_tz(
  function test_compute_temperature_features_hourly_temp_mean (line 65) | def test_compute_temperature_features_hourly_temp_mean(il_electricity_cd...
  function test_compute_temperature_features_hourly_hourly_degree_days (line 82) | def test_compute_temperature_features_hourly_hourly_degree_days(
  function test_compute_temperature_features_hourly_hourly_degree_days_use_mean_false (line 120) | def test_compute_temperature_features_hourly_hourly_degree_days_use_mean...
  function test_compute_temperature_features_hourly_daily_degree_days_fail (line 159) | def test_compute_temperature_features_hourly_daily_degree_days_fail(
  function test_compute_temperature_features_hourly_daily_missing_explicit_freq (line 178) | def test_compute_temperature_features_hourly_daily_missing_explicit_freq(
  function test_compute_temperature_features_hourly_bad_degree_days (line 198) | def test_compute_temperature_features_hourly_bad_degree_days(
  function test_compute_temperature_features_hourly_data_quality (line 217) | def test_compute_temperature_features_hourly_data_quality(
  function test_compute_temperature_features_daily_temp_mean (line 240) | def test_compute_temperature_features_daily_temp_mean(il_electricity_cdd...
  function test_compute_temperature_features_daily_daily_degree_days (line 254) | def test_compute_temperature_features_daily_daily_degree_days(
  function test_compute_temperature_features_daily_daily_degree_days_use_mean_false (line 289) | def test_compute_temperature_features_daily_daily_degree_days_use_mean_f...
  function test_compute_temperature_features_daily_hourly_degree_days (line 325) | def test_compute_temperature_features_daily_hourly_degree_days(
  function test_compute_temperature_features_daily_hourly_degree_days_use_mean_false (line 360) | def test_compute_temperature_features_daily_hourly_degree_days_use_mean_...
  function test_compute_temperature_features_daily_bad_degree_days (line 396) | def test_compute_temperature_features_daily_bad_degree_days(
  function test_compute_temperature_features_daily_data_quality (line 411) | def test_compute_temperature_features_daily_data_quality(il_electricity_...
  function test_compute_temperature_features_billing_monthly_temp_mean (line 428) | def test_compute_temperature_features_billing_monthly_temp_mean(
  function test_compute_temperature_features_billing_monthly_daily_degree_days (line 443) | def test_compute_temperature_features_billing_monthly_daily_degree_days(
  function test_compute_temperature_features_billing_monthly_daily_degree_days_use_mean_false (line 478) | def test_compute_temperature_features_billing_monthly_daily_degree_days_...
  function test_compute_temperature_features_billing_monthly_hourly_degree_days (line 514) | def test_compute_temperature_features_billing_monthly_hourly_degree_days(
  function test_compute_temperature_features_billing_monthly_hourly_degree_days_use_mean_false (line 549) | def test_compute_temperature_features_billing_monthly_hourly_degree_days...
  function test_compute_temperature_features_billing_monthly_bad_degree_day_method (line 585) | def test_compute_temperature_features_billing_monthly_bad_degree_day_met...
  function test_compute_temperature_features_billing_monthly_data_quality (line 600) | def test_compute_temperature_features_billing_monthly_data_quality(
  function test_compute_temperature_features_billing_bimonthly_temp_mean (line 619) | def test_compute_temperature_features_billing_bimonthly_temp_mean(
  function test_compute_temperature_features_billing_bimonthly_daily_degree_days (line 634) | def test_compute_temperature_features_billing_bimonthly_daily_degree_days(
  function test_compute_temperature_features_billing_bimonthly_hourly_degree_days (line 669) | def test_compute_temperature_features_billing_bimonthly_hourly_degree_days(
  function test_compute_temperature_features_billing_bimonthly_bad_degree_days (line 704) | def test_compute_temperature_features_billing_bimonthly_bad_degree_days(
  function test_compute_temperature_features_billing_bimonthly_data_quality (line 719) | def test_compute_temperature_features_billing_bimonthly_data_quality(
  function test_compute_temperature_features_shorter_temperature_data (line 738) | def test_compute_temperature_features_shorter_temperature_data(
  function test_compute_temperature_features_shorter_meter_data (line 757) | def test_compute_temperature_features_shorter_meter_data(il_electricity_...
  function test_compute_temperature_features_with_duplicated_index (line 776) | def test_compute_temperature_features_with_duplicated_index(
  function test_compute_temperature_features_empty_temperature_data (line 792) | def test_compute_temperature_features_empty_temperature_data():
  function test_compute_temperature_features_empty_meter_data (line 809) | def test_compute_temperature_features_empty_meter_data():
  function test_merge_features (line 827) | def test_merge_features():
  function test_merge_features_empty_raises (line 847) | def test_merge_features_empty_raises():
  function meter_data_hourly (line 853) | def meter_data_hourly():
  function test_compute_usage_per_day_feature_hourly (line 858) | def test_compute_usage_per_day_feature_hourly(meter_data_hourly):
  function test_compute_usage_per_day_feature_hourly_series_name (line 865) | def test_compute_usage_per_day_feature_hourly_series_name(meter_data_hou...
  function meter_data_daily (line 873) | def meter_data_daily():
  function test_compute_usage_per_day_feature_daily (line 878) | def test_compute_usage_per_day_feature_daily(meter_data_daily):
  function meter_data_billing (line 885) | def meter_data_billing():
  function test_compute_usage_per_day_feature_billing (line 890) | def test_compute_usage_per_day_feature_billing(meter_data_billing):
  function complete_hour_of_week_feature (line 897) | def complete_hour_of_week_feature():
  function test_get_missing_hours_of_week_warning_ok (line 904) | def test_get_missing_hours_of_week_warning_ok(complete_hour_of_week_feat...
  function partial_hour_of_week_feature (line 910) | def partial_hour_of_week_feature():
  function test_get_missing_hours_of_week_warning_triggered (line 917) | def test_get_missing_hours_of_week_warning_triggered(partial_hour_of_wee...
  function test_compute_time_features_bad_freq (line 924) | def test_compute_time_features_bad_freq():
  function test_compute_time_features_all (line 930) | def test_compute_time_features_all():
  function test_compute_time_features_none (line 949) | def test_compute_time_features_none():
  function occupancy_precursor (line 958) | def occupancy_precursor(il_electricity_cdd_hdd_hourly):
  function test_estimate_hour_of_week_occupancy_no_segmentation (line 974) | def test_estimate_hour_of_week_occupancy_no_segmentation(occupancy_precu...
  function one_month_segmentation (line 982) | def one_month_segmentation(occupancy_precursor):
  function test_estimate_hour_of_week_occupancy_one_month_segmentation (line 986) | def test_estimate_hour_of_week_occupancy_one_month_segmentation(
  function temperature_means (line 1011) | def temperature_means():
  function test_fit_temperature_bins_no_segmentation (line 1016) | def test_fit_temperature_bins_no_segmentation(temperature_means):
  function occupancy_lookup_no_segmentation (line 1026) | def occupancy_lookup_no_segmentation(occupancy_precursor):
  function test_fit_temperature_bins_no_segmentation_with_occupancy (line 1031) | def test_fit_temperature_bins_no_segmentation_with_occupancy(
  function test_fit_temperature_bins_one_month_segmentation (line 1048) | def test_fit_temperature_bins_one_month_segmentation(
  function occupancy_lookup_one_month_segmentation (line 1071) | def occupancy_lookup_one_month_segmentation(
  function test_fit_temperature_bins_with_occupancy_lookup (line 1080) | def test_fit_temperature_bins_with_occupancy_lookup(
  function test_fit_temperature_bins_empty (line 1123) | def test_fit_temperature_bins_empty(temperature_means):
  function test_compute_temperature_bin_features (line 1130) | def test_compute_temperature_bin_features(temperature_means):
  function even_occupancy (line 1139) | def even_occupancy():
  function test_compute_occupancy_feature (line 1143) | def test_compute_occupancy_feature(even_occupancy):
  function test_compute_occupancy_feature_with_nans (line 1153) | def test_compute_occupancy_feature_with_nans(even_occupancy):
  function occupancy_precursor_only_nan (line 1172) | def occupancy_precursor_only_nan(il_electricity_cdd_hdd_hourly):
  function segmentation_only_nan (line 1192) | def segmentation_only_nan(occupancy_precursor_only_nan):
  function test_estimate_hour_of_week_occupancy_segmentation_only_nan (line 1198) | def test_estimate_hour_of_week_occupancy_segmentation_only_nan(
  function test_compute_occupancy_feature_hour_of_week_has_nan (line 1206) | def test_compute_occupancy_feature_hour_of_week_has_nan(even_occupancy):

FILE: tests/test_io.py
  function test_meter_data_from_csv (line 33) | def test_meter_data_from_csv(sample_metadata):
  function test_meter_data_from_csv_gzipped (line 49) | def test_meter_data_from_csv_gzipped(sample_metadata):
  function test_meter_data_from_csv_with_tz (line 62) | def test_meter_data_from_csv_with_tz(sample_metadata):
  function test_meter_data_from_csv_hourly_freq (line 75) | def test_meter_data_from_csv_hourly_freq(sample_metadata):
  function test_meter_data_from_csv_daily_freq (line 88) | def test_meter_data_from_csv_daily_freq(sample_metadata):
  function test_meter_data_from_csv_custom_columns (line 101) | def test_meter_data_from_csv_custom_columns(sample_metadata):
  function test_meter_data_from_json_none (line 111) | def test_meter_data_from_json_none(sample_metadata):
  function test_meter_data_from_json_orient_list (line 119) | def test_meter_data_from_json_orient_list(sample_metadata):
  function test_meter_data_from_json_orient_list_empty (line 127) | def test_meter_data_from_json_orient_list_empty(sample_metadata):
  function test_meter_data_from_json_orient_records (line 135) | def test_meter_data_from_json_orient_records(sample_metadata):
  function test_meter_data_from_json_orient_records_empty (line 147) | def test_meter_data_from_json_orient_records_empty(sample_metadata):
  function test_meter_data_from_json_orient_records_with_estimated_true (line 155) | def test_meter_data_from_json_orient_records_with_estimated_true(sample_...
  function test_meter_data_from_json_orient_records_with_estimated_false (line 170) | def test_meter_data_from_json_orient_records_with_estimated_false(sample...
  function test_meter_data_from_json_bad_orient (line 186) | def test_meter_data_from_json_bad_orient(sample_metadata):
  function test_meter_data_to_csv (line 192) | def test_meter_data_to_csv(sample_metadata):
  function test_temperature_data_from_csv (line 205) | def test_temperature_data_from_csv(sample_metadata):
  function test_temperature_data_from_csv_gzipped (line 221) | def test_temperature_data_from_csv_gzipped(sample_metadata):
  function test_temperature_data_from_csv_with_tz (line 234) | def test_temperature_data_from_csv_with_tz(sample_metadata):
  function test_temperature_data_from_csv_hourly_freq (line 247) | def test_temperature_data_from_csv_hourly_freq(sample_metadata):
  function test_temperature_data_from_csv_custom_columns (line 260) | def test_temperature_data_from_csv_custom_columns(sample_metadata):
  function test_temperature_data_from_json_orient_list (line 272) | def test_temperature_data_from_json_orient_list(sample_metadata):
  function test_temperature_data_from_json_bad_orient (line 280) | def test_temperature_data_from_json_bad_orient(sample_metadata):
  function test_temperature_data_to_csv (line 286) | def test_temperature_data_to_csv(sample_metadata):

FILE: tests/test_json_serialization.py
  function test_json_daily (line 32) | def test_json_daily():
  function test_json_billing (line 75) | def test_json_billing():
  function test_json_hourly_with_zeros (line 118) | def test_json_hourly_with_zeros():
  function test_json_caltrack_hourly (line 133) | def test_json_caltrack_hourly():
  function test_legacy_deserialization_daily (line 177) | def test_legacy_deserialization_daily():
  function test_legacy_deserialization_hourly (line 209) | def test_legacy_deserialization_hourly(request):

FILE: tests/test_samples.py
  function test_samples (line 23) | def test_samples():
  function test_load_sample_hourly (line 48) | def test_load_sample_hourly():
  function test_load_sample_daily (line 82) | def test_load_sample_daily():
  function test_load_sample_billing_monthly (line 92) | def test_load_sample_billing_monthly():
  function test_load_sample_unknown (line 104) | def test_load_sample_unknown():

FILE: tests/test_segmentation.py
  function index_8760 (line 29) | def index_8760():
  function test_segment_time_series_invalid_type (line 33) | def test_segment_time_series_invalid_type(index_8760):
  function test_segment_time_series_single (line 38) | def test_segment_time_series_single(index_8760):
  function test_segment_time_series_one_month (line 45) | def test_segment_time_series_one_month(index_8760):
  function test_segment_time_series_three_month (line 65) | def test_segment_time_series_three_month(index_8760):
  function test_segment_time_series_three_month_weighted (line 85) | def test_segment_time_series_three_month_weighted(index_8760):
  function test_segment_time_series_drop_zero_weight_segments (line 105) | def test_segment_time_series_drop_zero_weight_segments(index_8760):
  function dataset (line 115) | def dataset():
  function test_iterate_segmented_dataset_no_segmentation (line 120) | def test_iterate_segmented_dataset_no_segmentation(dataset):
  function segmentation (line 133) | def segmentation(dataset):
  function test_iterate_segmented_dataset_with_segmentation (line 137) | def test_iterate_segmented_dataset_with_segmentation(dataset, segmentati...
  function test_iterate_segmented_dataset_with_processor (line 158) | def test_iterate_segmented_dataset_with_processor(dataset, segmentation):
  function test_segment_model (line 189) | def test_segment_model():
  function test_segmented_model (line 203) | def test_segmented_model():
  function test_segment_model_serialized (line 233) | def test_segment_model_serialized():
  function test_segmented_model_serialized (line 247) | def test_segmented_model_serialized():

FILE: tests/test_transform.py
  function test_as_freq_not_series (line 42) | def test_as_freq_not_series(il_electricity_cdd_hdd_billing_monthly):
  function test_as_freq_hourly (line 49) | def test_as_freq_hourly(il_electricity_cdd_hdd_billing_monthly):
  function test_as_freq_daily (line 57) | def test_as_freq_daily(il_electricity_cdd_hdd_billing_monthly):
  function test_as_freq_daily_all_nones_instantaneous (line 65) | def test_as_freq_daily_all_nones_instantaneous(il_electricity_cdd_hdd_bi...
  function test_as_freq_daily_all_nones (line 74) | def test_as_freq_daily_all_nones(il_electricity_cdd_hdd_billing_monthly):
  function test_as_freq_month_start (line 83) | def test_as_freq_month_start(il_electricity_cdd_hdd_billing_monthly):
  function test_as_freq_hourly_temperature (line 91) | def test_as_freq_hourly_temperature(il_electricity_cdd_hdd_billing_month...
  function test_as_freq_daily_temperature (line 99) | def test_as_freq_daily_temperature(il_electricity_cdd_hdd_billing_monthly):
  function test_as_freq_month_start_temperature (line 107) | def test_as_freq_month_start_temperature(il_electricity_cdd_hdd_billing_...
  function test_as_freq_daily_temperature_monthly (line 115) | def test_as_freq_daily_temperature_monthly(il_electricity_cdd_hdd_billin...
  function test_as_freq_empty (line 124) | def test_as_freq_empty():
  function test_as_freq_perserves_nulls (line 130) | def test_as_freq_perserves_nulls(il_electricity_cdd_hdd_billing_monthly):
  function test_day_counts (line 145) | def test_day_counts(il_electricity_cdd_hdd_billing_monthly):
  function test_day_counts_empty_series (line 154) | def test_day_counts_empty_series():
  function test_get_baseline_data (line 162) | def test_get_baseline_data(il_electricity_cdd_hdd_hourly):
  function test_get_baseline_data_with_timezones (line 169) | def test_get_baseline_data_with_timezones(il_electricity_cdd_hdd_hourly):
  function test_get_baseline_data_with_end (line 181) | def test_get_baseline_data_with_end(il_electricity_cdd_hdd_hourly):
  function test_get_baseline_data_with_end_no_max_days (line 189) | def test_get_baseline_data_with_end_no_max_days(il_electricity_cdd_hdd_h...
  function test_get_baseline_data_empty (line 199) | def test_get_baseline_data_empty(il_electricity_cdd_hdd_hourly):
  function test_get_baseline_data_start_gap (line 206) | def test_get_baseline_data_start_gap(il_electricity_cdd_hdd_hourly):
  function test_get_baseline_data_end_gap (line 224) | def test_get_baseline_data_end_gap(il_electricity_cdd_hdd_hourly):
  function test_get_baseline_data_with_overshoot (line 242) | def test_get_baseline_data_with_overshoot(il_electricity_cdd_hdd_billing...
  function test_get_baseline_data_with_ignored_gap (line 275) | def test_get_baseline_data_with_ignored_gap(il_electricity_cdd_hdd_billi...
  function test_get_baseline_data_with_overshoot_and_ignored_gap (line 308) | def test_get_baseline_data_with_overshoot_and_ignored_gap(
  function test_get_baseline_data_n_days_billing_period_overshoot (line 335) | def test_get_baseline_data_n_days_billing_period_overshoot(
  function test_get_baseline_data_too_far_from_date (line 352) | def test_get_baseline_data_too_far_from_date(il_electricity_cdd_hdd_bill...
  function test_get_reporting_data (line 400) | def test_get_reporting_data(il_electricity_cdd_hdd_hourly):
  function test_get_reporting_data_with_timezones (line 407) | def test_get_reporting_data_with_timezones(il_electricity_cdd_hdd_hourly):
  function test_get_reporting_data_with_start (line 419) | def test_get_reporting_data_with_start(il_electricity_cdd_hdd_hourly):
  function test_get_reporting_data_with_start_no_max_days (line 427) | def test_get_reporting_data_with_start_no_max_days(il_electricity_cdd_hd...
  function test_get_reporting_data_empty (line 437) | def test_get_reporting_data_empty(il_electricity_cdd_hdd_hourly):
  function test_get_reporting_data_start_gap (line 444) | def test_get_reporting_data_start_gap(il_electricity_cdd_hdd_hourly):
  function test_get_reporting_data_end_gap (line 464) | def test_get_reporting_data_end_gap(il_electricity_cdd_hdd_hourly):
  function test_get_reporting_data_with_overshoot (line 482) | def test_get_reporting_data_with_overshoot(il_electricity_cdd_hdd_billin...
  function test_get_reporting_data_with_ignored_gap (line 515) | def test_get_reporting_data_with_ignored_gap(il_electricity_cdd_hdd_bill...
  function test_get_reporting_data_with_overshoot_and_ignored_gap (line 548) | def test_get_reporting_data_with_overshoot_and_ignored_gap(
  function test_get_terms_unrecognized_method (line 575) | def test_get_terms_unrecognized_method(il_electricity_cdd_hdd_billing_mo...
  function test_get_terms_unsorted_index (line 582) | def test_get_terms_unsorted_index(il_electricity_cdd_hdd_billing_monthly):
  function test_get_terms_bad_term_labels (line 589) | def test_get_terms_bad_term_labels(il_electricity_cdd_hdd_billing_monthly):
  function test_get_terms_default_term_labels (line 600) | def test_get_terms_default_term_labels(il_electricity_cdd_hdd_billing_mo...
  function test_get_terms_custom_term_labels (line 607) | def test_get_terms_custom_term_labels(il_electricity_cdd_hdd_billing_mon...
  function test_get_terms_empty_index_input (line 616) | def test_get_terms_empty_index_input(il_electricity_cdd_hdd_billing_mont...
  function test_get_terms_strict (line 623) | def test_get_terms_strict(il_electricity_cdd_hdd_billing_monthly):
  function test_get_terms_nearest (line 684) | def test_get_terms_nearest(il_electricity_cdd_hdd_billing_monthly):
  function test_term_repr (line 738) | def test_term_repr(il_electricity_cdd_hdd_billing_monthly):
  function test_remove_duplicates_df (line 748) | def test_remove_duplicates_df():
  function test_remove_duplicates_series (line 757) | def test_remove_duplicates_series():
  function test_as_freq_hourly_to_daily (line 766) | def test_as_freq_hourly_to_daily(il_electricity_cdd_hdd_hourly):
  function test_as_freq_daily_to_daily (line 776) | def test_as_freq_daily_to_daily(il_electricity_cdd_hdd_daily):
  function test_as_freq_hourly_to_daily_include_coverage (line 784) | def test_as_freq_hourly_to_daily_include_coverage(il_electricity_cdd_hdd...
  function test_clean_caltrack_billing_daily_data_billing (line 793) | def test_clean_caltrack_billing_daily_data_billing(
  function test_clean_caltrack_billing_daily_data_daily (line 802) | def test_clean_caltrack_billing_daily_data_daily(il_electricity_cdd_hdd_...
  function test_clean_caltrack_billing_daily_data_daily_local_tz (line 809) | def test_clean_caltrack_billing_daily_data_daily_local_tz(il_electricity...
  function test_clean_caltrack_billing_daily_data_hourly (line 818) | def test_clean_caltrack_billing_daily_data_hourly(il_electricity_cdd_hdd...
  function test_clean_caltrack_daily_data_hourly (line 824) | def test_clean_caltrack_daily_data_hourly(il_electricity_cdd_hdd_hourly):
  function test_clean_caltrack_daily_data_hourly_local_tz (line 830) | def test_clean_caltrack_daily_data_hourly_local_tz(il_electricity_cdd_hd...
  function test_clean_caltrack_billing_data_estimated (line 837) | def test_clean_caltrack_billing_data_estimated(il_electricity_cdd_hdd_bi...
  function test_clean_caltrack_billing_data_uneven_datetimes (line 851) | def test_clean_caltrack_billing_data_uneven_datetimes(
  function test_overwrite_partial_rows_with_nan (line 897) | def test_overwrite_partial_rows_with_nan(il_electricity_cdd_hdd_billing_...
  function test_add_freq (line 908) | def test_add_freq(il_electricity_cdd_hdd_hourly):
  function test_trim_two_dataframes (line 919) | def test_trim_two_dataframes(
  function test_format_temperature_data_for_caltrack (line 945) | def test_format_temperature_data_for_caltrack(il_electricity_cdd_hdd_hou...
  function test_format_energy_data_for_caltrack_hourly (line 973) | def test_format_energy_data_for_caltrack_hourly(il_electricity_cdd_hdd_h...
  function test_format_energy_data_for_caltrack_daily (line 998) | def test_format_energy_data_for_caltrack_daily(il_electricity_cdd_hdd_da...
  function test_format_energy_data_for_caltrack_billing (line 1023) | def test_format_energy_data_for_caltrack_billing(il_electricity_cdd_hdd_...

FILE: tests/test_version.py
  function test_version (line 18) | def test_version():

FILE: tests/test_warnings.py
  function test_eemeter_warning (line 18) | def test_eemeter_warning():

[
  {
    "path": ".coveragerc",
    "chars": 37,
    "preview": "[run]\nomit =\n    .tox/*\n    setup.py\n"
  },
  {
    "path": ".dockerignore",
    "chars": 79,
    "preview": "**/*.pyc\n**/*.pyo\n**/*.pyd\n.git\n.tox\n**/__pycache__\n**/.DS_Store\n**/*.egg-info\n"
  },
  {
    "path": ".gitattributes",
    "chars": 33,
    "preview": "scripts/* linguist-documentation\n"
  },
  {
    "path": ".gitignore",
    "chars": 190,
    "preview": "*.py[cod]\n__pycache__/\n*.egg-info\n\n_build\nbuild/\ndist/\nprof/\nvenv/\nuv.lock\n\n.ipynb_checkpoints/\n\n.*\n!.github/\n!.travis.y"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 15541,
    "preview": "Changelog\n=========\n\nDevelopment\n-----------\n\n\nopendsm-1.2.7\n-----------\n\n* Switch build to use pyproject.toml and uv \n*"
  },
  {
    "path": "CHARTER.md",
    "chars": 12590,
    "preview": "# Technical Charter (the \"Charter\") for OpenDSM, a Series of LF Projects, LLC\n\nAdopted August 28, 2024\n\n\nThis charter (t"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 3212,
    "preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 7051,
    "preview": "Contributing\n============\n\nGuidelines\n----------\n\n* Make sure you follow PEP 008 style guide conventions. You can check "
  },
  {
    "path": "Dockerfile",
    "chars": 1286,
    "preview": "# syntax=docker/dockerfile:1.7\nFROM python:3.10-slim AS app\n\n# System deps (you had libenchant-2-dev)\nRUN apt-get update"
  },
  {
    "path": "LICENSE",
    "chars": 11355,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "MAINTAINERS.md",
    "chars": 951,
    "preview": "# Maintainers\n\nThe OpenEEmeter was originally created in late 2014 by Phil Ngo and later\ndeveloped and incubated at Recu"
  },
  {
    "path": "MANIFEST.in",
    "chars": 138,
    "preview": "include README.md LICENSE pytest.ini\ninclude opendsm/eemeter/samples/*.json opendsm/eemeter/samples/*.csv.gz\nrecursive-i"
  },
  {
    "path": "README.md",
    "chars": 8708,
    "preview": "# OpenDSM: Tools for calculating metered energy savings\r\n\r\n[![PyPI Version](https://img.shields.io/pypi/v/opendsm.svg)]("
  },
  {
    "path": "bump_version.sh",
    "chars": 725,
    "preview": "#!/bin/bash\n\nset -e  # fail script on any error, show commands\n\nOLD_VERSION=$1  # e.g., 0.0.0\nNEW_VERSION=$2  # e.g., 0."
  },
  {
    "path": "data/attribution.txt",
    "chars": 582,
    "preview": "This data is derived from NREL's ComStock datasets (2023/comstock_amy2018_release_2)\n\nThe ComStock database, part of the"
  },
  {
    "path": "data/features.csv",
    "chars": 74546,
    "preview": "id,summer_usage,winter_usage,annual_usage\n108585,28424.455657276467,51265.146636654434,110748.6876074653\n108587,17291.77"
  },
  {
    "path": "data/month_loadshape.csv",
    "chars": 273350,
    "preview": "id,1,2,3,4,5,6,7,8,9,10,11,12\n108585,178.96607321422954,156.2157615515202,109.81367662374429,96.78573476528025,63.693822"
  },
  {
    "path": "data/seasonal_day_of_week_loadshape.csv",
    "chars": 471916,
    "preview": "id,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21\n108585,2.0254250770765605,1.9560841562291102,1.931533183949555,"
  },
  {
    "path": "docker-compose.yml",
    "chars": 1192,
    "preview": "services:\n  shell:\n    build: .\n    platform: linux/amd64\n    image: eemeter_shell\n    stdin_open: true\n    tty: true\n  "
  },
  {
    "path": "docs/gridmeter/gridmeter.__version__.rst",
    "chars": 191,
    "preview": "=========================\n``gridmeter.__version__``\n=========================\n\n.. automodule:: gridmeter.__version__\n\n  "
  },
  {
    "path": "docs/gridmeter/gridmeter.bin_selection.rst",
    "chars": 443,
    "preview": "===========================\n``gridmeter.bin_selection``\n===========================\n\n.. automodule:: gridmeter.bin_selec"
  },
  {
    "path": "docs/gridmeter/gridmeter.bins.rst",
    "chars": 872,
    "preview": "==================\n``gridmeter.bins``\n==================\n\n.. automodule:: gridmeter.bins\n\n   .. contents::\n      :local:"
  },
  {
    "path": "docs/gridmeter/gridmeter.diagnostics.rst",
    "chars": 191,
    "preview": "=========================\n``gridmeter.diagnostics``\n=========================\n\n.. automodule:: gridmeter.diagnostics\n\n  "
  },
  {
    "path": "docs/gridmeter/gridmeter.distance_calc_selection.rst",
    "chars": 451,
    "preview": "=====================================\n``gridmeter.distance_calc_selection``\n=====================================\n\n.. au"
  },
  {
    "path": "docs/gridmeter/gridmeter.equivalence.rst",
    "chars": 191,
    "preview": "=========================\n``gridmeter.equivalence``\n=========================\n\n.. automodule:: gridmeter.equivalence\n\n  "
  },
  {
    "path": "docs/gridmeter/gridmeter.model.rst",
    "chars": 161,
    "preview": "===================\n``gridmeter.model``\n===================\n\n.. automodule:: gridmeter.model\n\n   .. contents::\n      :lo"
  },
  {
    "path": "docs/gridmeter/gridmeter.param_selection.rst",
    "chars": 211,
    "preview": "=============================\n``gridmeter.param_selection``\n=============================\n\n.. automodule:: gridmeter.par"
  },
  {
    "path": "docs/gridmeter/gridmeter.rst",
    "chars": 403,
    "preview": "=============\n``gridmeter``\n=============\n\n.. automodule:: gridmeter\n\n   .. contents::\n      :local:\n\n\nSubmodules\n======"
  },
  {
    "path": "docs/gridmeter/gridmeter.synthetic_data.rst",
    "chars": 206,
    "preview": "============================\n``gridmeter.synthetic_data``\n============================\n\n.. automodule:: gridmeter.synthe"
  },
  {
    "path": "opendsm/__init__.py",
    "chars": 2276,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/__init__.py",
    "chars": 730,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/base_settings.py",
    "chars": 2025,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/__init__.py",
    "chars": 799,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/algorithms/__init__.py",
    "chars": 276,
    "preview": "from .bisect_k_means import bisect_k_means as _bisecting_kmeans_clustering\nfrom .birch import birch as _birch_clustering"
  },
  {
    "path": "opendsm/common/clustering/algorithms/birch.py",
    "chars": 1976,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/algorithms/bisect_k_means.py",
    "chars": 3436,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/algorithms/dbscan.py",
    "chars": 1305,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/algorithms/hdbscan.py",
    "chars": 2147,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/algorithms/sklearn_bisect_k_means.py",
    "chars": 6894,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/algorithms/spectral.py",
    "chars": 14513,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/cluster.py",
    "chars": 8232,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/metrics/__init__.py",
    "chars": 43,
    "preview": "from .cluster_metrics import ClusterMetrics"
  },
  {
    "path": "opendsm/common/clustering/metrics/cluster_metrics.py",
    "chars": 46230,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\n\n   Copyright 2014-2025 OpenDSM contributors\n\n   Licensed under the Ap"
  },
  {
    "path": "opendsm/common/clustering/metrics/density_based_clustering_validation.py",
    "chars": 15445,
    "preview": "\"\"\"\nFrom https://github.com/FelSiq/DBCV\n\nMIT License\n\nCopyright (c) 2024 Felipe Alves Siqueira\n\nPermission is hereby gra"
  },
  {
    "path": "opendsm/common/clustering/scoring.py",
    "chars": 7653,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/settings.py",
    "chars": 19383,
    "preview": "from __future__ import annotations\n\nimport numpy as np\n\nimport pydantic\n\nfrom enum import Enum\nfrom typing import Option"
  },
  {
    "path": "opendsm/common/clustering/transform.py",
    "chars": 11782,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/clustering/voting.py",
    "chars": 7981,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\n\n   Copyright 2014-2025 OpenDSM contributors\n\n   Licensed under the Ap"
  },
  {
    "path": "opendsm/common/const.py",
    "chars": 2276,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/hourly_interpolation.py",
    "chars": 8523,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/metrics.py",
    "chars": 47279,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/pydantic_utils.py",
    "chars": 5380,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/stats/__init__.py",
    "chars": 639,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/stats/adaptive_loss.py",
    "chars": 17210,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/stats/adaptive_loss_Z.py",
    "chars": 15859,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/stats/basic.py",
    "chars": 10462,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\n\n   Copyright 2014-2024 OpenEEmeter contributors\n\n   Licensed under th"
  },
  {
    "path": "opendsm/common/stats/distribution_transform/__init__.py",
    "chars": 960,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/stats/distribution_transform/bisymlog.py",
    "chars": 5352,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/stats/distribution_transform/mu_sigma.py",
    "chars": 3204,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/stats/distribution_transform/raymaekers_robust_yeo_johnson.py",
    "chars": 8720,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/stats/distribution_transform/scipy_yeo_johnson.py",
    "chars": 2640,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/stats/distribution_transform/standardize.py",
    "chars": 882,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/stats/outliers.py",
    "chars": 2721,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\n\n   Copyright 2014-2024 OpenEEmeter contributors\n\n   Licensed under th"
  },
  {
    "path": "opendsm/common/stats/outliers_transformed.py",
    "chars": 1595,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\n\n   Copyright 2014-2024 OpenEEmeter contributors\n\n   Licensed under th"
  },
  {
    "path": "opendsm/common/test_data.py",
    "chars": 6533,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/common/utils.py",
    "chars": 10965,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/__init__.py",
    "chars": 1084,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/archived_gridmeter_changelog.md",
    "chars": 3187,
    "preview": "Changelog\n=========\n\nDevelopment\n-----------\n\n* Placeholder\n\n1.1.0\n-----\n\n* Add usage-pattern distance calculation as op"
  },
  {
    "path": "opendsm/comparison_groups/cg_clustering/__init__.py",
    "chars": 816,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/cg_clustering/bounds.py",
    "chars": 3308,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/cg_clustering/create_comparison_groups.py",
    "chars": 3667,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/cg_clustering/settings.py",
    "chars": 4990,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/cg_clustering/treatment_fit.py",
    "chars": 6950,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/common/__init__.py",
    "chars": 863,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\n\n   Copyright 2014-2024 OpenEEmeter contributors\n\n   Licensed under th"
  },
  {
    "path": "opendsm/comparison_groups/common/base_comparison_group.py",
    "chars": 4201,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/common/const.py",
    "chars": 3672,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/common/data.py",
    "chars": 24821,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/common/data_settings.py",
    "chars": 8209,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/common/tutorial_data.py",
    "chars": 1623,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/individual_meter_matching/__init__.py",
    "chars": 861,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/individual_meter_matching/create_comparison_groups.py",
    "chars": 3594,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/individual_meter_matching/distance_calc_selection.py",
    "chars": 8294,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/individual_meter_matching/highs_settings.py",
    "chars": 14098,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/individual_meter_matching/settings.py",
    "chars": 2962,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/random_sampling/__init__.py",
    "chars": 823,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/random_sampling/create_comparison_groups.py",
    "chars": 2972,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/random_sampling/settings.py",
    "chars": 2258,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/savings/__init__.py",
    "chars": 639,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/savings/archived_dev.py",
    "chars": 14180,
    "preview": "\n\n\n# TODO: need to cap IMM size if doing this for memory reasons\n# TODO: In GRIDmeter potentially could reduce df_t_coef"
  },
  {
    "path": "opendsm/comparison_groups/savings/cg_correction_testing.py",
    "chars": 17003,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/savings/model_correction.py",
    "chars": 14806,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/savings/scratch.ipynb",
    "chars": 48778,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"class\\n\",\n    \"\\n\",\n    \"inputs:\\n\""
  },
  {
    "path": "opendsm/comparison_groups/savings/settings.py",
    "chars": 4347,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/stratified_sampling/__init__.py",
    "chars": 918,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/stratified_sampling/bin_selection.py",
    "chars": 16937,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/stratified_sampling/bins.py",
    "chars": 10463,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/stratified_sampling/const.py",
    "chars": 789,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/stratified_sampling/create_comparison_groups.py",
    "chars": 5994,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/stratified_sampling/diagnostics.py",
    "chars": 13721,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/stratified_sampling/equivalence.py",
    "chars": 5698,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/stratified_sampling/model.py",
    "chars": 14486,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/stratified_sampling/param_selection.py",
    "chars": 3032,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/comparison_groups/stratified_sampling/settings.py",
    "chars": 7908,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/drmeter/__init__.py",
    "chars": 678,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/drmeter/models/__init__.py",
    "chars": 787,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/drmeter/models/caltrack/__init__.py",
    "chars": 712,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/drmeter/models/caltrack/data.py",
    "chars": 783,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/drmeter/models/caltrack/model.py",
    "chars": 833,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/__init__.py",
    "chars": 756,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/common/__init__.py",
    "chars": 640,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/common/data_processor_utilities.py",
    "chars": 15571,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/common/data_settings.py",
    "chars": 7506,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/common/exceptions.py",
    "chars": 1637,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/common/features.py",
    "chars": 33050,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/common/sufficiency_criteria.py",
    "chars": 24484,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/common/transform.py",
    "chars": 37679,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/common/warnings.py",
    "chars": 1962,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/__init__.py",
    "chars": 890,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/billing/__init__.py",
    "chars": 900,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/billing/data.py",
    "chars": 22818,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/billing/model.py",
    "chars": 6903,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/billing/plot.py",
    "chars": 5113,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/billing/settings.py",
    "chars": 1031,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/billing/weighted_model.py",
    "chars": 7616,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/__init__.py",
    "chars": 811,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/base_models/__init__.py",
    "chars": 640,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/base_models/c_hdd_tidd.py",
    "chars": 15558,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/base_models/full_model.py",
    "chars": 9245,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/base_models/hdd_tidd_cdd.py",
    "chars": 11136,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/base_models/tidd.py",
    "chars": 3089,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/data.py",
    "chars": 31846,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/fit_base_models.py",
    "chars": 6332,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/model.py",
    "chars": 39628,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/objective_function.py",
    "chars": 13070,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/optimize.py",
    "chars": 15201,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/optimize_results.py",
    "chars": 14341,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/parameters.py",
    "chars": 13404,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/plot.py",
    "chars": 6268,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/utilities/__init__.py",
    "chars": 640,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/utilities/base_model.py",
    "chars": 3907,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/utilities/const.py",
    "chars": 1802,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/utilities/ellipsoid_test.py",
    "chars": 9349,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/utilities/opt_settings.py",
    "chars": 4718,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/utilities/selection_criteria.py",
    "chars": 5361,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/daily/utilities/settings.py",
    "chars": 20320,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly/__init__.py",
    "chars": 953,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly/data.py",
    "chars": 17118,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly/model.py",
    "chars": 61476,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly/settings.py",
    "chars": 14827,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly_caltrack/__init__.py",
    "chars": 819,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly_caltrack/data.py",
    "chars": 4662,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly_caltrack/derivatives.py",
    "chars": 16010,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly_caltrack/design_matrices.py",
    "chars": 7114,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly_caltrack/metrics.py",
    "chars": 21130,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly_caltrack/model.py",
    "chars": 22564,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly_caltrack/segmentation.py",
    "chars": 18570,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly_caltrack/usage_per_day.py",
    "chars": 15071,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/models/hourly_caltrack/wrapper.py",
    "chars": 8557,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/samples/__init__.py",
    "chars": 661,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/samples/load.py",
    "chars": 3508,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "opendsm/eemeter/samples/metadata.json",
    "chars": 14407,
    "preview": "{\"il-electricity-cdd-hdd-hourly\": {\"id\": \"il-electricity-cdd-hdd-hourly\", \"temperature_filename\": \"il-tempF.csv.gz\", \"me"
  },
  {
    "path": "opendsm/eemeter/utilities/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "opendsm/eemeter/utilities/io.py",
    "chars": 9930,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "pyproject.toml",
    "chars": 1782,
    "preview": "[build-system]\nrequires = [\"hatchling>=1.25\"]\nbuild-backend = \"hatchling.build\"\n\n[project]\nname = \"opendsm\"\nversion = \"1"
  },
  {
    "path": "pytest.ini",
    "chars": 788,
    "preview": "[pytest]\naddopts =\n    # run in parallel - requires pytest-xdist\n    -n auto\n\n    # show coverage - requires pytest-cov\n"
  },
  {
    "path": "setup.cfg",
    "chars": 22,
    "preview": "[aliases]\ntest=pytest\n"
  },
  {
    "path": "tests/common/clustering/test_bisect_k_means.py",
    "chars": 17269,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/common/clustering/test_cluster.py",
    "chars": 29880,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/common/clustering/test_cluster_transform.py",
    "chars": 41717,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/common/clustering/test_spectral.py",
    "chars": 20895,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/common/clustering/test_voting.py",
    "chars": 17968,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/common/metrics.py",
    "chars": 1375,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/common/test_basic_stats.py",
    "chars": 4166,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/common/test_utils.py",
    "chars": 4245,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/comparison_groups/conftest.py",
    "chars": 2471,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/comparison_groups/imm/test_distance_calc_selection.py",
    "chars": 7577,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/comparison_groups/stratified_sampling/test_bin.py",
    "chars": 2376,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/comparison_groups/stratified_sampling/test_bin_selection.py",
    "chars": 9597,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/comparison_groups/stratified_sampling/test_diagnostics.py",
    "chars": 1295,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/comparison_groups/stratified_sampling/test_equivalence.py",
    "chars": 4231,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/comparison_groups/stratified_sampling/test_model.py",
    "chars": 11086,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/conftest.py",
    "chars": 2195,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/base_models/test_c_hdd_tidd_smooth.py",
    "chars": 3347,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/base_models/test_full_model_finder.py",
    "chars": 1143,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/test_billing_data.py",
    "chars": 22977,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/test_daily_data.py",
    "chars": 31531,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/test_daily_model.py",
    "chars": 4727,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/test_data.csv",
    "chars": 25214,
    "preview": "datetime,temperature,observed,season,day_of_week\n2019-03-02 00:00:00+00,53.137118613144565,73.24072778136863,shoulder,6\n"
  },
  {
    "path": "tests/eemeter/daily_model/test_fit_base_models.py",
    "chars": 6641,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/test_fit_model.py",
    "chars": 3615,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/test_objective_function.py",
    "chars": 5322,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/test_optimize.py",
    "chars": 4060,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/test_optimize_results.py",
    "chars": 7115,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/utilities/test_adaptive_loss.py",
    "chars": 3813,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/utilities/test_base_model.py",
    "chars": 6187,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/utilities/test_config.py",
    "chars": 3748,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/utilities/test_ellipsoid_test.py",
    "chars": 4151,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/daily_model/utilities/test_selection_criteria.py",
    "chars": 6210,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/hourly_model/conftest.py",
    "chars": 1198,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  },
  {
    "path": "tests/eemeter/hourly_model/test_hourly_model.py",
    "chars": 11264,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n#  Copyright 2014-2025 OpenDSM contributors\n#  Licensed under the Apache "
  }
]

// ... and 18 more files (download for full content)