semvec/pypi-packages huggingface dataset:
pycloudimage 0.1.4
Get Cloud Image from Internet
License: MIT

# PyCloudImage 0.1.4

## 介绍

 强大的获取卫星云图的工具 

## 例子

```python
from pycloudimage import *
#显示最新的风云四号A星全彩圆盘图
FY4A_DISK.getlatest().show()
```

## 类

```python
class CloudImage(ciinfo = '', latestapi = None, timeapi = None)
```

ciinfo : 云图的简要介绍

latestapi : URL字符串或字典

timeapi : URL字符串或字典，目前没有内置云图设置

## 方法

CloudImage.ciinfo => str

云图的简要介绍

CloudImage.getlatest(size = None, delwatermark = True) => PIL.Image.Image

下载最新云图

CloudImage.gettime(self, itime, size = None) => PIL.Image.Image

下载具体时间的云图，目前还不稳定

## API参数

url : 云图URL（必填）

crop : 云图裁剪

del : 云图填充去水印

size : 云图大小

## 内置云图

你可以通过查看源码或使用dir命令查看内置云图。
pillowfight 0.4
Eases the transition from PIL to Pillow for projects.
License: MIT

Pillow Fight
============

Pillow is a replacement for PIL that works as a drop-in replacement. Unlike
PIL, it's actively maintained and easy to install. It's pretty great. There's
only one problem, which is that users must first uninstall PIL before
installing Pillow, as they share a namespace.

This makes it very hard for Python modules or products that need to run on a
variety of configurations to easily depend on either PIL or Pillow without
inevitably breaking something (perhaps in subtle ways). That makes it hard to
safely  transition.

This package aims to "solve" that by providing a single dependency that can
intelligently depend on either PIL or Pillow, based on what's already on the
system. Packages that still need to work if PIL is installed, but aim to
transition to Pillow, can simply depend on the ``pillowfight`` package.


How it works
------------

This package is provided as a source distribution with a simple setup script.
When ``pillowfight`` is installed for the first time, its setup script will
run and start inspecting the system.

The setup script will look to see if PIL is already installed. If so, it will
print a warning saying that PIL is deprecated and to install Pillow. It will
then turn around and depend on PIL.

If PIL is not installed, it will instead depend on Pillow.


Using pillowfight
-----------------

Simply replace your PIL dependency with ``pillowfight`` in ``setup``'s
``install_requires`` list:

.. code-block:: python

    setup(name='MyPackage',
          version='1.0',
          install_requires=[
              'pillowfight'
          ]
    )


Why we wrote this
-----------------

We use Django and Pillow for a product that sysadmins can install in their
networks. There are a lot of configurations out there, and a lot of older
systems already using PIL.

We've been trying to figure out the right strategy for getting new and
existing users onto Pillow without breaking any installs. We don't have much
control over their systems, so we knew we had to be clever.

A lot of projects out there seem to have modified their ``setup.py`` files to
check what's on the system, but in practice, that doesn't work too well. When
building Python eggs, the ``requires.txt`` files would be populated with
either ``PIL`` or ``Pillow``, and that just wasn't going to work.

So we wrote this as a way to have a stable dependency that could do the right
thing. We hope others will find it useful.


Who's using it
--------------

We're using it for our code review product,
`Review Board <http://www.reviewboard.org/>`_.

If you're using it, `let us know <mailto:christian@beanbaginc.com>`_.
gokart-pipeliner 0.0.8
gokart pipeline
License: MIT
Requires Python: >=3.6,<4.0

# gokart-pipeliner
gokart pipeline project


# Usage

Please show [SampleTask.py](https://github.com/vaaaaanquish/gokart-pipeliner/blob/main/examples/SampleTasks.py) or [Eaxmple.ipynb](https://github.com/vaaaaanquish/gokart-pipeliner/blob/main/examples/Example.ipynb)

```python
from gokart_pipeliner import GokartPipeliner
from ExampleTasks import *

# make pipeline
preprocess = [TaskA, {'task_b': TaskB, 'task_c': TaskC}, TaskD]
modeling = preprocess + [TaskE, {'task_f': TaskF}, TaskF]
predict = [{'model': modeling, 'task_a': TaskA}, TaskG]

# instantiation (setting static params)
params = {'TaskA': {'param1':0.1, 'param2': 'sample'}, 'TaskD': {'param1': 'foo'}}
config_path_list = ['./conf/param.ini']
gp = GokartPipeliner(
    params=params,
    config_path_list=config_path_list)

# run (setting dynamic params)
running_params = {'TaskB': {'param1':'bar'}}
gp.run(predict, params=running_params)
```

task example
```python
class Task(gokart.TaskOnKart):
    foo = gokart.TaskInstanceParameter()

    def run(self):
        x = self.load('foo')
        self.dump(x)
```

## get task result

We can get result of latest pipeline tasks.
```python
task_b_result = gp.run([TaskA, TaskB], return_value=True)
```


## write requires

If you say "want to write requires" or "want to reuse existing tasks", we can use `override_requires` parameter.
```python
params = {'ExistingTask': {'override_requires': False}}
gp.run([ExistingTask], params=params)
```

## for jupyter notebook

### off logger
```python
gp.run([Task], params=params, verbose=False)
```

# Develop

```
pip install poetry
pip install poetry-dynamic-versioning

# poetry install
poetry build
# poetry lock
```
chronos-forecast 0.1.0
Time series prediction using probabilistic programming
License: MIT
Requires Python: >=3.7

# Chronos

Simple time series prediction model. Implemented using <a href="https://pyro.ai/" target="_blank">Pyro</a> and greatly inspired by <a href="https://facebook.github.io/prophet/" target="_blank">Prophet</a>.

## Requirements:

* python >= 3.7
* pandas >= 1.1
* numpy >= 1.19
* matplotlib >= 3.2
* torch >= 1.5
* pyro-ppl >= 1.3


## Installation

To install chronos, run the following command from your terminal:
```python
pip install chronos-forecast
```

## Simple Use Case

With the files included, you can load the [Divvy bike daily](https://www.kaggle.com/yingwurenjian/chicago-divvy-bicycle-sharing-data?select=data.csv) data (the data has been aggregated since the original file is 2GB) as follows:

```python
import pandas as pd
import numpy as np

divvy_data = pd.read_csv('data/divvy_daily_rides.csv')
divvy_data['ds'] = pd.to_datetime(divvy_data['ds'])
print(divvy_data.head())
```
```
          ds          y
0 2014-01-01  105421324
1 2014-01-02  123221770
2 2014-01-03    6662107
3 2014-01-04  201035389
4 2014-01-05   35549270
```

You can call Chronos as follows:

```python
>>> from chronos import Chronos
>>> import chronos_plotting
>>>
>>> my_chronos = Chronos(seasonality_mode="mul", distribution="Gamma")
>>> my_chronos.fit(divvy_data)
Employing Maximum A Posteriori
100.0% - ELBO loss: -1.5903 | Mean Absolute Error: 11152849920.0000

>>> predictions = my_chronos.predict(period=365)
Prediction no: 1000
>>> chronos_plotting.plot_components(predictions, my_chronos)
```

![alt text](images/Divvy_components.png)

Notice we can specify the distribution of the ride shares to be a gamma distribution to ensure they are never negative. Additionally, we made the seasonality multiplicative to make sure that its affect increases as the absolute number of
rides increases.