semvec/pypi-packages huggingface dataset:
Topsis-Arushi-102203683 0.1
A Python package implementing TOPSIS method for MCDM
Requires Python: >=3.6

# TOPSIS Implementation by Arushi Gadodia

A Python package that implements the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) method.

Submitted by: Arushi Gadodia
Roll Number: 102203683

## Installation

```bash
pip install Topsis-Arushi Gadodia-102203683
```

## Usage

From command line:
```bash
topsis input.csv "1,1,1,2" "+,+,-,+" output.csv
```

From Python:
```python
from topsis import calculate_topsis
calculate_topsis("input.csv", "1,1,1,2", "+,+,-,+", "output.csv")
```

## Input Format

1. Input file must be a CSV file with 3 or more columns
2. First column is the object/variable name
3. From 2nd column onwards should contain only numeric values
4. Weights should be comma-separated numbers (e.g. "1,1,1,2")
5. Impacts should be comma-separated +/- symbols (e.g. "+,+,-,+")

## Output

The program will create a result CSV file containing:
- All columns from input file
- Two additional columns: 'Topsis Score' and 'Rank'

## Error Handling

The program will check for:
- Correct number of parameters
- File existence
- Input file format
- Number of weights/impacts matching number of criteria
- Valid impact symbols (+/-)

## License

Â© 2024 Arushi Gadodia
This project is licensed under the MIT License - see the LICENSE file for details.#\x00 \x00T\x00o\x00p\x00s\x00i\x00s\x00
\x00
\x00
topsis-Shivansh-102203508 1.0.1
A Python package for performing TOPSIS analysis.
Requires Python: >=3.6

# TOPSIS-Python

A Python package for implementing the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) method.

## Description

TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) is a multi-criteria decision analysis method. This implementation helps decision makers to find the best alternative from a finite set of alternatives based on multiple criteria.

The package provides functionality to:
- Normalize decision matrices
- Apply user-defined weights to criteria
- Handle both positive and negative impact criteria
- Calculate relative closeness to ideal solutions
- Rank alternatives based on TOPSIS scores

## Installation

You can install the package via pip:

```bash
pip install topsis-Shivansh-102203508
```

## Usage

### Command Line Interface

```bash
topsis <InputDataFile> <Weights> <Impacts> <ResultFileName>
```

### Parameters:

- `InputDataFile`: Excel file (.xlsx) containing the decision matrix
- `Weights`: Comma-separated weights for each criterion (e.g., "0.25,0.25,0.25,0.25")
- `Impacts`: Comma-separated impacts for each criterion ('+' for positive, '-' for negative) (e.g., "-,+,+,+")
- `ResultFileName`: Output Excel file name where results will be saved

### Example:

```bash
topsis input.xlsx "0.25,0.25,0.25,0.25" "+,+,-,+" result.xlsx
```

### Input File Format

Your input Excel file should be structured as follows:
- First column: Alternative names/identifiers
- Subsequent columns: Criteria values
- First row: Header with criteria names

Example:
```
Model   Price   Storage   Camera   Battery
A1      800     128      12       4000
A2      900     256      16       4500
A3      1000    512      20       5000
```

### Output

The program will generate an Excel file containing:
- All original columns
- Additional column 'Topsis Score'
- Additional column 'Rank'

## Error Handling

The package handles various errors including:
- Incorrect number of command-line arguments
- Invalid input file format
- Mismatched weights or impacts
- File I/O errors

## Dependencies

- pandas
- sys

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Author

Shivansh Gupta

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Sample Code

```python
import pandas as pd
from topsis-Shivansh-102203508 import topsis

# Read your data
df = pd.read_excel('input.xlsx')

# Define weights and impacts
weights = "0.25,0.25,0.25,0.25"
impacts = "+,+,-,+"

# Calculate TOPSIS
result = topsis(df, weights, impacts)
```
Topsis-Madhav-102203782 1.0.2
A Python package to perform TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)
Requires Python: >=3.6

# Topsis_MadhavGarg_102203782

`Topsis_MadhavGarg_102203782`is a Python package for implementing the Technique for Order Preference by Similarity to Ideal Solution (TOPSIS). It is a popular multi-criteria decision-making method used to rank alternatives based on their relative closeness to the ideal solution.

