PyMetaAnalysis 0.1.0__tar.gz → 0.2.0__tar.gz

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/.github/workflows/release.yml

@@ -116,6 +116,7 @@ jobs:
       - name: Create release
         env:
           GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
         run: |
           args=("$GITHUB_REF_NAME" dist/* release-benchmark.json --verify-tag --generate-notes)
           version="${GITHUB_REF_NAME#v}"

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/CHANGELOG.md

@@ -6,6 +6,22 @@ Changes planned for the next release accumulate under `Unreleased`.
 
 ## Unreleased
 
+## 0.2.0 - 2026-07-16
+
+### Added
+
+- generic `meta_analysis()` accepts either sampling variances or standard
+  errors, with explicit validation and auditable conversion provenance.
+
+### Changed
+
+- package author metadata identifies the project maintainer directly.
+
+### Fixed
+
+- GitHub Release creation receives explicit repository context in tag-driven
+  release jobs.
+
 ## 0.1.0 - 2026-07-15
 
 ### Added

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/CITATION.cff

@@ -5,9 +5,11 @@ message: >-
 title: PyMetaAnalysis
 type: software
 authors:
-  - name: PyMetaAnalysis contributors
-version: 0.1.0
-date-released: 2026-07-15
+  - family-names: Ding
+    given-names: Zhaobo
+    email: ding.zb@yahoo.com
+version: 0.2.0
+date-released: 2026-07-16
 repository-code: https://github.com/ZhaoboDing/PyMetaAnalysis
 url: https://zhaoboding.github.io/PyMetaAnalysis/
 license: MIT

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: PyMetaAnalysis
-Version: 0.1.0
+Version: 0.2.0
 Summary: A pandas-first, auditable meta-analysis library for Python
 Project-URL: Documentation, https://zhaoboding.github.io/PyMetaAnalysis/
 Project-URL: Source, https://github.com/ZhaoboDing/PyMetaAnalysis
 Project-URL: Issues, https://github.com/ZhaoboDing/PyMetaAnalysis/issues
 Project-URL: Changelog, https://github.com/ZhaoboDing/PyMetaAnalysis/blob/main/CHANGELOG.md
-Author: PyMetaAnalysis contributors
+Author-email: Zhaobo Ding <ding.zb@yahoo.com>
 Maintainer-email: Zhaobo Ding <ding.zb@yahoo.com>
 License-Expression: MIT
 License-File: LICENSE
@@ -115,7 +115,7 @@ subgroup differences.
 
 | Input | Effects | Pooling/models |
 | --- | --- | --- |
-| Effect + sampling variance | Generic | Common/random inverse variance |
+| Effect + sampling variance or standard error | Generic | Common/random inverse variance |
 | Two-group events + totals | OR, RR, RD | Common MH OR/RR; common/random IV |
 | Two-group means + SDs + sizes | MD, Hedges' g | Common/random inverse variance |
 
@@ -124,6 +124,10 @@ and DerSimonian-Laird tau-squared estimators. Mean confidence intervals support
 the normal default plus unmodified and safeguarded Hartung-Knapp variants.
 Eligible random-effects fits include an HTS prediction interval.
 
+Generic analyses accept exactly one of `variance=` or `standard_error=`.
+Standard errors are squared internally and the conversion is recorded in the
+result provenance.
+
 Sparse binary behavior is explicit: study-level and Mantel-Haenszel continuity
 corrections are separate, relative-effect double-zero/double-all rows remain
 visible as exclusions, and RD exposes

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/README.md

@@ -66,7 +66,7 @@ subgroup differences.
 
 | Input | Effects | Pooling/models |
 | --- | --- | --- |
-| Effect + sampling variance | Generic | Common/random inverse variance |
+| Effect + sampling variance or standard error | Generic | Common/random inverse variance |
 | Two-group events + totals | OR, RR, RD | Common MH OR/RR; common/random IV |
 | Two-group means + SDs + sizes | MD, Hedges' g | Common/random inverse variance |
 
@@ -75,6 +75,10 @@ and DerSimonian-Laird tau-squared estimators. Mean confidence intervals support
 the normal default plus unmodified and safeguarded Hartung-Knapp variants.
 Eligible random-effects fits include an HTS prediction interval.
 
+Generic analyses accept exactly one of `variance=` or `standard_error=`.
+Standard errors are squared internally and the conversion is recorded in the
+result provenance.
+
 Sparse binary behavior is explicit: study-level and Mantel-Haenszel continuity
 corrections are separate, relative-effect double-zero/double-all rows remain
 visible as exclusions, and RD exposes

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/docs/getting-started.md

@@ -20,9 +20,10 @@ See [installation](installation.md) for all extras and development checks.
 
 ## 2. Prepare a DataFrame
 
-The generic API expects one effect estimate and one strictly positive sampling
-variance per study. A standard error is not a variance; square it before using
-it as `variance=`.
+The generic API expects one effect estimate and either a strictly positive
+sampling variance or standard error per study. Supply `variance=` or
+`standard_error=`; standard errors are squared internally and recorded in
+provenance.
 
 ```python
 import pandas as pd

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/docs/guides/generic-effects.md

@@ -1,8 +1,8 @@
 # Generic effects
 
 Use `meta_analysis()` when each study already has an effect estimate and its
-sampling variance. This is the generic inverse-variance workflow; it does not
-calculate an outcome-specific effect size.
+sampling variance or standard error. This is the generic inverse-variance
+workflow; it does not calculate an outcome-specific effect size.
 
 The pooling, tau-squared, confidence-interval, prediction-interval, and
 heterogeneity equations are specified under
@@ -49,22 +49,29 @@ result = ma.meta_analysis(
 All array-like arguments must be one-dimensional and have equal lengths.
 Generated row labels start at zero when no study labels are supplied.
 
-## Variance, not standard error
+## Variance or standard error
 
-`variance=` must contain finite, strictly positive sampling variances. Convert
-reported standard errors explicitly:
+Supply exactly one of `variance=` or `standard_error=`. Both must contain
+finite, strictly positive values. A reported standard-error column can be used
+directly:
 
 ```python
-data["vi"] = data["standard_error"] ** 2
+result = ma.meta_analysis(
+    data,
+    effect="yi",
+    standard_error="standard_error",
+)
 ```
 
-Do not pass confidence-interval widths or study sample variances unless they
-have first been converted to the sampling variance of the effect estimate.
+PyMetaAnalysis squares standard errors internally, retains both uncertainty
+columns in the study table, and records the conversion in provenance. Do not
+pass confidence-interval widths or study sample standard deviations as
+standard errors; they describe different quantities.
 
 ## Missing values
 
-The default `missing="raise"` rejects missing effects or variances. To
-retain incomplete rows as structured exclusions:
+The default `missing="raise"` rejects missing effects or values in the selected
+uncertainty input. To retain incomplete rows as structured exclusions:
 
 ```python
 result = ma.meta_analysis(

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/docs/guides/input-data.md

@@ -30,6 +30,8 @@ result = ma.meta_analysis(
 
 Column names must exist. Array-like inputs may be mixed with DataFrame columns,
 but every array must contain exactly one value for every DataFrame row.
+Generic analyses require exactly one uncertainty input: `variance=` or
+`standard_error=`.
 
 ## Array-like inputs
 
@@ -38,7 +40,7 @@ Lists, tuples, pandas Series, and one-dimensional NumPy arrays are accepted:
 ```python
 result = ma.meta_analysis(
     effect=[0.1, 0.3, -0.2],
-    variance=[0.02, 0.04, 0.03],
+    standard_error=[0.14, 0.20, 0.17],
     study=["A", "B", "C"],
 )
 ```

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/docs/guides/provenance-reporting.md

@@ -38,6 +38,10 @@ document.
 Each `TransformationRecord` has a stable name, resolved parameters, and the
 original row IDs it affected.
 
+Generic analyses supplied through `standard_error=` record a
+`standard_error_to_variance` transformation for every non-missing standard
+error that was squared before fitting.
+
 Binary analyses record:
 
 - the OR, RR, or RD effect-size transformation and its scales;

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/docs/guides/r-interoperability.md

@@ -139,7 +139,19 @@ rma.uni(
 ```
 
 The corresponding R `meta` configuration starts from standard errors rather
-than variances:
+than variances. PyMetaAnalysis can accept that uncertainty column directly as
+`standard_error=`; no manual squaring step is required:
+
+```python
+result = ma.meta_analysis(
+    studies,
+    effect="yi",
+    standard_error="sei",
+    model="random",
+    tau2_method="REML",
+    ci_method="hartung_knapp_adhoc",
+)
+```
 
 ```r
 metagen(

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/docs/index.md

@@ -82,9 +82,10 @@ lists unsupported methods explicitly.
 
 ## Project status
 
-PyMetaAnalysis 0.1.0 is the initial public release and has not undergone a
-formal external statistical audit. Pin the package version for consequential
-work and independently check important analyses. See the repository
+PyMetaAnalysis 0.2.0 adds direct generic standard-error input to the initial
+public analysis scope. It has not undergone a formal external statistical
+audit. Pin the package version for consequential work and independently check
+important analyses. See the repository
 [changelog](https://github.com/ZhaoboDing/PyMetaAnalysis/blob/main/CHANGELOG.md)
 and [contribution guide](development.md). For manuscripts and archived
 analyses, see [citing PyMetaAnalysis](citation.md).

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/docs/limitations.md

@@ -27,8 +27,7 @@ deferred functionality explicit.
 - multilevel, multivariate, network, dose-response, diagnostic-accuracy, or
   individual-participant-data meta-analysis;
 - robust variance estimation or dependent-effect clustering;
-- single proportions, incidence rates, correlations, survival outcomes, or
-  generic standard-error input helpers;
+- single proportions, incidence rates, correlations, or survival outcomes;
 - Knapp-Hartung variants beyond the two documented choices;
 - alternative prediction-interval methods;
 - formal funnel-asymmetry, trim-and-fill, selection-model, or publication-bias
@@ -70,7 +69,7 @@ workflow must version those artifacts separately.
 
 ## Stability and review status
 
-The package version is currently `0.1.0`. Public APIs and serialized schemas
+The package version is currently `0.2.0`. Public APIs and serialized schemas
 may change during the 0.x series. Pin versions in analysis environments and
 inspect changelog/schema updates before upgrading.
 

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/docs/reference/api.md

@@ -47,7 +47,8 @@ ma.meta_analysis(
     data=None,
     *,
     effect,
-    variance,
+    variance=None,
+    standard_error=None,
     study=None,
     subgroup=None,
     model="random",
@@ -66,7 +67,8 @@ Fits generic study effects using inverse-variance pooling.
 | --- | --- |
 | `data` | Optional DataFrame used by string-valued input selectors |
 | `effect` | Study effect column or array on a consistent model scale |
-| `variance` | Finite, strictly positive sampling variances—not standard errors |
+| `variance` | Finite, strictly positive sampling variances |
+| `standard_error` | Finite, strictly positive standard errors, squared internally |
 | `study` | Optional label column/array; defaults to index or row number |
 | `subgroup` | Optional subgroup column/array |
 | `model` | `"common"` or `"random"` |
@@ -77,6 +79,10 @@ Fits generic study effects using inverse-variance pooling.
 | `atol` | Strictly positive iterative-estimator tolerance |
 | `max_iter` | Positive iterative-estimator iteration limit |
 
+Supply exactly one of `variance` or `standard_error`. The selected argument
+supports the same DataFrame-column and array-like conventions as `effect`.
+Standard-error conversion is recorded in result provenance.
+
 ## `meta_binary()`
 
 ```text

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/docs/releasing.md

@@ -44,7 +44,7 @@ and its
    `CITATION.cff`. Hatchling reads the package version dynamically from
    `_version.py`.
 4. Move the relevant `CHANGELOG.md` entries from `Unreleased` to a dated
-   heading such as `## 0.1.0 - 2026-07-15`.
+   heading such as `## X.Y.Z - YYYY-MM-DD`.
 5. Run the complete validation suite.
 
 The local consistency check is:
@@ -56,7 +56,7 @@ python tools/check_release.py
 For a proposed tag, add:
 
 ```console
-python tools/check_release.py --tag v0.1.0
+python tools/check_release.py --tag vX.Y.Z
 ```
 
 The tag check rejects development versions, version mismatches, and releases
@@ -90,8 +90,8 @@ commit:
 ```console
 git switch main
 git pull --ff-only
-git tag -a v0.1.0 -m "PyMetaAnalysis 0.1.0"
-git push origin v0.1.0
+git tag -a vX.Y.Z -m "PyMetaAnalysis X.Y.Z"
+git push origin vX.Y.Z
 ```
 
 The release workflow then:

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/pyproject.toml

@@ -11,7 +11,7 @@ requires-python = ">=3.10"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [
-  { name = "PyMetaAnalysis contributors" },
+  { name = "Zhaobo Ding", email = "ding.zb@yahoo.com" },
 ]
 maintainers = [
   { name = "Zhaobo Ding", email = "ding.zb@yahoo.com" },

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/src/meta_analyze/_version.py

@@ -1,3 +1,3 @@
 """Single source of truth for the package version."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/src/meta_analyze/api.py

@@ -13,7 +13,11 @@ from .data import ColumnOrArray, MissingPolicy, normalize_studies
 from .estimators import fit_inverse_variance
 from .exceptions import InvalidStudyDataError, UnsupportedMethodError
 from .heterogeneity import classical_heterogeneity, tau2_inconsistency
-from .provenance import add_input_field, build_analysis_provenance
+from .provenance import (
+    TransformationRecord,
+    add_input_field,
+    build_analysis_provenance,
+)
 from .results import (
     FitDiagnostics,
     HeterogeneityResult,
@@ -65,7 +69,8 @@ def _fit_meta_analysis_single(
     data: pd.DataFrame | None = None,
     *,
     effect: ColumnOrArray,
-    variance: ColumnOrArray,
+    variance: ColumnOrArray | None = None,
+    standard_error: ColumnOrArray | None = None,
     study: ColumnOrArray | None = None,
     model: str = "random",
     tau2_method: str = "REML",
@@ -82,9 +87,14 @@ def _fit_meta_analysis_single(
     data:
         Optional pandas DataFrame. String-valued input arguments select columns
         from this frame.
-    effect, variance:
+    effect:
         A DataFrame column name or one-dimensional array-like containing study
-        effects and strictly positive sampling variances.
+        effects.
+    variance, standard_error:
+        Exactly one must be provided as a DataFrame column name or
+        one-dimensional array-like. Values must be finite and strictly
+        positive. Standard errors are squared internally to obtain sampling
+        variances.
     study:
         Optional study label column/array. DataFrame input defaults to its index;
         array-only input defaults to integer row labels.
@@ -118,6 +128,7 @@ def _fit_meta_analysis_single(
         data=data,
         effect=effect,
         variance=variance,
+        standard_error=standard_error,
         study=study,
         missing=missing,
     )
@@ -190,12 +201,30 @@ def _fit_meta_analysis_single(
         max_iter=max_iter,
         options=(),
     )
+    transformations: tuple[TransformationRecord, ...] = ()
+    if standard_error is not None:
+        uncertainty_input = ("standard_error", standard_error)
+        transformed_rows = tuple(
+            int(row) for row in np.flatnonzero(~pd.isna(studies.variance))
+        )
+        transformations = (
+            TransformationRecord(
+                name="standard_error_to_variance",
+                affected_rows=transformed_rows,
+            ),
+        )
+    else:
+        if variance is None:  # pragma: no cover - validated by normalize_studies
+            raise RuntimeError("variance input unexpectedly missing")
+        uncertainty_input = ("variance", variance)
+
     provenance = build_analysis_provenance(
         analysis_type="generic",
         data=data,
-        inputs=(("effect", effect), ("variance", variance)),
+        inputs=(("effect", effect), uncertainty_input),
         study=study,
         included=studies.included,
+        transformations=transformations,
     )
 
     return MetaAnalysisResult(
@@ -226,6 +255,26 @@ def meta_analysis(
     *,
     effect: ColumnOrArray,
     variance: ColumnOrArray,
+    standard_error: None = None,
+    study: ColumnOrArray | None = None,
+    subgroup: None = None,
+    model: str = "random",
+    tau2_method: str = "REML",
+    ci_method: str = "normal",
+    confidence_level: float = 0.95,
+    missing: MissingPolicy = "raise",
+    atol: float = 1e-10,
+    max_iter: int = 1000,
+) -> MetaAnalysisResult: ...
+
+
+@overload
+def meta_analysis(
+    data: pd.DataFrame | None = None,
+    *,
+    effect: ColumnOrArray,
+    variance: None = None,
+    standard_error: ColumnOrArray,
     study: ColumnOrArray | None = None,
     subgroup: None = None,
     model: str = "random",
@@ -244,6 +293,7 @@ def meta_analysis(
     *,
     effect: ColumnOrArray,
     variance: ColumnOrArray,
+    standard_error: None = None,
     study: ColumnOrArray | None = None,
     subgroup: ColumnOrArray,
     model: str = "random",
@@ -256,11 +306,31 @@ def meta_analysis(
 ) -> SubgroupMetaAnalysisResult: ...
 
 
+@overload
 def meta_analysis(
     data: pd.DataFrame | None = None,
     *,
     effect: ColumnOrArray,
-    variance: ColumnOrArray,
+    variance: None = None,
+    standard_error: ColumnOrArray,
+    study: ColumnOrArray | None = None,
+    subgroup: ColumnOrArray,
+    model: str = "random",
+    tau2_method: str = "REML",
+    ci_method: str = "normal",
+    confidence_level: float = 0.95,
+    missing: MissingPolicy = "raise",
+    atol: float = 1e-10,
+    max_iter: int = 1000,
+) -> SubgroupMetaAnalysisResult: ...
+
+
+def meta_analysis(
+    data: pd.DataFrame | None = None,
+    *,
+    effect: ColumnOrArray,
+    variance: ColumnOrArray | None = None,
+    standard_error: ColumnOrArray | None = None,
     study: ColumnOrArray | None = None,
     subgroup: ColumnOrArray | None = None,
     model: str = "random",
@@ -273,18 +343,21 @@ def meta_analysis(
 ) -> MetaAnalysisResult | SubgroupMetaAnalysisResult:
     """Fit a generic inverse-variance meta-analysis, optionally by subgroup.
 
-    ``effect`` and ``variance`` accept DataFrame column names or one-dimensional
-    array-like values. Sampling variances must be finite and strictly positive.
-    The default is a REML random-effects model with a normal confidence
-    interval. ``subgroup`` returns :class:`SubgroupMetaAnalysisResult` when
-    supplied; otherwise the return value is :class:`MetaAnalysisResult`.
-    Missing subgroup labels are rejected explicitly.
+    ``effect`` and the selected uncertainty input accept DataFrame column names
+    or one-dimensional array-like values. Supply exactly one of ``variance`` or
+    ``standard_error``; standard errors are squared internally. Uncertainty
+    values must be finite and strictly positive. The default is a REML
+    random-effects model with a normal confidence interval. ``subgroup``
+    returns :class:`SubgroupMetaAnalysisResult` when supplied; otherwise the
+    return value is :class:`MetaAnalysisResult`. Missing subgroup labels are
+    rejected explicitly.
     """
 
     overall = _fit_meta_analysis_single(
         data,
         effect=effect,
         variance=variance,
+        standard_error=standard_error,
         study=study,
         model=model,
         tau2_method=tau2_method,

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/src/meta_analyze/data.py

@@ -70,6 +70,7 @@ def _study_labels(
     *,
     data: pd.DataFrame | None,
     length: int,
+    uncertainty_label: str = "variance",
 ) -> NDArray[np.object_]:
     if study is None:
         labels: NDArray[Any]
@@ -82,17 +83,33 @@ def _study_labels(
 
     if len(labels) != length:
         raise InvalidStudyDataError(
-            f"study has length {len(labels)}, but effect and variance have "
-            f"length {length}."
+            f"study has length {len(labels)}, but effect and {uncertainty_label} "
+            f"have length {length}."
         )
     return np.asarray(labels, dtype=object)
 
 
+def _select_uncertainty_input(
+    variance: ColumnOrArray | None,
+    standard_error: ColumnOrArray | None,
+) -> tuple[ColumnOrArray, str, str]:
+    if (variance is None) == (standard_error is None):
+        raise InvalidStudyDataError(
+            "Exactly one of variance or standard_error must be provided."
+        )
+    if standard_error is not None:
+        return standard_error, "standard_error", "standard error"
+    if variance is None:  # pragma: no cover - guarded by the exclusive check
+        raise RuntimeError("variance input unexpectedly missing")
+    return variance, "variance", "variance"
+
+
 def normalize_studies(
     *,
     data: pd.DataFrame | None,
     effect: ColumnOrArray,
-    variance: ColumnOrArray,
+    variance: ColumnOrArray | None,
+    standard_error: ColumnOrArray | None = None,
     study: ColumnOrArray | None,
     missing: MissingPolicy,
 ) -> NormalizedStudies:
@@ -103,12 +120,15 @@ def normalize_studies(
     if missing not in {"raise", "drop"}:
         raise InvalidStudyDataError("missing must be either 'raise' or 'drop'.")
 
+    uncertainty, uncertainty_name, uncertainty_label = _select_uncertainty_input(
+        variance, standard_error
+    )
     raw_effect = _resolve_vector(effect, data=data, name="effect")
-    raw_variance = _resolve_vector(variance, data=data, name="variance")
-    if len(raw_effect) != len(raw_variance):
+    raw_uncertainty = _resolve_vector(uncertainty, data=data, name=uncertainty_name)
+    if len(raw_effect) != len(raw_uncertainty):
         raise InvalidStudyDataError(
-            "effect and variance must have the same length; "
-            f"got {len(raw_effect)} and {len(raw_variance)}."
+            f"effect and {uncertainty_label} must have the same length; "
+            f"got {len(raw_effect)} and {len(raw_uncertainty)}."
         )
     if data is not None and len(data) != len(raw_effect):
         raise InvalidStudyDataError(
@@ -116,55 +136,77 @@ def normalize_studies(
             "DataFrame row."
         )
 
-    labels = _study_labels(study, data=data, length=len(raw_effect))
+    labels = _study_labels(
+        study,
+        data=data,
+        length=len(raw_effect),
+        uncertainty_label=uncertainty_label,
+    )
 
     try:
         effect_values = np.asarray(raw_effect, dtype=np.float64)
-        variance_values = np.asarray(raw_variance, dtype=np.float64)
+        uncertainty_values = np.asarray(raw_uncertainty, dtype=np.float64)
     except (TypeError, ValueError) as error:
         raise InvalidStudyDataError(
-            "effect and variance must contain numeric values."
+            f"effect and {uncertainty_label} must contain numeric values."
         ) from error
 
     effect_missing = pd.isna(effect_values)
-    variance_missing = pd.isna(variance_values)
-    any_missing = effect_missing | variance_missing
+    uncertainty_missing = pd.isna(uncertainty_values)
+    any_missing = effect_missing | uncertainty_missing
     if np.any(any_missing) and missing == "raise":
         rows = np.flatnonzero(any_missing).tolist()
         raise InvalidStudyDataError(
-            f"Missing effect or variance values at row positions {rows}; "
+            f"Missing effect or {uncertainty_label} values at row positions {rows}; "
             "use missing='drop' to exclude them explicitly."
         )
 
     finite_effect = np.isfinite(effect_values) | effect_missing
-    finite_variance = np.isfinite(variance_values) | variance_missing
+    finite_uncertainty = np.isfinite(uncertainty_values) | uncertainty_missing
     if not np.all(finite_effect):
         rows = np.flatnonzero(~finite_effect).tolist()
         raise InvalidStudyDataError(
             f"Effect values must be finite; invalid rows: {rows}."
         )
-    if not np.all(finite_variance):
-        rows = np.flatnonzero(~finite_variance).tolist()
+    if not np.all(finite_uncertainty):
+        rows = np.flatnonzero(~finite_uncertainty).tolist()
         raise InvalidStudyDataError(
-            f"Variance values must be finite; invalid rows: {rows}."
+            f"{uncertainty_label.capitalize()} values must be finite; "
+            f"invalid rows: {rows}."
         )
 
-    nonpositive_variance = (~variance_missing) & (variance_values <= 0.0)
-    if np.any(nonpositive_variance):
-        rows = np.flatnonzero(nonpositive_variance).tolist()
+    nonpositive_uncertainty = (~uncertainty_missing) & (uncertainty_values <= 0.0)
+    if np.any(nonpositive_uncertainty):
+        rows = np.flatnonzero(nonpositive_uncertainty).tolist()
         raise InvalidStudyDataError(
-            f"Sampling variances must be strictly positive; invalid rows: {rows}."
+            f"Sampling {uncertainty_label}s must be strictly positive; "
+            f"invalid rows: {rows}."
         )
 
+    if uncertainty_name == "standard_error":
+        with np.errstate(over="ignore", under="ignore", invalid="ignore"):
+            variance_values = np.square(uncertainty_values)
+        invalid_variance = (~uncertainty_missing) & (
+            (~np.isfinite(variance_values)) | (variance_values <= 0.0)
+        )
+        if np.any(invalid_variance):
+            rows = np.flatnonzero(invalid_variance).tolist()
+            raise InvalidStudyDataError(
+                "Standard errors must produce finite, strictly positive sampling "
+                f"variances after squaring; invalid rows: {rows}."
+            )
+    else:
+        variance_values = uncertainty_values
+
     included = ~any_missing
     reasons = np.full(len(effect_values), None, dtype=object)
     for index in np.flatnonzero(any_missing):
-        if effect_missing[index] and variance_missing[index]:
-            reasons[index] = "missing effect and variance"
+        if effect_missing[index] and uncertainty_missing[index]:
+            reasons[index] = f"missing effect and {uncertainty_label}"
         elif effect_missing[index]:
             reasons[index] = "missing effect"
         else:
-            reasons[index] = "missing variance"
+            reasons[index] = f"missing {uncertainty_label}"
 
     if not np.any(included):
         raise InvalidStudyDataError(

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/src/meta_analyze/reporting.py

@@ -105,6 +105,13 @@ def method_details(result: MetaAnalysisResult) -> str:
         f"using {_measure_description(result.measure)}, pooled with {pooling}."
     ]
 
+    standard_error_rows = _transformation_rows(result, "standard_error_to_variance")
+    if standard_error_rows:
+        sentences.append(
+            "Supplied standard errors were squared to obtain sampling "
+            f"variances for {len(standard_error_rows)} row(s)."
+        )
+
     if result.model == "random":
         sentences.append(
             "Between-study variance was estimated with "

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/tests/test_api.py

@@ -42,6 +42,34 @@ def test_dataframe_columns_and_default_index_labels() -> None:
     assert result.study_results["row_id"].tolist() == [0, 1, 2]
 
 
+def test_standard_error_input_matches_sampling_variance_input() -> None:
+    effect = np.asarray([0.1, 0.4, -0.2])
+    standard_error = np.asarray([0.2, 0.3, 0.4])
+
+    from_standard_error = ma.meta_analysis(
+        effect=effect,
+        standard_error=standard_error,
+        model="common",
+    )
+    from_variance = ma.meta_analysis(
+        effect=effect,
+        variance=standard_error**2,
+        model="common",
+    )
+
+    assert from_standard_error.estimate == pytest.approx(from_variance.estimate)
+    assert from_standard_error.standard_error == pytest.approx(
+        from_variance.standard_error
+    )
+    assert from_standard_error.q == pytest.approx(from_variance.q)
+    np.testing.assert_allclose(
+        from_standard_error.study_results["variance"], standard_error**2
+    )
+    np.testing.assert_allclose(
+        from_standard_error.study_results["standard_error"], standard_error
+    )
+
+
 def test_explicit_study_column_overrides_dataframe_index() -> None:
     data = pd.DataFrame(
         {
@@ -162,6 +190,62 @@ def test_invalid_study_data_raises_domain_error(
         ma.meta_analysis(**kwargs, model="common")  # type: ignore[arg-type]
 
 
+@pytest.mark.parametrize(
+    ("kwargs", "match"),
+    [
+        ({"effect": [0.1]}, "Exactly one"),
+        (
+            {
+                "effect": [0.1],
+                "variance": [0.01],
+                "standard_error": [0.1],
+            },
+            "Exactly one",
+        ),
+        (
+            {"effect": [0.1], "standard_error": [0.0]},
+            "standard errors must be strictly positive",
+        ),
+        (
+            {"effect": [0.1], "standard_error": [np.inf]},
+            "Standard error values must be finite",
+        ),
+        (
+            {"effect": [0.1], "standard_error": ["invalid"]},
+            "standard error must contain numeric values",
+        ),
+        (
+            {"effect": [0.1], "standard_error": [1e308]},
+            "finite, strictly positive sampling variances after squaring",
+        ),
+        (
+            {"effect": [0.1], "standard_error": [1e-300]},
+            "finite, strictly positive sampling variances after squaring",
+        ),
+    ],
+)
+def test_standard_error_input_errors_are_explicit(
+    kwargs: dict[str, object], match: str
+) -> None:
+    with pytest.raises(ma.InvalidStudyDataError, match=match):
+        ma.meta_analysis(**kwargs, model="common")  # type: ignore[arg-type]
+
+
+def test_missing_standard_error_drop_records_specific_reasons() -> None:
+    result = ma.meta_analysis(
+        effect=[np.nan, 0.2, 0.3],
+        standard_error=[np.nan, np.nan, 0.2],
+        missing="drop",
+        model="common",
+    )
+
+    assert result.study_results["exclusion_reason"].tolist() == [
+        "missing effect and standard error",
+        "missing standard error",
+        None,
+    ]
+
+
 def test_random_effects_requires_two_included_studies() -> None:
     with pytest.raises(ma.InsufficientStudiesError, match="at least two"):
         ma.meta_analysis(effect=[0.1], variance=[0.01], model="random")

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/tests/test_properties.py

@@ -82,3 +82,35 @@ def test_normalized_weights_are_nonnegative_and_sum_to_one(
 
     assert np.all(weights >= 0.0)
     assert np.sum(weights) == pytest.approx(1.0, abs=1e-12)
+
+
+@given(study_vectors())
+@settings(max_examples=75, deadline=None)
+def test_standard_error_and_variance_inputs_are_equivalent(
+    vectors: tuple[np.ndarray, np.ndarray],
+) -> None:
+    effect, variance = vectors
+    from_variance = ma.meta_analysis(
+        effect=effect,
+        variance=variance,
+        model="common",
+    )
+    from_standard_error = ma.meta_analysis(
+        effect=effect,
+        standard_error=np.sqrt(variance),
+        model="common",
+    )
+
+    assert from_standard_error.estimate == pytest.approx(
+        from_variance.estimate, rel=1e-12, abs=1e-12
+    )
+    assert from_standard_error.standard_error == pytest.approx(
+        from_variance.standard_error, rel=1e-12, abs=1e-12
+    )
+    assert from_standard_error.q == pytest.approx(from_variance.q, rel=1e-11, abs=1e-11)
+    np.testing.assert_allclose(
+        from_standard_error.study_results["normalized_weight"],
+        from_variance.study_results["normalized_weight"],
+        rtol=1e-12,
+        atol=1e-12,
+    )

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/tests/test_release_readiness.py

@@ -26,6 +26,10 @@ def test_release_metadata_sources_match() -> None:
     assert 'license = "MIT"' in pyproject
     assert 'license-files = ["LICENSE"]' in pyproject
     assert '"License ::' not in pyproject
+    assert pyproject.count('{ name = "Zhaobo Ding", email = "ding.zb@yahoo.com" }') == 2
+    assert "family-names: Ding" in citation
+    assert "given-names: Zhaobo" in citation
+    assert "email: ding.zb@yahoo.com" in citation
 
 
 def test_release_metadata_checker_runs() -> None:
@@ -39,6 +43,19 @@ def test_release_metadata_checker_runs() -> None:
     assert ma.__version__ in completed.stdout
 
 
+def test_github_release_command_has_repository_context() -> None:
+    workflow = (ROOT / ".github/workflows/release.yml").read_text(encoding="utf-8")
+
+    assert (
+        """      - name: Create release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
+"""
+        in workflow
+    )
+
+
 def test_quickstart_notebook_is_valid_unexecuted_json() -> None:
     path = ROOT / "examples" / "quickstart.ipynb"
     notebook = json.loads(path.read_text(encoding="utf-8"))

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/tests/test_reporting.py

@@ -82,6 +82,32 @@ def test_array_inputs_and_generated_study_labels_are_explicit() -> None:
     assert dict(result.provenance.column_mapping) == {}
 
 
+def test_standard_error_provenance_records_column_and_conversion() -> None:
+    data = pd.DataFrame(
+        {
+            "yi": [0.1, 0.2, 0.3],
+            "sei": [0.1, np.nan, 0.2],
+        }
+    )
+    result = ma.meta_analysis(
+        data,
+        effect="yi",
+        standard_error="sei",
+        missing="drop",
+        model="common",
+    )
+
+    assert dict(result.provenance.column_mapping) == {
+        "effect": "yi",
+        "standard_error": "sei",
+    }
+    [transformation] = result.provenance.transformations
+    assert transformation.name == "standard_error_to_variance"
+    assert transformation.affected_rows == (0, 2)
+    assert "standard errors were squared" in result.method_details()
+    assert "for 2 row(s)" in result.method_details()
+
+
 def test_binary_provenance_records_corrections_and_uninformative_rows() -> None:
     result = _sparse_binary()
     transformations = {

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/tests/test_subgroups.py

@@ -80,6 +80,32 @@ def test_dataframe_column_preserves_group_order_labels_and_global_row_ids() -> N
     assert result.groups["A"].study_results["row_id"].tolist() == [2, 3]
 
 
+def test_generic_subgroups_accept_standard_error_column() -> None:
+    data = pd.DataFrame(
+        {
+            "yi": [0.0, 0.2, 0.8, 1.0],
+            "sei": [0.2, 0.2, 0.2, 0.2],
+            "region": ["A", "A", "B", "B"],
+        }
+    )
+    result = ma.meta_analysis(
+        data,
+        effect="yi",
+        standard_error="sei",
+        subgroup="region",
+        model="common",
+    )
+
+    assert isinstance(result, ma.SubgroupMetaAnalysisResult)
+    assert result.overall.estimate == pytest.approx(0.5)
+    assert result.groups["A"].estimate == pytest.approx(0.1)
+    assert dict(result.overall.provenance.column_mapping) == {
+        "effect": "yi",
+        "standard_error": "sei",
+        "subgroup": "region",
+    }
+
+
 def test_binary_mantel_haenszel_supports_subgroups() -> None:
     result = ma.meta_binary(
         event_treat=[12, 5, 20, 7],

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/tools/check_release.py

@@ -54,7 +54,7 @@ def _validate_tag(version: str, tag: str) -> None:
 
 def main() -> None:
     parser = argparse.ArgumentParser()
-    parser.add_argument("--tag", help="Optional release tag, for example v0.1.0")
+    parser.add_argument("--tag", help="Optional release tag in vX.Y.Z form")
     arguments = parser.parse_args()
 
     _validate_pyproject_version_source()

{pymetaanalysis-0.1.0 → pymetaanalysis-0.2.0}/tools/inspect_distribution.py

@@ -57,6 +57,7 @@ def _inspect(path: Path) -> None:
         with zipfile.ZipFile(path) as archive:
             metadata = archive.read(metadata_name).decode("utf-8")
         required_metadata = {
+            "Author-email: Zhaobo Ding <ding.zb@yahoo.com>",
             "License-Expression: MIT",
             "License-File: LICENSE",
             "Maintainer-email: Zhaobo Ding <ding.zb@yahoo.com>",