semvec/pypi-packages huggingface dataset:
eh-pytorch-tabnet 4.4.0
PyTorch implementation of TabNet
Requires Python: >=3.10
Keywords: neural-networks, pytorch, tabnet

# README

# TabNet : Attentive Interpretable Tabular Learning


* this is maintained fork version of [dreamquark-ai/tabnet](https://github.com/dreamquark-ai/tabnet) with some changes and improvements.

* it uses pytorch metrics instead of numpy metrics, and also enhanced predictions & evaluation for GPU CUDA enhancement.

* expect more changes in the future.

* for the record and license policy assume everything is changed.

* **thanks & credits to dreamquark-ai team for the implementation and research.**

This is a pyTorch implementation of Tabnet (Arik, S. O., & Pfister, T. (2019). TabNet: Attentive Interpretable Tabular Learning. arXiv preprint arXiv:1908.07442.) https://arxiv.org/pdf/1908.07442.pdf. Please note that some different choices have been made overtime to improve the library which can differ from the orginal paper.
random-shapes 0.1.0
Generate random shapes with ease.
Requires Python: >=3.11

# random-shapes

Generate random shapes with ease.

> This library is heavily inspired by [this stackoverflow answer](https://stackoverflow.com/a/50751932/12031297)

![Logo](docs/_static/random-shape-logo.png)

## Installation

You can install random-shapes via pip:

```sh
    pip install random-shapes
```

However, `uv` is recommended for installing python packages:

```sh
    uv add random-shapes
```

## Usage

Install the optional library `matplotlib` for visualization:

```sh
    pip install random-shapes[viz]
    # or
    uv add random-shapes --extra viz
```

With random-shapes it is easy to generate a random shape (`bezier.CurvedPolygon`):

```python

    from random_shapes import Shape

    shp = Shape.random(n=10, r=0.05, edgy=0.2)
    # Shape.curve is a bezier.CurvedPolygon, since Shape is a just wrapper
    shp.curve.plot(pts_per_edge=10)
```

![Random shape example](docs/_static/shape-example.png)

This shape can then be turned into a binary image:

```python
    import matplotlib.pyplot as plt

    binary_image = shp.rasterize(h=512, w=512)
    plt.imshow(binary_image, cmap="gray")
```

![Binary image example](docs/_static/rasterize-example.png)
smartmutate 1.0.1
Use Anthropic Claude to convert files
Requires Python: >=3.7


# smartmutate
Smartmutate is a file conversion tool built in Python that leverages Anthropic's Claude API to intelligently convert data between common file types. 

## Features

- Supports for common data formats like JSON, CSV, YAML, and XML (more formats coming soon)
- Available as command-line interface and as a Python Library
- Built-in format validation and error handling

## Installation

Install SmartMutate using pip:

```bash
pip install smartmutate
```

## Quick Start

SmartMutate can be used either directly from the command line or as a Python library. 

### Command Line

Convert files directly from the terminal:

```bash
# Set your Anthropic API key
export ANTHROPIC_API_KEY='your-api-key'

# Convert a file
smartmutate input.json output.yaml
```

### Python Library

Use the converter function in your Python code:

```python
from smartmutate import Converter

# Initialize the converter
converter = Converter(api_key="your-anthropic-key")

# Convert a file
converter.convert_file("input.json", "output.yaml")
```

## Supported Formats

SmartMutate currently supports conversions between:
- JSON
- YAML
- CSV
- TXT
- More formats coming soon...

Each format is validated before conversion to ensure data integrity.

## Configuration

SmartMutate uses your Anthropic API key for conversions. You can provide it in several ways:
1. Environment variable: `ANTHROPIC_API_KEY`
2. Direct initialization: `Converter(api_key="your-key")`
3. Command line argument: `--api-key` OR `--env` followed by the path to your `.env` file

## Error Handling

SmartMutate includes comprehensive error handling for:
- Invalid file formats
- Missing input files
- API connection issues
- Conversion failures

Each error provides clear feedback to help troubleshoot issues quickly.

## Development

### Running Tests

Run the test suite using pytest:

```bash
# Install development dependencies
pip install -e .[test]

# Run tests
pytest tests/
```

## Contributing

We welcome contributions! To get started:

1. Fork the repository
2. Create a feature branch
3. Make something cool or fix something bad
4. Submit a pull request

## License

This project is licensed under the MIT License. See the LICENSE file for details.
Topsis-Aryan-102213016 1.0.0
A Python package for TOPSIS-based decision-making.
Requires Python: >=3.6

# Topsis-FirstName-RollNumber

[![PyPI version](https://badge.fury.io/py/Topsis-Aryan-102213016.svg)](https://badge.fury.io/py/Topsis-Aryan-102213016)

A Python package to perform **Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS)** for multi-criteria decision-making. This package takes a dataset, weights, and impacts for the criteria, calculates TOPSIS scores, and ranks the alternatives accordingly.

---

## Features
- Supports decision-making for datasets with multiple criteria.
- Ensures input validation for proper formatting and values.
- Outputs TOPSIS scores and ranks for each alternative.

---

## Installation

Install the package using `pip`:
```bash
pip install Topsis-Aryan-102213016
Topsis-Palak-102216032 0.1.1
A Python package to perform TOPSIS analysis
Requires Python: >=3.6

# Topsis-Palak-102216032

## Overview

`Topsis-Palak-102216032` is a Python package that implements the **TOPSIS** (Technique for Order of Preference by Similarity to Ideal Solution) method for multi-criteria decision analysis (MCDA). This package allows you to evaluate and rank alternatives based on multiple criteria, considering both positive and negative impacts of each criterion.

The implementation supports reading input data from a CSV file, applying weights to the criteria, and calculating the TOPSIS score and rankings. The final results are saved to an output CSV file with the TOPSIS score and corresponding rank for each alternative.

## Features

- Normalize the decision matrix.
- Apply weights to the normalized data.
- Identify the ideal best and worst solutions based on the specified impacts.
- Calculate the distances to the ideal best and worst solutions.
- Compute the TOPSIS score for each alternative.
- Rank the alternatives based on the TOPSIS score.
- Save the results in a CSV file.

## Installation

You can install this package from PyPI using the following command:

```bash
pip Topsis-Palak-102216032
```bash


## Usage
Please provide the filename for the CSV, including the .csv extension. After that, enter the weights vector with values separated by commas. Following the weights vector, input the impacts vector, where each element is denoted by a plus (+) or minus (-) sign. Lastly, specify the output file name along with the .csv extension.

```py -m topsis.__main__ [input_file_name.csv] [weight as string] [impact as string] [result_file_name.csv]```

## Example Usage
The below example is for the data have 5 columns.
```topsis-ridham input.csv "1,1,2,0.5,0.75" "+,+,-,-,-" output.csv ```

## Example Dataset

Fund Name | P1 | P2 | P3 | P4 | P5
------------ | ------------- | ------------ | ------------- | ------------ | ------------
M1 | 0.78 | 0.61 | 5.5 | 34.7 | 10.4
M2 | 0.88 | 0.77 | 5 | 58.4 | 16.26
M3 | 0.61 | 0.37 | 5.9 | 39.9 | 11.7
M4 | 0.76 | 0.58 | 4.2 | 57.7 | 15.81
M5 | 0.84 | 0.71 | 3.2 | 48 | 13.19
M6 | 0.76 | 0.58 | 4 | 68.8 | 18.54
M7 | 0.81 | 0.66 | 6.5 | 38.2 | 11.54
M8 | 0.81 | 0.66 | 3.2 | 32.8 | 9.37

## Output Dataset
Fund Name | P1 | P2 | P3 | P4 | P5 | TOPSIS Score | Rank
------------ | ------------- | ------------ | ------------- | ------------ | ------------ | ------------ | ------------
M1 | 0.78 | 0.61 | 5.5 | 34.7 | 10.4 | 0.45384759973942024 | 6
M2 | 0.88 | 0.77 | 5 | 58.4 | 16.26 | 0.5250616666395651 | 5
M3 | 0.61 | 0.37 | 5.9 | 39.9 | 11.7 | 0.286469615636936 | 8
M4 | 0.76 | 0.58 | 4.2 | 57.7 | 15.81 | 0.6022625270239917 | 3
M5 | 0.84 | 0.71 | 3.2 | 48 | 13.19 | 0.8452645767159974 | 2
M6 | 0.76 | 0.58 | 4 | 68.8 | 18.54 | 0.5852919015001125 | 4
M7 | 0.81 | 0.66 | 6.5 | 38.2 | 11.54 | 0.3427884605083087 | 7
M8 | 0.81 | 0.66 | 3.2 | 32.8 | 9.37 | 0.8900689209819633 | 1

<br>

## Important Points
1) There should be only numeric columns except the first column i.e. Fund Name.
2) Input file must contain atleast three columns.

<br>