semvec/pypi-packages huggingface dataset:
Topsis-raj-102303324 0.1.8
TOPSIS implementation using Python
Requires Python: >=3.7

## TOPSIS Implementation in Python  

**Course:** UCS654 : Predictive Analytics using Statistics  
**Assignment:** Assignment-1 (TOPSIS)  
**Author:** Raj Gupta  
**Roll Number:** 102303324  

---

## About the Project  

This project provides a Python implementation of the  
**TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution)** method.  

TOPSIS is a multi-criteria decision-making (MCDM) technique used to rank alternatives  
based on their distance from the **ideal best** and **ideal worst** solutions.  

---

## Installation (User Manual)  

This package requires **Python 3.7 or higher**.  

### Dependencies  
- pandas  
- numpy  


Package listed on PyPI:-http://pypi.org/project/Topsis-raj-102303324/
## Install the Package Using pip  

```bash
pip install Topsis-raj-102303324
```
---
## Usage

Run the following command in the Command Prompt / Terminal:
``` bash 
topsis <inputFile> <weights> <impacts> <outputFile>
```

Example
``` bash
topsis sample.csv "1,1,1,1" "+,+,-,+" result.csv
```
topsis-padampreet-102303222 0.1.1
TOPSIS implementation using Python

# Topsis-Padampreet-102303222

This package implements the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) method.

## Installation
pip install Topsis-Padampreet-102303222

## Usage
topsis data.csv "1,1,1,2" "+,+,-,+" result.csv
Topsis-Suhani-102313038 1.0.1
TOPSIS implementation for multi-criteria decision making

# Topsis-Suhani-102313038

## Description
This package implements the Technique for Order Preference by Similarity to Ideal Solution (TOPSIS) for multi-criteria decision making.

## Installation
```bash
pip install Topsis-Suhani-102313038
```

## Usage
Enter csv file name with .csv extension, then enter weights (comma separated), followed by impacts '+' or '-' (comma separated), and csv file where result is to be stored.
```bash
python -m topsis_suhani_102313038.topsis input.csv "1,1,1,1" "+,-,+,+" output.csv
```

## Input Format
- CSV file with alternatives and criteria
- Weights must be comma-separated
- Impacts must be + or -

  ## Output
  - Topsis Score
  - Ranking

## License 
This project is licensed under the **MIT License**.
[License](../LICENSE)
mmguero 2.0.4
Seth Grover's useful Python helpers
Requires Python: >=3.9

# mmguero

**mmguero** is my personal collection of miscellaneous helper functions for Python.

## Contents

Run `mmguero` to get a list of the exported functions and classes, e.g.:

