semvec/pypi-packages huggingface dataset:
EnergyModels 0.0.9
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 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 EnergyModels
````

# Models list
  
  * LSTM
  * LSTM-CNN 
  * BILSTM
  * GRU
  * BIGRU
  * TimeDistributer
  * CNN
  * TCN
  * Transformer
  * Performer
  * Informer
  * Seq2Seq
  * Bert
  * Lstnet
  * DeepAr
  * FNN
  * Conv-Lstm
  * MLP
  * Nbeats
  * RBFN
  * Autoformer
  
  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**
        
  * Transformer :
  
        * must take value 
          * 1 : input_shape
          * 2 : n_outputs
          * 3 : head_size
          * 4 : num_heads
          * 5 : ff_dim
          * 6 : num_transformer_blocks
          * 7 : mlp_units 
        * default value = 0 
          * 8 , 9 : dropout  , mlp_units
    
  * Performer :
  
          * must take value 
            * 1 : maxlen
            * 2 : n_features
            * 3 : n_outputs
            * 4 : vocab_size
            * 5 : embed_dim
            * 6 : num_heads
            * 7 : ff_dim 
          * default value:
            * 8 : method => 'linear'
            * 9 : supports => 10
            * 10 : rate => 0.1 
            
  
# Package Folders 
 
 * Energy_Models
 
# how to use the package

 first you must read the data set you want to use the models on it 
 and then preprocess the data
 
 now you can build model by import it from Energy_Models folder :
 
  ````
  from Energy_Models import ==== as m
  
  ** [====] refer to model name **
  
  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
  ````
     
  now you can calculate loss using metrics function for train and test both by just primt_metrix func :
  
  **exists on Evaluation_Metrix if u want to just import it  :**
   
  ````
  from Energy_Models import Evaluation_Metrix as mx
  ````
 
  ````
  mx.print_metrics(Y_train,Y_pred_train,Y_test,Y_pred_test)
  
  ````
mfdfloods 0.1.34
Multiple flow direction floods hydrodynamic modelation
Requires Python: >=3.8
Keywords: mfdfloods,mfd,flood,drainpaths,hidrology,downstreams,multiple flow direction

# MFD Floods

A python script to model hidrologic behavior of downstream drainpaths. With a DTM cover of your study area you can define longitude and latitude (in the DTM distance unit) as a start point and an income flow to see how the water will flood the territory.

## Installation

With pip `pip install mfdfloods`

From source `python -m pip install -r /path/to/mfdfloods/directory`

## Dependencies

The script requires GDAL installed on your system and python-gdal as a python dependency.

To install GDAL execute `apt install gdal-bin libgdal-dev`.

## Module

Execute .py from inside the folder to test the algorithm.

The test.py is a script that call the class MFD and execute its modelization with
the datasource from the `data/` folder. There you have to place your GeoJSON files
with the modelized line geometry.

`python test.py <path:data> <lng:float> <lat:float>`

Arguments:

1. **data** is the pathname of the data directory. There you have to place a
   `dtm.tif`, a `mannings.tif` and a `hydrogram.csv` files.
2. **lng** is the longitude in your reference dtm distance units.
3. **lat** is the latitude in your reference dtm distance units.

The output will be placed in your **data** floder as three files with the name _(draft|flood|speed)\_{lng}-{lat}.tif_.

## Use

Include mfdfloods as a module on your scripts with `from mfdfloods import MFD` then instantiate the class MFD to execute its drainpaths method.
CasseySmithCV 0.1.0
Produces critical values using the methods described in Cassey Smith (2014).  Code is modernized from version published with paper to take advantage of advances in computing.
Requires Python: >=3.8
Keywords: EG Statistic,Monte Carlo,Statistics

# CasseySmithCV
 
Simulation software to generate critical values for the Ellison-Glaeser index (1997).  This is updated software from Cassey and Smith (2014); it modernizes the codebase and increases the performance of the simulations.

## Examples

Run a simulation of industries with 20 plants and sigma value of 1. 

```python
from CasseySmithCV import runSimulation, SimulationTable, SaveSimulationTable
resultDictionary = runSimulation(20,1)
```

Run all combinations of [20, 30] plants and [0.5, 1] sigma values:

```python
from CasseySmithCV import runSimulation, SimulationTable, SaveSimulationTable
resultDataFrame = SimulationTable([20, 30],[0.5, 1])
```

Run all combinations of [20, 30] plants and [0.5, 1] sigma values and save the results to a file:

```python
from CasseySmithCV import runSimulation, SimulationTable, SaveSimulationTable
SaveSimulationTable('filename.csv', [20, 30],[0.5, 1])
```

## Installation 

This package can be installed by using either the pip or conda command:

### Installing by pip

```
pip install CasseySmithCV
```

### Installing by conda

```
conda install -c tazzben casseysmithcv
```
prefab-cloud-django 0.2.0
Custom template tags for using prefab-cloud-python in Django applications
Requires Python: >=3.10,<4.0

# prefab-cloud-django

This project provides custom template tags for using [`prefab-cloud-python`][prefabpython] in Django applications

## Usage

1. Add this project to your Django application's dependencies
2. Add `prefab_cloud_django` to the list of `INSTALLED_APPS` in your app's `settings.py`
3. Configure your Prefab client in `settings.py`

```python
options = prefab.Options(
    api_key="...",
    ...
    log_boundary=BASE_DIR,
)

PREFAB = prefab.Client(options)
LOGGER = PREFAB.logger
```

3. In your templates, add `{% load prefab_tags %}`

4. Use these tags

```python
{% prefab_get "name-of-config" %}
{% prefab_enabled "name-of-flag" %}

# with default

{% prefab_get "name-of-config" default="default" %}

# with context

{% prefab_get "name-of-config" context=context %}
```

[prefabpython]: https://pypi.org/project/prefab-cloud-python/