semvec/pypi-packages huggingface dataset:
cnanalysis 0.1.0
A Python package for statistical and EDA analysis
License: MIT
Requires Python: >=3.7

## CNAnalysis
    CNAnalysis is a Python package for comprehensive statistical and exploratory data analysis (EDA). It provides tools for performing ANOVA, Chi-square tests, correlation matrices, outlier handling, encoding categorical features, and visualizing distributions.

## 📦 Installation
```bash
pip install cnanalysis
```
## 📚 Modules Overview
1. AnovaTest – One-Way ANOVA
    ```bash
    from cnanalysis import AnovaTest
    anova = AnovaTest(data=df, num_col='score',cat_col='group')
    result = anova.test()
    print(result)
    ```
2. ChiSquareTest – Chi-Square Test with Cramér’s V
    ```bash
    from cnanalysis import ChiSquareTest
    chi_test = ChiSquareTest(data=df, col1='gender', col2='purchase')
    result = chi_test.test()
    print(result)
    ```
3. CombineAnalysis – Grouped Bar Plots with Stats
    ```bash
    from cnanalysis import CombineAnalysis

    plotter = CombineAnalysis(data=df, number_col='sales', categorical_col='region')
    summary_df = plotter.PlotGroupedData()
    ```
4. CorrelationMat – Correlation Matrix Plot
    ```bash
    from cnanalysis import CorrelationMat

    corr = CorrelationMat(data=df)
    corr.plotCM()`
    ```
5. DescriptiveSAT – Descriptive Statistics + Outlier Count
    ```bash
    from cnanalysis import DescriptiveSAT

    desc = DescriptiveSAT(data=df)
    stats = desc.get_descriptive_statistics(columns=['height', 'weight'])
    print(stats)
    ```
6. DistributionOutViz – Histogram + Boxplot for Outlier 
    ```bash
    from cnanalysis import DistributionOutViz

    dist_viz = DistributionOutViz(data=df, num_cols=['price','income'])
    dist_viz.PlotDAO()

    ```
7. EncodeCat – Label, One-Hot, and Ordinal Encoding
    ```bash
    from cnanalysis import EncodeCat

    encoder = EncodeCat(data=df, method='label')
    encoded_df = encoder.encode()

    ```
8. HandleOutlier – Winsorization (Cap Outliers)
    ```bash
    from cnanalysis import HandleOutlier

    out = HandleOutlier(data=df, lower=0.05, upper=0.95)
    winsorized_df = out.winsorize()

    ```
9. CardinalityAndRareCategoryAnalyzer – Rare Category 
    ```bash
    from cnanalysis import CardinalityAndRareCategoryAnalyzer

    analyzer = CardinalityAndRareCategoryAnalyzer(data=df, thresh=0.01)
    report = analyzer.get_cardinality_n_rare_cat()
    print(report)

    ```

## 🧑‍💻 Author
**Roshan Kumar**<br>
**🎓 Student, B.Sc. in Computer Science and Data Analytics (CSDA)**<br>
**🏫 Indian Institute of Technology Patna (IITP)**<br>
**📧 rk1861303@gmail.com**

## 📝 License
This project is licensed under the MIT License – see the LICENSE file for details.
feedforward 0.8.0
Simple local workflow runs
License: MIT
Requires Python: >=3.8

# feedforward

This library makes it easy to run a linear DAG while extracting magical
parallelism if some steps don't make changes to some values.

## Comparison to dataflow

Sure, this is a dataflow-esque library that allows you to do transforms on
items in one direction towards a goal.  Where it differs from other dataflow
models is that there is only `map` and the items can never never change type
(for a given key).

Additionally all steps and inputs need to be known up front, but that isn't a
restriction of the core algorithm, just in the name of readability.

In exchange for those restrictions, you get a lot of API simplicity, as well as
the ability to run future steps eagerly given sufficient slots and automatic
bundling into "batches" of items like xargs does to amortize child set-up times.

## Restrictions

* The steps need to be decided up front (although it's cheap to have steps that
  maybe don't do anything).  This includes the order that they will apply in.
* Steps ought to be deterministic and idempotent within a run (if they aren't,
  you should mark individual steps `eager=False` or enable `deliberate=True` on
  the `Run`, which only uses intra-step parallelism).
* Steps ought to have static relationships between the inputs and output keys
  such as `%.py` input changes potentially affecting `%.java` outputs, using
  the wildcard `%` you might know from Make.  If you don't (say, files can
  include other arbitrary files), then you might need to model this as *any*
  input change invalidating *all* output keys which will tend to be inefficient.
* Steps ought to not change the type of a key's value (although they can create
  new keys, or delete existing keys, so you can work around this by including
  the type in the key and still get correctness).  If you wanted to support
  `str` <=> `int` transformations on the same key, this will only work if *all*
  subsequent steps work with either.
* Your input values, as well as all intermediate output values, need to fit in
  memory.  Nothing keeps you from using filenames, urls, or CAS keys as the
  value though.

# Version Compat

Usage of this library should work back to 3.8, but development (and mypy
compatibility) only on 3.10-3.12.  Linting requires 3.12 for full fidelity.

# Versioning

This library follows [meanver](https://meanver.org/) which basically means
[semver](https://semver.org/) along with a promise to rename when the major
version changes.

# License

feedforward is copyright [Tim Hatch](https://timhatch.com/), and licensed under
the MIT license.  See the `LICENSE` file for details.