## Installation

You can install the package using pip:

```bash
pip install Topsis_MadhavGarg_102203782
```

## Usage

### Input File Format

The input CSV file must follow this structure:

- The first column should contain the names of the alternatives (e.g., products, models, or options).
- Subsequent columns should contain the numerical values of the criteria for each alternative.
- The first row should provide headers for all columns.

### Example

Suppose you have an input CSV file named `data.csv` with the following content:

| Model | Price | Life | Performance | Portability |
| ----- | ----- | ---- | ----------- | ----------- |
| m1    | 3000  | 100  | 8           | 6           |
| m2    | 2500  | 80   | 7           | 9           |
| m3    | 4000  | 90   | 9           | 5           |

You want to apply the TOPSIS method with the following parameters:

- Weights for the criteria: `Price` (0.5), ` Life` (0.3), `Performance` (0.2)
- Impacts for the criteria: `Price` (-), ` Life` (+), `Performance` (+)

The command would be:

````bash
topsis data.csv "0.5,0.3,0.2" "-,+,+" results.csv


### Command-line Usage

After installation, you can use the `topsis` command in the terminal:

```bash
topsis <input_file> <weights> <impacts> <output_file>
````

- `<input_file>`: Path to the input CSV file.
- `<weights>`: Comma-separated string of weights for the criteria.
- `<impacts>`: Comma-separated string of '+' or '-' indicating the desirability of the criteria.
- `<output_file>`: Path to the output CSV file to save the results.

## Example

```bash
topsis data.csv "0.5,0.3,0.2" "+,-,+" results.csv
```

This command will process the `data.csv` file using the specified weights and impacts and output the results to `results.csv`.

## NOTE

- Ensure the input file contains at least three columns: one for alternatives and at least two for criteria.
- All criteria values should be numerical.
- The number of weights and impacts should match the number of criteria columns.
- Impacts must only include + (beneficial) or - (non-beneficial).

## License

This project is licensed under the MIT License. See the LICENSE file for details.
topsis-3770 1.0.0
A Python package implementing TOPSIS method for Multi-Criteria Decision Making (MCDM)
Requires Python: >=3.6

# TOPSIS Python Package

A Python package that implements the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) method. This package helps in solving Multi-Criteria Decision Making (MCDM) problems by ranking alternatives based on multiple criteria.

## Installation

```bash
pip install topsis-yourname
```

## Usage

The package can be used both as a command-line tool and as a Python module.

### Command Line Usage

```bash
python -m topsis <InputDataFile> <Weights> <Impacts> <ResultFileName>
```

Example:
```bash
python -m topsis data.xlsx "1,1,1,1,1" "+,-,+,-,+" result.csv
```

### Input File Format

- Excel file with .xlsx extension
- First column: Fund/Alternative names
- 2+ columns: Numerical values for criteria
- Example:
  ```
  Fund Name | Return | Risk | Expense | ...
  Fund A    | 10     | 20   | 30     | ...
  Fund B    | 15     | 25   | 35     | ...
  ```

### Parameters

- Weights: Comma-separated values of weights (e.g., "1,1,1,1,1")
- Impacts: Comma-separated +/- signs for maximizing/minimizing criteria (e.g., "+,-,+,-,+")
- ResultFileName: Output CSV file name

### Output

The program will create a CSV file containing the input data along with:
- Topsis Score
- Rank

## Sample Python Usage

```python
from topsis import topsis

topsis("input.xlsx", [1,1,1,1,1], ['+','-','+','-','+'], "output.csv")
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Author

Sarabjeet Singh (ssingh20_be22@thapar.edu)
ashmeet-102217211 0.0.1
TOPSIS Python Package
Requires Python: >=3.6

# TOPSIS Package

This package implements the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) method for decision-making.

