semvec/pypi-packages huggingface dataset:
th2analytics 0.0.15
A Python package for interacting with the thaink2 analytics APIs
Requires Python: >=3.8

# **th2analytics**

[![PyPI version](https://badge.fury.io/py/th2analytics.svg)](https://pypi.org/project/th2analytics/)  
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)  
[![Python Versions](https://img.shields.io/pypi/pyversions/th2analytics.svg)](https://pypi.org/project/th2analytics/)

**th2analytics** is a Python library that provides a simple and efficient wrapper for interacting with the [thaink2](https://thaink2.com/) analytics APIs. It enables users to generate future forecasts rapidly while adapting to various types of data.

---

## **Features**
- Generate forecasts quickly using an intuitive interface.
- Supports multiple forecasting models like ARIMA, XGBOOST, Random, and others.
- Customizable parameters for forecast horizon, grouping, and target variables.
- Lightweight and easy to integrate into existing workflows.

---

## **Installation**

Install the package using pip:

```bash
pip install th2analytics
```

A bearer token is needed in order to perform the API request, use the following url to generate a valid token [thaink2 token generator](https://clever.thaink2.fr/app_direct/th2token/)

```python
from th2analytics.forecasting import ForecastingAPI
import numpy as np
import pandas as pd

api_token = "************" # get your token here: https://clever.thaink2.fr/app_direct/th2token/


# Initialize the API wrapper
api = ForecastingAPI(
    base_url = "https://clever.thaink2.fr/app_direct/th2apis/private/",
    api_token = api_token
)

np.random.seed(42)
dates = pd.date_range(start='2022-01-01', periods=100, freq='D')
values = np.random.randn(100).cumsum()
# Create a DataFrame from the generated data
input_data = pd.DataFrame({'date': dates, 'value': values})
# Generate the forecast
forecast = api.th2forecast_api(
    actuals = input_data,
    fcast_horizon = 30,
    group_target = None,
    target_var = "value",
    date_var = "date",
    models_list = ["xgboost"]
)
# Print the forecast

forecast_df = pd.json_normalize(forecast)
print(forecast_df)

```
deepnote-sqlalchemy-redshift 0.8.17
Amazon Redshift Dialect for sqlalchemy
Requires Python: <3.14,>=3.9

sqlalchemy-redshift
===================

Amazon Redshift dialect for SQLAlchemy.

Installation
------------

The package is available on PyPI::

    pip install sqlalchemy-redshift

.. warning::

    This dialect requires either ``redshift_connector`` or ``psycopg2``
    to work properly. It does not provide
    it as required, but relies on you to select the distribution you need:

    * psycopg2 - standard distribution of psycopg2, requires compilation so few system dependencies are required for it
    * psycopg2-binary - already compiled distribution (no system dependencies are required)

    See `Psycopg2's binary install docs <http://initd.org/psycopg/docs/install.html#binary-install-from-pypi>`_
    for more context on choosing a distribution.

Usage
-----
The DSN format is similar to that of regular Postgres::

    >>> import sqlalchemy as sa
    >>> sa.create_engine('redshift+psycopg2://username@host.amazonaws.com:5439/database')
    Engine(redshift+psycopg2://username@host.amazonaws.com:5439/database)

See the `RedshiftDDLCompiler documentation
<https://sqlalchemy-redshift.readthedocs.org/en/latest/ddl-compiler.html>`_
for details on Redshift-specific features the dialect supports.

Running Tests
-------------
Tests are ran via tox and can be run with the following command::

    $ tox

However, this will not run integration tests unless the following
environment variables are set:

* REDSHIFT_HOST
* REDSHIFT_PORT
* REDSHIFT_USERNAME
* PGPASSWORD (this is the redshift instance password)
* REDSHIFT_DATABASE
* REDSHIFT_IAM_ROLE_ARN

Note that the IAM role specified will need to be associated with
redshift cluster and have the correct permissions to create databases
and tables as well drop them. Exporting these environment variables in
your shell and running ``tox`` will run the integration tests against
a real redshift instance. Practice caution when running these tests
against a production instance.

Continuous Integration (CI)
---------------------------

Project CI is built using AWS CodePipeline and CloudFormation. Please see the ``ci/`` folder and included ``README.txt``
for details on how to spin up the project's CI.

Releasing
---------

To perform a release, you will need to be an admin for the project on
GitHub and on PyPI. Contact the maintainers if you need that access.

You will need to have a `~/.pypirc` with your PyPI credentials and
also the following settings::

    [zest.releaser]
    create-wheels = yes

To perform a release, run the following::

    python -m venv ~/.virtualenvs/dist
    workon dist
    pip install -U pip setuptools wheel
    pip install -U tox zest.releaser
    fullrelease  # follow prompts, use semver ish with versions.

The releaser will handle updating version data on the package and in
CHANGES.rst along with tagging the repo and uploading to PyPI.
pylizlib 0.3.53
Add your description here
Requires Python: >=3.12

# PYLIZ
This is a simple python library that contains some useful functions that I use in my projects.

## Installation
```bash
pip install pylizlib
```

## Description
The main class of this library is **PylizLib**. It's a class used for handle file and directories for a python script/project.

It allows you to:
- easily manage directories and files
- easily read and write a single configuration file

### Example

```python
from pylizlib import PylizLib

# Create an instance of PylizLib.
# This will create a directory with the name of your app in your home directory.
app = PylizLib("name_of_your_app") 

# Create a directory in the app directory.
app.add_folder("key_for_folder", "name_of_folder")

# Get the path directory.
path = app.get_folder_path("key_for_folder")

# create app ini file and get/set value
app.create_ini("medializ.ini", [])
app.set_ini_value("section", "key", "value")
value = app.get_ini_value("section", "key")
```
changepoint 0.4.0
A Bayesian change point library
Requires Python: <4,>=3.7
Keywords: changepoint

# changepoint

Python bindings for important functionality of the rust library [changepoint](https://crates.io/crates/changepoint), a library for doing change point detection for steams of data.

## Installation

Install via pip with
```bash
$ python3 -m pip install "changepoint"
```

__Note__: If there is no binary distribution for your OS, architecture, and Python version, you will need the Rust compiler to build the package and install a Python tool called Maturin:
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
python3 -m pip install maturin
```

See [rustup.rs](https://rustup.rs/) for instructions on installing Rust.

## Quick Docs
By convention in these docs and examples, 
```python
import changepoint as cpt
```

### Models
#### Bocpd

The Bayesian change point detector, `Bocpd`, takes a prior distribution, aka one of
```python,ignore
cpt.BetaBernoulli
cpt.NormalGamma
cpt.NormalInvChiSquared
cpt.NormalInvGamma
cpt.NormalInvWishart
cpt.PoissonGamma
```

Then, a `Bocpd` may be created:
```python
cpd = cpt.Bocpd(
    prior=cpt.NormalGamma(),
    lam=12,
)
```
where the prior is a `NormalGamma` and the characteristic run length is `12`.

Each step of the data stream, `data`, can be processed by
```python
import random
import numpy as np

data = [random.gauss() for _ in range(30)] + [
    random.gauss(1, 2) for _ in range(30)
]

n = len(data)
change_point_history = np.zeros((n, n))
for i, x in enumerate(data):
    change_point_history[i, : i + 1] = cpd.step(x)

print(cpt.map_changepoints(change_point_history))
```


#### ArgpCpd

`ArgpCpd` has an implicit prior as it is a Gaussian Process of the form `X_{i+1} = c X_{i-l-1, ..., i-1} + ε`
where `c` is the scale, `X_{i-l-1, ..., i-1}` is the previous vales in the sequence (`l` is the max-lag parameter), and `ε` is a white noise parameter.
It behaves similarity to the `Bocpd` class; for example,

```python
argp = cpt.ArgpCpd(logistic_hazard_h=-2, scale=3, noise_level=0.01)
n = len(data)
change_point_history = np.zeros((n + 1, n + 1))
xs = []
ys = []
for i, x in enumerate(data):
    cps = argp.step(x)
    change_point_history[i, : len(cps)] = cps

print(cpt.map_changepoints(change_point_history))
```

## Example

An example IPython notebook can be found [here](ChangePointExample.ipynb).
mirrorit 1.0.2
For mirroring text.
Requires Python: >=3.5


# Mirrorit

This **cli tool** can mirror your subject very clever and easy in different ways.

## Installation

The installation proccess can be done using the pip tool:
```
pip install mirrorit
```

### Project Link
[Project link in Pypi](https://www.pypi.org/project/mirrorit)

[Project link in Github](https://www.github.com/Lunethra/Mirrorit)
## Documentation

A help doc is in the tool but the main documentaion is here:  
(the tool doc is accessed using "mirrorit --help" or "mirrorit -h")  

Mirroring can be done in multiple ways:  
  -
  1.mirroring the **whole** text. (--mode w)  
  2.mirroring the **lines** of the text (--mode l)  
  3.mirroring every word of the text without changing the index of words (--mode t)  
  4.mirroring every word of the text without changing the index of words, split words between symbols and spaces. (--mode k)

Working with files also has multiple ways:
  | Different modes of working with files |
  |---|
  1.Overwriting the file (-s)  
  2.Saving output as a new file (-n)  
  3.Just showing the output in terminal (-j)  

### Difference between mode "t" and mode "k"
in mode "k" the words are splited with the spaces between them.  
### Example of words spliting in "t" and "k" mode
file.txt:
```txt
Lune Lu!ne !Lu!ne! !Lu!ne
```
second command:
```shell
mirrorit file.txt -m t -j
Output:
enuL en!uL !en!uL! !en!uL
```
command:
```shell
mirrorit file.txt -m k -j
Output:
enuL uL!en !uL!en! !uL!en
```


as you can see, the text mirroring is different.

⚠️ You cannot enter more than one word when using the cli (not file) mode.  
This means you cannot enter spaces in input.
## Usage/Examples

You can use the tool by just giving the name you want to greet.
```bash
Mirrorit Lunethra
Output: arhtenuL
```

or say mirror files.
```bash
mirrorit file.txt -s
Output: mirrored_file.txt
```
## Support

To resolve issues and make suggestions, please visit the project's GitHub page.


## License

This project uses [MIT License](https://github.com/Lunethra/Mirrorit/blob/main/LICENSE).
siguls-gui 0.9.0
GUI for the Signal Generator for User-Specified Laboratory Signals (SIGULS)
Requires Python: >=3.11

# SIGULS-GUI

This Python package contains the GUI for interacting with the Signal Generator for User-Specified Laboratory Signals (SIGULS). 

## Installation

To install the SIGULS-GUI through pip, use the following command:

`pip install siguls-gui`

## Opening the GUI

Open a terminal/command prompt with access to the Python PATH and type:

`siguls-gui`