semvec/pypi-packages huggingface dataset:
dioptra-zeph-elena 1.3.3
An orchestrator for distributed IP tracing
License: MIT
Requires Python: <4.0,>=3.10

# 🌬️ Zeph

[![Tests](https://img.shields.io/github/actions/workflow/status/dioptra-io/zeph/tests.yml?logo=github)](https://github.com/dioptra-io/zeph/actions/workflows/tests.yml)
[![Coverage](https://img.shields.io/codecov/c/github/dioptra-io/zeph?logo=codecov&logoColor=white)](https://app.codecov.io/gh/dioptra-io/zeph)
[![PyPI](https://img.shields.io/pypi/v/dioptra-zeph?color=blue&logo=pypi&logoColor=white)](https://pypi.org/project/dioptra-zeph/)

> Zeph is a reinforcement learning based algorithm for selecting prefixes to probe based on previous measurements in order to maximize the number of nodes and links discovered. Zeph can be used on top of the [Iris](https://iris.dioptra.io) platform.


## 🚀 Quickstart

Zeph has a command line interface to configure and run the algorithm.

First, install the Zeph package:

```
pip install dioptra-zeph
```

Zeph takes as input a list of /24 (IPv4) or /64 (IPv6) prefixes:
```sh
# prefixes.txt
8.8.8.0/24
2001:4860:4860::/64
```

To start a measurement from scratch:
```bash
zeph prefixes.txt
```

To start from a previous measurement:
```bash
zeph prefixes.txt UUID
```

Zeph relies on [iris-client](https://github.com/dioptra-io/iris-client) and [pych-client](https://github.com/dioptra-io/pych-client)
for communicating with Iris and ClickHouse. See their respective documentation to know how to specify the credentials.

## ✨ Generate prefix lists from BGP RIBs

You can create an _exhaustive_ list of /24 prefixes from a BGP RIB dump:
```bash
pyasn_util_download.py --latest
# Connecting to ftp://archive.routeviews.org
# Finding most recent archive in /bgpdata/2022.05/RIBS ...
# Downloading ftp://archive.routeviews.org//bgpdata/2022.05/RIBS/rib.20220524.1000.bz2
#  100%, 659KB/s
# Download complete.
zeph-bgp-convert --print-progress rib.20220524.1000.bz2 prefixes.txt
```

## 📚 Publications

```bibtex
@article{10.1145/3523230.3523232,
    author = {Gouel, Matthieu and Vermeulen, Kevin and Mouchet, Maxime and Rohrer, Justin P. and Fourmaux, Olivier and Friedman, Timur},
    title = {Zeph &amp; Iris Map the Internet: A Resilient Reinforcement Learning Approach to Distributed IP Route Tracing},
    year = {2022},
    issue_date = {January 2022},
    publisher = {Association for Computing Machinery},
    address = {New York, NY, USA},
    volume = {52},
    number = {1},
    issn = {0146-4833},
    url = {https://doi.org/10.1145/3523230.3523232},
    doi = {10.1145/3523230.3523232},
    journal = {SIGCOMM Comput. Commun. Rev.},
    month = {mar},
    pages = {2–9},
    numpages = {8},
    keywords = {active internet measurements, internet topology}
}
```

## 🧑‍💻 Authors

Iris is developed and maintained by the [Dioptra group](https://dioptra.io) at [Sorbonne Université](https://www.sorbonne-universite.fr) in Paris, France.
dioptra-iris-client-elena 0.5.2
Python client for the Iris API.
License: MIT
Requires Python: !=2.7.*,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,!=3.7.*,!=3.8.*,>=3.9

# 🕸️ Iris Python Client

[![Tests](https://img.shields.io/github/actions/workflow/status/dioptra-io/iris-client/tests.yml?logo=github)](https://github.com/dioptra-io/iris-client/actions/workflows/tests.yml)
[![Coverage](https://img.shields.io/codecov/c/github/dioptra-io/iris-client?logo=codecov&logoColor=white)](https://app.codecov.io/gh/dioptra-io/iris-client)
[![PyPI](https://img.shields.io/pypi/v/dioptra-iris-client?logo=pypi&logoColor=white)](https://pypi.org/project/dioptra-iris-client/)

Minimalist Python client for the [Iris](https://github.com/dioptra-io/iris) API,
built on top of [Authlib](https://github.com/lepture/authlib) and [httpx](https://github.com/encode/httpx).

## Installation

```bash
pip install dioptra-iris-client
```

## Usage

```python
from iris_client import IrisClient, AsyncIrisClient

base_url = "https://api.iris.dioptra.io"
username = "user@example.org"
password = "password"

# Synchronous client
with IrisClient(base_url, username, password) as client:
    measurements = client.get("/measurements/").json()

# Asynchronous client
async with AsyncIrisClient(base_url, username, password) as client:
    measurements = (await client.get("/measurements/")).json()

# Helper function to fetch all the results from a paginated endpoint,
# available for both clients:
all_measurements = client.all("/measurements/")
```


### Credential provider chain

The Iris client looks for credentials in a way similar to the [AWS SDK](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html):

1. If one of `base_url`, `username` or `password` is specified, these values will be used.
2. If none of the previous values are specified, and one of `IRIS_BASE_URL`, `IRIS_USERNAME` or `IRIS_PASSWORD`
   environment variables are present, these values will be used.
3. If none of the previous values are specified, and the file `~/.config/iris/credentials.json` exists,
   the fields `base_url`, `username` and `password` will be used.
pydantic-api-sdk-notion 0.0.37
Type Safe SDK For Notion API
License: MIT
Requires Python: <4.0,>=3.12
Keywords: notion, pydantic, api, type-safe

# Type-Safe Notion API SDK

[![PyPI version](https://img.shields.io/pypi/v/pydantic-api-sdk-notion)](https://pypi.org/project/pydantic-api-sdk-notion/)

A Python SDK for interacting with the Notion API, featuring **complete IntelliSense support**. Always **up-to-date** with the latest Notion API documentation.

---

## Installation

Install the SDK using pip:

```bash
pip install pydantic-api-sdk-notion
```

## Quick Start

```python
# Import the NotionClient object from the SDK
from pydantic_api.notion.sdk import NotionClient

# Import all Notion-API related types from pydantic_api.notion.models
from pydantic_api.notion.models import (
    TitleDatabaseProperty,
    NumberDatabaseProperty,
    PeopleDatabaseProperty,
    RichTextDatabaseProperty,
    # The SDK provides Factory classes for quick instantiation of Notion API objects
    SortObjectFactory,
    ParentObjectFactory,
    RichTextObjectFactory,
)

# Instantiate a Notion client
notion_api_key = '<your-notion-api-key>'
client = NotionClient(auth=notion_api_key)

# List users
list_user_response = client.users.list(page_size=5)  # Returns `NotionPaginatedData[UserObject]`
print(type(list_user_response.results[0]))  # Prints 'PersonUserObject' or 'BotUserObject'

# Create a new database
new_database = client.databases.create(
    parent=ParentObjectFactory.new_page_parent(
        page_id="13e6c6f3f38d80269039f0186aaf95bb"
    ),
    title=[
        RichTextObjectFactory.new_text(content="🌿 Magical Plant Database"),
    ],
    properties={
        "Plant": TitleDatabaseProperty.define(),
        "Scientific Name": RichTextDatabaseProperty.define(),
        "Price ($)": NumberDatabaseProperty.define(format="dollar"),
        "Discovered By": PeopleDatabaseProperty.define(),
    },
)

# Query the database
records = client.databases.query(
    database_id=new_database.id,
    sorts=[
        SortObjectFactory.new_property_sort(
            property="Price", direction="descending"
        )
    ],
    page_size=3,
)
```

## Additional Notes

The **types used in this SDK** are maintained in a separate GitHub repository:  
[https://github.com/stevieflyer/pydantic-api-models-notion](https://github.com/stevieflyer/pydantic-api-models-notion)

This repository ensures type definitions stay **in sync with the latest Notion API updates**. Developers can directly use these types for their own projects, even without the SDK.

## Development

This repository uses [devenv](https://devenv.sh/). Devenv and enabled direnv will give you the best developer experience.

## Releasing

Create a new release [here](https://github.com/stevieflyer/pydantic-api-sdk-notion/releases/new).
Choose a semver-style tag with a `v` prefix, (i.e. `vX.X.X`). The release will happen automatically.
hadolint-coatl 2.14.0
Python wrapper around invoking hadolint (https://github.com/hadolint/hadolint)
License: MIT
Requires Python: >=3.9

# hadolint-coatl

[![GitHub Release](https://img.shields.io/github/v/release/coatl-dev/hadolint-coatl)](https://github.com/coatl-dev/hadolint-coatl/releases/latest)
[![Downloads](https://static.pepy.tech/badge/hadolint-coatl)](https://pepy.tech/project/hadolint-coatl)

A python wrapper to provide a pip-installable [hadolint] binary. Inspired by
[shellcheck-py].

Internally this package provides a convenient way to download the pre-built
hadolint binary for your particular platform.

## Installation

```bash
pip install hadolint-coatl
```

## Usage

After installation, the `hadolint` binary should be available in your
environment (or `hadolint.exe` on windows).

### As a pre-commit hook

See [pre-commit] for instructions

Sample `.pre-commit-config.yaml`:

```yaml
  - repo: https://github.com/coatl-dev/hadolint-coatl
    rev: 2.14.0
    hooks:
      - id: hadolint
```

[hadolint]: https://github.com/hadolint/hadolint
[pre-commit]: https://pre-commit.com
[shellcheck-py]: https://github.com/shellcheck-py/shellcheck-py