semvec/pypi-packages huggingface dataset:
wawpybus 0.0.6
A package providing tools to collect and analyse Warsaw open bus data

# WawPybus

### A package providing tools to collect, process and analyse Warsaw Open Bus Data

##### A final project for Database and network design and administration classes

## Installation

Package is available at PyPi and can be downloaded using pip:    
``
pip install wawpybus  
``

PyPi project: https://pypi.org/project/wawpybus/    
Source code: https://gitlab.uw.edu.pl/ig386329/pybus    


## Usage  
Package is designed to collect, process and analyse Warsaw open bus data. It is easy to use and handy.
It is modular and highly extendable       
* It enables downloading bus position withing given time range and frequency    
* Compares bus positions at given time with stops coordinates  
* Checks buses punctuality by downloading timetable for bus line at stop and compare arrival times between actual and timetable  
* Checks if buses exceeded speed between consecutive positions  
* Calculates mean difference in time between actual bus arrival and timetable  
* Finds bus which arrival time differs the most from timetable  
* Enables to check which buses exceeded given speed threshold  

Tutorial is included in package in a form of Jupyter Notebook: **WawPybus_tutorial.ipynb**      


## Comments on Warsaw Open Data  
Data available at https://api.um.warszawa.pl/# should be improved. It is inconsistent and contains errors.
For example once stop number is named in english once in polish as 'slupek', some stops coordinates are null, 
json returned from api has wrong structure - each key has name 'key' and respects to actual key name, 
the same with values.
tiresia 0.0.11
Tiny sklearn-based AutoML tool.
Requires Python: >=3.6

<!---
<div align="center">
    <img src="docs/tiresia.png" width=150 height=180>
</div>
--->

# tiresia

## Installation
```
pip install tiresia
```

