mini-causal 0.1.3__tar.gz

mini_causal-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MasemeneMatlakanaBenny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mini_causal-0.1.3/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: mini-causal
+Version: 0.1.3
+Summary: A mini package for causal inference
+Author-email: Masemene Matlakana Benny <bennymasemene46@gmail.com>
+Project-URL: Homepage, https://github.com/MasemeneMatlakanaBenny/Mini_Causal
+Project-URL: Issues, https://github.com/MasemeneMatlakana/Mini_Causal/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=3.0.2
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: scipy>=1.17.1
+Dynamic: license-file
+
+# MiniCausal
+
+![logo](images/cropped_logo.jpeg)

mini_causal-0.1.3/README.md

@@ -0,0 +1,3 @@
+# MiniCausal
+
+![logo](images/cropped_logo.jpeg)

mini_causal-0.1.3/mini_causal/__init__.py

@@ -0,0 +1 @@
+

mini_causal-0.1.3/mini_causal/model_selection.py

@@ -0,0 +1 @@
+from mini_causal.utils import treatment_control_selection

mini_causal-0.1.3/mini_causal/utils.py

@@ -0,0 +1,157 @@
+import numpy as np
+import pandas as pd
+from sklearn import clone
+
+def clone_model(model):
+    return clone(model)
+
+
+def treatment_control_selection(df, control_size=0.2, random_seed=None):
+    """
+    Randomly split dataframe into treatment and control groups.
+
+    Args:
+        df (pd.DataFrame):
+            the input dataframe
+
+        control_size (float):
+            Fraction assigned to control group
+
+        random_seed(int or None):
+            for reproducibilit
+
+    Returns:
+        treatment,control
+    """
+
+    if random_seed is not None:
+        np.random.seed(random_seed)
+
+    n_samples = len(df)
+
+    # Shuffle row indices
+    indices = np.random.permutation(n_samples)
+
+    # Split point
+    split_idx = int(n_samples * (1 - control_size))
+
+    # Indices
+    treat_idx = indices[:split_idx]
+    control_idx = indices[split_idx:]
+
+
+    treatment = df.iloc[treat_idx]
+    control = df.iloc[control_idx]
+
+    return treatment,control
+
+
+
+def make_treatment_control_df(treatment,control)->pd.DataFrame:
+    df=pd.concat([treatment,control])
+
+    return df.sort_index()
+
+
+def summary_stats(treatment:np.ndarray,control:np.ndarray)->pd.DataFrame:
+    n_treatment=len(treatment)
+    n_control=len(control)
+
+    mean_control_preds=float(np.mean(control))
+    mean_treatment_preds=float(np.mean(treatment))
+
+    variance_treatment=float(np.var(treatment,ddof=1))
+    variance_control=float(np.var(control,ddof=1))
+
+    return pd.DataFrame(
+        {
+            "type":["treatment","control"],
+            "n":[n_treatment,n_control],
+            "mean":[mean_treatment_preds,mean_control_preds],
+            "sample_variance":[variance_treatment,variance_control]
+        })
+    
+
+
+def causal_effects_stratum(X:pd.DataFrame,causal_effects:np.ndarray,strata_feature:str):
+    """
+    Args:
+        X (pd.DataFrame):
+            X values stored in a dataframe that will be used for the prediction.
+
+        causal_effects(np.ndarray):
+            the causal effects values
+        
+        strata_feature(str):
+           the name of the feature that will be used for strata
+
+    Returns:
+        pd.DataFrame:
+           - a dataframe with the following columns: strata_feature,mean,size and weight of the strata
+           -  the mean is based on the type arg i.e if preds ,then it will be the mean for the 
+           predictions, else if probs then it will be the mean for the predicted probabilities
+    """
+    N=len(X)
+    X["causal_effects"]=causal_effects
+        
+    results=X.groupby(strata_feature)["causal_effects"].agg(["mean","size"]).reset_index()
+    results["weight_rss"]= results["size"] * N
+
+    return results
+ 
+def stratum_weight_rss(X:pd.DataFrame,
+                       treatment_model,
+                       control_model,
+                       feature:str,
+                       strata_feature:str,
+                       type:str="preds")->pd.DataFrame:
+    """
+    The causal effect based on the stratum to validate the effect per stratum of the treatment.
+
+    Args:
+        X (pd.DataFrame):
+            X values stored in a dataframe that will be used for the prediction.
+
+        strata_feature (str):
+            the name of the feature that will be used for strata
+
+        treatment_model:
+            the trained treatment estimator
+
+        control_model:
+            the trained control estimator
+
+        type (str): {preds,probs}
+            return the stratum values based on the predicted probabilites or predicted values of the target
+
+
+    Returns:
+        pd.DataFrame:
+           - a dataframe with the following columns: strata_feature,mean,size and weight of the strata
+           -  the mean is based on the type arg i.e if preds ,then it will be the mean for the 
+           predictions, else if probs then it will be the mean for the predicted probabilities
+
+    """
+    X_control=X.drop([feature,strata_feature],axis=1)
+    X_treatment=X.drop(strata_feature,axis=1)
+
+    treatment_probs=treatment_model.predict_proba(X_treatment)[:,1]
+    control_probs=control_model.predict_proba(X_control)[:,1]
+
+    treatment_preds=treatment_model.predict(X_treatment)
+    control_preds=control_model.predict(X_control)
+    
+    causal_effects_probs=treatment_probs-control_probs
+    causal_effects=treatment_preds-control_preds
+
+    if type=="preds":
+        return causal_effects_stratum(X=X,causal_effects=causal_effects_probs,
+                                      strata_feature=strata_feature)
+    
+    elif type=="probs":
+        return causal_effects_stratum(X=X,causal_effects=causal_effects,
+                                      strata_feature=strata_feature)
+    
+    else:
+        raise ValueError("Type invalid")
+    

