semvec/pypi-packages huggingface dataset:
complex 0.2.0
Compute complex numbers operations such as addition, substraction, multiplication , division, modulus, conjugate and angle.
License: MIT
Requires Python: >=3
Keywords: Complex Operations

[![Downloads](https://pepy.tech/badge/complex)](https://pepy.tech/project/complex)
[![Downloads](https://pepy.tech/badge/complex/month)](https://pepy.tech/project/complex/month)
[![Downloads](https://pepy.tech/badge/complex/week)](https://pepy.tech/project/complex/week)

# Complex
> Compute complex numbers operations such as addition, substraction, multiplication , division, modulus, conjugate and angle.

## Installation

OS X , Windows & Linux:

```sh
pip install complex
```
## Usage example
Use for complex number mathematics

```python
from complex import Complex
x = Complex(2,3)
y = Complex(4,5)
print(x+y, x-y, x*y, x/y, x.mod(), y.mod(), x.angle(), y.angle(), x.conjugate(), y.conjugate(), x.log(), y.log())
```

## Development setup
For local development setup

```sh
git clone https://github.com/deepak7376/complex
cd complex
pip install -r requirements.txt
```
## Meta
Deepak Yadav – [@imdeepak_dky](https://twitter.com/imdeepak_dky) – dky.united@gmail.com

Distributed under the MIT license. See ``LICENSE`` for more information.

[https://github.com/deepak7376/complex/blob/master/LICENSE](https://github.com/deepak7376)

## Contributing

1. Fork it (<https://github.com/deepak7376/complex/fork>)
2. Create your feature branch (`git checkout -b feature/fooBar`)
3. Commit your changes (`git commit -am 'Add some fooBar'`)
4. Push to the branch (`git push origin feature/fooBar`)
5. Create a new Pull Request

## References
None
pandas-similarity 1.0.1
Python library for measuring similarity between entries of a Pandas Dataframe.
License: MIT

# Pandas Similarity

[![Generic badge](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8-blue)](https://www.python.org/downloads/release/python-380/)

Pandas similarity is a small library that count and return a similarity index between the entries of a dataframe.

This index can be used to remove very similar observations in a Dataframe. This is useful when you have Dataset coming from different sources about the same subject.

### Installing
Install and update using pip:

```Shell
pip install pandas-similarity
```

### A simple example

*IndexCalculator* return a **normalized index between 0 and 1**.

```Python
import pandas as pd
from pandas_similarity import IndexCalculator

# Create a Pandas Dataframe.
df = pd.DataFrame([
    [1050, "Ixelles", 0, 360000],
    [1050, "Ixelles", 1, 340000]],
    columns=['postal_code', 'city', 'property_type', 'price'])

# Print the index of similarity between all entries of the dataframe.
print(IndexCalculator(df).get_index())

# Index: 0.6667
```

In this example, we have a Dataframe with two observations, where *price* and *property_type* are different. The similarity index returned by *IndexCalculator* is *0.667*.

## About the author
Author: [Joffrey Bienvenu](https://github.com/Joffreybvn), Junior developper & ML student @ [Becode](https://becode.org/).
rimp 0.0.4
A hacky project that lets you import repls from https://repl.it into your project
License: MIT

# rimp
A hacky project that lets you import repls from https://repl.it into your project

## How to install
```
pip install rimp
```

Wow, that was easy wasn't it?

## How to use

There's only 1 command you'll need to know how to use, `load_repl`.

*load_repl*(name: `str`, project: `str`, force_reinstall: `bool`=False, verbose: `bool`=True):

**name**: The name of the repl.it user you're installing from (eg.
[https://repl.it/@**21natzil**/Permissions](https://repl.it/@21natzil/Permissions))

**project**: The name of the repl you're installing (eg. [https://repl.it/@21natzil/**Permissions**]((https://repl.it/@21natzil/Permissions)))

**force_reinstall**: If True, rimp will install the repl again, even if it's already downloaded

**verbose**: If False, it will *not* print anything to stdout with installation information

It's advised you checkout the `test.py` file for examples of this being used. ***PLEASE NOTE***, you can only import
repls with a proper `setup.py` file. If you want an example on the most minimal `setup.py` file you can make:

* See [this link](https://repl.it/@21natzil/Permissions) if you only wish to make *files* importable
* See [this link](https://repl.it/@21natzil/discordy) if you wish to make a whole directory importable

From here, it's just a matter of figuring out what you must import, which depends on the repl you're installing and should look at those docs.

## Things to note
1. The `name` option in the `setup.py` is required but can be anything
2. Downloading huge repls is slow, but only needs to be done once, so only set force_reinstall to True when necessary.
3. I have not tested on Mac, however it should work on Windows + Linux
4. This project installs repls to a .rimp file in the current working directory.

### Change Log
**0.0.0** - Project Creation
python-expression 0.1
 Serialize and deserialize nested compound expression strings such as (a = 1 or (b = 2 and c = 3)) into parsable expression graphs such as [ key:a operator:= value:1, conjunction:or, [ key:b operator:= value:2, conjunction:and, key:c operator:= value:3 ] ]. 
License: MIT

# Expression

## About

Serialize and deserialize nested compound expression strings such as `(a = 1 or (b = 2 and c = 3))` into parsable expression trees such as `[key:a operator:= value:1, conjunction:or, [key:b operator:= value:2, conjunction:and, key:c operator:= value:3]]`.

You may want to:-
- provide an easy to configure filter on an endpoint such as `GET /services?filter=(price lt 200 and duration is 2hrs)`.
- build an ORM filter based on the expression.
- simply evaluate that an expression is `True` or `False`.

These sets of classes make few assumptions as to how conditions will be evaluated. It lets the author configure handlers that can be used to resolve conditions.

## Install

- [ ] Todo

## Configure

## Use

Deserialize a string into a tree of conditions.

```python
expression = Expression('(a = 1 and b = 2)')
conditions = expression.to_conditions()

print(conditions.conditions[0].key))        # a
print(conditions.conditions[0].operator))   # =
print(conditions.conditions[0].value))      # 1

print(conditions.conditions[1].value))      # and

print(conditions.conditions[2].key)))       # b
print(conditions.conditions[2].operator))   # =
print(conditions.conditions[2].value))      # 2
```

Evaluate an expression such `date date_between 2020-09-26,2020-09-28` as a boolean.

Instantiate the Evaluate object, passing through resolved expression arguments. In this case the `date` key will be resolved to a date object of `2020-09-27`.

```python
evaluate = Evaluate({
    "date": datetime.strptime("2020-09-27", '%Y-%M-%d')
})
```

Before evaluating ensure that the `date_between` expression can be handled by a designated Handler such as `DateBetweenHandler`.
```python
evaluate.add_condition_handlers({
    'date_between': DateBetweenHandler
})
```

Now evaluate the expression from string.
```python
result = evaluate.from_expression('date date_between 2020-09-26,2020-09-28')
self.assertTrue(result)
```

You can plug in any custom handler to suit the usecase.
```python
class DateBetweenHandler(Handler):

    def handle(self, condition):
        key = self._data.get(condition.key)

        values = condition.value.split(',')
        date1 = datetime.strptime(values[0], '%Y-%M-%d')
        date2 = datetime.strptime(values[1], '%Y-%M-%d')

        return date1 <= key <= date2
```

## Contribute

### Running tests
```
coverage run -m unittest2 discover -p="*Test.py"
coverage html
```

or use

```
bash bin/run-tests
```

```
bash bin/run-tests *Test.py
```
physicscalc 0.4
This is the package that houses various functions which can be used to calculate values for problems involving circuit design , value of the components which are needed to construct the circuit and so on
License: MIT
Keywords: physics,calculator,physicscalculations,Research,solutions

# physicscalc
This package consists of all different formulae used in physics for solving problems ,researching ,so on and so forth
## Development Status:

Under Development (Early release)

### Developed by:

 [Vishal Balaji Sivaraman](https://github.com/TheSocialLion)

### Installation:

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

```bash
pip install physicscalc
```

### To import physicscalc:

```python
import  physicscalc
```


## License:
[MIT](https://choosealicense.com/licenses/mit/)