semvec/pypi-packages huggingface dataset:
Topsis-Simardeep-102003559 1.0.0
Topsis package for Multiple Criteria Decision Making problems(MCDM) problems
Requires Python: >=3.6

Topsis-Simardeep-102003559 is a Python library for dealing Multiple Criteria Decision Making(MCDM)
## Installation

```bash
pip install Topsis-Simardeep-102003559
```

## Usage

Enter csv filename followed by _.csv_ extentsion, then enter the _weights_ string with values separated by commas, followed by the _impacts_ string with comma separated signs _(+,-)_ and name of file followed by -.csv- extension in which the user wants the output file
```bash
topsis sample.csv "1,1,1,1" "-,+,+,+" sample_result.csv
```

## Example

#### sample.csv

A csv file showing data for different mobile handsets having varying features.

```

 Mobile Name  Cost  Storage Space  Camera  Looks 
0          M1   250             16      12      5     
1          M2   200             16       8      3     
2          M3   300             32      16      4     
3          M4   275             32       8      4     
4          M5   225             16      16      2     

``` 

weights string =  "0.25,0.25,0.25,0.25"

impacts string =  "-,+,+,+"

### input:

```python
topsis sample.csv "0.25,0.25,0.25,0.25" "-,+,+,+" sample_result.csv
```

### output:
```

 Mobile Name  Cost  Storage Space  Camera  Looks  Performance  Rank
0          M1   250             16      12      5     0.534277     3
1          M2   200             16       8      3     0.308368     5
2          M3   300             32      16      4     0.691632     1
3          M4   275             32       8      4     0.534737     2
4          M5   225             16      16      2     0.401046     4

An output csv file will also be auto generated.
``` 

## License
2023 Simardeep Singh

This repository is licensed under the MIT license. See LICENSE for details.
Topsis-Harinderjit-102017151 1.0.6
topsis package for MCDM problems
Requires Python: >=3.6

# Topsis-Harinderjit-102017151

_for: **Assignment-1 (UCS654)**_
_submitted by: **Harinderjit Singh**_
_Roll no: **102017151**_
_Group: **3CSE7**_


<!-- This is a Python library for dealing with Multiple Criteria Decision Making(MCDM) problems by using technique for Order of Preference by Similarity to Ideal Solution(TOPSIS). -->
This is a Python library for solving Multiple Criteria Decision Making(MCDM) problems by using Topsis.

## Installation

