semvec/pypi-packages huggingface dataset:
Topsis-Piyush-102217003 0.1.0
A Python package for implementing Topsis method
Requires Python: >=3.6

# Topsis-Piyush-102217003

[![PyPI version](https://badge.fury.io/py/102217003_piyush_garg.svg)](https://pypi.org/project/102217003_piyush_garg/)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

A Python package for implementing the **Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS)**, a multi-criteria decision-making method.

---

## Installation

Install the package from PyPI:

```bash
pip install Topsis-Piyush-102217003
```
## Usage

### Input
The package expects a CSV file with the following structure:

The first row contains column headers.
The first column contains alternative names.
The subsequent columns contain numerical values for different criteria.
Output
The result will include the following:

Topsis Score: A score for each alternative.
Rank: Ranking of the alternatives based on the score.

### Explanation of Parameters:
"data.csv": Input CSV file path.
"1,1,1": Weights for each criterion.
"+,+,-": Impact of each criterion (+ for beneficial, - for non-beneficial).
"result.csv": Output CSV file path.

### Features
Handles both beneficial and non-beneficial criteria.
Scalable to multiple alternatives and criteria.
Provides normalized scores for accurate decision-making.

### Dependencies
Ensure you have the following Python libraries installed (they will be auto-installed via pip):

numpy
pandas

### Contributing
Contributions are welcome! Please follow these steps:

Fork the repository.
Create a new branch for your feature or bug fix.
Submit a pull request.

### Acknowledgments
Inspired by the Topsis method for decision-making.
Developed by Piyush Garg.
p2pchat 0.1.1
A Python package for P2P chat bot development

# P2PChat Bot Framework

A lightweight Python framework for creating chat bots for the P2P Chat platform.

## Installation

```bash
pip install p2pchat
```
## QuickStart For your first bot
from p2pchat import Bot

bot = Bot(prefix='$')  # Custom prefix or defaults to !

@bot.command()
async def hello(ctx):
    await ctx.get('api').send_message("Hello there!", ctx.get('chat_id'))

bot.run("your_bot_token")
ansar-connect 1.1.54
Tools and runtime for network messaging
Requires Python: >=3.7


ansar-connect
=============

The **ansar-connect** library implements clear and concise network messaging for a wide range
of networking requirements. From multi-processing within a single host through to messaging
beween different LANs on the Internet. There is a single send method that does it all.

Features
--------

- Implements bi-directional, asynchronous network messaging,
- Provides a synchronous request-response layer,
- Inherits the data sophistication of **ansar.encode**,
- Seamlessly extends the asynchronous runtime from **ansar.create**, to span local and wide-area networks.


Changelog
=========

1.1.54 (2025-01-20)
-------------------

- Wide area networking (ansar-mx.net) offline until further notice.

1.1.21 (2024-09-09)
-------------------

- Better data entry around update procedures.

- Clean org of api into crud groups.

- Finalize behaviour of overlay function.

- Support for refactor of cloud to use GroupTable.

1.1.3 (2024-09-22)
------------------

- Add HTTP integration

- Fix the teardown and reconnect of pub-sub sessions after keep-alive close

1.0.6 (2024-06-19)
------------------

- Fix handling of --main-role in abort scenarios

- Additions to docs - Odds And Ends, Dining Philosphers

- Implement self-checking of transports - directories and peers

- Fix/remove typos in comments

1.0 (2024-05-27)
----------------

- Implement standard listen and connect

- Implement publish and subscribe

- Create **ansar-host** and **ansar-lan** services

- Launch **ansar-wan** cloud service

- Complete **ansar-connect** docs
Topsis-JagritGoyal-102217007 0.0.1
A Python package to perform TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)
Requires Python: >=3.6

# Topsis_JagritGoyal_102217007

`Topsis_JagritGoyal_102217007`is a Python library designed to implement the Technique for Order Preference by Similarity to Ideal Solution (TOPSIS). This method, widely used in multi-criteria decision-making, helps evaluate and rank alternatives by measuring their proximity to the ideal solution.

## Installation

You can install the package using pip:

```bash
pip install Topsis_JagritGoyal_102217007
```

