semvec/pypi-packages huggingface dataset:
rxml 2.3.6
RXML is a python library to read and write xml files up to 2 times faster than python's xml included library.
Requires Python: >=3.10

<h2 align="center">Like my work? consider supporting it!</h2>

[![BuyMeACoffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-ffdd00?style=for-the-badge&logo=buy-me-a-coffee&logoColor=black)](https://buymeacoffee.com/nephilim)

<h1 align="center">RXML</h1>

<p align="center"><em><code>rxml</code> is a simple python library to read xml files up to 2 times faster than python's <code>xml(ElementTree)</code> library.</em></p>

<p align="center">
<a href="https://pypi.org/project/rxml" target="_blank">
    <img src="https://img.shields.io/pypi/v/rxml?color=%2334D058&label=pypi%20package" alt="Package version">
</a>
<a href="https://pypi.org/project/rxml" target="_blank">
    <img src="https://img.shields.io/pypi/pyversions/rxml.svg?color=%2334D058" alt="Supported Python versions">
</a>
</p>

## Installation

To install `rxml` you can use `pip`:

```bash
pip install rxml
```

Simply as that!

## Example usage

To a given xml with `test.xml` as name:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<note example_attr="example value">
    <to>
        <name>Example Name</name>
    </to>
    <from>
        <name>Example Name</name>
    </from>
    <heading>An Example Heading</heading>
    <body>An Example Body!</body>
</note>
```

We write the following python code:

```python
from rxml import read_file

root_node = read_file("test.xml", "note")
```

where `"test.xml"` is the `file_name` and `"note"` is the `root_tag`.

After that we can simply iter through the children with:

```python
for node in root_node.children:
    # do something with the node here
```

You can also write it to a file or string(refer to the `.pyi` file for the args).

```python
from rxml import Node, write_file

example_node = Node(
    name="hello_world", 
    attrs={"example_attr": "example"},
    text="Hello World!"
)
write_file(example_node, "test_ex.xml")
```

## Node attributes

This is how the `Node` looks like:

```python
class Node:
    name: str
    attrs: dict[str, str]
    children: list[Node]
    text: str
```
floydipsum 1.0.0
Generates Lorem Ipsum text using Pink Floyd lyrics
Requires Python: >=3.13
Keywords: lorem, ipsum, text, generator, floyd, pink, lyrics, utility, command-line, cli

# floydipsum

floydipsum randomly selects a Pink Floyd song's lyrics as a replacement for standard lorem ipsum text.

```
Usage:
    floydipsum [options]

Options:
    -d, --debug         Enable debug mode
    -h, --help          Show this help screen
    -n, --number=<num>  Number of songs to download [default: 50]
    -s, --save          Save lyrics to file
    -t, --title         Print the song title along with the lyrics
    --version           Prints the version
```

## Installation

```bash
pip install floydipsum
```

## License

floydipsum is freeware released under the [MIT License](https://github.com/scholnicks/floydipsum/blob/main/LICENSE).
piccard 1.1.1
Visualizing demographic evolution using geographically inconsistent census data
Requires Python: >=3.7

# piccard

Developed by Abdulmohseen AlAli, Elise Corbin, and Maliha Lodi.

The latest release of piccard is available on PyPI at https://pypi.org/project/piccard/.

To install the latest release, run:
```bash
pip install piccard==1.1.1
```
Then import the package using:
```python
from piccard import piccard as pc
```

To view the full documentation, please visit https://piccard.readthedocs.io/.
asksageclient 1.42
Ask Sage Python Client API
Requires Python: >=3.7

# Ask Sage Python Client v1.42

This is the official Python client for the Ask Sage API. It allows you to interact with the Ask Sage service, providing a simple and pythonic way to make requests to the service.

Check Ask Sage API documentation here: https://docs.asksage.ai

## Installation

You can install the Ask Sage Python client via pip:

pip install asksageclient

## Usage

First, import the client:

from asksageclient import AskSageClient

Then, instantiate the client:

client = AskSageClient('your_email_here', 'your_api_key_here')
Warning: Do not store credentials in code, use environment variables/secrets instead

Now, you can use the client to interact with the Ask Sage service. For example, to interact with the main endpoint:

response = client.query(message='Who is Nic Chaillan?')

print(response)

## Endpoints

The client provides methods for all the Ask Sage API endpoints:

- `get_models`
- `add_dataset`
- `delete_dataset`
- `assign_dataset`
- `get_user_logs`
- `get_user_logins`
- `query`
- `query_plugin`
- `execute_plugin`
- `follow_up_questions`
- `tokenizer`
- `get_personas`
- `get_datasets`
- `get_plugins`
- `count_monthly_tokens`
- `count_monthly_teach_tokens`
- `train`
- `train_with_file`
- `file`

Each method corresponds to an endpoint of the Ask Sage API. The `content` parameter should be a dictionary containing the data you want to send in the request body.

## Error Handling

The client includes basic error handling. If a request fails, it will print an error message and return `None`.

## Contributing

Contributions are welcome! Please submit a pull request or create an issue to contribute to this project.

## License

See the LICENSE file for details.
calculator-xyz 0.1.1
Biblioteca de operações matemáticas básicas em Python.
Requires Python: >=3.8

# publicar Lib pyhton

sempre que for atualizar a lib é necessário excluir a pasta dist que é criada

- python -m pip install build twine wheel
- python -m build
- python -m twine upload dist/*

o nome da pasta src deve ser o nome da lib
caen-felib 1.4.0
Official Python binding for the CAEN FELib.
Requires Python: >=3.9

# caen-felib
The official Python binding for the CAEN FELib.

## Install
You need to install both the latest version of CAEN FELib and an implementation like the CAEN Dig2 from [the CAEN website](https://www.caen.it/products/caen-felib-library/).

Then, install this module and have fun:

    pip install caen-felib

## Examples
Few examples may be found on the [`examples`](https://github.com/caenspa/py-caen-felib/tree/master/examples) folder of the project repository.

## Copyright notice
Copyright &copy; 2024 CAEN SpA

The caen-felib module is free software; you can redistribute it and/or
modify it under the terms of the **GNU Lesser General Public
License** as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.

The caen-felib module is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along
with the caen-felib module; if not, see https://www.gnu.org/licenses/.

The license applies to the caen-felib module source as a whole, though
individual source files can have a different license which is required to be
compatible with the GNU Lesser General Public Library, version 3.

## Documentation
Python API is described on the CAEN FELib library documentation, starting from CAEN FELib v1.2.3.

## References
Requirements and documentation can be found at https://www.caen.it/products/caen-felib-library/.

## Support
For technical support, go to https://www.caen.it/mycaen/support/ (login and
MyCAEN+ account required).
AdsbAnomalyDetector 0.9
Low altitude aircraft anomaly detector
Keywords: python, deep learning, tensorflow, aircraft, classification, ADS-B

[![GitHub](https://img.shields.io/badge/GitHub-View_on_GitHub-blue?logo=GitHub)](https://github.com/DApIA-Project/Anomaly-Detection)

This library is a tool to detect anomalies in ADS-B messages. It is based on an artificial intelligence model that has been trained to detect spoofing, flooding and replay attacks.

All the used models are pre-trained and weight are stored in the library. On first use, the library will download the hashtable needed for the detection of replay attacks. Do not stop the program during the download
process.

<!-- make an image link to github -->
If you meet any problem with the library, feel free to open an issue our GitHub repository.

## Installation

```bash
pip install AdsbAnomalyDetector
```

## Usage

The library provides a function `predict` that should be connected to an ADS-B stream.
The function takes as input a list of ADS-B messages in a JSON format.

Every call should correspond to a unique timestamp, and so every messages should have the same timestamp.
If you want to process a whole timeseries, you should call the function multiple times.

The function stores the messages in caches, hence do not go backwards in time. Or the cache will automatically be cleared.

Here is an example of how to use the library, and show the format of the messages :

```python
from AdsbAnomalyDetector import predict, AnomalyType

messages = [ # list of flights messages at t = 1609459200
    {
        "icao24": "3C4A4D",
        "callsign": "AFR123",
        "timestamp": "1609459200",
        "latitude": "48.8583",
        "longitude": "2.2945",
        "altitude": "10000",
        "geoaltitude": "10000",
        "velocity": "250",
        "vertical_rate": "0",
        "track": "90",
        "alert": "False",
        "spi": "False"
    },
    {
        "icao24": "39AC45",
        "callsign": "SAMU31",
        "timestamp": "1609459200",
        ...
    }, ...
]

messages = predict(messages)
```

By default the function will return for each message a json object with the following fields :
- anomaly : equals AnomalyType.VALID if the message is valid, else it will be equal to the type of anomaly detected (AnomalyType.SPOOFING, AnomalyType.REPLAY, AnomalyType.FLOODING)
- tag : a string useful under saturation to separate messages of simultaneous flights with identical ICAO24

You can set the parameter `compress` to False if you want the function to return the full message + the anomaly field.

You can also activate the debug mode by setting the parameter `debug` to True. In this case, the function will return some additional information about the predictions of each models.
gdsfactoryhub 0.1.13
Software Development Kit - SDK for DoData
Requires Python: >=3.11

# GDSFactory Hub 0.1.13

In chip design, you need to efficiently manage multiple types of data, including:

- **Simulations**
- **Layouts**
- **Verification results** (DRC, LVS, etc.)
- **Measurements**
- **Yield and qualification data**

<!-- ![data-wave](https://i.imgur.com/A6l1g3D.png) -->

GDSFactory Hub provides a **cutting-edge data storage solution** designed specifically for the complexities of chip design. Our platform seamlessly integrates into your existing workflow, offering a **scalable, efficient, and organized** way to store, manage, and analyze all your critical data.

By using GDSFactory Hub, you can enhance efficiency, improve collaboration, and streamline your design process.

```{note}
This tool requires an active GDSFactory+ subscription. To learn more, visit [GDSFactory.com](https://GDSFactory.com).
```

<!-- ![data-types](https://i.imgur.com/DVDGNFm.png) -->

![device-die-wafer](https://i.imgur.com/v8wlnFr.png)

## Database Relationships

GDSFactory Hub uses a structured database schema that captures the relationships between different entities in chip design:

```mermaid
flowchart LR
    A["project"]
    A --> B["cell"]
    B --> C["device"]
    C --> D["device_data"]
    D --> E["analysis"]
    A --> F["wafer"]
    F --> G["die"]
    G --> D
    H["function"] --> E
```

This relationship model allows you to:

- **Filter across relationships**: Query device data by project, wafer, or cell attributes
- **Trace data lineage**: Follow the path from analysis results back to the original project
- **Perform complex queries**: Filter analyses by device characteristics, wafer properties, or project settings

## Installation

We support Python 3.11, 3.12, and 3.13 and recommend [VSCode](https://code.visualstudio.com/) IDE and [uv](https://docs.astral.sh/uv/).
If you don't have `uv` install it with the following command:

```bash
# On macOS and Linux.
curl -LsSf https://astral.sh/uv/install.sh | sh
```

```bash
# On Windows.
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

Then install GDSFactory Hub with:

```
uv pip install "gdsfactoryhub" --upgrade
```

Or add it to the dependencies of your current project with:

```
uv add gdsfactoryhub
```

## Setup

Ensure you create a `.env` file in your working directory with the following contents (fill in your details):

```
GDSFACTORY_HUB_API_URL="https://{org}.gdsfactoryhub.com"
GDSFACTORY_HUB_QUERY_URL="https://query.{org}.gdsfactoryhub.com"
GDSFACTORY_HUB_KEY="<same api key as in GDSFactory+>"
```

The `.env` file should be placed in the project where you run the notebooks.

## Run notebooks

To run the notebooks, you can use either VSCode or JupyterLab from your activated virtual environment.

- VSCode: Ensure you select the same Conda Python interpreter where the packages were installed.
- JupyterLab: Launch JupyterLab by running jupyter-lab from the same terminal used for the installation.
django-paddle-billing 0.1.14
Django + Paddle Billing Integration
Requires Python: >=3.9

# Django Paddle Billing

This package provides an integration between Django, a high-level Python Web framework, and Paddle Billing, a platform for selling digital products and services.

## Features

- Easy setup and configuration
- Seamless integration with Django projects
- Comprehensive handling of Paddle Billing features, including webhooks

## Installation

To install the package, use pip:

```bash
pip install django-paddle-billing
```

## Usage

After installing the package, add it to your `INSTALLED_APPS` in your Django settings:

```python
INSTALLED_APPS = [
    ...
    'django_paddle_billing',
    ...
]
```

Then, run migrations:

```bash
python manage.py migrate
```

You can now use the package in your Django project.

## Local webhook testing

In order to test webhooks locally, you can user cloudflared tunnel:
[Cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/get-started/create-local-tunnel/)

### Temporary URL

```bash
cloudflared tunnel --url http://localhost:8000/
```

### Permanent URL

Then, you can create a tunnel for your webhook:

```bash
cloudflared tunnel login
cloudflared tunnel create sandbox.paddle
# Create config file
# ...
cloudflared tunnel route dns sandbox.paddle sandbox-paddle.example.com
cloudflared tunnel run sandbox.paddle
```

Note: The deep level of DNS requires to be paid Advanced DNS (10$/month), so sandbox.paddle.example.com is not free

## Testing

This package uses pytest for testing. To run the tests, use the following command:

```bash
pytest
```

## Contributing

Contributions are welcome! Please read our [contributing guidelines](CONTRIBUTING.md) for details.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
geojson-pydantic 2.1.0
Pydantic data models for the GeoJSON spec.
Requires Python: >=3.9
Keywords: geojson, Pydantic

# geojson-pydantic

<p align="center">
  <em> <a href="https://docs.pydantic.dev/latest/" target="_blank">Pydantic</a> models for GeoJSON.</em>
</p>
<p align="center">
  <a href="https://github.com/developmentseed/geojson-pydantic/actions?query=workflow%3ACI" target="_blank">
      <img src="https://github.com/developmentseed/geojson-pydantic/workflows/CI/badge.svg" alt="Test">
  </a>
  <a href="https://codecov.io/gh/developmentseed/geojson-pydantic" target="_blank">
      <img src="https://codecov.io/gh/developmentseed/geojson-pydantic/branch/main/graph/badge.svg" alt="Coverage">
  </a>
  <a href="https://pypi.org/project/geojson-pydantic" target="_blank">
      <img src="https://img.shields.io/pypi/v/geojson-pydantic?color=%2334D058&label=pypi%20package" alt="Package version">
  </a>
  <a href="https://pypistats.org/packages/geojson-pydantic" target="_blank">
      <img src="https://img.shields.io/pypi/dm/geojson-pydantic.svg" alt="Downloads">
  </a>
  <a href="https://github.com/developmentseed/geojson-pydantic/blob/main/LICENSE" target="_blank">
      <img src="https://img.shields.io/github/license/developmentseed/geojson-pydantic.svg" alt="License">
  </a>
  <a href="https://anaconda.org/conda-forge/geojson-pydantic" target="_blank">
      <img src="https://anaconda.org/conda-forge/geojson-pydantic/badges/version.svg" alt="Conda">
  </a>
</p>

---

**Documentation**: <a href="https://developmentseed.org/geojson-pydantic/" target="_blank">https://developmentseed.org/geojson-pydantic/</a>

**Source Code**: <a href="https://github.com/developmentseed/geojson-pydantic" target="_blank">https://github.com/developmentseed/geojson-pydantic</a>

---

## Description

`geojson_pydantic` provides a suite of Pydantic models matching the [GeoJSON specification rfc7946](https://datatracker.ietf.org/doc/html/rfc7946). Those models can be used for creating or validating geojson data.

## Install

```bash
$ python -m pip install -U pip
$ python -m pip install geojson-pydantic
```

Or install from source:

```bash
$ python -m pip install -U pip
$ python -m pip install git+https://github.com/developmentseed/geojson-pydantic.git
```

Install with conda from [`conda-forge`](https://anaconda.org/conda-forge/geojson-pydantic):

```bash
$ conda install -c conda-forge geojson-pydantic
```

## Contributing

See [CONTRIBUTING.md](https://github.com/developmentseed/geojson-pydantic/blob/main/CONTRIBUTING.md).

## Changes

See [CHANGES.md](https://github.com/developmentseed/geojson-pydantic/blob/main/CHANGELOG.md).

## Authors

Initial implementation by @geospatial-jeff; taken liberally from https://github.com/arturo-ai/stac-pydantic/

See [contributors](hhttps://github.com/developmentseed/geojson-pydantic/graphs/contributors) for a listing of individual contributors.

## License

See [LICENSE](https://github.com/developmentseed/geojson-pydantic/blob/main/LICENSE)
aissemble-open-inference-protocol-shared 1.1.0
Shared Utilities for aiSSEMBLE Open Inference Protocol
Requires Python: <3.13,>=3.10

# aiSSEMBLE&trade; Open Inference Protocol Shared Utils
![PyPI - Version](https://img.shields.io/pypi/v/aissemble-open-inference-protocol-shared)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aissemble-open-inference-protocol-shared)
![PyPI - Format](https://img.shields.io/pypi/format/aissemble-open-inference-protocol-shared)
![PyPI - Downloads](https://img.shields.io/pypi/dm/aissemble-open-inference-protocol-shared)
[![Build (github)](https://github.com/boozallen/aissemble-open-inference-protocol/actions/workflows/build.yaml/badge.svg)](https://github.com/boozallen/aissemble-open-inference-protocol/actions/workflows/build.yaml)

Contains common functionality shared across multiple interfaces

## Content Type Precedence

When constructing an `InferenceResponse`, the `build_inference_response` utility determines the `content_type` for each output using the following precedence chain:

1. **Handler Output Content Type**: If the handler's output specifies a `content_type`, it takes highest precedence and is used directly.
2. **Per-Output Content Type**: If `request.outputs` is set, the `content_type` specified for each output is used.
3. **Request-Level Content Type**: If no per-output type is set, falls back to the request-level `content_type` (from `request.parameters.content_type`).
4. **Default Fallback**: If none of the above are set, defaults to `None` as the content type.

This ensures that the most specific content type is always used, with clear and predictable fallback behavior.

## Examples
For working examples and more details on shared features, configuration options, and usage, refer to the [Examples](https://github.com/boozallen/aissemble-open-inference-protocol/blob/dev/aissemble-open-inference-protocol-examples/README.md#shared) documentation.
ventricle 0.0.10
An opinionated modern async server, worker and scheduler
Requires Python: >=3.10

# Ventricle

An async REST-server, scheduler and worker all in one. Highly customizable, as it is just wrapping other battle-tested libaries.

```python
from ventricle import Ventricle

app = Ventricle()

@app.worker()
async def hello_world_worker():
    print("I am actually just python threading")

@app.rest.get("/endpoint")
async def rest_endpoint():
    await hello_world_worker()
    return {"how": "I am actually just FastAPI"}

@app.scheduler.scheduled_job("cron", minute=0)
async def hourly_job():
    print("I am actually just APScheduler")

    
# start all of them
app.start(
    rest=True,
    schedular=True,
    worker=True
)
```