semvec/pypi-packages huggingface dataset:
py-simple-history 0.0.1
A super simple history tracking class / mixin.
Requires Python: >=3.8

# py_simple_history 0.0.1<a name="mark0"></a>

***A super basic python History Tracking object***

---

- [About](#mark1)
- [Installation](#mark2)
- [Usage](#mark3)
	- [history_mixin](#mark4)
- [Example](#mark5)

---

# About<a name="mark1"></a>[^](#mark0)

In this instance "History" means the state of an object at any given time. This module aims to provide a simple interface for tracking and moving through histories.

# Installation<a name="mark2"></a>[^](#mark0)

Available on pip - `pip install py_simple_history`

# Usage<a name="mark3"></a>[^](#mark0)

### history_mixin<a name="mark4"></a>[^](#mark3)
> **Abstract mixin to add simple history-tracking to an object.**
> 
> ```py
> class history_mixin(object):
> 	def __init__(self, start_data):
> 		...
> 	def add_history(self, data):
> 		"""Add a history point. Clears any undone data history points."""
> 	def clear_history(self, data=None):
> 		"""Clears history. Sets a new history point, if no data specified uses the current data point."""
> 	def redo(self):
> 		"""Redoes history one step if possible."""
> 	def undo(self):
> 		"""Undoes history one step if possible."""
> ```
### Example<a name="mark5"></a>[^](#mark0)

> ```py
> from py_simple_history import history_mixin
> 
> class demo_object(history_mixin):
>     def __init__(self, initial_data):
>         history_mixin.__init__(self, initial_data)
>         self.load(self.data:=initial_data)
>         ...
> 
>     def on_update(self, new_data):
>         self.add_history(new_data)
>         self.load(data)
> 
>     def load(self, data):
>         self.data = data
> 
>     def step_back(self):
>         self.load(self.undo())
> 
>     def step_forward(self):
>         self.load(self.redo())
> ```
Energy-models 0.0.1
Prediction models in timeseries
Requires Python: >=3.7

# Energy Models Package

                             THIS IS A PACKAGE OF MODELS OF PREDICT IN TIMESERIES FORECASTING                
             this package helps any developer in univariate and multivariate-multi-step time series forcasting in house-power-consumption dataset lets take a look about each type 
             Real-world time series forecasting is challenging for a whole host of reasons not limited to problem features such as having multiple input variables,the requirement 
             to predict multiple time steps,nd the need to a perform the same type of prediction for multiple physical sites.

# Installation

````
pip install Power_models
````

# Models list
  
  * LSTM 
  * BILSTM
  * GRU
  * BIGRU
  * TimeDistributer
  * CNN
  * TCN
  All models take 3 parameters except TCN :
    
    * must take value 
      -1 : n_steps
      -2 : n_features 
    * default value = 1 
      -3 : n_outputs  
      
  TCN Model you can build it by just give it data to build function
      
  
# Package Folders 
 
 * Data
 * models
 
# how to use the package

 first you must read the data set you want to use the models on it 
 and then import preprocess_data from Data folder :
 
 ````
 from Data import preprocess_data as pr
 
 df = pd.read_csv('Data.txt',sep=';', 
                  parse_dates={'date_time' : ['Date', 'Time']}, infer_datetime_format=True, 
                  low_memory=False, na_values=['nan','?'], index_col='date_time')

 pr.fill_missing(df.values)
 df.to_csv('new_data.csv')
 
 df = pd.read_csv('new_data.csv',parse_dates=['date_time'], index_col= 'date_time')
 ````
 
 next step you can use functions on preprocess_data to split and scale the data . 
 
   ````
   X_train, X_test = pr.train_test_split(df)
   X_train, X_test, scaler = pr.scale_data(X_train, X_test)
   ```` 
   
 After that converting the data to supervised.
 now you can build model by import it from models folder :
 
  ````
  from models import Models as m
  model=m.lstm(21, 7 , 7 ).getModel()
  21 ==> n_steps
  7 ==> n_features
  7==>n_outputs
  ````
  
 After that you will able to predict and evaluate your models used. 
 
  ````
  y=model.predict(X)
  X==>input
  ````
 
 Models have evaluation function you can give it  the model and (actual , predicted) values 
 
  ````
  m.evaluate(model,actual,pred)
  ````
   
 Else you can calculate loss using metrics function for train and test both :
 
  ````
  m.print_metrics(model,Y_train,Y_pred_train,Y_test,Y_pred_test)
  ````
pwerpy 1.0.1
Easier communication between Microsoft Power BI REST API and a client
Requires Python: <4,>=3.7
Keywords: python,power bi,power bi rest api,powerbi


# pwerpy

This Python package, makes communication between Microsoft Power BI REST API and a client easier.

*Read this in other languages: [Español](https://github.com/4ssef/powerpy_package/blob/master/README_es.md).*

## Requirements
* Python >= 3.7 and < 4
## Installation
```bash
pip install pwerpy
```
## Before Using:
It's mandatory to have these in order to successfully use `pwerpy`, otherwise, you won't be able to make any request to Power BI REST API:
* Your Azure Active Directory (AD) Client ID
* Your Azure AD Username
* Your Azure AD Password
## Usage/Examples
Once you have your client ID and both workspace username and password, you're ready to go!

To get your Azure Active Directory tenant ID (tenant id)
```python
from pwerpy import powerpy

domain_name = 'YOUR_DOMAIN_NAME'

tenant_id = powerpy.get_tenant_id(domain_name)
```

To get your authentication access token, in order to request your Bearer authorization token
```python
from pwerpy import powerpy

tenant_id = 'YOUR_TENANT_ID'
client_id = 'YOUR_CLIENT_ID'
user = 'YOUR_WORKSPACE_USERNAME'
pwd = 'YOUR_WORKSPACE_PASSWORD'

access_token = powerpy.get_access_token(tenant_id, client_id, user, pwd)
```

To get your Bearer authorization token
```python
from pwerpy import powerpy

access_token = 'YOUR_ACCESS_TOKEN'

auth = powerpy.get_authorization_token(access_token)
```

To make a GET request
```python
from pwerpy import powerpy

url = 'YOUR_POWER_BI_REST_API_URL'
auth = 'YOUR_BEARER_AUTHORIZATION_TOKEN'

response = powerpy.get(url, auth)
```

To make a POST request
```python
from pwerpy import powerpy

url = 'YOUR_POWER_BI_REST_API_URL'
auth = 'YOUR_BEARER_AUTHORIZATION_TOKEN'

response = powerpy.post(url, auth)
```
These are the essential functions in order to communicate with Power BI REST API successfully.
## Functions
### powerpy
* get_tenant_id()
* get_access_token()
* get_authorization_token()
* get()
* post()
### skills
* get_token_usage()
* get_datasets_in_group()
* get_datasets_names_in_group()
* refresh_dataset_in_group_by_name()
* refresh_dataset_by_id()

## License

Pwerpy is licensed under the [MIT](https://choosealicense.com/licenses/mit/) license.

Copyright © 2022, Fernando Assef (4ssef)
image-processing-abevilaqua 0.0.1
My short description
Requires Python: >=3.8

# Projeto: Pacote de Processamento de Imagens
## Autora do Projeto: Karina Kato
### Aula: Coding Lab PRO - Digital Innovation One

# package_name
image_processing:

- MÃ³dulo "Processing":
  - CorrespondÃªncia de histograma;
  - Similaridade estrutural;
  - Redimensionar imagem;

- MÃ³dulo "Utils":
  - Ler imagem;
  - Salvar imagem;
  - Plotar imagem;
  - Resultado do grÃ¡fico;
  - Plotar histograma;

## Installation

Comandos para instalaÃ§Ã£o:
```bash
pip install image_processing_abevilaqua
```
## Usage

```python
from image-processing.processing import transformation
transfer_histrogram(image1, image2)
```

## Author
Andre Bevilaqua

## License
[MIT](https://choosealicense.com/licenses/mit/)