semvec/pypi-packages huggingface dataset:
discord-python-SniperThrilla 0.0.6
A small example package
Requires Python: >=3.10

# discord-python
A discord API wrapper made for developing discord bots in python.

## Features
- Application Commands
- Message Components
- Modals
- Automatic Gateway Integration
- Low-level access to websockets

## Installation
There is currently no package, so just grab the files and dump them in your directory.

## Usage

```python
# Create a client and add two commands.
client = Client.Client()

# Register a new application command /help with a string parameter called "test" and responds with the function "help"
client.registerApplicationCommand("help", Enums.ApplicationCommand.SUB_COMMAND, "my epic description", help, [ApplicationCommands.ApplicationCommandOption(3, "test", True)])

# Register another application command called /menu
client.registerApplicationCommand("menu", Enums.ApplicationCommand.SUB_COMMAND, "testing select menus", menu)

client.syncApplicationCommands()
client.run("BOT TOKEN HERE")
```

```python
# For the /help command, the callback function is called help, but can be called anything.
# Instead of registering the commands as above, you can use a decorator as follows.
@client.AppCommand(name="help", type=Enums.ApplicationCommand.SUB_COMMAND, description="my epic description", parameters = [ApplicationCommands.ApplicationCommandOption(Enums.ApplicationCommand.STRING, "test", "description", True)])
def help(client : Client.Client, interaction : InteractionResponder.Interaction):

    # Respond with a message saying, "Hello, World!"
    response = InteractionResponder.InteractionResponseText(interaction=interaction, text="Hello, world!", ephemeral=True)
    
    # Create an action row.
    actionRow = InteractionResponder.ActionRow(client=client)

    # Adds a button to the message with the option set by the user as the label
    actionRow.addComponent(InteractionResponder.Button(interaction.options[0]['value'], Enums.ButtonStyle.BLURPLE, client, "test1", callback=callback_test1))
    response.addActionRow(actionRow)
    response.generateJSON()
    
    # Send the message to discord!
    message = Message.Message(url=response.url, method=Message.HTTPMethods.POST, json=response.json, client=client)
    client.messageQueue.append(message)
```

## Contributing

Feel free to open an issue to discuss any changes.

## License

[GPLv3](https://choosealicense.com/licenses/gpl-3.0/)
topsis-7016 1.1.0
topsis package for MCDM problems
Requires Python: >=3.6
Keywords: topsis

# topsis-7016

_for: **Project-1 (UCS654)**_
_submitted by: **Mukul Sharda**_
_Roll no: **102197016**_
_Group: **3CS-4**_


topsis-7016 is a Python library which implements the TOPSIS algorithm used for Multiple Criteria Decision Making(MCDM). [Know more about Topsis](https://en.wikipedia.org/wiki/TOPSIS)

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install topsis-7016.

```bash
pip install topsis-7016
```

## Usage

Enter filename followed by _.csv_ or _.xlsx_  extentsion, then enter the _weights_ vector with vector values separated by commas, followed by the _impacts_ vector with comma separated signs _(+,-)_, make sure to pass the file where you want to store your results.

```python3
from topsis import topsis
topsis.main("file_path", "weights", "impacts", "output.csv")
```

## Example

#### sample.csv

A csv file showing data for different mobile handsets having varying features.

| Model  | Storage space(in gb) | Camera(in MP)| Price(in $)  | Looks(out of 5) |
| :----: |:--------------------:|:------------:|:------------:|:---------------:|
| M1 | 16 | 12 | 250 | 5 |
| M2 | 16 | 8  | 200 | 3 |
| M3 | 32 | 16 | 300 | 4 |
| M4 | 32 | 8  | 275 | 4 |
| M5 | 16 | 16 | 225 | 2 |

weights vector = [ 0.25 , 0.25 , 0.25 , 0.25 ]

impacts vector = [ + , + , - , + ]

## Other notes

* Make sure the csv does not contain categorical values.
* Make sure your dataset has atleast 3 rows and 3 columns.
* The length of weights vector and impact vector must equal the number of columns in dataset.
* While writing weights vector or impact vectors, please make sure not to put extra spaces.
fps-tracker 1.0.1
A Python package to detect and calculate the webcam frame rate per second in any system.
Requires Python: >=3.8

# FPS Tracker

fps_tracker helps to detect and measure the webcam's frame rate per second in any system

This frame rate depends on both the computational speed and the webcam's capability as usual.

### You can install using pip:

```
pip3 install fps_tracker
```

### Import package:

```
import cv2
import time
from fps_tracker import Tracker
```

### You can call the module using the syntax:

```
trackfps.FPS(img, pos1, Average_FPS, pos2)
```

- img is the frame in which the FPS will be calculated and displayed
- pos1 is the pixel position of the measured FPS in text
- Average_FPS is the average FPS measured for every 5 seconds. This argument is optional and default is set to True
- pos2 is the pixel postion of the average FPS in text 

### Sample python program:

```
cap = cv2.VideoCapture(0)
trackfps = Tracker()
while True:
    ret, image = cap.read()
    img = trackfps.FPS(img = image)
    cv2.imshow('Frames', img)
    k = cv2.waitKey(1)
    if k & 0xFF == 27:
        break
cv2.destroyAllWindows()
```
Topsis-Harshit-102003653 0.2
Python program using TOPSIS to calculate ranks based on data, weights and impacts

Author: Harshit Sharma
Version: 0.2


What is Topsis ?

Technique for Order Preference by Similarity to Ideal Solution (TOPSIS) came in the 1980s as a multi-criteria-based decision-making method. TOPSIS chooses the alternative of shortest the Euclidean distance from the ideal solution and greatest distance from the negative ideal solution. 

To make this definition easier, letâ€™s suppose you want to buy a mobile phone, you go to a shop and analyze 5 mobile phones on basis of RAM, memory, display size, battery, and price. At last, youâ€™re confused after seeing so many factors and donâ€™t know how to decide which mobile phone you should purchase. TOPSIS is a way to allocate the ranks on basis of the weights and impact of the given factors. 

Weights mean how much a given factor should be taken into consideration (default weight = 1 for all factors). like you want RAM to have weighed more than other factors, so the weight of RAM can be 2, while others can have 1.
Impact means that a given factor has a positive or negative impact. Like you want Battery to be large as possible but the price of the mobile to be less as possible, so youâ€™ll assign â€˜+â€™ weight to the battery and â€˜-â€˜ weight to the price.
This method can be applied in ranking machine learning models on basis of various factors like correlation, R^2, accuracy, Root mean square error, etc. Now that we have understood what is TOPSIS, and where we can apply this. Letâ€™s see what is the procedure to implement TOPSIS on a given dataset, consisting of multiple rows (like various mobile phones) and multiple columns (like various factors).




Installation:

pip install Topsis-Harshit-102003653





How to use?

Open terminal and intall Topsis-Harshit-102003653 and give input data with weights and impacts