<!-- Use the package manager [pip](https://pip.pypa.io/en/stable/) to install topsis-3283. -->
<!-- Write the following command in your command line. -->
Install the package using : 
```bash
pip install Topsis-Harinderjit-102017151
```

## Usage

Enter csv filename followed by _.csv_ extension, then enter the _weights_ vector with vector values separated by commas, then enter the _impacts_ vector with comma separated signs _(+,-)_, followed by filename where result will be stored.
```bash
topsis sample.csv "1,1,1,1" "+,-,+,+" output.csv
```
or vectors can be entered without " "
```bash
topsis sample.csv 1,1,1,1 +,-,+,+ output.csv
```
But the second representation does not provide for inadvertent spaces between vector values. So, if the input string contains spaces, make sure to enclose it between double quotes _(" ")_.

## Example

Consider this sample.csv file  

First column of file is removed by model before processing so follow the following format.  

All other columns of file should not contain any categorical values.

| Model  | P1 | P2 | P3 | P4 | P5 |
| :----: |:--:|:--:|:--:|:--:|:--:|
| M1 |0.85|0.72|4.6|41.5|11.92|
| M2 |0.66|0.44|6.6|49.4|14.28|
| M3 |0.9 |0.81|6.7|66.5|18.73|
| M4 |0.8 |0.64|6.9|69.7|19.51|
| M5 |0.84|0.71|4.7|36.5|10.69|
| M6 |0.91|0.83|3.6|42.3|11.91|
| M7 |0.65|0.42|6.9|38.1|11.52|
| M8 |0.71|0.5 |3.5|60.9|16.4 |

weights vector = [ 1,2,1,2,1 ]

impacts vector = [ +,-,+,+,- ]

### input:

```python
topsis sample.csv "1,2,1,2,1" "+,-,+,+,-" output.csv
```

### output:

output.csv file will contain following data :

| Model | P1 | P2 | P3 | P4 | P5 | Topsis score | Rank |
| :---: |:--:|:--:|:--:|:--:|:--:| :----------: | :--: |
| M1 |0.85|0.72|4.6|41.5|11.92| 0.3267076760116426 | 6 |
| M2 |0.66|0.44|6.6|49.4|14.28| 0.6230956090525585 | 2 |
| M3 |0.9 |0.81|6.7|66.5|18.73| 0.5006083702087599 | 5 |
| M4 |0.8 |0.64|6.9|69.7|19.51| 0.6275096427934269 | 1 |
| M5 |0.84|0.71|4.7|36.5|10.69| 0.3249142875298663 | 7 |
| M6 |0.91|0.83|3.6|42.3|11.91| 0.2715902624653612 | 8 |
| M7 |0.65|0.42|6.9|38.1|11.52| 0.5439263412940541 | 4 |
| M8 |0.71|0.5 |3.5|60.9|16.4 | 0.6166791918077927 | 3 |
encosy 3.0.0
ECS python implementation
Requires Python: >=3.10,<4.0

# encosy
## [Docs](https://cruxyu.github.io/encosy/)

## Installation

### Using pip
Releases of `encosy` can be installed using pip::

    $ pip install encosy

Source releases and any binaries can be downloaded from the PyPI link.

    https://pypi.org/project/encosy/


### Using git and poetry
For poetry guide follow [this link](https://python-poetry.org/docs/)::
    
    git clone https://github.com/Cruxyu/encosy.git
    poetry install

### Profiling
#### CPU
To create a profile.prof

    from file_with_app import app
    import cProfile
    import pstats
    
    
    def main():
        with cProfile.Profile() as pr:
            app()
        stats = pstats.Stats(pr)
        stats.sort_stats(pstats.SortKey.TIME)
        # stats.print_stats()
        stats.dump_stats("app.prof")
    
    
    if __name__ == "__main__":
        main()

To see viz of a profile

    poetry run python -m snakeviz app.prof

#### Memory
To test memory run

    mprof run app.py  

To see the results run
    
    mprof plot
vtivrt 1.0.0
vtivrt is a library for decoding/encoding of VITA Radio Transport (VITA 49) data streams, for use with VTI Instruments products.
Requires Python: >=3.6

VTI VRT
=======

vtivrt is a library for decoding/encoding of VITA Radio Transport (VITA 49) data streams, for use with VTI Instruments products.

.. code-block:: python

    >>> import vtivrt
    >>> reader = vtivrt.VtiVrtReader('example.local', 9901)
    >>> packet = reader.read(True)
    >>> packet.stream_id
    257
    >>> packet.timestamp
    Decimal('1646852.220398853')
    >>> packet.data
    [-5.2093963623046875, -5.208981990814209, -5.208486080169678, -5.207897663116455]
    >>> packet.context[0].data.trigger_timestamp
    Decimal('1646852.220391333')

The main classes of interest exposed by vtivrt are:
 * `vtivrt.reader.VtiVrtReader` - Connects to a streaming socket, performs handshaking with the server, and reads data.
 * `vtivrt.reader.VtiVrtThread` - Creates multiple instances of `vtivrt.reader.VtiVrtReader` and collates data from all of them in a background thread.
 * `vtivrt.packet.VtiVrtPacket` - Represents one VRT packet, and optionally its associated context packets.

Installing
----------

vtivrt is available on `PyPI <https://pypi.org/project/vtivrt>`_:

.. code-block:: sh

    $ python -m pip install vtivrt

Documentation
-------------

Full documentation is available at `vtivrt.readthedocs.io <https://vtivrt.readthedocs.io/>`_.

Supported Versions
------------------

vtivrt officially supports Python 3.6+.

Features
--------

* Allows reading and writing VRT data streams to transfer high speed streaming data to and from VTI Instruments products.
vti-jsonrest 1.0.2
A client library for discoverable REST APIs using JSON payloads.
Requires Python: >=2.7

JSONREST
========

JSONREST is a client library for discoverable REST APIs using JSON payloads.

.. code-block:: python

    >>> import jsonrest
    >>> j = jsonrest.JSONREST('http://example/')
    >>> dir(j)
    ['foo', 'bar', 'baz']
    >>> j.foo
    JSONREST('http://example/foo/', ['x', 'y', 'z'])
    >>> j.foo.x = 42
    >>> print(j.foo.x)
    42


JSONREST exposes the REST API as an object-oriented interface, with the object hierarchy mirroring the directory structure of the URLs. In order to make this work, it depends on the server responding to GET requests on directories with a JSON array containing all available API endpoints (or other directories) that reside there, with directories identified by a trailing forward-slash (/).

Installing
----------

JSONREST is available on `PyPI <https://pypi.org/project/vti-jsonrest/>`_:

.. code-block:: sh

    $ python -m pip install vti-jsonrest

Documentation
-------------

Full documentation is available at `jsonrest.readthedocs.io <https://jsonrest.readthedocs.io/>`_.

Supported Versions
------------------

JSONREST officially supports Python 2.7 & 3.6+.

Features
--------
* Makes REST APIs behave like a normal python object
* Supports tab-completion in REPLs and Jupyter notebooks
* Keep-Alive & Connection Pooling
VloerverwarmingMonitor-sldewit 0.0.4
Monitoring systeem voor vloerverwarming
Requires Python: >=3.7


# VloerverwarmingMonitor

[![Stable Release][stable_release]][stable_release]
[![Project Maintenance][maintenance-shield]][user_profile]
[![License][license-shield]](LICENSE)
[![BuyMeCoffee][buymecoffeebadge]][buymecoffee]

Monitoring system for a floor heating system with heat exchanger. 

This system is design to monitor several different loops in a floor heating system using a heat exchanger. The measured data is published to a MQTT broker. 

# Hardware setup

The system is built arround 1-wire temperature sensor DS18B20 connected to a Raspberry Pi with 1-wire setup as default on GPIO 4. 

My specific project will be using 10 DS18B20 sensors to monitor my total 8 loops + supply/return on the heat exchanger. They are connected as shown in this picture:

![Figure 1-1](https://github.com/sldewit/VloerverwarmingMonitor/blob/5161e3ec3d567c0ba0c02cbbaa3b987bfebc9c35/Fritzing/Vloerverwarming%20monitor_schema.svg)

My POC setup for now uses only 5 DS18B20 sensors. 

Below my basic call structure for 5 different sensors.

```
   try:
        client = mqtt.Client() 
        client.on_connect = on_connect
        client.will_set('vloerverwarming/status', "offline")
        client.username_pw_set("mqtt","test_mqtt")
        client.connect("ha.de-wit.me", 1883, 60)
        client.publish('vloerverwarming/status',payload = "online", qos=0, retain=True)
        client.publish('vloerverwarming/version/installed',payload = "1.0.0", qos=0, retain=True)
        client.publish('vloerverwarming/version/latest',payload = "1.0.0", qos=0, retain=True)
        client.loop_start()
    except Exception as e:
        print(f"Failed to connect to MQTT: {e}")
        exit()

    Sensors = []

    Sensors.append(TemperatureSensor('vloerverwarming/kring1/aanvoertemp',"28dfc6571f64ff",client))
    Sensors.append(TemperatureSensor('vloerverwarming/kring1/afvoertemp',"28dfd9571f64ff",client))
    Sensors.append(TemperatureSensor('vloerverwarming/kring2/aanvoertemp',"2828ff571f64ff",client))
    Sensors.append(TemperatureSensor('vloerverwarming/kring2/afvoertemp',"28aafd571f64ff",client))
    Sensors.append(TemperatureSensor('vloerverwarming/aanvoertemp',"282bfe571f64ff",client))

    stopFlag = Event()
    thread= MyThread(stopFlag, 10)
    thread.start()
```

[buymecoffee]: https://www.buymeacoffee.com/sldewit
[buymecoffeebadge]: https://www.buymeacoffee.com/assets/img/custom_images/yellow_img.png
[license-shield]: https://img.shields.io/github/license/sldewit/vloerverwarmingMonitor.svg
[maintenance-shield]: https://img.shields.io/badge/maintainer-%40sldewit-blue.svg
[user_profile]: https://github.com/sldewit
[stable_release]: https://shields.io/github/v/release/sldewit/VloerverwarmingMonitor?label=stable&sort=semver
famodels 1.0.20
The library describes the most common models used in trading systems.
Requires Python: >=3.9
Keywords: finance,trading,models

# fa-models
A set of models often used for trading services. The library offers no algorithms - just models.

## General
Run and compiled for Python 3.9.13.

## Development


### Installation as Consuming Developer

Simply run:

`pip install fa-models`

### Setup as Contributor
Create the virtul environment: `py -m venv .venv`
Start the Environment: `./.venv/Scripts/activate`. Use `deactivate`to stop it.
Update the PIP: `py -m pip install --upgrade pip`

All the required libraries must be listed in requirements.txt and installed by  `py -m pip install -r .\requirements.txt`

To cleanup the environment run:
`pip3 freeze > to-uninstall.txt` and then
`pip3 uninstall -y -r to-uninstall.txt`

or `pip3 install pip-autoremove`

### Build Library
Preqrequisite: make sure that you give your Operating System user the right to modify files in the python directory. The directory where pyhton is installed.
Use `python setup.py bdist_wheel` to create the dist, build and .eggs folder.

## Reference from a different project
In order to use your own version of the project - to maybe contribute to the library - simply clone the code from github into new directory. Then add the path of that new directory to the requirements.txt file of your project. Then change in fa-models whatever you recommend to improve. Don't forget the Open-Closed Principle: extend only (unless it requires a breaking change)


### Releasing a new version

Install the tools build, twine and bumpver: `python -m pip install build twine bumpver`
Upgrade the setuptools: `pip install --upgrade setuptools`

Delete any old files in the /dist folder.

Bump the version in pyproject.toml: `bumpver update --patch`

Build the project: `python -m build`

Check the distribution: `twine check dist/*`

Upload to test-pypi to validate: `twine upload -r testpypi dist/*`

Login with username: svabra (password should be known)

Finally, upload to pypi production: `twine upload dist/*`
alpha-viewer 0.1.5
Alphafold Protein model viewer
Requires Python: >=3.8

# alpha_viewer
Class to view Alphafold models

alpha_viewer is based on the alphafold2 colab notebook visualization. It automatically chooses the best available prediction. alpha_viewer includes functions to plot PAE (`plot_pae`) and pLDDT (`plot_pLDDT`). It also allows for coloring of the py3Dmol view based on pLDDT with `show_confidence`. alpha_viewer contains `.obs`, a pandas data-frame, that can be used for custom annotations based on aa postion within the chain(s). You can use a key of `.obs` to color the py3Dmol view of your protein(s) based that annotation with `show_annotation`. This can also be used to inspect substructures with `show_substructures`. 

alpha-viewer has been tested to work with `monomer`, `monomer_ptm` and `multimer` models.
So far it's sadly not possible to save the py3Dmol view for exporting.

If you use alpha_viewer in your publication please cite: <a href="https://doi.org/10.5281/zenodo.6548465"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.6548465.svg" alt="DOI"></a>


-------
### Install

you can install this repository from pypi with:\
`pip install alpha-viewer`


It's recommended to use alpha_viewer within jupyterlab. Please enable jupyterlab extensions and install `jupyter-widgets/jupyterlab-manager` and `jupyterlab_3dmol`


A tutorial notebook can be found in `https://github.com/Intron7/alpha_viewer/tree/main/tutorials`
thecodingscoiety 0.0.3
A package of function created by and for The Coding Society
Requires Python: >=3.7

# rollno-parser


To create a python script to parse roll number of panimalar students to get their student info.

Roll Number in Panimalar follows the system (YEAROFJOIN)YYYY-PEC-(DEPT)DD-(ROLLNO)XXXX

eg) 2021PECCB101

2021 - Year of Join
PEC - Panimalar Engineering College
CB - Department (Computer Science and Business Systems
101 - Roll No