```bash
$ 🧰 mmguero v#.#.#
   Seth Grover's useful Python helpers

🌐 Project URLs:
   Homepage, https://github.com/mmguero/python-mmguero
   Issues, https://github.com/mmguero/python-mmguero/issues
   Repository, https://github.com/mmguero/python-mmguero.git

📦 Public functions and classes:
  ⚙️  aggressive_url_encode()
  ⚙️  append_to_file()
  ⚙️  ask_for_password()
  ⚙️  ask_for_string()
  🧱 AtomicInt
  ⚙️  base64_decode_files_to_dir()
  ⚙️  base64_decode_if_prefixed()
  ⚙️  base64_encode_files_in_dir()
  🧱 BoolOrExtra
  🧱 CaselessDictionary
  ⚙️  check_output_input()
  ⚙️  choose_multiple()
  ⚙️  choose_one()
  ⚙️  chown_recursive()
  ⚙️  clear_screen()
  ⚙️  contains_whitespace()
  🧱 ContextLockedOrderedDict
  ⚙️  count_lines_mmap()
  ⚙️  custom_make_translation()
  ⚙️  deep_get()
  ⚙️  deep_merge()
  ⚙️  deep_merge_in_place()
  ⚙️  deep_set()
  ⚙️  dict_search()
  ⚙️  display_message()
  ⚙️  display_program_box()
  ⚙️  distro_info()
  ⚙️  download_to_file()
  ⚙️  dynamic_import()
  ⚙️  eprint()
  ⚙️  escape_ansi()
  ⚙️  escape_for_curl()
  ⚙️  evp_bytes_to_key()
  ⚙️  file_contents()
  ⚙️  flatten()
  ⚙️  get_function_name()
  ⚙️  get_iterable()
  ⚙️  get_main_script_dir()
  ⚙️  get_main_script_path()
  ⚙️  get_primary_ip()
  ⚙️  get_verbosity_env_var_count()
  ⚙️  git_clone()
  ⚙️  json_obj_serializer()
  ⚙️  load_file_if_json()
  ⚙️  load_str_if_json()
  ⚙️  main()
  ⚙️  max_hash_value_by_key()
  ⚙️  max_hash_value_by_value()
  ⚙️  min_hash_value_by_key()
  ⚙️  min_hash_value_by_value()
  ⚙️  parse_curl_file()
  ⚙️  pop_line()
  ⚙️  pushd()
  ⚙️  remove_empty_folders()
  ⚙️  remove_falsy()
  ⚙️  remove_prefix()
  ⚙️  remove_suffix()
  ⚙️  rmtree_except()
  ⚙️  run_process()
  ⚙️  run_sub_process()
  ⚙️  same_file_or_dir()
  ⚙️  set_logging()
  ⚙️  sha256_sum()
  ⚙️  shakey_sum()
  ⚙️  size_human_format()
  ⚙️  str2bool()
  ⚙️  str2bool_or_extra()
  ⚙️  tablify()
  ⚙️  temporary_filename()
  ⚙️  test_socket()
  ⚙️  touch()
  ⚙️  unescape_for_curl()
  ⚙️  unwrap_method()
  🧱 UserInputDefaultsBehavior
  🧱 UserInterfaceMode
  ⚙️  val2bool()
  ⚙️  which()
  ⚙️  yes_or_no()
```

## Installation

Using `pip`, to install the latest [release from PyPI](https://pypi.org/project/mmguero/):

```
python3 -m pip install -U mmguero
```

Or to install directly from GitHub:


```
python3 -m pip install -U 'git+https://github.com/mmguero/python-mmguero'
```

## Authors

* **Seth Grover** - *Initial work* - [mmguero](https://github.com/mmguero)

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
topsis-aarzoo-102303061 1.0.0
A Python package for TOPSIS multi-criteria decision making
Requires Python: >=3.6

Project Description 
Submitted by: Aarzoo  
Roll Number: 102303061  

This is a Python package that solves Multiple Criteria Decision Making (MCDM) problems using the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS).  
It ranks alternatives based on their closeness to the ideal best and ideal worst solutions.

Installation

Install the package using pip:

pip install topsis-aarzoo-102303061

Usage

Provide the input CSV file followed by the weights vector and impacts vector.

python <program.py> <InputDataFile> <Weights> <Impacts> <OutputResultFileName>

Example:

python topsis.py data.csv "1,1,1,2" "+,+,-,+" output-result.csv

Input

- CSV file
- First column contains alternatives
- Remaining columns contain numeric criteria values
- Number of weights and impacts must match the number of criteria

Output

- CSV file with two additional columns:
  - Topsis Score
  - Rank

Notes

- Input CSV should not contain categorical values
- Weights and impacts must be correctly specified

License

MIT
Topsis-Saksham-102303157 1.0.0
A Python package for TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) analysis
Requires Python: >=3.6

# Topsis-Saksham-102303157

A Python package implementing TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution), a multi-criteria decision analysis method.

## Description

TOPSIS is a method of compensatory aggregation that compares a set of alternatives by identifying weights for each criterion, normalizing scores for each criterion, and calculating the geometric distance between each alternative and the ideal alternative.

## Installation

```bash
pip install Topsis-Saksham-102303157
```

## Usage

### Command Line

After installation, you can use the `topsis` command directly from the terminal:

