semvec/pypi-packages huggingface dataset:
autodla 0.2.8
A simple ORM with history tracking for rapid POC development
Requires Python: >=3.9
Keywords: orm, database, sql, postgresql, prototype, poc, history-tracking

# AutoDLA

A lightweight, powerful and modern ORM focused on simplifying development.

[Documentation](https://autoDLA.readthedocs.io/en/latest/)

## Installation

### Using PyPi
```bash
pip install autodla
```

### From source
```bash
git clone https://github.com/GuzhiRegem/autoDLA.git
cd autoDLA/
pip install .
```

### Features

To keep AutoDLA as lightweight as possible, you need to install separatelly the features you need to use, that includes the DataBase connection you are going to use, to install a feature, you can run the installation command as follows:
```bash
pip install autodla[<package_name>]
```
For example, PostgreSQL connection:
```bash
pip install autodla[db-postgres]
```
MemoryDB comes bundled with AutoDLA for quick prototyping without any external
dependencies.

## How to use

AutoDLA works with models, to start, you'll need to first build a usable model that inherits from [Object](reference/object.md):
```python
from autodla import Object, primary_key

class User(Object):
    id: primary_key = primary_key.auto_increment()
    name: str
    age: int
```
> **WARNING:** For model definition there is **1 rule** to ensure good data integrity:

> - Each Model should have one and only one field of type [`primary_key`](reference/primary_key.md) (`id` in this case)

If you try to use this, it will fail, as the main focus of the library is to interact with a DataBase, you need a DataBase connection, we'll use PostgreSQL for this example.

```bash
pip install autodla[db-postgres] #install db connector
```

We need to instanciate the DataBase and then attach the Model into it.

```python
from autodla.dbs import PostgresDB, MemoryDB

# Use MemoryDB() for pure in-memory work. PostgresDB maintains a local
# SQLite store and syncs it to PostgreSQL in the background.
db = MemoryDB()
db.attach([User])
```

Done!

You now can use your object as you would normally and the changes are going to be reflected on the DataBase, enjoy!

---

### Uses

#### Create a user
```python
user = User.new(name="John", age=30)
```

#### Retrieve all users
```python
users = User.all(limit=None, skip=0)
```

#### Integrity of python id for the percieved same object
```python
print(id(user) === id(users[-1]))
# This prints True
```

---

This is protected under MIT licence
llama-index-graph-rag-cognee 0.2.0
llama-index graph rag cognee integration
Requires Python: <4,>=3.10

# LlamaIndex Graph Rag Integration: Cognee

Cognee assists developers in introducing greater predictability and management into their Retrieval-Augmented Generation (RAG) workflows through the use of graph architectures, vector stores, and auto-optimizing pipelines. Displaying information as a graph is the clearest way to grasp the content of your documents. Crucially, graphs allow systematic navigation and extraction of data from documents based on their hierarchy.

For more information, visit [Cognee documentation](https://docs.cognee.ai/)

## Installation

```shell
pip install llama-index-graph-rag-cognee
```

## Usage

```python
import os
import pandas as pd
import asyncio

from llama_index.core import Document
from llama_index.graph_rag.cognee import CogneeGraphRAG


async def example_graph_rag_cognee():
    # Gather documents to add to GraphRAG
    news = pd.read_csv(
        "https://raw.githubusercontent.com/tomasonjo/blog-datasets/main/news_articles.csv"
    )[:5]
    news.head()
    documents = [
        Document(text=f"{row['title']}: {row['text']}")
        for i, row in news.iterrows()
    ]

    # Instantiate cognee GraphRAG
    cogneeRAG = CogneeGraphRAG(
        llm_api_key=os.environ["OPENAI_API_KEY"],
        llm_provider="openai",
        llm_model="gpt-4o-mini",
        graph_db_provider="networkx",
        vector_db_provider="lancedb",
        relational_db_provider="sqlite",
        relational_db_name="cognee_db",
    )

    # Add data to cognee
    await cogneeRAG.add(documents, "test")

    # Process data into a knowledge graph
    await cogneeRAG.process_data("test")

    # Answer prompt based on knowledge graph
    search_results = await cogneeRAG.search(
        "Tell me who are the people mentioned?"
    )
    print("\n\nAnswer based on knowledge graph:\n")
    for result in search_results:
        print(f"{result}\n")

    # Answer prompt based on RAG
    search_results = await cogneeRAG.rag_search(
        "Tell me who are the people mentioned?"
    )
    print("\n\nAnswer based on RAG:\n")
    for result in search_results:
        print(f"{result}\n")

    # Search for related nodes in graph
    search_results = await cogneeRAG.get_related_nodes("person")
    print("\n\nRelated nodes are:\n")
    for result in search_results:
        print(f"{result}\n")


if __name__ == "__main__":
    asyncio.run(example_graph_rag_cognee())
```

## Supported databases

**Relational databases:** SQLite, PostgreSQL

**Vector databases:** LanceDB, PGVector, QDrant, Weviate

**Graph databases:** Neo4j, NetworkX
ftbqcache 0.1.0
Add your description here
Requires Python: >=3.10

This is a simple helper intended to be used at Fivetran to cache queries to BigQuery. It's used as follows:

```python
from ftbqcache import fetch_with_cache

df = fetch_with_cache("select 1")
```

Queries are run in `analytics-only`. You need to have your own credentials, obviously. Results are cached for 1h as parquet files in `./cache`.
openbim 0.0.8
Structure information modeling.
Keywords: dynamics, finite-element-analysis, structural-analysis, seismic, earthquake-engineering


<p align="center">
  <a href="https://gallery.stairlab.io/">
    <img src="https://veux.io/_static/images/stairlab_large.svg" alt="STAIRLab logo" width="200" height="165">
  </a>
</p>

<h3 align="center">xbim</h3>


<p align="center">
  extended building information modeling
  <br>
  <a href="https://gallery.stairlab.io/"><strong>Explore the STAIRLab gallery »</strong></a>
</p>
testing.mysql 0.3.0.1
MySQL testing framework
Requires Python: >=3.6

<!--img src="logo.png" height="64px"/-->

![Build Status](https://gitlab.com/xihh87/testing.mysql/badges/main/pipeline.svg)

`testing.mysql` is a framework to test queries in an ephemeral database.

To test in local environment:

```
$ mk start
$ mk test
```

To install from pypi:

```bash
python -m pip install testing.mysql
```

This is how you use the module:

```
@pytest.fixture(scope="session", autouse=True)
def mysql(request):
    container = testing.mysql.DockerMySQL(
        {
            "username": "user",
            "password": "password",
            "port": "9998",
            "dbname": "fastfarm",
        }
    )
    container.wait_until_ready()
    container.load_schema("tests/data/schema.sql")
    container.load_schema("migrations/code_to_apply_migrations.sql")
    container.load_data_on_table("tests/data/dataset.tsv", "table")
    container.load_data_on_table("tests/data/repeat_as_needed.tsv", "another_table")

    def stop_container():
        container.stop()

    request.addfinalizer(stop_container)
    return container


@pytest.fixture(scope="function")
def conn(mysql, request):
    c = mysql.connect()

    def close_connection():
        c.close()

    request.addfinalizer(close_connection)
    return c


def test_latest_images(conn):
    # write your test
    pass
```
keypractice 0.1.11
A slim, cross-platform terminal-based typing trainer with YAML-based exercises and analytics.
Requires Python: >=3.7

# Maintenance Scripts

## Publishing to PyPI

1. Make sure you have an API token from https://pypi.org/account/ (starts with `pypi-`).
2. Run the script:
   ```sh
   bash maintenance/publish_pypi.sh
   ```
   - You will be prompted for your API token if not set as the `PYPI_API_TOKEN` environment variable.
   - The script will build and upload your package to PyPI.

## Publishing to the AUR

1. Update `maintenance/PKGBUILD`:
   - Set your name/email as Maintainer.
   - Set the correct `pkgver` and update the `url` to your GitHub repo.
   - Download the release tarball and update the `sha256sums` (use `sha256sum` on the tarball).
2. Create a new directory and copy `PKGBUILD` into it:
   ```sh
   mkdir keypractice-aur && cp maintenance/PKGBUILD keypractice-aur/
   cd keypractice-aur
   makepkg
   ```
3. If the package builds, upload it to the AUR:
   - Create a new package at https://aur.archlinux.org/
   - Push your PKGBUILD and `.SRCINFO` to the AUR git repo as instructed by the AUR web interface.

---

**Never share your PyPI API key publicly!**