semvec/pypi-packages huggingface dataset:
fastapix 0.1.0
FastAPI X is a powerful CLI tool to help you! :rocket:
Requires Python: >=3.7

<h1 align="center">
    <strong>FastAPI X</strong>
</h1>
<p align="center">
    <a href="https://github.com/Kludex/fastapix" target="_blank">
        <img src="https://img.shields.io/github/last-commit/Kludex/fastapix" alt="Latest Commit">
    </a>
        <img src="https://img.shields.io/github/workflow/status/Kludex/fastapix/CI">
        <a href="https://github.com/Kludex/fastapix/actions?workflow=CI" target="_blank">
            <img src="https://img.shields.io/badge/Coverage-100%25-success">
        </a>
    <br />
    <a href="https://pypi.org/project/fastapix" target="_blank">
        <img src="https://img.shields.io/pypi/v/fastapix" alt="Package version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/fastapix">
    <img src="https://img.shields.io/github/license/Kludex/fastapix">
</p>

:warning: **This project is still under development.**

## Features

The most important feature are the project and component generators.

- [X] Show environment variables the project is reading - `fastapix env`.
- [X] Show application routes. - `fastapix routes`.
- [X] Show application middlewares. - `fastapix middlewares`.
- [ ] Project generator - `fastapix new app`.
    - [ ] Generate a new project.
    - [ ] Generate Dockerfile.
- [ ] Component generator - `fastapix new component`.
    - [ ] Generate a new component based on the current project structure.
- [ ] Plugin system. People will be able to create their own commands.
- [ ] Embed Flake8-FastAPI - `fastapix lint`.
- [ ] Embed formatter - `fastapix format`.
- [ ] Show information about the project - `fastapix info`.

## Installation

```bash
pip install fastapix
```

## License

This project is licensed under the terms of the MIT license.
sqlalchemy-pyodbc-mssql 0.1.1
SA dialect for MSSQL using PyODBC which handles MSSQL-specific limitations

sqlalchemy_pyodbc_mssql Readme
==========================================

.. image:: https://circleci.com/gh/level12/sqlalchemy_pyodbc_mssql.svg?&style=shield
    :target: https://circleci.com/gh/level12/sqlalchemy_pyodbc_mssql

.. image:: https://codecov.io/gh/level12/sqlalchemy_pyodbc_mssql/branch/master/graph/badge.svg
    :target: https://codecov.io/github/level12/sqlalchemy_pyodbc_mssql?branch=master

Overview
--------

PyODBC is Microsoft's recommended DBAPI layer for connecting a python application to MSSQL. However,
the layer is not MSSQL-specific, and so it has some limitations:

