semvec/pypi-packages huggingface dataset:
ouparams 0.0.1
"A package to estimate process parameters for Ornstein-Uhlenbeck"
Requires Python: >=3.6

# ouparams
A python module to Find Process Parameters for Ornstein-Uhlenbeck Processes
```
Input:
	- x the process dataset in numpy array format
Output:
	- mu, sigma, theta
	  Ornstein–Uhlenbeck process with long-term mean mu, volatility sigma, and mean reversion speed theta.
```

# Installation
Clone the github repository and install it with `pip install .`

or

```
pip install git+https://github.com/mghadam/ouparams.git
```

# Usage
```
# A sample OU process in numpy array format
import numpy
ds = numpy.array([0.8, 0.58606434, 0.49098481, 0.49343492, 0.54575029,0.51207641, 0.50084814, 0.52559959, 0.53000366, 0.53668143])

# Estimating the OU parameters
from ouparams import ouparams
mu, sigma, theta = ouparams.find(ds)
# 0.5171166243459767, 0.038885729337555484, 1.5906939803229536

```
The calculation matches with Mathematica's [FindProcessParameters](https://reference.wolfram.com/language/ref/FindProcessParameters.html) for [OrnsteinUhlenbeckProcess](https://reference.wolfram.com/language/ref/OrnsteinUhlenbeckProcess.html)
```
ds = {0.8, 0.58606434, 0.49098481, 0.49343492, 0.54575029, 0.51207641,
    0.50084814, 0.52559959, 0.53000366, 0.53668143};
FindProcessParameters[ds, 
 OrnsteinUhlenbeckProcess[\[Mu], \[Sigma], \[Theta]]]
 {\[Mu] -> 0.517117, \[Sigma] -> 0.0388857, \[Theta] -> 1.59069}
```
zweifach 1.0.3
Custom integration for django-otp package
Requires Python: >=3.6

Zweifach
========

Zweifach (german for "two times") is an app to make integration of django-otp a bit more biased.

Integration of two factor auth is enforced by a middleware which will ensure two things:

- make sure a user who is required to enable 2FA for its account will be redirected to the setup-view until setup is done.
- make sure a user who has 2FA enabled will be redirected to verify-view for token input after login until verified.


Quickstart
----------

- Install packages by running 'pip install zweifach django-otp qrcode'
- Add 'zweifach' to INSTALLED_APPS.
- Add 'zweifach.middleware.ZweifachMiddleware' to MIDDLEWARE, *after* AuthenticationMiddleware.
- Inlcude 'zweifach.urls' somewhere in your url-config.
- Configure django-otp as described further down below


Settings
--------

settings.ZWEIFACH_AUTH_REQUIRED

    default: []

    A list of checks which determine, if a user needs 2FA to use its account.

    examaple::

        ZWEIFACH_AUTH_REQUIRED = [
            lambda user: user.is_staff,  # all staff unsers must use two factor auth
            lambda user: '2fa' in user.groups.values_list("name", flat=True),  # all users in group '2fa' must use two factor auth
        ]


settings.ZWEIFACH_URL_EXCLUDES

    default: []

    A list of url which are always accessible without 2FA.
    Verify and Setup views are always excluded as well as settings.LOGIN_URL and the admin login view, if admin is enabled.

    example::

        ZWEIFACH_URL_EXCLUDES = [
            '/imprint/',
            '/faq/how-to-setup-2fa/',
        ]

Note: If a url is accessible without login, it can of course still be viewed without any 2FA interaction.


Notes about django-otp configuration
------------------------------------

A compatible installation of django-otp should be setup as follows:

Add to INSTALLED_APPS::

    'django_otp',
    'django_otp.plugins.otp_totp',
    'django_otp.plugins.otp_static',

Add to MIDDLEWARE (between AuthenticationMiddleware and ZweifachMiddleware)::

    'django_otp.middleware.OTPMiddleware'

Configure issuer::

    OTP_TOTP_ISSUER = 'MyProject'


Usage
-----

To generate static recovery tokens (also useful for first login on freshly installed systems) use::

    ./manage.py addstatictoken <username>


Development
-----------

Ensure basic code style with::

    tox

Build package with::

    python3 -m build

Upload package to PyPI::

    python3 -m twine upload dist/zweifach-x.x.x*
pietoolbelt 0.3.26
Toolbelt for PiePline training pipeline

# PiePline toolbelt