## Installation
```bash
pip install ashmeet_102217211

## To run file :
pyhton topsis.py <input_file_location> "weights" "impacts" <output_file_location.csv>


Where:
<input_file> is the path to the CSV file containing the decision matrix.
<weights> is a comma-separated list of weights for the criteria (e.g., 1,1,1,1).
<impacts> is a comma-separated list of impact directions for the criteria (e.g., +,+,-,- where + indicates a benefit criterion and - indicates a cost criterion).
<output_file> is the path where the results will be saved, including the TOPSIS score and rank for each alternative.
topsis-Sarthak-Srivastava-102217018 1.0.1
This Python package implements the TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) method for rank calculation. It helps in ranking alternatives based on multiple criteria by determining their proximity to the ideal and negative-ideal solutions. The package is efficient and easy to use for decision-making tasks.
Requires Python: >=3.6

# Topsis Rank Calculation
It takes 4 parameters in cmd as input. First being the input dataset. Second being the Weights. Third being the Impacts. Fourth being the Result file Name
![image could not be loaded](image.png)

## Installation
```pip install 102217018-topsis```

## License

Â© 2025 Sarthak Srivastava

This repository is licensed under the MIT license. See LICENSE for details.
Topsis-Rohit-102203986 1.0.1
A Python package to perform TOPSIS analysis
Requires Python: >=3.6

# Topsis
TOPSIS( Technique for order for preference by similarity to Ideal solution ) for MCDM (Multiple criteria decision making) in Python compiled by Rohit Deepchandani, 102203986, TIET, Patiala. 

## Installation
```pip install Topsis-Rohit-102203986```

## Usage
Enter csv filename followed by .csv extentsion, then enter the weights vector with vector values separated by commas, followed by the impacts vector with comma separated signs (+,-) and enter the output file name followed by .csv extension.

```python [InputDataFile as .csv] [Weights as a string] [Impacts as a string] [ResultFileName as .csv]```

### Example
```python sample.csv "1,1,1,1" "-,+,+,+" output.csv```

## Please Note That"

The first column and first row are removed by the library before processing, in attempt to remove indices and headers. So the csv MUST follow the format as shown in sample.csv shown in the Example section.
The input data file MUST contain three or more columns.
The second to last columns of the data file MUST contain NUMERIC values.
The number of weights, impacts and columns (second to last) MUST be SAME.
Impacts MUST either be '+' or '-'.
Impacts and Weights MUST be separated by , (comma).

## License

Â© 2025 Rohit Deepchandani

This reopsitory is licensed under MIT License. See LICENSE for details.
pypi-wayback 0.2.2
🕰️ Access any PyPI package’s history
Requires Python: <4.0,>=3.10

# PyPI Wayback Machine

[![PyPI - Version](https://img.shields.io/pypi/v/pypi-wayback)](https://pypi.org/project/pypi-wayback)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/pypi-wayback)](https://pypi.org/project/pypi-wayback)
![Python Version](https://img.shields.io/badge/python-3.10-blue)
[![License](https://img.shields.io/github/license/waleko/pypi-wayback)](https://github.com/waleko/pypi-wayback/blob/main/LICENSE)
[![Build Status](https://img.shields.io/github/actions/workflow/status/waleko/pypi-wayback/main.yaml)](https://github.com/<your-repo>/actions)

---

**PyPI Wayback Machine** is a modern and simple tool to retrieve historical PyPI pages of any package at a specific date — think of it as a next-gen version of `pypi-timemachine` but with added flexibility. Whether you're tracking down a past release or examining dependency changes, this tool has you covered.

## 🚀 Features

- **Access PyPI pages at any past date**
- **Dockerized for quick setup** 
- **Lightweight and performant**

## 📦 Installation & Usage

### Docker
Quickly start the server using Docker:
```bash
docker run -p 8080:8080 ghcr.io/waleko/pypi-wayback
```

### Python
Alternatively, you can run it directly using Python:
```bash
pip install pypi-wayback
python -m pypi_wayback --port 8080
```

### Accessing a Package's Historical Page

Once the server is running, access the PyPI page of a package by navigating to the following URL:
```
http://localhost:8080/<date>/<package_name>
```

For example, to view the PyPI page for the `requests` package on **January 1, 2020**:
```
http://localhost:8080/2020-01-01/requests
```

## 🤝 Contributing
Feel free to open issues or pull requests if you want to help improve this project. Contributions are more than welcome!

## ⚖️ License
This project is licensed under the MIT License.