```bash
topsis <InputDataFile> <Weights> <Impacts> <OutputResultFileName>
```

### Example

```bash
topsis data.csv "1,1,1,2" "+,+,-,+" output.csv
```

### Parameters

- **InputDataFile**: Path to the input CSV file
- **Weights**: Comma-separated weights for each criterion (e.g., "1,1,1,2")
- **Impacts**: Comma-separated impacts (+ or -) for each criterion (e.g., "+,+,-,+")
- **OutputResultFileName**: Path for the output CSV file

### Input File Format

The input CSV file should have:
- First column: Names/identifiers of alternatives
- Remaining columns: Numeric values for each criterion

Example (data.csv):
```csv
Fund Name,P1,P2,P3,P4,P5
M1,0.67,0.45,6.5,42.6,12.56
M2,0.6,0.36,3.6,53.3,14.47
M3,0.82,0.67,3.8,63.1,17.1
```

### Output

The program generates a CSV file with two additional columns:
- **Topsis Score**: The calculated TOPSIS score for each alternative
- **Rank**: Ranking based on TOPSIS score (1 = best)

## Features

- Input validation (file existence, column count, numeric values)
- Proper error handling with descriptive messages
- Vector normalization method
- Weighted normalized decision matrix
- Euclidean distance calculation
- TOPSIS score and ranking

## Requirements

- Python 3.6+
- pandas >= 1.0.0
- numpy >= 1.18.0

## License

MIT License

## Author

Saksham (Roll Number: 102303157)

## Contributing

Contributions, issues, and feature requests are welcome!

## Support

For support, email your.email@example.com
lineflow-rl 0.2.0
Python tool to simulate assembly lines.
Requires Python: <3.14

# LineFlow

[![PyPI](https://img.shields.io/pypi/v/lineflow-rl)](https://pypi.org/project/lineflow-rl/)

`LineFLow` is a python framework to simulate assembly lines. It allows to model
arbitrary discrete part assembly lines and provides an `gymnasium` environment to
optimize them with reinforcement learning. The documentation can be
found [here](https://hs-kempten.github.io/lineflow/).

![til](docs/imgs/lineflow.gif)
# Install

Install with

```bash
pip install lineflow-rl
```

# Examples


## Visualization 
This is how an assembly line can be implemented and visualized:


```python
from lineflow.simulation import Line, Source, Sink, Process

class SimpleLine(Line):

    def build(self):

        # Set up stationary objects
        source = Source(
            name='Source',
            processing_time=5,
            position=(100, 500),
            unlimited_carriers=True,
        )

        process = Process('Process', processing_time=6, position=(350, 500))
        sink = Sink('Sink', processing_time=3, position=(600, 500))
        
        # Wire them with buffers
        source.connect_to_output(station=process, capacity=3)
        process.connect_to_output(station=sink, capacity=2)


line = SimpleLine()
line.run(simulation_end=500, visualize=True)

df = line.get_observations()
```

## Training RL agents

This is how an RL agent can be trained using `LineFlow`:

```python

from stable_baselines3 import PPO
from lineflow.simulation import LineSimulation

line = SimpleLine()
env = LineSimulation(line, simulation_end=100)
model = PPO("MlpPolicy", env)
model.learn(total_timesteps=100)
```

# Docs

Serve the docs with

```bash
mkdocs serve
```


# Paper

If you use our work in your research, please consider citing us with

```
@misc{LineFlow,
      title={LineFlow: A Framework to Learn Active Control of Production Lines}, 
      author={Kai Müller and Martin Wenzel and Tobias Windisch},
      year={2025},
      eprint={2505.06744},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      url={https://arxiv.org/abs/2505.06744}, 
}
```

See [this README](./scripts/README.md) for more details how to run the benchmarks.


# Funding

The research behind LineFlow is funded by the Bavarian state ministry of research. Learn more
[here](https://kefis.fza.hs-kempten.de/de/forschungsprojekt/599-lineflow).