# Installation:
[![PyPI version](https://badge.fury.io/py/pietoolbelt.svg)](https://badge.fury.io/py/pietoolbelt)
[![PyPI Downloads/Month](https://pepy.tech/badge/pietoolbelt/month)](https://pepy.tech/project/pietoolbelt)
[![PyPI Downloads](https://pepy.tech/badge/pietoolbelt)](https://pepy.tech/project/pietoolbelt)

`pip install pietoolbelt`

##### Install latest version before it's published on PyPi
`pip install -U git+https://github.com/PiePline/pietoolbelt`

# Functional
* `augmentations`
    * `augmentations.detection` - predefined augmentations for detection task
    * `augmentations.segmentation` - predefined augmentations for segmentation task
* `datasets`
    * `datasets.stratification` - stratification by histogram
    * `datasets.utils` - set of datasets constructors that
* `losses`
    * `losses.common` - losses utils
    * `losses.regression` - regression losses
    * `losses.segmentation` - losses for single and multi-class segmentation
    * `losses.detection` - losses for detection task
* `metrics` - 
    * `metrics.common` - common utils for metrics
    * `cpu` - metrics, that calculates by `numpy`
        * `metrics.cpu.classification` - classification metrics
        * `metrics.cpu.detection` - detection metrics
        * `metrics.cpu.regression` - regression metrics
        * `metrics.cpu.segmentation` - segmentation metrics
    * `torch` - metrics, that calculates by `torch`
        * `metrics.torch.classification` - classification metrics
        * `metrics.torch.detection` - detection metrics
        * `metrics.torch.regression` - regression metrics
        * `metrics.torch.segmentation` - segmentation metrics
* `models` - models zoo and constructors
    * `decoders.unet` - UNet decoder, that automatically constructs by encoder
    * `encoders.common` - basic interfaces for encoders
    * `encoders.inception` - InceptionV3 encoder
    * `encoders.mobile_net` - MobileNetV2 encoder
    * `encoders.resnet` - ResNet encoders
    * `albunet` - albunet model
    * `utils` - models utils
    * `weights_storage` - pretrained weights storage
* `steps` - some training process steps
    * `regression.train` - train step for regression task
    * `regression.bagging` - bagging step for regression task
    * `segmentation.bagging` - bagging step for segmentation task
    * `segmentation.inference` - inference for segmentation model
    * `segmentation.predict` - predict step for segmentation task
    * `stratification` - dataset stratification class
* `img_matcher` - image comparison and matching tool based on descriptors
* `mask_composer` - mask composer tools that can effectively combine masks for regular, instance or multiclass segmentation
* `train_config` - some predefined train configs for [PiePline](https://github.com/PiePline/piepline)
* `tta` - test time augmentations 
* `utils` - some utils
* `viz` - image visualisation tools
datasource-contributor 0.0.14
A CUI tool that automatically crawls website data and contributes to http://www.citybrain.org
Requires Python: >=3.6
Keywords: git tag datasource-contributor tagup tag-up version autotag auto-tag commit message

# datasource-contributor

数据资源贡献工具。
1. 基于spider爬取链接中的数据信息
2. 登录citybrain.org
3. 将爬取的item贡献到citybrain.org站点中
4. 将数据注册到中枢系统
5. 构建CUI入口
auto-datahandler 0.0.10
数据（段落、评论、图片、视频）的自动化处理 在之前项目packageDIY的基础上进行代码的简化和整合
Requires Python: >=3.6.8

数据（段落、评论、图片、视频）的自动化处理 在之前项目packageDIY的基础上进行代码的简化和整合
load-animate 1.0.2
Displays cool loading animations to the terminal
Requires Python: >=3.6

# Loading

loading.py is an extremely minimal python package that allows for you to get those cool animated loading
texts you see in terminal applications

![loading gif](/img/load.gif)

##### tutorial

this package doesn't require a vast amount of explaining to learn how to use it. Here's an example
python script:

```python
from load_animate import Loading

if __name__ == '__main__':
    load = Loading() #creates a load instance
    load.start("loading stuff ") #starts displaying the loading terminal to the terminal
    time.sleep(5) #wait 5 seconds
    load.stop() #stop displaying the loading animation to the terminal
```

loading.py uses multiprocessing to allow you to load and process chunks of data whilst showing this cool animation to the user.
listgits 2.0.0
Python command line program for listing git repositories under a folder root, and optionally run any git command on those repos
Requires Python: >=3.10

# listgits
Python command line program for listing all git repositories under a folder root

Usage:

```
python listgits
```

Options :

* -h: Show the possible options
* -s: Short form, not showing non-git folders
* -l: Show only local repos, which do not have any remotes (includes --s)
* -r: Show only repos that have remotes (includes --s)
* -f somestring: Find a local repo by adding a part of the remote url. All matching local repos will be displayed
* -g commands: Git options, passes the string of options in to git, and runs git with those instead of the default remote command


Read this [blogpost](http://hermit.no/how-to-list-git-repositores-under-a-common-folder-root/) for more information on how to use it.