## 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 | Battery Life | Performance | Portability |
| ----- | ----- | ------------ | ----------- | ----------- |
| m1    | 300   | 10           | 8           | 6           |
| m2    | 250   | 8            | 7           | 9           |
| m3    | 400   | 9            | 9           | 5           |

You want to apply the TOPSIS method with the following parameters:

- Weights for the criteria: `Price` (0.5), `Battery Life` (0.3), `Performance` (0.2)
- Impacts for the criteria: `Price` (-), `Battery 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-Trish-Rustagi-102203584 0.1.0
A Python package for implementing the TOPSIS method.
Requires Python: >=3.6

# TOPSIS Implementation in Python
A Python implementation of the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) for multi-criteria decision-making problems. This package processes an input dataset, calculates the TOPSIS scores, and ranks alternatives based on their scores.

## Installation
You can install this package directly from PyPI:
```pip install 102203584```

## Usage
### Command-Line Interface
Run the script using the following format:
``` python <program.py> <InputDataFile> <Weights> <Impacts> <ResultFileName> ```

### Arguments:

1. InputDataFile: Path to the input .csv file containing the dataset.
-The first column should contain the names of the alternatives.
-The remaining columns should contain numeric criteria values.

2. Weights: Comma-separated values representing the importance of each criterion.

3. Impacts: Comma-separated values (+ or -) indicating whether the criterion is beneficial (+) or non-beneficial (-).

4. ResultFileName: Name of the output .csv file where the results (TOPSIS scores and ranks) will be saved

## Dependencies
This package requires the following Python libraries:
-pandas
-numpy

## License
This repository is licensed under the MIT license. See LICENSE for details.
102203092-topsis 1.1.2
MCDM solved using TOPSIS
Requires Python: >=3.6

## Project description
# MCDM solution using TOPSIS using CLI
A Python package made by me to solve the problem of MCDM (Multi Criteria Decision Making) implemented using TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) algorithm. 
This package supports both CSV and Excel files.

### Installation

Follow the steps below to install and use the package:

Install the Package from PyPI (recommended):

`pip install 102203092_topsis`

Repo Clone (optional):

`git clone`

`cd TOPSIS-pypi`

(Optional) Install Locally: If you have the source code and want to install the package locally:

`pip install setuptools wheel`

`python setup.py sdist bdist_wheel`

`pip install .`

| Argument   | Description                         |
|------------|-------------------------------------|
| input_file | "CSV/Excel" file path              |
| weights`   | Comma-separated numbers            |
| impacts  | Comma-separated '+' or '-'         |
| output_file | Output CSV/Excel file path         |


### Usage
1. After installation, you can use the package directly from the command line using topsis-cli.
2. The CLI supports both .csv and .xlsx formats for input and output files.
3. Command-Line Interface (CLI)
4. Package installed from PyPi can be globally used irrespective of directory

`topsis-cli <input_file> <weights> <impacts> <output_file>`

### Args:
1. **input_file:** Path to the input file (must be .csv or .xlsx).
2. **weights:** Comma-separated list of weights for the criteria (e.g., 0.4,0.3,0.3).
3. **impacts:** Comma-separated list of impacts for the criteria (+ for positive, - for negative).
4. **output_file:** Path to save the output file (can be .csv or .xlsx).

### Input File Format

| Col 1       | Col 2             | Col 3           |
|-------------|-------------------|-----------------|
| Alternte ID | Criterion 1 Value | Criterion 2 Value |


### Output File Format

| Col 1       | Col 2            | Col 3             | Col 4          | Col 5       |
|-------------|------------------|-------------------|----------------|------------|
| Alternate ID| Criterion 1 Value | V2                | Topsis Score   | Rank       |
              
**_Uday Sharma_**

**_102203092_**
jupyter-cell-modifier 0.1.0
A Jupyter extension that runs code before and after cell execution
Requires Python: >=3.7
Keywords: jupyter, ipython, extension

---
noteId: "5f6f6480d69d11efb434399aaf79651c"
tags: []

---

# Jupyter Cell Modifier

A Jupyter extension that runs code before and after cell execution.

## Installation

EOL
Topsis-Nikhil-Garg-102203275 1.0.1
A Python package for performing TOPSIS analysis.
Requires Python: >=3.6

