semvec/pypi-packages huggingface dataset:
takk 0.1.21
A project that makes it easier to develope and deploy Python projects
Requires Python: >=3.10

# Takk

Define your architecture in pure Python-servers, workers, scheduled jobs, and databases connect automatically through type hints.

## Overview

Takk is a Python framework that eliminates configuration overhead by using type hints to automatically wire up your infrastructure. Write pure Python code and let Takk handle the connections between servers, workers, databases, and scheduled jobs.

No YAML. No configuration files. Just Python.

## Features

- **Type-hint driven** - Your type annotations define your architecture
- **Automatic dependency injection** - Components connect without manual wiring
- **Pure Python** - Everything is code, nothing is configuration
- **Full IDE support** - Autocomplete and type checking work out of the box
- **Minimal boilerplate** - Focus on your logic, not setup

## Installation
```bash
uv add takk
```

## Quick Start
```python
from takk.models import Project, FastAPIApp, Worker
from takk.secrets import SlackWebhook

from my_app.settings import AppSettings
from my_app import app

background_worker = Worker("background")

project = Project(
    name="my-custom-server",
    shared_settings=[AppSettings],

    workers=[background_worker],

    my_server=FastAPIApp(app),
)
```

## How It Works

Takk uses Python type hints to understand your application's resources and automatically creates the necessary connections. When you annotate a settings class with a type like `PostgresDsn`or `RedisDsn`, Takk:

1. Detects the dependency through type
2. Instantiates the component with appropriate configuration
3. Injects it into your environment

Read the [full article](https://docs.takkthon.com/blog/deploy-with-python-type-hints) to see how we built this approach.

## Core Components

### Server
```python
from takk.models import Project, FastAPIApp, Worker
from takk.secrets import SlackWebhook

project = Project(
    name="my-custom-server",

    custom_network_app=NetworkApp(
        command=["/bin/bash", "-c", "uv run main.py"],
        port=8000,
    ),
)
```

### Worker
```python
from takk import Worker

worker = Worker("name-of-worker")

worker.run(function, Args(...))
```

### Database
```python
from pydantic import PostgresDsn, RedisDsn, BaseModel
from takk import Database

class MyAppSettings(BaseModel):
    redis_url: RedisDsn
    psql_db: PostgresDsn
```

### Scheduled Jobs
```python
from takk.models import Compute, Project, Job

from my_app.train import train_model, TrainConfig

project = Project(
    name="ml-example",

    train_pokemon_model=Job(
        train_model,
        cron_schedule="0 3 * * *",  # Runs daily at 3 AM
        arguments=TrainConfig(...),
    ),
)
```

## Requirements

- Python 3.10+
- Type hints support


## Examples

Check out the [examples directory](examples/) for complete applications:

- [Simple web server](examples/web_server/)
- [Background worker with scheduling](examples/worker/)
- [Full-stack application](examples/fullstack/)

## Learn More

- [Documentation](https://docs.takkthon.com/docs)
dbhydra 2.3.7
Data science friendly ORM combining Python
Requires Python: >=3.6

# dbhydra
Data science friendly ORM (Object Relational Mapping) library combining Python, Pandas, and various SQL dialects
For full documentation see official [documentation](http://app.forloop.ai/dbhydra/documentation) - currently unavailable but we're working on it!

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install dbhydra.

```bash
pip install dbhydra
```

## Usage

```python
import dbhydra.dbhydra_core as dh
db1=dh.db()

table1 = dh.Table(db1,"test",["test1","test2","test3","test4"],["int","int","int","int"])
#table1.drop()
#table1.create()
#rows=[[1,2,3,4],[5,4,7,9]]
#table1.insert(rows)

list1=table1.select("SELECT * FROM test")
print(list1)

#list2=table1.select_all()
#print(list2)

#table1.drop()

table1.export_to_xlsx()

tables=db1.get_all_tables()
table_dict=db1.generate_table_dict()
print(tables)

columns=table_dict['test'].get_all_columns()
types=table_dict['test'].get_all_types()
print(columns,types)

table_test=dh.Table.init_all_columns(db1,"test")

print(table_test.columns)

table2 = dh.Table(db1,"test_new",["id","test2"],["int","nvarchar(20)"])
#table2.create()
#table2.drop()
```
## Current scope
Aims: Easy integration with Pandas, SQL SERVER/MySQL database, and exports/imports to/from excel/CSV format

Done: Table functions (Create, Drop, Select, Update, Insert, and Delete) should be working fine

Todo: Group by, Order by, Where, Linking of FK, Customizable PK,...


## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

## License
[MIT](https://choosealicense.com/licenses/mit/)