semvec/pypi-packages huggingface dataset:
sql-adapters 0.3.0
SQL adapters for various databases - SQLAlchemy simplifed
Requires Python: >=3.10

# sql-adapters

A Python library that wraps SQLAlchemy core to deliver an opinionated style
of development wherein databases are implemented as adapters which are interfaces
to the data source.


```python
import sql_adapters.sqlite as sql
from sql_adapters import (
    Column,
    declarative_base,
    delete,
    insert,
    select,
    text,
    update,
)

base = declarative_base()


class _TestTable(base):
    __tablename__ = "test_table"

    id = Column(sql.INTEGER, primary_key=True, autoincrement=True)
    name = Column(sql.TEXT, nullable=False)
    date_created = Column(
        sql.TZDateTime,
        nullable=False,
        default=lambda: datetime.now().astimezone(),
    )


class returns:
    class select_result(NamedTuple):
        id: int
        name: str
        date_created: datetime


class DemoAdapter(sql.SqliteAdapter):
    def __init__(
        self,
        read_only: bool = False,
    ):
        super().__init__("test", mode="ro" if read_only else "rw")

    @staticmethod
    def init():
        adapter = DemoAdapter(read_only=False)
        with adapter:
            base.metadata.create_all(adapter.connection)

    def add_item(self, name: str):
        self.execute(insert(_TestTable).values(name=name))

    def get_item(self, item_id: int) -> returns.select_result:
        stmt = select(_TestTable).where(_TestTable.id == item_id)
        result = self.execute(stmt)
        data = self.read_values(result, returns.select_result)
        return next(data)
```
liquipediarl 1.0.6
Liquipedia Rocket League API Wrapper
Requires Python: >=3.7

# LiquipediaRL

**LiquipediaRL** is a Python wrapper for the [Liquipedia Rocket League](https://liquipedia.net/rocketleague) site

> This wrapper uses the official Liquipedia (MediaWiki) API and abides by the [TOS](https://liquipedia.net/api-terms-of-use)

---

## Installation

```cmd
pip install liquipediarl
```

---

## Examples

```python
from liquipediarl import LiquipediaRL

lp = LiquipediaRL(
    app_name="App Name",
    app_version="1.0.0",
    website="https://example.com",
    email="you@example.com"
)
```

## get_player()

```python
# Gets info for a specified player page
player = lp.get_player("SquishyMuffinz")
# Player names are as they appear in the URL:
# https://liquipedia.net/rocketleague/SquishyMuffinz

print(player.keys())
print(player['info']['earnings'])
print(player['settings']['camera'])
```
## get_all_players()

```python
# Gets all the players from a specified region
players = lp.get_all_players("Oceania")
# Regions are as follows:
# Africa, Americas, Asia, Europe, Oceania

# Or use 'all=True' to get all regions at once
all_players = lp.get_all_players(all=True)
# Note: returns 1 page per 30 secs to comply with rate limits

print(len(players))
print(players[:5])

```

---

[![PyPI version](https://img.shields.io/pypi/v/liquipediarl)](https://pypi.org/project/liquipediarl/)
[![Python](https://img.shields.io/pypi/pyversions/liquipediarl)](https://pypi.org/project/liquipediarl/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

[@8pq8](https://github.com/8pq8)
dume-api 0.1.0
Helpers for scraping the DUME public procurement API
Requires Python: >=3.9
Keywords: scraping, public procurement, dume

Tiny helper for downloading the “données essentielles” exposed at https://dume.chorus-pro.gouv.fr/#/accueil/donnees-essentielles/rechercher. Everything here reproduces the JSON calls the official SPA makes to `https://dume.chorus-pro.gouv.fr/dumes/donneesEssentielles`.

## Setup

```bash
pip install dume-api
```

## Quick start

```py
import dume_api as dume

# Lightweight list view (same fields as the website table).
rows = dume.get_contracts(date="2024-01-11")

# Add filters the same way you would in the UI.
rows = dume.get_contracts(
    date_start="2024-01-01",
    date_end="2024-01-31",
    cpv_code="45210000",
    type_de="Marché public",
)

# Request the complete contract structure (one API call per reference).
contracts = dume.get_contracts(date="2024-01-05", complete=True)

# Single-contract lookup (used internally by the snippet above).
record = dume.get_contract("AIFEDUME-daoxup8c")
```

That’s it—you rarely need to instantiate anything else. If you do want to manage your own session (different base URL, manual iteration, etc.), instantiate `dume_api.DumeApiClient`.

## Filters & options

Both helper functions accept the same keyword arguments as the website:

Supported filter keywords and their UI equivalents:

| Argument | UI label | Notes |
| --- | --- | --- |
| `reference` / `reference_unique` | Référence fonctionnelle | Exact ref such as `AIFEDUME-daoxup8c`. |
| `date` | Date de publication | Shortcut that sets both start and end to a single day. |
| `date_start` / `date_end` | Date de publication (du/au) | `YYYY-MM-DD` strings; use both to define a range. |
| `internal_id` | Identifiant interne | Matches the `ID` column returned by the API. |
| `nature` | Nature | Use the exact label (`Marché`, `Contrat de concession`, …). |
| `procedure` | Procédure | Exact label shown on the site (`Procédure adaptée`, etc.). |
| `cpv_code` | Code CPV | Full CPV value (e.g. `45210000`). |
| `type_de` | Type de DE | Accepts `MP`, `Marché public`, `CC`, or `Contrat de concession`. |
| `acheteur_id` | Acheteur / Autorité concédante | Provide the SIRET coming from the autocomplete. |
| `titulaire_id` | Titulaire / Concessionnaire | Provide the SIRET coming from the autocomplete. |

### Behind the scenes

- The platform caps each query at 100 rows, so `get_contracts()` automatically splits large date ranges and toggles between MP/CC when needed. If the API still returns 100 results for a tiny filter the helper raises an error so you can narrow it manually.
- Each HTTP request retries on 429/5xx responses, backing off exponentially. Call `dume.configure_client(pause=0.5, max_retries=5)` to slow down or override the defaults.
nmslib-nobrainz 2.1.2
Non-Metric Space Library (NMSLIB)

Non-Metric Space Library (NMSLIB) is an efficient cross-platform
 similarity search library and a toolkit for evaluation of similarity search methods. 
 The goal of the project is to create an effective and comprehensive toolkit for searching 
 in generic and non-metric spaces. Even though the library contains a variety of metric-space 
 access methods, our main focus is on generic and approximate search methods, in particular, 
 on methods for non-metric spaces. NMSLIB is possibly the first library with a principled 
 support for non-metric space searching.