semvec/pypi-packages huggingface dataset:
schema-change-risk-engine 0.0.10
Common MySQL Schema Alter Issues Check Engine Package
Requires Python: >=3.6
Keywords: mysql,schema

# SchemaChangeRiskEngine (SCRE):

A tool for assessing the risk of schema changes in a MySQL database when using tools like gh-ost or flywheel.

## The problem

Based on [Impact analysis of database schema changes](https://www.researchgate.net/publication/221555365_Impact_analysis_of_database_schema_changes)
and real world learning. It was found we should restrict riskier changes and patterns.

Such patterns include:

* BLOB & TEXT column overuse and storage/memory waste
* ENUM columns issues with casting during value parsing of a change
* SET columns issues with casting during value parsing of a change
* Foreign Key and Trigger usage preventing non-blocking and non-atomic changes
* No Primary Key causing slow migration or table level locking verses row level locking
* Renaming columns and tables leading toward application, data warehouse, and data lake sync issues

## The solution

This tool addresses this by allowing you to pass any CREATE or ALTER statement, and it will return a boolean if it's safe.

### Example

```python
from schema_change_risk_engine import SchemaChangeRiskEngine as SCRE

engine = SCRE()
changeStatements = [
    """
        CREATE TABLE `test` (
        `id` int(11) NOT NULL AUTO_INCREMENT,
        `name` varchar(255) NOT NULL,
        PRIMARY KEY (`id`)
        )
        ENGINE=InnoDB
        DEFAULT CHARSET=utf8mb4
        COLLATE=utf8mb4_0900_ai_ci
    """,
    "ALTER TABLE `test` ADD COLUMN `age` int(11) NOT NULL DEFAULT 0",
    "ALTER TABLE `test` RENAME COLUMN `age` to `years_old`",
    "ALTER TABLE `test` ADD COLUMN `gener` ENUM('M', 'F','T','NC') NOT NULL DEFAULT 'NC'",
    "ALTER TABLE `test` ADD COLUMN `hobbies` SET('S', 'R','T','NC') NOT NULL DEFAULT 'NC'",
    "ALTER TABLE `test` ADD COLUMN `bio` TEXT NOT NULL",
    "ALTER TABLE `test` ADD COLUMN `photo` BLOB NOT NULL",
    "ALTER TABLE `test` ADD COLUMN `order_date` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP",
    "ALTER TABLE `test` ADD TRIGGER `test_trigger` AFTER INSERT ON `test` FOR EACH ROW BEGIN INSERT INTO `test` (`name`) VALUES ('test'); END",
    "ALTER TABLE `test` ADD FOREIGN KEY (`id2`) REFERENCES `test` (`id`)",
    "ALTER TABLE `test` RENAME TO `test2`",
    "ALTER TABLE `test` RENAME TABLE `test2` TO `test`"
]

> for idx, change in enumerate(changeStatements):
    print("Statement %s: %s" % (idx + 1, engine.validate(change)))

Statement
1: (True, None)
Statement
2: (True, None)
Statement
3: (False, 'Renaming columns is not allowed')
Statement
4: (False, 'ENUM data type is not allowed')
Statement
5: (False, 'SET is not allowed')
Statement
6: (False, 'TEXT columns are not allowed')
Statement
7: (False, 'BLOB columns are not allowed')
Statement
8: (False, 'DATETIME data type is not allowed')
Statement
9: (False, 'Triggers are not allowed')
Statement
10: (False, 'Foreign keys are not allowed')
Statement
11: (False, 'Renaming tables is not allowed')
Statement
12: (False, 'Renaming tables is not allowed')



```
Newestearthquake-Indonesia-BMKG 0.3
This package will get the latest earthquake from BMKG | Meteorological, Climatological, and Geophysical Agency.
Requires Python: >=3.6

# Newest Indonesia Earthquake
This package will get the newest earthquake from BMKG | Meteorological, Climatological, and Geophysical Agency.

## How it work?
This package will scrape from [BMKG](https://bmkg.go.id) to get newest quake happened in Indonesia.

It package will use BeautifulSoup4 and Request,to produce output in the form of JSON that is ready to be used in web or mobile applications

## How To Use!
```
import  gempaterbaru

if __name__ == '__main__':
    print("Aplikasi utama")
    result = gempaterbaru.ekstrasi_data()
    gempaterbaru.tampilkan_data(result)
```
### Author
Deni Rahmawan
pyro-thunder 0.0.0.dev2
Probabilistic modeling framework to define, experiment with, and critique models in service of iterating through Box's loop.
Requires Python: >=3.10

# pyro-thunder

<p align="center">
    <em>Probabilistic modeling framework to define, experiment with, and critique models in service of iterating through Box's loop.</em>
</p>

[![build](https://github.com/cameronraysmith/pyro-thunder/workflows/Build/badge.svg)](https://github.com/cameronraysmith/pyro-thunder/actions)
[![codecov](https://codecov.io/gh/cameronraysmith/pyro-thunder/branch/main/graph/badge.svg)](https://codecov.io/gh/cameronraysmith/pyro-thunder)
[![PyPI version](https://badge.fury.io/py/pyro-thunder.svg)](https://badge.fury.io/py/pyro-thunder)

---

**Documentation**: <a href="https://cameronraysmith.github.io/pyro-thunder/" target="_blank">https://cameronraysmith.github.io/pyro-thunder/</a>

**Source Code**: <a href="https://github.com/cameronraysmith/pyro-thunder" target="_blank">https://github.com/cameronraysmith/pyro-thunder</a>

---

## Usage

[pyro-thunder](https://github.com/cameronraysmith/pyro-thunder) is pre-development. Please see the document outlining the [specification proposal](https://cameronraysmith.github.io/pyro-thunder/specification).

## Installation

```console
python -m pip install "pyro-thunder @ git+https://github.com/cameronraysmith/pyro-thunder.git@main"
```

## Development

### Setup environment

We use [hatch](https://hatch.pypa.io/latest/install/) to manage the development environment and production build. Ensure it's installed on your system. It is often convenient to do this with [pipx](https://pypa.github.io/pipx/installation/).

### Run unit tests

You can run all the tests with:

```bash
hatch run test
```

### Format the code

Execute the following command to apply linting and check typing:

```bash
hatch run lint
```

### Publish a new version

You can check the current version with:

```bash
hatch version
```

You can bump the version, create a commit and associated tag with one command such as `hatch version patch` or `minor` or `major`. Your git default text editor will open so you can add information about the release.

When you push the tag on github, the workflow will automatically publish it on PyPI and a github release will be created as draft.

## Serve the documentation

You can serve the mkdocs documentation with:

```bash
hatch run docs-serve
```

It'll automatically watch for changes in your code.

## License

This project is licensed under the terms of the GNU Affero 3.0-only license.
delegatefn 0.4.2
Signature-preserving function delegation
Requires Python: >=3.9,<4.0

# delegatefn

A Python package for adding the parameters of a delegatee function to a delegator function, while keeping the original parameters of the delegator function.

## Installation

To install `delegatefn`, use `pip`:

```bash
pip install delegatefn
```

## Usage

To use the `delegate` decorator function, import it from `delegatefn`:

```python
from delegatefn import delegate
```

Then, decorate your delegator function with the `delegate` decorator, passing in the delegatee function as an argument:

```python
@delegate(delegatee)
def delegator(c: int, d: int, e: int, **kwargs):
    ...
```

The delegator function will now have the parameters of delegatee added to it, while keeping its original parameters.

You can also customize the behavior of the `delegate` decorator by passing in the following keyword arguments:

- `kwonly`: A boolean value indicating whether the parameters of delegatee should be converted to keyword-only arguments. The default value is `True`.

- `delegate_docstring`: A boolean value indicating whether the docstring of delegatee should be used as the docstring of the delegator function. The default value is `True`.

- `ignore`: An iterable of strings containing the names of the parameters of delegatee that should be ignored. The default value is an empty set.

Here is an example of how to use these keyword arguments:

```python
@delegate(delegatee, kwonly=True, delegate_docstring=True, ignore={"a", "b"})
def delegator(c: int, d: int, e: int, **kwargs):
    ...
```

## Example

Here is an example of how to use the `delegate` decorator:

```python
from delegatefn import delegate

def delegatee(a: int, b: int, **kwargs):
    ...

@delegate(delegatee)
def delegator(c: int, d: int, e: int, **kwargs):
    ...
```

The delegator function will now have the parameters `a: int`, `b: int`, and `kwargs` added to it, in addition to its original parameters `c: int`, `d: int`, and `e: int`.

## Acknowledgements

This approach was inspired by [fast.ai](https://www.fast.ai/posts/2019-08-06-delegation.html).
japandata 0.5.2
Geographic data about Japan
Requires Python: >=3.8

# japandata

[![PyPI](https://img.shields.io/pypi/v/japandata?label=latest%20release)](https://pypi.org/project/japandata/)

**japandata** is a python library that provides easy access to detailed geographic data about Japan.

* [`japandata.maps`](#maps): Maps of Japan, its prefectures, and municipalities
* [`japandata.population`](#population): Demographic data
* [`japandata.indices`](#indices): Economic health indicators
* [`japandata.readings`](#readings): Kana and romaji readings of place names

<!-- TODO: Add a nice plot here  -->

## japandata.maps 

National, prefectural, and municipal topojson maps from 1920 to today.

```python
from japandata.maps import load_map

prefecture_map = load_map(date=2022, scale='jp_pref', quality='coarse')
```

See `notebooks/maps.ipynb` to understand the different types of maps that can be loaded.

- Source: [Asanobu Kitamoto, ROIS-DS Center for Open Data in the Humanities](https://geoshape.ex.nii.ac.jp/city/choropleth/)
- License: CC BY-SA 4.0


## japandata.population

National, prefectural, and municipal demographic data annually from 1967.

```python
from japandata.population.data import japan_pop, pref_pop, city_pop,
                                      japan_age, pref_age, city_age
```

* `japan_pop`, `pref_pop`, `city_pop`: Contain data on total population, gender split, number of households, births, deaths, and migrations, for Japanese and non-Japanese residents.
* `japan_age`, `pref_age`, `city_age`: Contain age distributions split by gender for Japanese and non-Japanese residents.

See `notebooks/population.ipynb` for example uses of this dataset.

- Source: [Basic Register of Residents](https://www.soumu.go.jp/main_sosiki/jichi_gyousei/daityo/gaiyou.html) via [Official Statistics Portal Site](https://www.e-stat.go.jp/stat-search/files?page=1&toukei=00200241&tstat=000001039591)
- License: [CC BY 4.0 International](https://www.soumu.go.jp/menu_kyotsuu/policy/tyosaku.html#tyosakuken)

## japandata.indices

Fiscal health indices for municipal and prefectural governments annually from 2005. These indices are used to e.g. determine fiscal transfers between municipalities.

```python
from japandata.indices import city, pref, prefmean
```

`city` covers municipal governments, `pref` covers prefectural governments, and `prefmean` provides weighted means of municipal indices grouped by prefecture.

See `notebooks/indices.ipynb` for example uses of this dataset.

- Source: [Ministry of Internal Affairs](https://www.soumu.go.jp/iken/shihyo_ichiran.html)
- License: [CC BY 4.0 International](https://www.soumu.go.jp/menu_kyotsuu/policy/tyosaku.html#tyosakuken)

## japandata.readings

Kana and romaji pronunciation information for Japanese place names.


```python
from japandata.readings import city_names, pref_names
```

See `notebooks/readings.ipynb` for code to integrate this information with the maps.


# Installation

```bash
$ pip install japandata
```

# Licenses

- Code: MIT
- Data: Noted above
Python-CartolaFC 3.1.0
Uma interface em Python para a API Rest do Cartola FC
Requires Python: >=3.7
Keywords: python,cartolafc,api

# Python Cartola FC API

[![PyPi Version](https://img.shields.io/pypi/v/python-cartolafc.svg)](https://pypi.org/project/python-cartolafc/)
[![Build Status](https://github.com/vicenteneto/python-cartolafc/actions/workflows/main.yml/badge.svg)](https://github.com/vicenteneto/python-cartolafc/actions/workflows/main.yml)
[![Development Status](http://img.shields.io/:status-production/stable-brightgreen.svg)](https://github.com/vicenteneto/python-cartolafc)
[![License](http://img.shields.io/:license-mit-blue.svg)](https://github.com/vicenteneto/python-cartolafc/blob/main/LICENSE)

Uma interface em Python para a API Rest do Cartola FC.


# Índice

- [Sobre este projeto](#sobre-este-projeto)
- [Versões](#versoes)
- [Instalação](#instalacao)
- [Exemplo](#exemplo)
- [Contribuintes](#contribuintes)
- [Direitos autorais e licença](#direitos-autorais-e-licenca)


## Sobre este projeto

Este projeto é uma interface em Python para a API REST do Cartola FC. [Cartola FC](https://cartolafc.globo.com/) é um 
esporte fantasy sobre futebol, ou seja, é um jogo fictício no qual as pessoas montam seus times com jogadores de futebol 
da vida real. Foi lançado no ano de 2005.

Criado e mantido por [Globo.com](http://www.globo.com/) e promovido pelo canal de TV por assinatura 
[Sportv](http://sportv.globo.com/), este jogo de futebol virtual conta com mais de 5 milhões de usuários registrados. 
Logo na abertura da temporada 2016, o jogo registrou a sua melhor marca entre times escalados em uma única rodada em 12 
anos de história do fantasy, incríveis 2.723.915 de usuários montaram as suas equipes para a primeira rodada do 
Campeonato Brasileiro de 2016. A 10ª rodada do Campeonato Brasileiro de 2017 instituiu um novo recorde, onde 5.540.835
times foram escalados no jogo.


## Versões

Este projeto foi testado e funciona em Python 3.8, 3.9 e 3.10.


## Instalação

PyPI:

```bash
    $ pip install Python-CartolaFC
```

Ou baixando o código fonte e executando:

```bash
    $ python setup.py install
```

Versão em desenvolvimento:

```bash
    $ pip install git+https://github.com/vicenteneto/python-cartolafc.git#egg=Python-CartolaFC
```


## Exemplo

A API Python-CartolaFC destina-se a mapear os objetos no CartolaFC (por exemplo, Atleta, Clube, Liga, Equipe) em objetos 
Python facilmente gerenciados:

```python
>>> import cartolafc
>>> api = cartolafc.Api()
>>> time = api.time(nome='Falydos FC')
>>> time.ultima_pontuacao
48.889892578125
>>> time.info.nome
'Falydos FC'
```

Mais exemplos disponíveis no Github:
[https://github.com/vicenteneto/python-cartolafc/tree/main/examples](https://github.com/vicenteneto/python-cartolafc/tree/main/examples)


## Contribuintes

Identificou algum bug ou tem alguma requisição de funcionalidade nova?
[Por favor, abra uma nova issue](https://github.com/vicenteneto/python-cartolafc/issues/new>).


## Direitos autorais e licença

Copyright 2017-, Vicente Neto. Este projeto é licenciado sob a 
[Licença MIT](https://github.com/vicenteneto/python-cartolafc/blob/main/LICENSE).