mini_causal-0.1.3/mini_causal.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: mini-causal
+Version: 0.1.3
+Summary: A mini package for causal inference
+Author-email: Masemene Matlakana Benny <bennymasemene46@gmail.com>
+Project-URL: Homepage, https://github.com/MasemeneMatlakanaBenny/Mini_Causal
+Project-URL: Issues, https://github.com/MasemeneMatlakana/Mini_Causal/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=3.0.2
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: scipy>=1.17.1
+Dynamic: license-file
+
+# MiniCausal
+
+![logo](images/cropped_logo.jpeg)

mini_causal-0.1.3/mini_causal.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+mini_causal/__init__.py
+mini_causal/model_selection.py
+mini_causal/utils.py
+mini_causal.egg-info/PKG-INFO
+mini_causal.egg-info/SOURCES.txt
+mini_causal.egg-info/dependency_links.txt
+mini_causal.egg-info/requires.txt
+mini_causal.egg-info/top_level.txt
+tests/test_causal_counter.py
+tests/test_causal_counter_classifier.py
+tests/test_causal_counter_reg.py
+tests/test_causality_classifier.py
+tests/test_causality_reg.py
+tests/test_partial_counter.py
+tests/test_partial_counter_classifier.py
+tests/test_partial_counter_reg.py

mini_causal-0.1.3/mini_causal.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mini_causal-0.1.3/mini_causal.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pandas>=3.0.2
+numpy>=2.4.4
+scipy>=1.17.1

mini_causal-0.1.3/mini_causal.egg-info/top_level.txt

@@ -0,0 +1 @@
+mini_causal