## Description
[tiresia](https://en.wikipedia.org/wiki/Tiresias) is just a wrapper around [scikit-learn](https://scikit-learn.org/stable/) ```GridSearchCV```. The idea is to simplify the model testing workflow. With tiresia you can choose which models to test and to exclude and provide a ```param_grid``` for the ones you want to explore deeper, while keeping the parameters of the less interesting ones on default. 

## Example
```python
from tiresia.predictor import AutoPredictor

from sklearn.datasets import make_regression, make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score, r2_score

test_type = "regressor"

if test_type == "classifier":
    train, target = make_classification(5000, 20)
elif test_type == "regressor":
    train, target = make_regression(5000, 20)
    
x_train, x_test, y_train, y_test = train_test_split(train, target, test_size=0.3)

autopred = AutoPredictor(estimator_type=test_type,
                         scoring=r2_score,
                         greater_is_better=True)
autopred.fit(x_train, y_train, x_test, y_test)

predictions = autopred.predictions
results     = autopred.results

print(results)

                        REGRESSOR r2_score
18                        LassoCV    1.000
12                 HuberRegressor    1.000
23                      LinearSVR    1.000
22               LinearRegression    1.000
21                    LassoLarsIC    1.000
20                    LassoLarsCV    1.000
29                RANSACRegressor    1.000
17                          Lasso    1.000
16                         LarsCV    1.000
15                           Lars    1.000
14                    KernelRidge    1.000
28     PassiveAggressiveRegressor    1.000
31                          Ridge    1.000
32                        RidgeCV    1.000
33                   SGDRegressor    1.000
35     TransformedTargetRegressor    1.000
2                   BayesianRidge    1.000
24                   MLPRegressor    0.998
6                    ElasticNetCV    0.992
11  HistGradientBoostingRegressor    0.957
10      GradientBoostingRegressor    0.925
5                      ElasticNet    0.881
8             ExtraTreesRegressor    0.853
27    OrthogonalMatchingPursuitCV    0.827
30          RandomForestRegressor    0.824
1                BaggingRegressor    0.794
0               AdaBoostRegressor    0.751
36               TweedieRegressor    0.743
13            KNeighborsRegressor    0.686
3           DecisionTreeRegressor    0.486
26      OrthogonalMatchingPursuit    0.387
7              ExtraTreeRegressor    0.386
34                            SVR    0.357
19                      LassoLars    0.353
25                          NuSVR    0.285
9        GaussianProcessRegressor    0.038
4                  DummyRegressor   -0.003
```
myimage 0.1.1
A handful module for uploading local image and then get the path from specific server, especially good for those writing markdown journals.
Requires Python: >=3.5

# 我的图床

## 需求来源
使用Typora写完的Markdown文章在发布到其他平台（比如公众号、知乎等），
需要考虑将文章内的图片引用转成在线外链。

本项目灵感来自于PicGo这款软件，但它存在一些问题，
比如多图片上传的bug等，基于此开发了替代版本。

## 使用说明
### 使用阿里云OSS服务
#### 初始化
1. 初始化会需要输入AK、SK、EndPoint和BucketName四个信息，
这些都可以在你的阿里云服务上找到，具体可以访问：
https://oss.console.aliyun.com/overview

2. 运行后将自动存储这些信息为二进制文件，之后便可以不用输入这些信息，
防止你的秘钥泄露

```python    
AK = "XXXX"
SK = "XXXX"
END_POINT = "oss-cn-hangzhou.aliyuncs.com"
BUCKET_NAME = "XXXX"
ali_oss = AliOss(AK, SK, END_POINT, BUCKET_NAME)
```

#### 程序使用
```python
from myimage.upload.ali_oss import AliOss
ali_oss = AliOss()

# upload single image
ali_oss.upload_img("/Users/mark/Pictures/xxxx.jpg")

# upload multi images
ali_oss.upload_multi_imgs([
    "/Users/mark/Pictures/xxxx.jpg",
    "/Users/mark/Pictures/image-20201015195312768.png"
])
```
#### 命令行使用
在typora中可以配置自己的命令行，方便上传图片。
我已经写了一个`ali_oss_cmd.py`，可以使用它去上传一张或多张图片。

以我的typora为例，配置为：
```shell script
/Users/mark/PycharmProjects/mark_scripts/venv/bin/python /Users/mark/PycharmProjects/mark_scripts/myimage/upload/ali_oss_cmd.py
```
注意，如果你不是使用的默认`python`，则要指定`python`的具体位置。

否则，可以直接使用下面的简短版本：
```shell script
python /Users/mark/PycharmProjects/mark_scripts/myimage/upload/ali_oss_cmd.py
```

注意，要修改自己本地的文件路径。

### 使用SM.MS图床（SM.MS是2020年开发的，不保证2021年目前的可用性）
该图床可无需注册使用，即随手上传图片，并获得一个外链。

```python
import myimage
img_path = r'xxxx'
img_path_online = myimage.upload_img(img_path)
```

### 使用七牛云（七牛云是2020年开发的，不保证2021年目前的可用性）
需要配置您键信息，支持两种方式，具体可以参考官方说明：https://portal.qiniu.com/kodo/bucket

#### 1. （推荐）配置settings文件启动
在`myimage/myimage`下新建`settings.py`文件，填写一下键信息：
```python
DOMAIN = xxx
BUCKET = xxx
AK = xxx
SK = xxx
```

接着就可以使用以下代码上传图片了：
```python
import myimage
q = myimage.IMG_Qiniuyun()

img_path = r'xxx'
img_path_online = q.upload_img(img_path)
```
#### 2. 直接通过参数输入启动
```python
import myimage
q = myimage.IMG_Qiniuyun()
q.init_from_params(domain='xx', bucket='xx', ak='xx', sk='xx')

img_path = r'xxx'
img_path_online = q.upload_img(img_path)
```

## update log
- [x] 已完成阿里云的支持  

## TODO
- [ ] 支持腾讯云、Github等其他图床平台
- [ ] 完善markdown的转换
- [ ] 其他一些功能欢迎issue

## Others
### project Init
```shell script
git remote add origin git@github.com:MarkShawn2020/myimage.git
git branch -M main
git push -u origin main
```
stsmd 0.0.6
A small package to get closest text document with SMD and Sentence transformers embeddings
Requires Python: >=3.6

# Sentence Mover's Distance using Sentence Transformers Package

Calculates Sentence Mover's Distance using [Fast Word Mover's Distance](https://github.com/src-d/wmd-relax) and the embeddings provided by Sentence Transformers.

**Installation**

Before installing the package, check that you have already installed :
> [Numpy](https://pypi.org/project/numpy/)
>
> [Sentence Transformers](https://pypi.org/project/sentence-transformers/)
>
> [wmd](https://pypi.org/project/wmd/)
>
> [NLTK] (https://pypi.org/project/nltk/)

Then
```
pip install stsmd
```
Tested on Linux and macOS.

**Usage**

You must have the document you want to find the closest document as a string and the other documents as a list of strings.

```python
from stsmd import SMD

calc = SMD("Politician speaks to the media in Illinois.", ["The president greets the press in Chicago.", "The President delivers his inaugural address."])

print(calc.get_closest())
```

This returns the number of the nearest document and its distance.
docwmd 0.0.6
A small package using wmd to get closet doc to a chosen doc
Requires Python: >=3.6

# Word Mover's Distance using Fast Word Mover's Distance

Calculates Word Mover's Distance using [Fast Word Mover's Distance](https://github.com/src-d/wmd-relax).

**Installation**

Before installing the package, check that you have already installed :
> [Numpy](https://pypi.org/project/numpy/)
>
> [wmd](https://pypi.org/project/wmd/)
>
> [NLTK](https://pypi.org/project/nltk/)
>
> [Spacy](https://pypi.org/project/spacy/)
>
> [en_core_web_lg](https://spacy.io/usage/models)

```
pip install numpy
pip install wmd
pip install nltk
pip install spacy
python -m spacy download en_core_web_lg
```

Then
```
pip install docwmd
```
Tested on Linux and macOS.

**Usage**

You must have the document you want to find the closest document as a string and the other documents as a list of strings.

```python
from docwmd import docWMD

calc = docWMD("Politician speaks to the media in Illinois.", ["The president greets the press in Chicago.", "The President delivers his inaugural address."])

print(calc.get_closest())
```

This returns the number of the nearest document and its distance.
mkdocs-versioning 0.4.0
A tool that allows for versioning sites built with mkdocs
Requires Python: >=3.6

# mkdocs-versioning

`mkdocs-versioning` is a plugin for [mkdocs](https://www.mkdocs.org/), a tool designed to create static websites usually for generating project documentation. 

`mkdocs-versioning` extends mkdocs by differentiating between different versions of documentation you may build. For example, a newer versions of some software may work differently from an older version and it is important that users of an older version of the software reads the appropriate version of the documentation in order to ensure that the user has the correct information and uses the software appropriately.

## Setup

Install the plugin using pip:

```bash
pip install mkdocs-versioning
```

Next, add the following lines to your `mkdocs.yml`:

```yml
plugins:
  - search
  - mkdocs-versioning:
      version: 0.3.0
```

> If you have no `plugins` entry in your config file yet, you'll likely also want to add the `search` plugin. MkDocs enables it by default if there is no `plugins` entry set.

## Usage

Instructions on how to use the plugin is available at https://zayd62.github.io/mkdocs-versioning/

## Contributing 

Please note that mkdocs-versioning is currently in **Beta** and there may be missing feature/documentation so if you could help out by either:

1. finding and reporting bugs
2. contributing by checking out the [issues](https://github.com/zayd62/mkdocs-versioning/issues)

## Troubleshooting

### Combined use of awesome-pages and mkdocs-versioning

In case of using [awesome-pages](https://github.com/lukasgeiter/mkdocs-awesome-pages-plugin/) the order of registration within the `plugins` is important. The following error may occur:

```
Traceback (most recent call last):
  [...]
  File "/path/to/mkversion/entry.py", line 47, on_config
    for count, i in enumerate(nav):
TypeError: 'NoneType' object is not iterable
```

You need to make sure, that the `awesome-pages` plugin is register **after** `mkdocs-versioning`:

```yaml
plugins:
  - mkdocs-versioning:
      version: "1.0"
  - awesome-pages
````
kirisearch 0.0.1
Kiri Search
Requires Python: >=3.6

<h1 align="center">Kiri Search</h1>

<p align="center">
   <a href="https://pypi.org/project/kiri/"><img src="https://img.shields.io/pypi/v/kiri"/></a> <img src="https://img.shields.io/pypi/pyversions/kiri"/> <a href="https://www.apache.org/licenses/LICENSE-2.0"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg"/></a>
</p>

<p align="center">
Kiri Search is an unmaintained fork of <a href="https://github.com/kiri-ai/kiri">Kiri NLE</a> with added search functionality.
</p>

## Getting started

### Installation

Install Kiri via PyPi:

```bash
pip install kirisearch
```

### Basic usage

```python
from kiri_search import Kiri, Document

# Unprocessed documents
documents = [
    Document("Look at examples to see awesome use cases!"),
    Document("Check out the docs to see what's possible!")
]

# Use our inference API
kiri = Kiri(api_key="abc")
# Or run locally
kiri = Kiri(local=True)

# Process documents
kiri.upload(documents)

# Start building!
search_results = kiri.search("What are some cool apps that have been built?")

print(search_results.to_json())

# Prints
{
   "max_score": 0.3804888461635889,
   "total_results": 2,
   "results": [
      {
         "document": {
            "id":"LzhtWcpV2eoMk8GJwaw7na",
            "content":"Look at examples to see awesome use cases!"
         },
         "score": 0.3804888461635889,
         "preview":" Look at examples to see awesome use cases!"
      },
      {
         "document": {
            "id":"bcLb8xUK585Zm6rZrwj89A",
            "content":"Check out the docs to see what's possible!"
         },
         "score": 0.1742559312454076,
         "preview":" Check out the docs to see what's possible!"
      }
   ]
}

```

## Why Kiri?

1. No experience needed

   - Entrance to practical AI should be simple
   - Get state-of-the-art performance in your task without being an expert

2. There is an overwhelming amount of models

   - We implement the best ones for various use cases
   - A few general models can accomplish more with less optimisation

3. Deploying models cost effectively is hard work
   - If our models suit your use case, no deployment is needed
   - Our API scales, is always available, and you only pay for usage
pyintan 0.3.0
Python package for parsing INTAN data.

# pyintan
Python reader for INTAN rhs files

# Installation

Open a terminal and:

```
git clone https://github.com/alejoe91/pyintan/
cd pyintan
python setup.py develop
```

# Basic usage

In python (or ipython):

```
import pyintan

file = pyintan.File('path-to-rhs')

# all fields are lists of objcts

analog_signals = file.analog_signals[0]
adc_signals = file.adc_signals[0]
dac_signals = file.dac_signals[0]
# actual signals are: analog_signals.signal

digital_in_signals = file.digital_in_signals[0]
digital_out_signals = file.digital_out_signals[0]
# event times are: digital_in_signals.times

stimulation = file.stimulation[0]
# contains stimulation information
```
jsonnet-binary 0.17.0
An UNOFFICIAL Python interface to Jsonnet, available as whl packages for Mac, Linux and Windows.

# jsonnetbin
An **unofficial** Python interface to [Jsonnet](https://github.com/google/jsonnet).

This package is created to provide binary wheels and support all major platforms (Linux, Windows, and macOS) for Python 3.x. It ought to act as a drop-in replacement for the official package.

For production builds, I *highly* recommend the [official package](https://pypi.org/project/jsonnet/).
transformation-tree 1.2.2
Transformation Tree library developed for CIS 422 @                  University of Oregon
Requires Python: >=3.7.9

# Transformation Tree Library

This transformation tree library allows you to quickly build out possible modification paths for input data, and test various outcomes. The library also allows these pipelines and trees to be saved and loaded with ease. The library provides four major modules to build out transformation trees and pipelines, as well as provided operators and visualization tools to help build a pipeline.

Links: [User Documentation](https://github.com/Sephta/time-series-modeling/blob/main/docs/user.md), [Developer Documentation](https://github.com/Sephta/time-series-modeling/blob/main/docs/dev.md), [Install Instructions](https://github.com/Sephta/time-series-modeling/blob/main/docs/install.md)

### Authors:

CIS 422 @ University of Oregon  
Team Bitwise  
Ronny Fuentes, Kyra Novitzky, Stephanie Schofield, Alec Springel, Seth Tal

Last modified February 10, 2021

## Installation

### For Users:

```
pip install transformation-tree
```

[PyPi package info](https://pypi.org/project/transformation-tree/1.2.0/ "PyPi package info")

See the documentation below for use cases and examples.

### For Developers:

- make sure python is installed and added to PATH
- check python version (>=3.7.9)
- make sure pip is installed
- clone the repository:

```
git clone https://github.com/Sephta/time-series-modeling.git
```

- install dependencies:

```
pip install -r requirements.txt
```

All source code can be found within transformation_tree.

## Using the library

There are four major modules in the library:

- tree
- preprocessing
- forecasting
- stats_and_vis

which can be imported like so:

```
from transformation_tree.tree import *
from transformation_tree.preprocessing import *
from transformation_tree.forecasting import *
from transformation_tree.stats_and_vis import *
```

To learn how to create a transformation tree, please visit the [User Documentation](https://github.com/Sephta/time-series-modeling/blob/main/docs/user.md).
wmm2015 1.1.1
WMM2015 geomagnetic model with simple object-oriented Python interface
Requires Python: >=3.7
Keywords: geomagnetic

# WMM2015

![Actions Status](https://github.com/space-physics/wmm2015/workflows/ci/badge.svg)
[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/space-physics/WMM2015.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/space-physics/WMM2015/context:python)
[![Python versions (PyPI)](https://img.shields.io/pypi/pyversions/wmm2015.svg)](https://pypi.python.org/pypi/wmm2015)
[![Downloads](http://pepy.tech/badge/wmm2015)](http://pepy.tech/project/wmm2015)


WMM2015 World Magnetic Model...in simple, object-oriented Python.
[WMM2020](https://github.com/space-physics/wmm2020) is also available.
Tested on Linux, Mac and Windows.
Most C compilers work.
At this time Visual Studio is not supported since MSVC doesn't export function symbols without additional headers,
which is typically done with something like SWIG.

![image](./src/wmm2015/tests/incldecl.png)

## Install

for the latest release from PyPi:

```sh
python -m pip install wmm2015
```

Optionally, to get the cutting-edge development version:

```sh
git clone https://github.com/space-physics/wmm2015

python -m pip install -e wmm2015
```

This Python wrapper of WMM2015 uses our build-on-run technique.
The first time you use WMM2015, you will see messages from the build system and C compiler.


## Usage

an example script

```sh
python RunWMM2015.py
```

or as a Python module:

```python
import wmm2015

mag = wmm2015.wmm(glat, glon, alt_km, yeardec)
```

## Reference

* WMM2015 [inclination map](https://www.ngdc.noaa.gov/geomag/WMM/data/WMM2015/WMM2015_I_MERC.pdf)
* WMM2015 [declination map](https://www.ngdc.noaa.gov/geomag/WMM/data/WMM2015/WMM2015_D_MERC.pdf)
wmm2020 1.1.1
WMM2020 geomagnetic model with simple object-oriented Python interface
Requires Python: >=3.7
Keywords: geomagnetic

# WMM2020

![Actions Status](https://github.com/space-physics/wmm2020/workflows/ci/badge.svg)
[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/space-physics/wmm2020.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/space-physics/wmm2020/context:python)
[![Python versions (PyPI)](https://img.shields.io/pypi/pyversions/wmm2020.svg)](https://pypi.python.org/pypi/wmm2020)
[![Downloads](http://pepy.tech/badge/wmm2020)](http://pepy.tech/project/wmm2020)


WMM2020 World Magnetic Model...in simple, object-oriented Python.
[WMM2015](https://github.com/space-physics/wmm2015) is also available.
Tested on Linux, Mac and Windows.
Most C compilers work.
At this time Visual Studio is not supported since MSVC doesn't export function symbols without additional headers,
which is typically done with something like SWIG.

![image](./src/wmm2020/tests/incldecl.png)

## Install

for the latest release from PyPi:

```sh
python -m pip install wmm2020
```

Optionally, to get the cutting-edge development version:

```sh
git clone https://github.com/space-physics/wmm2020

python -m pip install -e wmm2020
```

This Python wrapper of WMM2020 uses our build-on-run technique.
The first time you use WMM2020, you will see messages from the Meson build system and your C compiler.


## Usage

an example script

```sh
python RunWMM2020.py
```

or as a Python module:

```python
import wmm2020

mag = wmm2020.wmm(glat, glon, alt_km, yeardec)
```

## Reference

* WMM2020 [inclination map](https://www.ngdc.noaa.gov/geomag/WMM/data/WMM2020/WMM2020_I_MERC.pdf)
* WMM2020 [declination map](https://www.ngdc.noaa.gov/geomag/WMM/data/WMM2020/WMM2020_D_MERC.pdf)
flaris 0.1.0
A lightweight and easy-to-use game development framework.
Requires Python: >=3.7

# Flaris

## Installation

### From Source

```
git clone https://github.com/eDGYuvRmgW/flaris
cd flaris
python3 -m pip install --upgrade setuptools
python3 setup.py install
cd ..
rm -rf flaris
```