- parameterized queries with GROUP BY will not always work ([source](https://github.com/mkleehammer/pyodbc/issues/479))
- stored procedures (such as those called by the prepared statements in pyodbc) are limited to
  2100 parameters ([source](https://docs.microsoft.com/en-us/sql/sql-server/maximum-capacity-specifications-for-sql-server?view=sql-server-2017))

SQLAlchemy has a PyODBC dialect for MSSQL usage, but it also shares these limitations.

- for GROUP BY details, see https://github.com/sqlalchemy/sqlalchemy/issues/4540

[PyMSSQL](http://www.pymssql.org) exists as an alternative DBAPI layer and dialect for SQLAlchemy. Since it prepares queries
by rolling parameters into the query string itself (properly quoted, of course) rather than issuing
ODBC prepared statements, it does not share the above problems.

sqlalchemy_pyodbc_mssql extends the built-in SQLAlchemy PyODBC dialect in order to work around
these limits in a manner consistent with PyMSSQL's implementation. Most queries are passed as-is to
PyODBC to be prepared and executed normally. Those that would not work, due to the above issues,
are given special treatment to avoid the limitations and keep the app developer from needing to
keep track of when to apply workarounds.

Usage
-----

-  Installation
    - for usage in app: `pip install sqlalchemy_pyodbc_mssql`
    - to run tests: `pip install sqlalchemy_pyodbc_mssql[tests]`
-  Usage
    - see [SQLAlchemy instructions for PyODBC usage](https://docs.sqlalchemy.org/en/13/dialects/mssql.html#module-sqlalchemy.dialects.mssql.pyodbc)
    - dialect name to use is `mssql+pyodbc_mssql`
        - examples:
            - `mssql+pyodbc_mssql://<username>:<password>@<dsnname>`
            - `mssql+pyodbc_mssql://<username>:<password>@<dbname>?driver=SQL+Server+Native+Client+11.0`


Changelog
=========

0.1.1 released 2022-10-24
-------------------------

- resolve cache warning from SQLAlchemy 1.4 (480007f_)

.. _480007f: https://github.com/level12/sqlalchemy_pyodbc_mssql/commit/480007f


0.1.0 released 2019-06-17
-------------------------

- initial release
kalmankit 1.7.8
Multidimensional implementation of Kalman Filter algorithms
Requires Python: >=3.6, <4

<p align="center">
  <img src="img/logo.png" width="700">
</p>

![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/Xylambda/kalmankit?label=VERSION&style=badge)
![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/Xylambda/kalmankit?style=badge)
![GitHub issues](https://img.shields.io/github/issues/Xylambda/kalmankit?style=badge)
![workflow](https://github.com/Xylambda/kalmankit/actions/workflows/cicd.yaml/badge.svg)
[![doc](https://img.shields.io/badge/DOCS-documentation-blue.svg?style=badge)](https://xylambda.github.io/kalmankit/)

The Kalman filter is an optimal estimation algorithm: it estimates the true 
state of a signal given that this signal is noisy and/or incomplete. This 
package provides a multidimensional implementation of:
* **Standard Kalman Filter**: if the noises are drawn from a gaussian 
distribution and the underlying system is governed by linear equations, the 
filter will output the best possible estimate of the signal's true state.

* **Extended Kalman Filter**: can deal with nonlinear systems, but it does not
guarantee the optimal estimate. It works by linearizing the function locally
using the Jacobian matrix.


## Installation
**Normal user**
```bash
pip install kalmankit
```

**Developer**
```bash
git clone https://github.com/Xylambda/kalmankit.git
pip install -e kalmankit/. -r kalmankit/requirements-dev.txt
```

## Tests
To run tests you must install the library as a `developer`.
```bash
cd kalmankit/
pytest -v tests/
```

## Usage
The library provides 3 examples of usage:
1. [Moving Average](examples/moving_average.py)
2. [Market Beta estimation](examples/market_beta.py)
3. [Extended Kalman Filter](examples/extended.py)

A `requirements-example.txt` is provided to install the needed dependencies to
run the examples.

## References
* Matlab - [Understanding Kalman Filters](https://www.youtube.com/playlist?list=PLn8PRpmsu08pzi6EMiYnR-076Mh-q3tWr)

* Bilgin's Blog - [Kalman filter for dummies](http://bilgin.esme.org/BitsAndBytes/KalmanFilterforDummies)

* Greg Welch, Gary Bishop - [An Introduction to the Kalman Filter](https://www.cs.unc.edu/~welch/media/pdf/kalman_intro.pdf)

* Simo Särkkä - Bayesian filtering and Smoothing. Cambridge University Press.


## Cite
If you've used this library for your projects please cite it:

```latex
@misc{alejandro2021kalmankit,
  title={kalmankit - Multidimensional implementation of Kalman Filter algorithms},
  author={Alejandro Pérez-Sanjuán},
  year={2021},
  howpublished={\url{https://github.com/Xylambda/kalmankit}},
}
```
image-processing-clpe 0.0.1
Image Processing Package using Skimage
Requires Python: >=3.8

# package_name

Description. 
The package package_name is used to:
	Processing:
	- Histogram matching
	- Structural similarity
	- Resize image
	Utils:
	- Read image
	- Save image
	- Plot image
	- Plot result
	- Plot histogram

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install image_processing_

```bash
pip install image_processing_clpe
```


## Author
Carlos_Eduardo

## License
[MIT](https://choosealicense.com/licenses/mit/)