mini_causal-0.1.3/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mini-causal" 
+version = "0.1.3"
+description = "A mini package for causal inference"
+authors = [
+    {name = "Masemene Matlakana Benny", email = "bennymasemene46@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    #  requirements:
+    "pandas >= 3.0.2",
+    "numpy >= 2.4.4",
+    "scipy >= 1.17.1"
+]
+
+[project.urls]
+Homepage = "https://github.com/MasemeneMatlakanaBenny/Mini_Causal"
+Issues = "https://github.com/MasemeneMatlakana/Mini_Causal/issues"
+
+[tool.setuptools]
+packages = ["mini_causal"]

mini_causal-0.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mini_causal-0.1.3/tests/test_causal_counter.py

@@ -0,0 +1,134 @@
+import pytest
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+from mini_causal.causal_counter import CausalCounterfactual
+
+
+@pytest.fixture
+def sample_data():
+    df=pd.DataFrame({
+        "X1":[11,19,20,23,24,25,11,19,20],
+        "X2":[23,15,17,8,12,15,17,16,17],
+        "location":["North","North","South","South","South","North","South","South","North"],
+        "y_class":np.array([19,11,17,30,31,32,77,80,19])
+    })
+
+
+    return df
+
+@pytest.fixture
+def log_model():
+    """
+    Returns:
+        LogisticRegression fitted on sample set
+    """
+    
+    return LogisticRegression(solver="liblinear")
+
+@pytest.fixture
+def log_causal_counter(sample_data,log_model):
+    treatment=sample_data
+    control=sample_data
+    model=log_model
+
+    log_counter=CausalCounterfactual(model=model,
+                                     treatment=treatment,
+                                     control=control,
+                                     feature="X1",
+                                     label="y_class")
+    
+    return log_counter
+
+def test_hypotheses_keys(log_causal_counter):
+    log_counter=log_causal_counter
+   
+    assert "Ho" in log_counter.hypotheses()
+    assert "Ha" in log_counter.hypotheses()
+
+def test_control_model(log_causal_counter,log_model,sample_data):
+    log_counter=log_causal_counter
+    control=sample_data
+    model=log_model
+   
+    X_control=control.drop(["X1","y_class"],axis=1)
+    y_control=control["y_class"]
+
+    model.fit(X_control,y_control)
+
+    assert model == log_counter.control_model()
+
+
+def test_treatment_model(log_causal_counter,log_model,sample_data):
+    log_counter=log_causal_counter
+    treatment=sample_data
+    model=log_model
+   
+    X=treatment.drop("y_class",axis=1)
+    y=treatment["y_class"]
+
+    model.fit(X,y)
+
+    assert model == log_counter.treatment_model()
+
+def test_average_causality(log_causal_counter):
+    log_counter=log_causal_counter
+
+    assert type(log_counter.average_causal_effect()) == float
+
+
+def test_inferential_stats(log_causal_counter):
+    log_counter=log_causal_counter
+
+    correlation=log_counter.correlation()
+    pvalue=log_counter.p_value
+
+    t_stats=log_counter.t_statistic
+
+    assert type(correlation)==float
+    assert type(pvalue)==float
+    assert type(t_stats)==float
+
+
+def test_correlation_ci(log_causal_counter):
+    log_counter=log_causal_counter
+
+    assert "upper_bound" in log_counter.correlation_confidence_interval()
+    assert "lower_bound" in log_counter.correlation_confidence_interval()
+
+
+def test_strat_exp(log_causal_counter,sample_data):
+    log_counter=log_causal_counter
+    X=sample_data.drop("y_class",axis=1)
+    
+    strat_df=log_counter.causal_effect_stratified(
+        X=X,
+        strata_feature="location",
+        type="preds"
+    )
+
+    columns=strat_df.columns
+
+    assert "mean" in columns
+    assert "size" in columns
+    assert "weight_rss" in columns
+
+def test_individual_causal_effects(log_causal_counter,sample_data):
+    log_counter=log_causal_counter
+    df=sample_data
+
+    X=df.drop(["y_class","location"],axis=1)
+    y=df["y_class"]
+
+    causal_effects=log_counter.individual_causal_effects(X=X)
+    causal_resids=log_counter.individual_causal_effects_resid(X=X,y_true=y)
+
+    assert type(causal_effects)==np.ndarray
+    assert type(causal_resids)==np.ndarray
+
+
+
+
+
+
+

mini_causal-0.1.3/tests/test_causal_counter_classifier.py

@@ -0,0 +1,74 @@
+import pytest
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+from mini_causal.causal_counter import CausalCounterfactualClassifier
+
+
+@pytest.fixture
+def sample_data():
+    df=pd.DataFrame({
+        "X1":[11,19,20,23,24,25,11,19,20],
+        "X2":[23,15,17,8,12,15,17,16,17],
+        "y_class":np.array([19,11,17,30,31,32,77,80,19])
+    })
+
+
+    return df
+
+@pytest.fixture
+def log_model():
+    """
+    Returns:
+        LogisticRegression fitted on sample set
+    """
+    
+    return LogisticRegression(solver="liblinear")
+
+@pytest.fixture
+def log_causal_counter(sample_data,log_model):
+    treatment=sample_data
+    control=sample_data
+    model=log_model
+
+    log_counter=CausalCounterfactualClassifier(model=model,
+                                     treatment=treatment,
+                                     control=control,
+                                     feature="X1",
+                                     label="y_class")
+    
+    return log_counter
+
+
+
+def test_individual_causal_effects(log_causal_counter,sample_data):
+    log_counter=log_causal_counter
+    df=sample_data
+
+    X=df.drop("y_class",axis=1)
+    y=df["y_class"]
+
+    causal_effects=log_counter.individual_causal_effects(X=X)
+    causal_resids=log_counter.individual_causal_effects_resid(X=X,y_true=y)
+    causal_probs=log_counter.individual_causal_effects_probs(X=X)
+
+    assert type(causal_effects)==np.ndarray
+    assert type(causal_resids)==np.ndarray
+    assert type(causal_probs)==np.ndarray
+
+def test_causal_effect(log_causal_counter,sample_data):
+    log_counter=log_causal_counter
+    df=sample_data
+
+    X=df.drop("y_class",axis=1)
+    y=df["y_class"]
+
+    causal_effect_preds=log_counter.average_causal_effect(X=X)
+    causal_effect_resid=log_counter.average_causal_effect_resid(X=X,y_true=y)
+    causal_effect_probs=log_counter.average_causal_effect_probs(X=X)
+
+    assert type(causal_effect_preds)==float
+    assert type(causal_effect_resid)==float
+    assert type(causal_effect_probs)==float
+
+

mini_causal-0.1.3/tests/test_causal_counter_reg.py

@@ -0,0 +1,136 @@
+import pytest
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+from mini_causal.causal_counter import CausalCounterfactualRegression
+
+
+@pytest.fixture
+def sample_data():
+    df=pd.DataFrame({
+        "X1":[11,19,20,23,24,25,11,19,20],
+        "X2":[23,15,17,8,12,15,17,16,17],
+        "location":["North","North","South","South","South","North","South","South","North"],
+        "y_reg":np.array([19,11,17,30,31,32,77,80,19])
+    })
+
+
+    return df
+
+@pytest.fixture
+def linear_model():
+    """
+    Returns:
+        Linear Regression class
+    """
+    
+    return LinearRegression()
+
+@pytest.fixture
+def linear_causal_counter(sample_data,log_model):
+    treatment=sample_data
+    control=sample_data
+    model=log_model
+
+    linear_counter=CausalCounterfactualRegression(
+        model=model,
+        treatment=treatment,
+        control=control,
+        feature="X1",
+        label="y_reg")
+    
+    return linear_counter
+
+def test_hypotheses_keys(linear_causal_counter):
+    linear_counter=linear_causal_counter
+   
+    assert "Ho" in linear_counter.hypotheses()
+    assert "Ha" in linear_counter.hypotheses()
+
+def test_control_model(linear_causal_counter,log_model,sample_data):
+    linear_counter=linear_causal_counter
+    control=sample_data
+    model=log_model
+   
+    X_control=control.drop(["X1","location","y_class"],axis=1)
+    y_control=control["y_class"]
+
+    model.fit(X_control,y_control)
+
+    assert model == linear_counter.control_model()
+
+
+def test_treatment_model(linear_causal_counter,linear_model,sample_data):
+    linear_counter=linear_causal_counter
+    treatment=sample_data
+    model=linear_model
+   
+    X=treatment.drop(["location","y_reg"],axis=1)
+    y=treatment["y_reg"]
+
+    model.fit(X,y)
+
+    assert model == linear_counter.treatment_model()
+
+def test_average_causality(linear_causal_counter,sample_data):
+    linear_counter=linear_causal_counter
+    df=sample_data
+
+    X=df.drop(["location","y_reg"],axis=1)
+
+    assert type(linear_counter.average_causal_effect(X=X))==float
+
+
+def test_inferential_stats(linear_causal_counter):
+    linear_counter=linear_causal_counter
+
+    correlation=linear_counter.correlation()
+    pvalue=linear_counter.p_value
+
+    t_stats=linear_counter.t_statistic
+
+    assert type(correlation)==float
+    assert type(pvalue)==float
+    assert type(t_stats)==float
+
+
+def test_correlation_ci(linear_causal_counter):
+    linear_counter=linear_causal_counter
+
+    assert "upper_bound" in linear_counter.correlation_confidence_interval()
+    assert "lower_bound" in linear_counter.correlation_confidence_interval()
+
+
+def test_strat_exp(linear_causal_counter,sample_data):
+    linear_counter=linear_causal_counter
+    X=sample_data
+    
+    strat_df=linear_counter.causal_effect_stratified(
+        X=X,
+        strata_feature="location",
+        type="preds"
+    )
+
+    columns=strat_df.columns
+
+    assert "mean" in columns
+    assert "size" in columns
+    assert "weight_rss" in columns
+
+def test_individual_causal_effects(linear_causal_counter,sample_data):
+    linear_counter=linear_causal_counter
+    df=sample_data
+
+    X=df.drop(["y_reg","location"],axis=1)
+    y=df["y_reg"]
+    
+
+    causal_effects=linear_counter.individual_causal_effects(X=X)
+    causal_resids=linear_counter.individual_causal_effects_resid(X=X,y_true=y)
+
+    assert type(causal_effects)==np.ndarray
+    assert type(causal_resids)==np.ndarray
+
+
+
+

mini_causal-0.1.3/tests/test_causality_classifier.py

@@ -0,0 +1,69 @@
+import pytest
+import pandas as pd
+import numpy as np
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from mini_causal.causality import CausalModelsClassifier
+
+@pytest.fixture
+def sample_data():
+    
+    X=np.array([[1,2,3,4,5,6,7,8,9,10]]).reshape(-1,1)
+    y=np.array([1,1,1,0,0,0,1,1,0,0,1,0])
+
+    return X,y
+
+@pytest.fixture
+def log_model(sample_data):
+   X,y=sample_data
+
+   model=LogisticRegression(solver="liblinear")
+
+   return model.fit(X,y)
+
+@pytest.fixture
+def dt_model(sample_data):
+   X,y=sample_data
+
+   model=DecisionTreeClassifier()
+
+   return model.fit(X,y)
+
+
+@pytest.fixture
+def causal_classifier(log_model,dt_model):
+   
+   first_model=log_model
+   sec_model=dt_model
+
+   return CausalModelsClassifier(
+      first_model=first_model,
+      second_model=sec_model
+   )
+   
+
+def test_individual_causal_effect(causal_classifier):
+   causal_class=causal_classifier
+
+   causal_effects_arr=causal_class.individual_causal_effects()
+   causal_effects_resid=causal_class.individual_causal_effects_resid()
+   causal_effects_probs=causal_class.individual_causal_effects_probs()
+
+   assert type(causal_effects_arr)==np.array
+   assert type(causal_effects_resid)==np.array
+   assert type(causal_effects_probs)==np.array
+
+
+def test_causal_effects(causal_classifier):
+   causal_class=causal_classifier
+
+   causal_effect_preds=causal_class._average_causal_effect()
+   causal_effect_resid=causal_class.average_causal_effect_resid()
+   causal_effect_probs=causal_class.average_causal_effect_probs()
+   
+   assert type(causal_effect_preds)==float
+   assert type(causal_effect_resid)==float
+   assert type(causal_effect_probs)==float
+
+   
+

mini_causal-0.1.3/tests/test_causality_reg.py

@@ -0,0 +1,67 @@
+import pytest
+import numpy as np
+from sklearn.linear_model import LinearRegression
+from sklearn.tree import DecisionTreeRegressor
+from mini_causal.causality import CausalModelsRegression
+
+@pytest.fixture
+def sample_data():
+
+    X=np.array([[1,2,3,4,5,6,7,8,9,10]]).reshape(-1,1)
+    y=np.array([13,16,19,11,55,16,18,30,19,10])
+
+    return X,y
+
+@pytest.fixture
+def linear_model(sample_data):
+   X,y=sample_data
+
+   model=LinearRegression()
+
+   return model.fit(X,y)
+
+@pytest.fixture
+def dt_model(sample_data):
+   X,y=sample_data
+
+   model=DecisionTreeRegressor()
+
+   return model.fit(X,y)
+
+
+@pytest.fixture
+def causal_regressor(linear_model,dt_model):
+   
+   first_model=linear_model
+   sec_model=dt_model
+
+   return CausalModelsRegression(
+      first_model=first_model,
+      second_model=sec_model
+   )
+   
+
+def test_individual_causal_effect(causal_regressor):
+   causal_reg=causal_regressor
+
+   causal_effects_arr=causal_reg.individual_causal_effects()
+   causal_effects_resid=causal_reg.individual_causal_effects_resid()
+   
+
+   assert type(causal_effects_arr)==np.array
+   assert type(causal_effects_resid)==np.array
+   
+
+def test_causal_effects(causal_regressor):
+   causal_reg=causal_regressor
+
+   causal_effect_preds=causal_reg._average_causal_effect()
+   causal_effect_resid=causal_reg.average_causal_effect_resid()
+  
+   
+   assert type(causal_effect_preds)==float
+   assert type(causal_effect_resid)==float
+
+
+   
+

mini_causal-0.1.3/tests/test_partial_counter.py

@@ -0,0 +1,105 @@
+import pytest
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LogisticRegression,LinearRegression
+from mini_causal.partial_counter import PartialCounterfactual
+
+
+@pytest.fixture
+def sample_data():
+    X=pd.DataFrame({"X1":[11,19,20,23,24,25],
+                    "X2":[23,15,17,8,12,15]})
+    y_class=np.array([1,1,0,0,1,1])
+    y_reg=np.array([19,37,65,67,45])
+
+
+    return X,y_class,y_reg
+
+
+@pytest.fixture
+def log_model(sample_data):
+    """
+    Returns:
+        LogisticRegression fitted on sample set
+    """
+    X,y=sample_data
+    log_model=LogisticRegression(solver="liblinear")
+    return log_model.fit(X,y)
+
+@pytest.fixture
+def linear_model(sample_data):
+    """
+    Returns:
+        LinearRegression fitted on sample set
+    """
+    X,_,y=sample_data
+    lr=LinearRegression()
+
+    return lr.fit(X,y)
+
+
+def test_initialization_reg(linear_model,sample_data):
+    """
+    """
+    X,_,y_reg = sample_data
+
+    causal_feat_reg= PartialCounterfactual(linear_model, X, y_reg)
+
+    assert causal_feat_reg.model== linear_model
+    assert len(causal_feat_reg.y) == len(y_reg)
+
+def test_initialization_class(log_model,sample_data):
+    """
+    """
+    X, y_class,_ = sample_data
+
+    causal_feat_classifier= PartialCounterfactual(log_model, X, y_class)
+   
+    assert causal_feat_classifier.model ==log_model
+    assert len(causal_feat_classifier.y) == len(y_class)
+
+def test_causal_effects(linear_model,log_model):
+    """
+    Testing If individual causal effects are returned as numpy array
+
+    Parameters:
+        linear_model : LinearRegression
+        log_model : LogisticRegression
+
+    """
+    X, y_class,y_reg= sample_data
+
+    causal_feat_reg = PartialCounterfactual(linear_model,X, y_reg)
+    causal_feat_classifier = PartialCounterfactual(log_model,X, y_class)
+
+
+    individual_causals_reg=causal_feat_reg._individual_causal_effects(feature="X1")
+    individual_causals_classifier=causal_feat_classifier._individual_causal_effects(feature="X2")
+
+    assert isinstance(individual_causals_reg, np.ndarray)
+    assert isinstance(individual_causals_classifier,np.ndarray)
+
+
+def test_average_causal_effects(linear_model,log_model):
+    """
+     Testing If average causal effects are returned as float values rather
+
+    Parameters:
+        linear_model : LinearRegression
+        log_model : LogisticRegression
+
+    """
+    X, y_class,y_reg= sample_data
+
+    causal_feat_reg = PartialCounterfactual(linear_model,X, y_reg)
+    causal_feat_classifier = PartialCounterfactual(log_model,X, y_class)
+
+
+    ace_reg=causal_feat_reg._average_causal_effects(feature="X1")
+    ace_classifier=causal_feat_classifier.average_effects(feature="X2")
+
+    assert isinstance(ace_reg,float)
+    assert isinstance(ace_classifier,float)
+
+
+

mini_causal-0.1.3/tests/test_partial_counter_classifier.py

@@ -0,0 +1,57 @@
+import pytest
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+from mini_causal.partial_counter import PartialCounterfactualClassifier
+
+
+
+@pytest.fixture
+def sample_data():
+    X=pd.DataFrame({"X1":[11,19,20,23,24,25],
+                    "X2":[23,15,17,8,12,15]})
+    y=[1,1,0,0,1,1]
+
+    return X,y
+
+
+@pytest.fixture
+def model(sample_data):
+    X,y=sample_data
+    log_model= LogisticRegression(solver="liblinear")
+    
+    return log_model.fit(X,y)
+
+def test_initialization(model, sample_data):
+    X, y = sample_data
+
+    partial_counter= PartialCounterfactualClassifier(model, X, y)
+
+    assert partial_counter.model == model
+    assert len(partial_counter.y) == len(y)
+
+
+def test_causal_effects():
+    X, y = sample_data
+
+    partial_counter= PartialCounterfactualClassifier(model, X, y)
+
+    individual_causals=partial_counter._individual_causal_effects(feature="X1")
+    individual_causals_probs=partial_counter._individual_causal_effects_probs(feature="X2")
+
+    assert isinstance(individual_causals, np.ndarray)
+    assert isinstance(individual_causals_probs,np.ndarray)
+
+
+def test_average_causal_effects():
+    X, y = sample_data
+
+    partial_counter= PartialCounterfactualClassifier(model, X, y)
+    ate=partial_counter.average_treatment_effect(feature="X1")
+    ate_probs=partial_counter.average_treatment_effect_probs(feature="X2")
+
+    assert isinstance(ate,float)
+    assert isinstance(ate_probs,float)
+
+
+

mini_causal-0.1.3/tests/test_partial_counter_reg.py

@@ -0,0 +1,47 @@
+import pytest
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+from mini_causal.partial_counter import PartialCounterfactualRegression
+
+
+@pytest.fixture
+def sample_data():
+    X=pd.DataFrame({"X1":[11,19,20,23,24,25],
+                    "X2":[23,15,17,8,12,15]})
+    y=[12,19,13,4,3,11]
+
+    return X,y
+
+@pytest.fixture
+def model(sample_data):
+    X,y=sample_data
+    lr=LinearRegression()
+
+    return lr.fit(X,y)
+
+def test_initialization(model, sample_data):
+    X, y = sample_data
+
+    partial_reg= PartialCounterfactualRegression(model, X, y)
+
+    assert partial_reg.model == model
+    assert len(partial_reg.X)== len(partial_reg.X)
+    assert len(partial_reg.y) == len(y)
+
+def test_individual_causal_effect(model,sample_data):
+    X, y = sample_data
+
+    partial_reg= PartialCounterfactualRegression(model, X, y)
+    individual_effects=partial_reg.individual_causal_effects("X1")
+
+    assert isinstance(individual_effects,np.ndarray)
+
+
+def test_average_causal_effect(model,sample_data):
+    X, y = sample_data
+
+    partial_reg= PartialCounterfactualRegression(model, X, y)
+    average_effect=partial_reg.average_causal_effect("X1")
+
+    assert isinstance(average_effect,float)