pycausal-inference-joshlim 0.1.0__tar.gz

pycausal_inference_joshlim-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Josh Lim
+
+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.

pycausal_inference_joshlim-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: pycausal-inference-joshlim
+Version: 0.1.0
+Summary: A Python package for causal inference methods including ATE estimation, propensity score methods, and meta-learners
+Author-email: Josh Lim <j.lim703@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jhl126/pycausal-inference-joshlim
+Project-URL: Documentation, https://github.com/jhl126/pycausal-inference-joshlim#readme
+Project-URL: Repository, https://github.com/jhl126/pycausal-inference-joshlim
+Project-URL: Bug Tracker, https://github.com/jhl126/pycausal-inference-joshlim/issues
+Keywords: causal inference,statistics,machine learning,treatment effects
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: lightgbm>=3.3.0
+Requires-Dist: patsy>=0.5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: pylint>=2.12.0; extra == "dev"
+Requires-Dist: mypy>=0.950; extra == "dev"
+Dynamic: license-file
+
+[![Tests](https://github.com/jhl126/pycausal-inference-joshlim/workflows/Tests/badge.svg)](https://github.com/jhl126/pycausal-inference-joshlim/actions)
+
+# Causal Inference Python Package - Josh Lim
+
+This package provides key causal inference methods. These methods include ATE estimation from randomized experiments, propensity score methods, and meta-learners.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/jhl126/pycausal-inference-joshlim.git
+cd pycausal-inference-joshlim
+
+# Install in editable mode
+uv pip install -e .
+```
+
+## Usage
+
+Import functions with the following code:
+
+```python
+from pycausal_inference_joshlim import calculate_ate_ci, calculate_ate_pvalue
+from pycausal_inference_joshlim import ipw, doubly_robust
+from pycausal_inference_joshlim import s_learner_discrete, t_learner_discrete, x_learner_discrete, double_ml_cate
+```
+
+## API Documentation
+
+### RCT Module
+- `calculate_ate_ci(data)` - Calculates the average treatment effect (ATE) and confidence interval from randomized experiment data
+- `calculate_ate_pvalue(data)` - Calculates the p-value for the ATE estimate
+
+### Propensity Score Module
+- `ipw(data)` - Estimates the ATE using inverse probability weighting
+- `doubly_robust(data)` - Estimates the ATE using the doubly robust estimator
+
+### Meta-Learners Module
+- `s_learner_discrete(data)` - Estimates heterogeneous treatment effects using the S-Learner approach
+- `t_learner_discrete(data)` - Estimates heterogeneous treatment effects using the T-Learner approach
+- `x_learner_discrete(data)` - Estimates heterogeneous treatment effects using the X-Learner approach
+- `double_ml_cate(data)` - Estimates heterogeneous treatment effects using Double ML

pycausal_inference_joshlim-0.1.0/README.md

@@ -0,0 +1,42 @@
+[![Tests](https://github.com/jhl126/pycausal-inference-joshlim/workflows/Tests/badge.svg)](https://github.com/jhl126/pycausal-inference-joshlim/actions)
+
+# Causal Inference Python Package - Josh Lim
+
+This package provides key causal inference methods. These methods include ATE estimation from randomized experiments, propensity score methods, and meta-learners.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/jhl126/pycausal-inference-joshlim.git
+cd pycausal-inference-joshlim
+
+# Install in editable mode
+uv pip install -e .
+```
+
+## Usage
+
+Import functions with the following code:
+
+```python
+from pycausal_inference_joshlim import calculate_ate_ci, calculate_ate_pvalue
+from pycausal_inference_joshlim import ipw, doubly_robust
+from pycausal_inference_joshlim import s_learner_discrete, t_learner_discrete, x_learner_discrete, double_ml_cate
+```
+
+## API Documentation
+
+### RCT Module
+- `calculate_ate_ci(data)` - Calculates the average treatment effect (ATE) and confidence interval from randomized experiment data
+- `calculate_ate_pvalue(data)` - Calculates the p-value for the ATE estimate
+
+### Propensity Score Module
+- `ipw(data)` - Estimates the ATE using inverse probability weighting
+- `doubly_robust(data)` - Estimates the ATE using the doubly robust estimator
+
+### Meta-Learners Module
+- `s_learner_discrete(data)` - Estimates heterogeneous treatment effects using the S-Learner approach
+- `t_learner_discrete(data)` - Estimates heterogeneous treatment effects using the T-Learner approach
+- `x_learner_discrete(data)` - Estimates heterogeneous treatment effects using the X-Learner approach
+- `double_ml_cate(data)` - Estimates heterogeneous treatment effects using Double ML

pycausal_inference_joshlim-0.1.0/pycausal_inference_joshlim/__init__.py

@@ -0,0 +1,24 @@
+"""pycausal_inference_joshlim - Causal Inference Toolkit"""
+
+__version__ = "0.1.0"
+
+# Import key functions for easy access
+from .rct import calculate_ate_ci, calculate_ate_pvalue
+from .propensity import ipw, doubly_robust
+from .meta_learners import (
+    s_learner_discrete,
+    t_learner_discrete,
+    x_learner_discrete,
+    double_ml_cate
+)
+
+__all__ = [
+    "calculate_ate_ci",
+    "calculate_ate_pvalue",
+    "ipw",
+    "doubly_robust",
+    "s_learner_discrete",
+    "t_learner_discrete",
+    "x_learner_discrete",
+    "double_ml_cate",
+]

pycausal_inference_joshlim-0.1.0/pycausal_inference_joshlim/meta_learners.py

@@ -0,0 +1,163 @@
+import numpy as np
+import pandas as pd
+from lightgbm import LGBMRegressor
+from sklearn.linear_model import LogisticRegression
+
+
+def simple_data(self):
+        """Generate simple data with known treatment effect"""
+        np.random.seed(42)
+        n = 1000
+        
+        # Covariates
+        x1 = np.random.normal(0, 1, n)
+        x2 = np.random.normal(0, 1, n)
+        
+        # Treatment assignment (confounded)
+        prob_t = 1 / (1 + np.exp(-(0.5 * x1 + 0.3 * x2)))
+        t = np.random.binomial(1, prob_t, n)
+        
+        # Outcome with constant treatment effect = 2.0
+        y = 2.0 * t + x1 + 0.5 * x2 + np.random.normal(0, 0.5, n)
+        
+        df = pd.DataFrame({'x1': x1, 'x2': x2, 't': t, 'y': y})
+        
+        # Split into train/test
+        train = df.iloc[:800].copy()
+        test = df.iloc[800:].copy()
+        
+        return train, test
+
+def heterogeneous_data(self):
+        """Generate data with heterogeneous treatment effect"""
+        np.random.seed(123)
+        n = 1500
+        
+        # Covariates
+        x1 = np.random.normal(0, 1, n)
+        x2 = np.random.normal(0, 1, n)
+        
+        # Treatment assignment
+        prob_t = 1 / (1 + np.exp(-(0.4 * x1)))
+        t = np.random.binomial(1, prob_t, n)
+        
+        # Outcome with heterogeneous effect: effect depends on x1
+        # CATE(x1) = 1 + 0.5*x1
+        te = 1.0 + 0.5 * x1
+        y = te * t + x1 + 0.3 * x2 + np.random.normal(0, 0.5, n)
+        
+        df = pd.DataFrame({'x1': x1, 'x2': x2, 't': t, 'y': y})
+        
+        train = df.iloc[:1200].copy()
+        test = df.iloc[1200:].copy()
+        
+        return train, test
+
+def continuous_treatment_data(self):
+        """Generate data with continuous treatment"""
+        np.random.seed(789)
+        n = 1000
+        
+        # Covariates
+        x1 = np.random.normal(0, 1, n)
+        x2 = np.random.normal(0, 1, n)
+        
+        # Continuous treatment
+        t = 10 + x1 + 2*x2 + np.random.normal(0, 1, n)
+        
+        # Outcome: linear effect of treatment
+        y = t + x1 + 0.5*x2 + np.random.normal(0, 0.5, n)
+        
+        df = pd.DataFrame({'x1': x1, 'x2': x2, 't': t, 'y': y})
+        
+        train = df.iloc[:800].copy()
+        test = df.iloc[800:].copy()
+        
+        return train, test
+
+def s_learner_discrete(train, test, X, T, y) -> pd.DataFrame:
+    model = LGBMRegressor()
+    model.fit(train[X + [T]], train[y])
+    
+    t0 = test.copy()
+    t1 = test.copy()
+    
+    t0[T] = 0
+    t1[T] = 1
+    
+    cate = model.predict(t1[X + [T]]) - model.predict(t0[X + [T]])
+    
+    output = test.copy()
+    output['cate'] = cate
+    
+    return output 
+
+def t_learner_discrete(train, test, X, T, y) -> pd.DataFrame:
+    t0 = train.loc[train[T] == 0]
+    t1 = train.loc[train[T] == 1]
+    
+    model0 = LGBMRegressor()
+    model1 = LGBMRegressor()
+    
+    model0.fit(t0[X], t0[y])
+    model1.fit(t1[X], t1[y])
+    
+    cate = model1.predict(test[X]) - model0.predict(test[X])
+    
+    output = test.copy()
+    output['cate'] = cate
+    
+    return output
+
+def x_learner_discrete(train, test, X, T, y) -> pd.DataFrame:
+    t0 = train.loc[train[T] == 0]
+    t1 = train.loc[train[T] == 1]
+    
+    model0 = LGBMRegressor()
+    model1 = LGBMRegressor()
+    
+    model0.fit(t0[X], t0[y])
+    model1.fit(t1[X], t1[y])
+    
+    pseudo0 = model1.predict(t0[X]) - t0[y]
+    pseudo1 = t1[y] - model0.predict(t1[X])
+    
+    tau_model0 = LGBMRegressor()
+    tau_model1 = LGBMRegressor()
+    
+    tau_model0.fit(t0[X], pseudo0)
+    tau_model1.fit(t1[X], pseudo1)
+    
+    lr = LogisticRegression(penalty=None)
+    lr.fit(train[X], train[T])
+    
+    e = lr.predict_proba(test[X])[:, 1]
+    
+    cate = e * tau_model0.predict(test[X]) + (1 - e) * tau_model1.predict(test[X])
+    
+    output = test.copy()
+    output['cate'] = cate
+    
+    return output
+
+def double_ml_cate(train, test, X, T, y) -> pd.DataFrame:
+    model_t = LGBMRegressor()
+    model_t.fit(train[X], train[T])
+    T_res = train[T] - model_t.predict(train[X])
+    
+    model_y = LGBMRegressor()
+    model_y.fit(train[X], train[y])
+    Y_res = train[y] - model_y.predict(train[X])
+    
+    Y_star = Y_res / T_res
+    w = T_res ** 2
+    
+    model = LGBMRegressor()
+    model.fit(train[X], Y_star, sample_weight = w)
+    
+    cate = model.predict(test[X])
+    
+    output = test.copy()
+    output['cate'] = cate
+    
+    return output

pycausal_inference_joshlim-0.1.0/pycausal_inference_joshlim/propensity.py

@@ -0,0 +1,60 @@
+# Solution obtained from Claude to solve for packaging error
+import subprocess
+import sys
+
+subprocess.run([sys.executable, "-m", "pip", "install", "packaging"], capture_output=True)
+
+# Add imports
+import numpy as np
+import pandas as pd
+from patsy import dmatrices, dmatrix
+from sklearn.linear_model import LinearRegression, LogisticRegression
+
+"""Test 1: IPW with simple positive treatment effect"""
+np.random.seed(42)
+n = 1000        
+# Generate data with known ATE = 2
+x = np.random.normal(0, 1, n)
+prob_t = 1 / (1 + np.exp(-(0.5 * x)))
+t = np.random.binomial(1, prob_t, n)
+y = 2 * t + x + np.random.normal(0, 0.5, n)       
+df = pd.DataFrame({'x': x, 't': t, 'y': y})
+
+"""Test 5: IPW with categorical covariate"""
+np.random.seed(101)
+n = 1000        
+# Generate data with categorical confounder
+group = np.random.choice(['A', 'B', 'C'], n)
+group_effect = {'A': 0, 'B': 1, 'C': 2}
+x_numeric = np.array([group_effect[g] for g in group])        
+prob_t = 1 / (1 + np.exp(-(0.5 * x_numeric)))
+t = np.random.binomial(1, prob_t, n)
+y = 2.0 * t + x_numeric + np.random.normal(0, 0.5, n)        
+df = pd.DataFrame({'group': group, 't': t, 'y': y})
+
+def ipw(df: pd.DataFrame, ps_formula: str, T: str, Y: str) -> float:
+    X = dmatrix(ps_formula, df)
+    model = LogisticRegression(penalty = None, max_iter = 1000).fit(X, df[T])
+    ps = model.predict_proba(X)[:,1]
+    return np.mean((df[T] - ps) / (ps*(1-ps)) * df[Y])
+
+def doubly_robust(df: pd.DataFrame, formula: str, T: str, Y: str) -> float:
+    X = dmatrix(formula, df)
+    model = LogisticRegression(penalty=None, max_iter=1000).fit(X,df[T])
+    ps = model.predict_proba(X)[:,1]
+    
+    Y_mat, X_out = dmatrices(f"{Y} ~ {T} + {formula}", df)
+    outcome_model = LinearRegression().fit(X_out, np.array(Y_mat).flatten())
+    
+    mu1_df = df.copy()
+    mu0_df = df.copy()
+    mu1_df[T] = 1
+    mu0_df[T] = 0
+    mu1x = dmatrix(f"{T} + {formula}", mu1_df)
+    mu0x = dmatrix(f"{T} + {formula}", mu0_df)
+
+    mu1 = outcome_model.predict(mu1x).flatten()
+    mu0 = outcome_model.predict(mu0x).flatten()
+    
+    ate = np.mean(df[T] * (df[Y] - mu1) / ps + mu1) - np.mean((1-df[T]) * (df[Y] - mu0) / (1-ps) + mu0)
+    return ate 

pycausal_inference_joshlim-0.1.0/pycausal_inference_joshlim/rct.py

@@ -0,0 +1,61 @@
+from typing import Tuple
+
+import numpy as np
+import pandas as pd
+from scipy.stats import norm
+
+# Positive effect data
+np.random.seed(42)
+n = 1000
+positive_effect_data = pd.DataFrame({
+    'I': range(n),
+    'T': np.random.binomial(1, 0.5, n),
+    })
+positive_effect_data['Y'] = np.where(
+    positive_effect_data['T'] == 1, 
+    np.random.normal(10, 2, n),
+    np.random.normal(8, 2, n)
+    )
+        
+# No effect data
+np.random.seed(123)
+n = 500
+no_effect_data = pd.DataFrame({
+    'I': range(n),
+    'T': np.random.binomial(1, 0.5, n),
+    })
+no_effect_data['Y'] = np.random.normal(5, 3, n)
+
+def calculate_ate_ci(data: pd.DataFrame, alpha: float = 0.05) -> Tuple[float, float, float]:
+    avg_treatment = data.loc[data['T']==1]['Y'].mean()
+    avg_control = data.loc[data['T']==0]['Y'].mean()
+    ATE_estimate = avg_treatment - avg_control
+    
+    n_1 = len(data.loc[data['T']==1])
+    n_0 = len(data.loc[data['T']==0])
+    var_1 = data.loc[data['T']==1]['Y'].var()
+    var_0 = data.loc[data['T']==0]['Y'].var()
+    se_ate = np.sqrt(var_1/n_1 + var_0/n_0)
+    
+    z = norm.ppf(1-alpha/2)
+    
+    ci_lower = ATE_estimate - z*se_ate
+    ci_upper = ATE_estimate + z*se_ate
+    
+    return(ATE_estimate, ci_lower, ci_upper)
+
+def calculate_ate_pvalue(data: pd.DataFrame) -> Tuple[float, float, float]:
+    avg_treatment = data.loc[data['T']==1]['Y'].mean()
+    avg_control = data.loc[data['T']==0]['Y'].mean()
+    ATE_estimate = avg_treatment - avg_control
+    
+    n_1 = len(data.loc[data['T']==1])
+    n_0 = len(data.loc[data['T']==0])
+    var_1 = data.loc[data['T']==1]['Y'].var()
+    var_0 = data.loc[data['T']==0]['Y'].var()
+    se_ate = np.sqrt(var_1/n_1 + var_0/n_0)
+    
+    t_statistic = ATE_estimate / se_ate
+    p_value = 2 * (1-norm.cdf(abs(t_statistic)))
+    
+    return(ATE_estimate, t_statistic, p_value) 

pycausal_inference_joshlim-0.1.0/pycausal_inference_joshlim.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: pycausal-inference-joshlim
+Version: 0.1.0
+Summary: A Python package for causal inference methods including ATE estimation, propensity score methods, and meta-learners
+Author-email: Josh Lim <j.lim703@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jhl126/pycausal-inference-joshlim
+Project-URL: Documentation, https://github.com/jhl126/pycausal-inference-joshlim#readme
+Project-URL: Repository, https://github.com/jhl126/pycausal-inference-joshlim
+Project-URL: Bug Tracker, https://github.com/jhl126/pycausal-inference-joshlim/issues
+Keywords: causal inference,statistics,machine learning,treatment effects
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: lightgbm>=3.3.0
+Requires-Dist: patsy>=0.5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: pylint>=2.12.0; extra == "dev"
+Requires-Dist: mypy>=0.950; extra == "dev"
+Dynamic: license-file
+
+[![Tests](https://github.com/jhl126/pycausal-inference-joshlim/workflows/Tests/badge.svg)](https://github.com/jhl126/pycausal-inference-joshlim/actions)
+
+# Causal Inference Python Package - Josh Lim
+
+This package provides key causal inference methods. These methods include ATE estimation from randomized experiments, propensity score methods, and meta-learners.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/jhl126/pycausal-inference-joshlim.git
+cd pycausal-inference-joshlim
+
+# Install in editable mode
+uv pip install -e .
+```
+
+## Usage
+
+Import functions with the following code:
+
+```python
+from pycausal_inference_joshlim import calculate_ate_ci, calculate_ate_pvalue
+from pycausal_inference_joshlim import ipw, doubly_robust
+from pycausal_inference_joshlim import s_learner_discrete, t_learner_discrete, x_learner_discrete, double_ml_cate
+```
+
+## API Documentation
+
+### RCT Module
+- `calculate_ate_ci(data)` - Calculates the average treatment effect (ATE) and confidence interval from randomized experiment data
+- `calculate_ate_pvalue(data)` - Calculates the p-value for the ATE estimate
+
+### Propensity Score Module
+- `ipw(data)` - Estimates the ATE using inverse probability weighting
+- `doubly_robust(data)` - Estimates the ATE using the doubly robust estimator
+
+### Meta-Learners Module
+- `s_learner_discrete(data)` - Estimates heterogeneous treatment effects using the S-Learner approach
+- `t_learner_discrete(data)` - Estimates heterogeneous treatment effects using the T-Learner approach
+- `x_learner_discrete(data)` - Estimates heterogeneous treatment effects using the X-Learner approach
+- `double_ml_cate(data)` - Estimates heterogeneous treatment effects using Double ML

pycausal_inference_joshlim-0.1.0/pycausal_inference_joshlim.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+pycausal_inference_joshlim/__init__.py
+pycausal_inference_joshlim/meta_learners.py
+pycausal_inference_joshlim/propensity.py
+pycausal_inference_joshlim/rct.py
+pycausal_inference_joshlim.egg-info/PKG-INFO
+pycausal_inference_joshlim.egg-info/SOURCES.txt
+pycausal_inference_joshlim.egg-info/dependency_links.txt
+pycausal_inference_joshlim.egg-info/requires.txt
+pycausal_inference_joshlim.egg-info/top_level.txt
+tests/test_meta_learners.py

pycausal_inference_joshlim-0.1.0/pycausal_inference_joshlim.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pycausal_inference_joshlim-0.1.0/pycausal_inference_joshlim.egg-info/requires.txt

@@ -0,0 +1,13 @@
+pandas>=1.3.0
+numpy>=1.21.0
+scipy>=1.7.0
+scikit-learn>=1.0.0
+lightgbm>=3.3.0
+patsy>=0.5.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=3.0.0
+black>=22.0.0
+pylint>=2.12.0
+mypy>=0.950

pycausal_inference_joshlim-0.1.0/pycausal_inference_joshlim.egg-info/top_level.txt

@@ -0,0 +1 @@
+pycausal_inference_joshlim

pycausal_inference_joshlim-0.1.0/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pycausal-inference-joshlim"  
+version = "0.1.0"
+description = "A Python package for causal inference methods including ATE estimation, propensity score methods, and meta-learners"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Josh Lim", email = "j.lim703@gmail.com"}
+]
+keywords = ["causal inference", "statistics", "machine learning", "treatment effects"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+]
+
+dependencies = [
+    "pandas>=1.3.0",
+    "numpy>=1.21.0",
+    "scipy>=1.7.0",
+    "scikit-learn>=1.0.0",
+    "lightgbm>=3.3.0",
+    "patsy>=0.5.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=3.0.0",
+    "black>=22.0.0",
+    "pylint>=2.12.0",
+    "mypy>=0.950",
+]
+
+[project.urls]
+Homepage = "https://github.com/jhl126/pycausal-inference-joshlim"
+Documentation = "https://github.com/jhl126/pycausal-inference-joshlim#readme"
+Repository = "https://github.com/jhl126/pycausal-inference-joshlim"
+"Bug Tracker" = "https://github.com/jhl126/pycausal-inference-joshlim/issues"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "-v --cov=pycausal_inference_joshlim --cov-report=html --cov-report=term"
+
+[tool.black]
+line-length = 88
+target-version = ['py38', 'py39', 'py310', 'py311']
+include = '\.pyi?$'
+
+[tool.mypy]
+python_version = "3.8"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false

pycausal_inference_joshlim-0.1.0/setup.cfg

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

pycausal_inference_joshlim-0.1.0/tests/test_meta_learners.py

@@ -0,0 +1,96 @@
+import numpy as np
+import pandas as pd
+
+from pycausal_inference_joshlim import s_learner_discrete, t_learner_discrete, x_learner_discrete, double_ml_cate
+
+def simple_data():
+        """Generate simple data with known treatment effect"""
+        np.random.seed(42)
+        n = 1000
+        
+        # Covariates
+        x1 = np.random.normal(0, 1, n)
+        x2 = np.random.normal(0, 1, n)
+        
+        # Treatment assignment (confounded)
+        prob_t = 1 / (1 + np.exp(-(0.5 * x1 + 0.3 * x2)))
+        t = np.random.binomial(1, prob_t, n)
+        
+        # Outcome with constant treatment effect = 2.0
+        y = 2.0 * t + x1 + 0.5 * x2 + np.random.normal(0, 0.5, n)
+        
+        df = pd.DataFrame({'x1': x1, 'x2': x2, 't': t, 'y': y})
+        
+        # Split into train/test
+        train = df.iloc[:800].copy()
+        test = df.iloc[800:].copy()
+        
+        return train, test
+    
+def continuous_treatment_data():
+        """Generate data with continuous treatment"""
+        np.random.seed(789)
+        n = 1000
+        
+        # Covariates
+        x1 = np.random.normal(0, 1, n)
+        x2 = np.random.normal(0, 1, n)
+        
+        # Continuous treatment
+        t = 10 + x1 + 2*x2 + np.random.normal(0, 1, n)
+        
+        # Outcome: linear effect of treatment
+        y = t + x1 + 0.5*x2 + np.random.normal(0, 0.5, n)
+        
+        df = pd.DataFrame({'x1': x1, 'x2': x2, 't': t, 'y': y})
+        
+        train = df.iloc[:800].copy()
+        test = df.iloc[800:].copy()
+        
+        return train, test
+    
+def test_s_learner_returns_dataframe():
+    train, test = simple_data()
+    result = s_learner_discrete(train, test, ['x1', 'x2'], 't', 'y')
+    assert isinstance(result, pd.DataFrame)
+    
+def test_s_learner_has_cate_column():
+     train, test = simple_data()
+     result = s_learner_discrete(train, test, ['x1', 'x2'], 't', 'y')
+     assert 'cate' in result.columns
+     
+def test_s_learner_constant_effect():
+     train, test = simple_data()
+     result = s_learner_discrete(train, test, ['x1', 'x2'], 't', 'y')
+     assert abs(result['cate'].mean() - 2.0) < 0.5
+    
+def test_s_learner_return_numeric_cate():
+     train, test = simple_data()
+     result = s_learner_discrete(train, test, ['x1','x2'], 't','y')
+     assert pd.api.types.is_numeric_dtype(result['cate'])
+
+def test_s_learner_no_nan_values():
+     train, test = simple_data()
+     result = s_learner_discrete(train, test, ['x1', 'x2'], 't', 'y')
+     assert result['cate'].isna().sum() == 0
+     
+def test_t_learner_returns_dataframe():
+     train, test = simple_data()
+     result = t_learner_discrete(train, test, ['x1','x2'], 't', 'y')
+     assert isinstance(result, pd.DataFrame)
+     
+def test_x_learner_returns_dataframe():
+     train, test = simple_data()
+     result = x_learner_discrete(train, test, ['x1','x2'],'t','y')
+     assert isinstance(result, pd.DataFrame)
+     
+def test_double_ml_returns_dataframe():
+     train, test = continuous_treatment_data() 
+     result = double_ml_cate(train, test, ['x1','x2'],'t','y')           
+     assert isinstance(result, pd.DataFrame)
+     
+def test_double_ml_continuous_treatment(): 
+     train, test = continuous_treatment_data() 
+     result = double_ml_cate(train, test, ['x1','x2'],'t','y') 
+     estimated_ate = result['cate'].mean() 
+     assert abs(estimated_ate - 1) < 0.5