# TOPSIS Python Package

This package implements the TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) method for multi-criteria decision-making.

## Installation

Install the packageÂ usingÂ pip:
pip install Topsis-<Nikhil_Garg>-<102203275>

## Usage

Run the following command after importing the package:

```python
from topsis import Topsis

Topsis.calculate('input_file.csv', '1,1,1,2', '+,+,-,+', 'output_file.csv')
Topsis-HarshulDeepSingh-102203259 1.0.0
A Python package for performing TOPSIS analysis.
Requires Python: >=3.6

# TOPSIS Python Package

This package implements the TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) method for multi-criteria decision-making.

## Installation

Install the package using pip:pip install Topsis-Harshul-102203259

## Usage

Run the following command after importing the package:

```python
from topsis import Topsis

Topsis.calculate('input_file.csv', '1,1,1,2', '+,+,-,+', 'output_file.csv')
wow-addon-packager 0.13.0
A developer-friendly World of Warcraft addon packager
Requires Python: >=3.13
Keywords: Addons, WoW, World of Warcraft

# wap

[![GitHub Actions CI status for default branch](https://github.com/t-mart/wap/actions/workflows/ci.yml/badge.svg)](https://github.com/t-mart/wap/actions/workflows/ci.yml)
[![Latest release on PyPI](https://img.shields.io/pypi/v/wow-addon-packager)](https://pypi.org/project/wow-addon-packager/)

A developer-friendly World of Warcraft addon packager.

![demonstration of wap usage](https://raw.githubusercontent.com/t-mart/wap/master/docs/assets/demo.gif)

## Features

- [Builds](https://t-mart.github.io/wap/commands/build/) Retail, Classic,
  Vanilla addons (or all three!)
- [Publishes](https://t-mart.github.io/wap/commands/publish/) your addons to CurseForge
- [Generates valid TOC files](https://t-mart.github.io/wap/toc-gen/) automagically
- [Continuously rebuilds](https://t-mart.github.io/wap/commands/build/#-watch) your addon during
  development
- Sets up new addon projects quickly, ready to go with one
  [command](https://t-mart.github.io/wap/commands/new-project/)
- Consolidates all configuration in
  [one easy-to-edit file](https://t-mart.github.io/wap/configuration)
- Supports and is tested on Windows, macOS, and Linux
- Has awesome [documentation](https://t-mart.github.io/wap/)

## wap in 5 minutes

These instructions create and upload a working addon without editing a single line of code!

1. Download and install [Python 3.11](https://www.python.org/downloads/).

2. Install `wap`:

    ```console
    pip install --upgrade --user wow-addon-packager
    ```

3. Create a new a project:

    ```console
    wap new-project
    ```

    And then, answer the prompts. Don't worry too much about your answers -- you can always change
    them later in your configuration file.

4. Change to your new project's directory. For example, if you named it `MyAddon` in the last step,
   you'd type:

    ```console
    cd MyAddon
    ```

5. Build your addon package and link it to your local World of Warcraft installation:

    ```console
    wap build --link
    ```

    At this point, **you can play the game with your addon**.

6. Upload your addon to CurseForge with your
   [API token](https://authors.curseforge.com/account/api-tokens) so that others can use it:

    ```console
    wap publish --curseforge-token "<api-token>"
    ```

## Project Information

- License: MIT
- PyPI: <https://pypi.org/project/wow-addon-packager/>
- Source Code: <https://github.com/t-mart/wap>
- Documentation: <https://t-mart.github.io/wap/>
- GitHub Action: <https://github.com/t-mart/wap-action>
- Supported Python Versions: 3.11 and later
- Badge: [![Packaged by wap](https://img.shields.io/badge/packaged%20by-wap-d33682)](https://github.com/t-mart/wap)
- Contribution Guide: <https://t-mart.github.io/wap/contributing>
pypixcode 1.0.4
Este projeto é uma biblioteca Python para gerar codigo e qrcode do Pix. Ele fornece uma interface simples e intuitiva para criar, modificar e validar dados de Pix.
Requires Python: <4.0,>=3.13
Keywords: packaging, pix, qrcode



Este projeto é uma biblioteca Python para gerar codigo e qrcode do Pix. Ele fornece uma interface simples e intuitiva para criar, modificar e validar dados de Pix.

## Instalação

Para instalar o projeto, use o pip:

```bash
pip install pypixcode
```

## Uso
Exemplo de como gerar um código Pix:

```python
from pypixcode import PixBuilder

name = "Fulano De Tau"
pix_key = "42fbd387-e918-48c7-abd9-13958bea32ce"
value = "1.00"
city = "Para De Minas"
tx_id = "***"

# Cria uma instância do PixBuilder
pix_builder = PixBuilder(name, pix_key, value, city, tx_id)

code = pix_builder.get_code()

# result str:  00020126580014BR.GOV.BCB.PIX013642fbd387-e918-48c7-abd9-13958bea32ce52040000530398654041.005802BR5913Fulano De Tau6013Para De Minas62070503***63045039
```

Exemplo de como gerar um QR em base64 do código Pix:

```python
from pypixcode import PixBuilder

name = "Fulano De Tau"
pix_key = "42fbd387-e918-48c7-abd9-13958bea32ce"
value = "1.00"
city = "Para De Minas"
tx_id = "***"

# Cria uma instância do PixBuilder
pix_builder = PixBuilder(name, pix_key, value, city, tx_id)

code = pix_builder.get_qrcode()
# result base64 image: iVBORw0KGgoAAAANSUhEUgAAAQkAAAEJAQAAAACvE+/JAAACuklEQVR42u1ZMY6rUBCbfApKjsBNyMWQiMTFkptwBEoKxKztednVr7b78peSYvVEXuGdeDz2EPnb5xGfK58rplf2iLhlbhHDmvkcMvsXvuqfeN7jyp/49fPPrhDukvnauzym4QS+fR6Pe65bCrMh3DlQzscYAnmhunHfO8DdY3SFC3wsLGgBbqDOufXOcPMcD3IXTzpyI8IW7lL4QIYT+MiDK/jMlLtUBjQYyvnXH1NlqM8Z0AMpQxDpTB6U1vlVt1USNSV3t+MGWsQ0QCgM4b5FQWNC3AVtt/6iPHgqA3/9FD6c0HT7skEoHqNjdRdUMogZ+A4gTckwvpsd4XKWsaaQL8zfG9AngQP9atlq+PUnCC18zprospU8WEnb01LIMNAIsjSCtMg25CyFDEUMmbFLvQVv1stFqgcth3ApA/EVGSZy9zLlbozCHGJsOXOeTHUXkSKKp7tGGwzkHf/C4SpktAscbeLuJY2gmnEmW+puc7nUXXkGBratnrl6hqUkV3432slSGVDdCj+srjJEtpMlGarBFgZ3pQkw4pbtZEmGlJ358bvJpnPlLoX2wklOAfK1tBUDMFtOtY7uBt6RPqe5SPL5GlzDDxxZtzWzs0t3tYg6LXX3UcuQd9PNITNGSfPUXaEaOYnJ3Y57vXUrl2bZapwQKaFlemdqKx54ChkriUk8yYeFFHjlaLOsbm1xKr2PxVhlNVPu0uLcU348S3dBi8VWdzkSvj0Dg0Qc03u0eQqZRgJpm33LQl0eZSEs1yKvprvNKTBalnsw3UDK3SicyfkyDrsmYSkDeZBa8WuqnaF+S9PtOQ3u9b1deL2rm66vUqhcldVU03N05W7BxUmLBU01JmGmd9/qKgkjpj3LLsjvnr5vfvS+B0LGTbSSMDywa7SsPUglIHL3Wd5xtdXdz6v9z5X/7coXs9mf7/Qucv8AAAAASUVORK5CYII=

```

## Contribuição

1. Faça um fork do projeto
2. Crie uma branch para sua feature (`git checkout -b feature/nova-feature`)
3. Commit suas mudanças (`git commit -am 'Adiciona nova feature'`)
4. Faça um push para a branch (`git push origin feature/nova-feature`)
5. Abra um Pull Request

## Licença

Este projeto está licenciado sob a Licença MIT - veja o arquivo `LICENSE` para mais detalhes.
Topsis-Rohit-102203804 1.2.0
Implementation of TOPSIS for multi-criteria decision making
Requires Python: >=3.6

# Topsis-Rohit-102203804

A Python package implementing the TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) method for multi-criteria decision making. This package helps compute rankings for alternatives based on their proximity to ideal best and worst solutions.

## Installation

Install the package using pip:

```bash
pip install Topsis-Rohit-102203804
```

Install required dependencies:

```bash
pip install pandas numpy pyexcel
```

## Features

- Compute TOPSIS scores and rankings for alternatives
- Support for custom weights and impacts for decision criteria
- Export results to CSV file
- Comprehensive input validation
- Both command-line and programmatic usage
- Support for CSV and Excel input files

## Usage

### Command Line Interface

```bash
topsis <InputDataFile> <Weights> <Impacts> <ResultFileName>
```

Parameters:
1. `InputDataFile`: Path to input dataset (CSV/XLSX)
2. `Weights`: Comma-separated criterion weights (e.g., "1,2,3")
3. `Impacts`: Comma-separated criterion impacts ('+' for maximize, '-' for minimize)
4. `ResultFileName`: Output file path for results

Example:
```bash
topsis data.csv "1,1,1,1,1" "+,+,-,+,-" result.csv
```

### Python Package Usage

```python
from topsis_rohit_102203804.topsis import topsis

# Perform TOPSIS analysis
topsis("input.csv", [1,1,1,1,1], ['+','+','-','+','-'], "output.csv")
```

## Input Data Format

### File Requirements
- Must contain at least 3 columns
- First column: Names of alternatives
- Columns 2 onwards: Numeric values for criteria

Example Input CSV:
```
Alternative,Criterion1,Criterion2,Criterion3
A1,250,16,12
A2,200,18,11
A3,180,20,10
```

## Output Format

The package generates a CSV file with the original data plus two additional columns:
- Topsis Score: Calculated similarity to ideal solution
- Rank: Final ranking of alternatives

## Error Handling

The package validates:
- Number of command-line arguments
- File existence and readability
- Minimum column requirement (3 or more)
- Numeric values in criteria columns
- Matching counts of weights, impacts, and criteria
- Valid impact symbols (+ or -)
- Proper formatting of weights and impacts (comma-separated)

## Prerequisites

- Python 3.6 or higher
- Dependencies:
  - pandas
  - numpy
  - pyexcel

## License

MIT License

## Author

Rohit ([GitHub Profile](https://github.com/therohitsingla))
Topsis-BaneetSingh-102203180 1.0.0
A TOPSIS implementation for multiple-criteria decision analysis
Requires Python: >=3.6

# Topsis-Baneet-102203180

A Python package for implementing the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) method.

## Installation

```bash
pip install Topsis-Baneet-102203180
```

## Usage

You can use this package either through command line or as a Python module.

### Command Line Usage

```bash
python -m topsis_baneet_102203180 input.csv "1,1,1,2" "+,+,-,+" result.csv
```

### Python Module Usage

```python
from topsis_baneet_102203180 import topsis

# Process TOPSIS
result = topsis("input.csv", "1,1,1,2", "+,+,-,+", "result.csv")
```

## Input Format

1. Input file (CSV):
   - First column: Object/Variable names
   - Subsequent columns: Numeric values only

2. Weights: Comma-separated numeric values
   - Example: "1,1,1,2"

3. Impacts: Comma-separated '+' or '-' values
   - Example: "+,+,-,+"

## Output

The program will generate a CSV file with:
- All original columns
- Additional 'Topsis Score' column
- Additional 'Rank' column

## License

MIT License

## Author

Baneet Singh
cefin 0.2
Repository of Insper's Finance Unit
Keywords: finance, financial data


# cefin
We are Insper's Finance Unit. This repository holds code and data used in our studies.

# Installation
```commandline
pip install cefin
```

# Data Feeder
All of our data can be retrieved through the `CefinData` class. The available methods are:
- `titulos_publicos()`: Brazilian Public Bonds secondary market. Source is from the [Brazilian Central Bank website](https://www4.bcb.gov.br/pom/demab/negociacoes/apresentacao.asp?frame=1). Our data has been cleaned and strucured.