semvec/pypi-packages huggingface dataset:
scignumpy 0.1.3
A lightweight numerical computation library inspired by NumPy.
Requires Python: >=3.6

# SciGNumpy

SciGNumpy is a lightweight numerical computation library inspired by NumPy. It provides core functionality for handling arrays, matrices, and mathematical computations.

## Features

- Multi-dimensional arrays and matrices.
- Element-wise operations, broadcasting, and scalar operations.
- Linear algebra operations (e.g., dot product, transpose, determinant, inverse).
- Mathematical functions (e.g., sine, cosine, exponential, logarithm).
- Statistical functions (e.g., sum, mean, min, max).

## Installation

Install SciGNumpy using pip:

```bash
pip install scignumpy
```
clustered-imputation 1.0.2
Adding correlation to handle MNAR
Keywords: python, imputation, MNAR


# Clustering Imputation
## Installation
To install the package, run:
```bash
pip install clustering-imputation
```
## Usage

```python
from clustered_imputation import clusterImputer
df = ...  # Load your dataset
x = clusterImputer(data , basic_imputation , num_imputation , corr_threshold , max_iter)
x.impute()
```
# About the Package
## Features to be passed to the class clusterImputer
* data --> Pass your dataframe
* basic_imputation : Literal["mice" , "sice" , "em"] --> What imputation you want to perform on your clusters
* num_imputation : Literal["mean" , "median"] --> How do you want to handle your initial numeric column imputation for creating correlation matrix
* corr_threshold : 0.6 -->Threshold value to be used with respect to correlation matrix to create clusters
* max_iter : 10 -->Maximum iteration for MICE and SICE
## Problem Statement

* Traditional imputation techniques face several challenges:

* High-Dimensional and Sparse Data: Existing methods struggle with large, sparse datasets; efficient techniques for such cases are needed.

* Temporal Dependencies: Current methods often overlook temporal correlations in data.
## Need to develop a new algo
* Non-Random Missingness: Few methods address non-random missing patterns; improvements here could boost real-world application accuracy. We aim to develop an imputation method that considers "Missing Not at Random" (MNAR).

* Computational Complexity: MICE and EM methods are computationally expensive for high-dimensional data. Our approach aims to reduce time complexity.

## Philosophy of Our Solution: Clustered MICE/EM

We propose a clustering-based approach:

* Identify correlations between features.

* Apply MICE/EM within clusters rather than on the entire dataset.

* Combine results to reconstruct the dataset.

* This method effectively handles MNAR data by leveraging feature correlations.

