semvec/pypi-packages huggingface dataset:
dbt-fivetran 0.0.33
dbt (data build tool) adapter for Fivetran Datalake
Requires Python: >=3.9

# Overview

When you run dbt with this adapter, it will create a local duckdb file named as `<your-database-name>.local.db`. 
It will be placed in `target` folder in your project folder if it exists. Otherwise, it will be placed in
the root of your project folder.


# Example profile

```
testprj:
  target: dev
  outputs:
    dev:
      type: fivetran
      extensions:
        - httpfs
        - iceberg
      threads: 2
      max-memory: 4096
      database: <s3-bucket-name>
      schema: <schema-name>
      polaris_uri: https://polaris.fivetran.com/api/catalog
      polaris_credentials: <fivetranPolarisCredentials>
      polaris_scope: "PRINCIPAL_ROLE:ALL"
      polaris_catalog: <fivetran-group-id>
```
useful-math-functions 0.4.0
useful-math-functions for Optimization, Benchmarking, Visualizing, and more ...
Requires Python: <3.12,>=3.10

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8373435.svg)](https://doi.org/10.5281/zenodo.8373435)

# useful-math-functions

`useful-math-functions` is a collection of useful mathematical functions with a
focus on:

1. **ease of use** - the functions are designed to be as easy to use as possible
2. **pure python** - the functions are written in much python as possible and
   only use external libraries when necessary
3. **documentation** - the functions are documented in code itself with:
   1. Examples
   2. Equations
   3. References
   4. Links to external resources

## Installation

The package can be installed via pip:

```bash
pip install useful-math-functions
```

and for Visualizations:

```bash
# matplotlib
pip install useful-math-functions[matplotlib]

# plotly
pip install useful-math-functions[plotly]

# all visualizations
pip install useful-math-functions[all]
```

## Usage

The package can be imported like any other python package:

```python
from umf.core.create import OptBench
res = OptBench(["DeJongN5Function"], dim=3)
res.plot_type_3d = "plot_surface"
res.plot()
res.save_as_image()
```

![_](https://github.com/Anselmoo/useful-math-functions/blob/main/docs/extra/images/DeJongN5Function.png?raw=true)

To use the newly added functions:

```python
from umf.functions.optimization.special import HimmelblauFunction
import numpy as np

x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = HimmelblauFunction(X, Y).__eval__

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111, projection="3d")
ax.plot_surface(X, Y, Z, cmap="viridis")
plt.savefig("HimmelblauFunction.png", dpi=300, transparent=True)
```

```python
from umf.functions.optimization.valley_shaped import Rosenbrock2DFunction
import numpy as np

x = np.linspace(-2, 2, 100)
y = np.linspace(-1, 3, 100)
X, Y = np.meshgrid(x, y)
Z = RosenbrockFunction(X, Y).__eval__

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111, projection="3d")
ax.plot_surface(X, Y, Z, cmap="viridis")
plt.savefig("RosenbrockFunction.png", dpi=300, transparent=True)
```

## Documentation

The documentation can be found
[here](https://anselmoo.github.io/useful-math-functions/).

## Contributing

Contributions are welcome. For major changes, please open an issue first to
discuss what you would like to change.

## License

The project is licensed under the
[MIT](https://github.com/Anselmoo/useful-math-functions/blob/main/LICENSE)
license.
slowpoke-flask 0.1.1
Track slow Flask routes and monitor bottlenecks
Requires Python: >=3.7

# 🐢 Slowpoke
<h1 align="center" style="font-size: 4rem;">🐢 SLOWPOKE</h1>

**Slowpoke** is a lightweight Python package that helps you monitor and log **slow API routes** in your Flask application. If you're wondering _"Which endpoints are dragging me down?"_, Slowpoke has your back.

---

## 🚀 Installation

Until we publish on PyPI, install directly from GitHub:

```bash
pip install git+https://github.com/vedangit/slowpoke.git
```

---

## ⚙️ Usage

### 1. Add `slowpoke` to your Flask app

```python
from slowpoke import monitor

app = Flask(__name__)
monitor(app)

```

> The `threshold_ms` parameter sets the time (in milliseconds) after which a request is considered slow.

---

### 2. Run your app normally

Make requests as usual. Slowpoke will track how long each endpoint takes.

---

### 3. View the report

Once you've made some requests, generate a report from the command line:

```bash
slowpoke report
```

This will print a table of all routes that exceeded the threshold, including method, endpoint, duration, and timestamp.

---

## 🧪 Example App

You can test out `slowpoke` quickly by running the example Flask app:

```bash
cd examples
python app.py
```

Then hit some routes and run:

```bash
slowpoke report
```

---

## 🛣️ Roadmap

### ✅ Version 0 (Current):
- Log all Flask routes that exceed a threshold.
- CLI tool to view slow route report.

### 🔜 Version 1 (Coming soon):
- Middleware-based integration.
- Save reports to file.
- Optional integration with logging tools.
- FastAPI + Django support.

---

## 🧠 Why Slowpoke?

- 🚀 Fast to integrate  
- 🔍 Focused on performance bottlenecks  
- 🧼 Clean CLI reporting  
- 💻 Perfect for side projects or production  

---

## 👩‍💻 Author

Made with ❤️ by [Vedangi](https://github.com/vedangit)

---

## 📄 License

MIT License