semvec/pypi-packages huggingface dataset:
html-mitra 0.0.4
Create , edit html files easily with preformatted headers and preview them on your localhost or as a file.
Keywords: python,html,html_mitra,dev_gautam,nepal

### Developed by Dev Gautam Kumar
## Requirements

## Usage
You can use this library to create an HTML file if you are new to HTML
# Import
|from html-mitra import html |
# Create HTML file with preformatted headers
html.create_html(file_name)
# Create HTML elements
html.create_element(element_name,inner_content)
# Append elements and contents
html.append(file_name,content)
# Overwrite a file
html.overwrite(file_name,content)
# Delete a file
html.delete(file_name)
# Complete and serve the file
html.finish(file_name)
## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
CleanFill 0.0.5
To fill NaN value in a matrix.
Requires Python: >=3.7

# CleanFill
ClearFill is a python library you can use to fill NaN value in a matrix using various predictions techniques. This is useful in the context of collaborative filtering. It can be used to predict items rating in the context of recommendation engine. This code will fill NaN (Not A Number) with some predicted value according to the desired method of prediction. 

Alot of time, part of the data is left unfilled. This is frustating as sometime you are force to dump alot of data because of missing values. But if you use a library like CleanFill, you can avoid having to remove this potentially useful data.

It's a simple data transformation tool.

# How it works
ClearFill take in a numpy array matrix containing NaN and fill them with estimated value. For a demonstration simply look at test.py

# Available prediction methode
- Linear regression
- Nearest value
- Slope One (Fastest)
- Weighted Slope One
- Bipolar Slope One

# Installation
pip install CleanFill

# Depedencies
You'll need numpy and scipy installed in your venv to run this library.

# Exemple for NaN as value
```
import numpy as np
from CleanFill import CleanFill



nan = np.NaN
my_data = np.array([[7, nan, 8, 7],
                    [6, 5, nan, 2],
                    [nan, 2, 2, 5],
                    [1, 3, 4, 1],
                    [2, nan, 2, 1]])


print(CleanFill.fill_linear(my_data))
print(CleanFill.fill_slope_one(my_data))
print(CleanFill.fill_weighted_slope_one(my_data))
print(CleanFill.fill_bipolar_slope_one(my_data))
```

# Exemple for 0 as value
```
import numpy as np
from CleanFill import CleanFill


my_data2 = np.array([[7, 0, 8, 7],
                    [6, 5, 0, 2],
                    [0, 2, 2, 5],
                    [1, 3, 4, 1],
                    [2, 0, 2, 1]])


my_data2 = CleanFill.ZeroToNaN(my_data2)

print(CleanFill.fill_linear(my_data2))
print(CleanFill.fill_slope_one(my_data2))
print(CleanFill.fill_weighted_slope_one(my_data2))
print(CleanFill.fill_bipolar_slope_one(my_data2))
kusto-pandas 0.1.0
A wrapper around a Pandas DataFrame which allows you to use the syntax of the Kusto Query Language to transform the DataFrame

KustoPandas is a wrapper around a Pandas DataFrame which allows you to use the syntax of the 
[Kusto Query Language](https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/) to transform the data frame.  Under the hood the commands are converted to the corresponding Pandas method, so you get all the performance of Pandas, but with the nice syntax of Kusto.

For installation use pip

```python
python -m pip install kusto_pandas
```

See the following jupyter notebooks for example usage

[KustoPandas walkthrough](https://github.com/js850/KustoPandas/blob/master/examples/kusto_pandas_walkthrough.ipynb)

[Trump approval ratings](https://github.com/js850/KustoPandas/blob/master/examples/trump_approval_ratings.ipynb)


Here are some very basic usage examples.  Please see the walkthrough above for more details.

```python
import pandas as pd
from kusto_pandas import Wrap
dataframe = pd.read_csv("data.csv")
w = Wrap(dataframe)

w.where("Column1 > 0").summarize("count(), AvgOfCol1 = avg(Column1) by Column2")

```

In the above, multiple tabular operators are chained together, however if you prefer you can enter the full Kusto query 

```python
w.execute("""
w
| where Column1 > 0
| summarize count(), AvgOfCol1 = avg(Column1) by Column2
""")
```

If you are working in a Jupyter notebook, then you may find it more convenient to use an IPython magic

![Kusto magic impage](https://github.com/js850/KustoPandas/raw/master/KustoMagic.png)
tfshow 0.0.1
Cyber tf visualizer
Requires Python: >=3.6

# tfshow
cyber tf visualizer.

## Install
tfshow need graphviz, so you should install graphviz first.
```shell
sudo apt-get install graphviz

pip install tfshow
```

## Quick start
After install tfshow, you can use below cmd to visualize coordinate transformation.
```shell
tfshow -f demo.record
```

then you can see the result
![tf graph](docs/img/example.jpg)