For further details refer this [ppt](https://docs.google.com/presentation/d/1UZ2uDkleSgB2ZttjG1D6nmQhqk7uz5FQRW5UmSkB0Sg/edit?usp=sharing)
## Contributing

Pull requests are welcome. For major changes, please open an issue first
to discuss what you would like to change.

Please make sure to update tests as appropriate.
dash-basecomponent 0.1.4
A base component library for Dash applications

# Dash BaseComponent

A BaseComponent class for building modular Plotly Dash apps.

See [this article](https://www.codingwithricky.com/2025/02/15/dash-basecomponent/) for more info.

## Installation

To install the `dash-basecomponent` package, use the following command:

```bash
pip3 install dash-basecomponent
```

## Usage

To use these components in your own Dash application, simply import the component you want to use and add it to your application's layout.

For example:
```python
from dash import Dash, html, callback
from dash_basecomponent import BaseComponent as bc

class Counter(html.Div, bc):
    def __init__(self, **kwargs):
        super().__init__([
            html.Button("Increment", id=self.child_id("button")),
            html.Span("0", id=self.child_id("count"), style={"marginLeft": "10px"}),
        ], **kwargs)
    
    @callback(
        bc.ChildOutput("count", "children"),
        bc.ChildInput("button", "n_clicks"),
        prevent_initial_call=True
    )
    def increment_count(n_clicks):
        return str(n_clicks)

app = Dash(__name__)
app.layout = Counter()

if __name__ == "__main__":
    app.run_server(debug=True)
```

## Examples

The `examples` directory contains several example applications that demonstrate how to use these components.

* `hello_world.py`: An example application that uses the `InputCombiner` and `ExpandContract` components.
* `tic_tac_toe.py`: An example application that uses the `Game` component.
* `snake.py`: An example application that uses the `SnakeGameBoard` component.
* `example.py`: An example application that uses the `Counter` component.

## Contributing

Contributions to this project are welcome. If you have a new component you'd like to add, or if you've found a bug in one of the existing components, please submit a pull request.

## License

This project is licensed under the MIT License. See the `LICENSE` file for details.
commondata-languages 1.1.0
Work with ISO 639-1, ISO 639-2B, ISO 639-2T, and ISO 639-3 language data.
Requires Python: >=3.13

# commondata-languages

Work with [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1), [ISO 639-2B, ISO 639-2T](https://en.wikipedia.org/wiki/ISO_639-2), and [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3) language data.

List, lookup with fuzzy search.

## Installation

```bash
pip install commondata-languages
```

## Usage

**Iterate over all languages:**

```python
from commondata_languages import LanguageData

languages = LanguageData()

for language in languages:
    print(language.name)
```

**List all languages:**

```python
from commondata_languages import LanguageData

languages = LanguageData()

print(languages.all())
```

**Lookup a language**

```python
from commondata_languages import LanguageData

languages = LanguageData()

# Lookup by name (case insensitive, fuzzy search)
language = languages["Hindi"]

# Lookup by ISO 639-1
language = languages["en"]

# Lookup by ISO 639-3
language = languages["eng"]

# Lookup by ISO 639-2B
language = languages["chi"]

# Lookup by ISO 639-2T
language = languages["zho"]

# Look up with fuzzy search
language = languages["Englih"]

print(language)
> Language(name='English', iso1='en', iso2b='eng', iso2t='eng', iso3='eng', scope='Individual', type='Living')
```

***Use CLI to lookup a language***

```bash
python -m commondata-languages English
```

**Load languages data into pandas dataframe**

```python
import pandas as pd

from commondata_languages.data import languages

df = pd.DataFrame(languages)
```

## Other Formats and Datasets

Download CSV, XLSX, JSON and YAML files from [commondata.net/library](https://commondata.net/library/#languages).

[commondata.net](https://commondata.net) maintains a collection of essential datasets in a variety of formats, including
python bindings. Check out the full library here: [commondata.net/library](https://commondata.net/library).

## Contributing

Contributions are welcome! Please open an issue or submit a pull request [here](https://github.com/commondata-net/commondata-languages-python).

## License

This project is licensed under GPLv3. See the [LICENSE](https://github.com/commondata-net/commondata-languages-python/blob/main/LICENSE) file for details.

## Support

For feedback, feature requests, or support, please email [support@commondata.net](mailto:support@commondata.net).
tffs 1.1.2
Feature selection based on top frequency
Requires Python: >=3.6

# TFFS

## Description
TFFS (**Feature Selection based on Top Frequency**) is a feature selection method that leverages **Random Forest** to identify the most frequently important features across multiple model runs. This method helps in reducing dimensionality while retaining significant features for better model performance.

## Installation

```bash
pip install tffs
```

## 🔥 Functionality
The library provides multiple feature selection functions that combine **TFFS** with classical selection techniques:

### 🏷 Core Function:
```python
get_frequency_of_feature_by_percent(df, number_of_runs, percent, n_estimators)
```

## 📌 Parameters
The function `get_frequency_of_feature_by_percent()` accepts the following parameters:

| Parameter          | Type               | Description |
|--------------------|--------------------|-------------|
| **`df`**          | `pandas.DataFrame`  | The input dataset containing features and target variables. The first column should be the class label. |
| **`number_of_runs`** | `int`             | The number of times a Random Forest model is built to compute feature importance. |
| **`percent`**     | `float`             | The percentage of top important features to retain (e.g., `percent=20` keeps the top 20% most important features). |
| **`n_estimators`** | `int`              | The number of decision trees in the Random Forest model. |

## 📤 Return
The function returns:
- A **NumPy array** containing the **indices** of the selected features that are among the top `percent%` most important features across multiple Random Forest runs.

### 🔄 Example Return:
```python
array([0, 2, 4, 7, 9])
```

## 📌 Example Usage
```python
import pandas as pd
from tffs import get_features_by_forward_and_tffs

# Create a sample DataFrame
data = pd.DataFrame({
    'class': [0, 1, 0, 1, 2, 0, 1, 2, 0, 1],
    'feature_1': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
    'feature_2': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'feature_3': [5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
    'feature_4': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'feature_5': [5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
    'feature_6': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'feature_7': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
    'feature_8': [3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
    'feature_9': [4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
})

# Run the function
selected_features = get_features_by_forward_and_tffs(
    data,
    percent_tffs=50,
    number_run=10,
    n_estimators=100,
    percent_forward=30
)

print("Selected features:", selected_features)
```

## Author
**Vu Thi Kieu Anh** 

---
© 2025
sphinxify 0.12
Convert Javadoc to Sphinx docstrings.
Requires Python: >=3.6
Keywords: javadoc, sphinx, doxygen

# sphinxify
Convert Javadoc and Doxygen to Sphinx docstrings.

## Why?
The [RobotPy][] project ports Java libraries to Python.

A converter was originally written in HTML + JavaScript, but then the need to
be able to programmatically convert doc comments arose.

This also makes it easier to use in certain editors such as vim...

## Usage
Run `sphinxify` and give it a Javadoc comment.  It will keep reading until EOF.

If a Java function prototype is also given, sphinxify will also output a
Python type-hinted function signature.

You can also run `sphinxify server` and it will pop up a browser that you can
use to run sphinxify on the input also.

There is also a `sphinxify yaml` mode for the [robotpy-ctre][].

[RobotPy]: https://robotpy.github.io
[robotpy-ctre]: https://github.com/robotpy/robotpy-ctre