semvec/pypi-packages huggingface dataset:
memeNexus 0.7.1
A toolbox for meme trading
Requires Python: ==3.11.*

# MemeNexus

MemeNexus is a Python library for interacting with meme coins. It provides tools for fetching token information, analyzing token performance, and monitoring trading activities.

## Installation

```bash
pip install memeNexus
```

## Quick Start

```python
import asyncio

from meme_nexus.clients import DexScreenerClient


async def main():
    # Initialize the client
    client = DexScreenerClient()

    # Search for a meme token
    token_address = "2RBko3xoz56aH69isQMUpzZd9NYHahhwC23A5F3Spkin"
    response = await client.search_by_token_address(token_address)

    # Process and analyze the results
    for pair in response.pairs:
        print(f"Chain: {pair.chainId}")
        print(f"DEX: {pair.dexId}")
        print(f"Price: ${pair.priceUsd}")
        print(f"24h Volume: ${pair.volume.h24:,.2f}")
        if pair.liquidity:
            print(f"Liquidity: ${pair.liquidity.usd:,.2f}")
        if pair.info and pair.info.socials:
            print("Social Links:")
            for social in pair.info.socials:
                print(f"- {social.type}: {social.url}")
        print("---")


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

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
modules-for-freethreading 0.3.2
A module to handle module compatibility between free-threading and regular Python builds
Requires Python: >=3.13


# Modules for free-threading built python

## Description

See [https://github.com/python/cpython/pull/135550](https://github.com/python/cpython/pull/135550), [PEP779](https://peps.python.org/pep-0779/#open-issues).
Now the free-threading is not a experimental feature anymore. However, the `.pyd` files are different between two executable.
This repository is make sure that if the `.pyd` files are not the files for the executable version, it will be reinstall for the currently version.

## Note

Make sure that the packages have at least a version that is compatible with the current python executable version.
The `cp313-cp313` should be used for the normal, while the `cp313-cp313t` should be used for the free-threading.

## Usage

```sh
pip install modules_for_freethreading
```

The code below is an example of using the `numpy` module. If the `numpy` module is not compatible with the current python executable version, it will be reinstalled for the corrently version.
```python
import modules_for_freethreading
modules_for_freethreading.add_module("numpy"[, module_version="2.2.0"])
import numpy
```

## Note

If the module's name is different from the install name, you should set it : 
```python
import modules_for_freethreading
modules_for_freethreading.add_module("jpype")
modules_for_freethreading.add_other_name("jpype", "jpype1")
import jpype
```

## License

MIT
omni-python-sdk 0.1.11
A Python SDK for Omni API
Requires Python: >=3.9

# omni-python-sdk

Python SDK for interacting with the Omni API

## Installation

```bash
pip install -r requirements.txt
```

## Usage
```python
from omni_python_sdk import OmniAPI

# Set your API key and base URL
api_key = "your_api_key"
base_url = "https://your_domain.omniapp.co"
#these can optionally be set in an .env file with the following keys:
# OMNI_API_KEY=<<your api key>>
# OMNI_BASE_URL=<<your base url>>

# Define your query
query = {
    "query": {
        "sorts": [
            {
                "column_name": "order_items.created_at[date]",
                "sort_descending": False
            }
        ],
        "table": "order_items",
        "fields": [
            "order_items.created_at[date]",
            "order_items.sale_price_sum"
        ],
        "modelId": "your_model_id",
        "join_paths_from_topic_name": "order_items"
    }
}

# Initialize the API with your credentials
api = OmniAPI(api_key, base_url)
# if you've optionally set your keys in a .env file no arguments are required:
# api = OmniAPI()
# if your environment variables are stored in an alternative location
# api = OmniAPI(env_file='<<path_to_custom_env>>')

# Run the query and get a table
table = api.run_query_blocking(query)

# Convert the table to a Pandas DataFrame
df = table.to_pandas()

# Display the first few rows of the DataFrame
print(df.head())
```

To run the example, you need to replace `your_api_key`, `your_domain`, and `your_model_id` with your own values.

To get a query object, you can use the Inspector on a Omni Workbook. The query object is a JSON object that represents the query you want to run. You can find the Inspector in the View menu on a Workbook. Look for the "Query Structure" section.

For a simple command line interface, you can run the following command:

```bash
python3 examples/query.py OMNI_API_KEY https://OMNI_URL '{"query": {"sorts": [{"column_name": "omni_dbt__order_items.created_at[date]", "sort_descending": false}], "table": "omni_dbt__order_items", "fields": ["omni_dbt__order_items.created_at[date]", "omni_dbt__order_items.total_sale_price"], "modelId": "OMNI_MODEL_ID", "join_paths_from_topic_name": "order_items"}}
```
riweather 1.0.2
Grab publicly available weather data
Requires Python: >=3.10
Keywords: noaa, weather

# riweather

[![Tests](https://github.com/ensley-nexant/riweather/workflows/Tests/badge.svg)](https://github.com/ensley-nexant/riweather/actions?workflow=Tests)
[![Codecov](https://codecov.io/gh/ensley-nexant/riweather/branch/main/graph/badge.svg)](https://codecov.io/gh/ensley-nexant/riweather)
[![Release](https://github.com/ensley-nexant/riweather/actions/workflows/release.yml/badge.svg)](https://github.com/ensley-nexant/riweather/actions/workflows/release.yml)

Grab publicly available weather data with `riweather`. [See the full documentation](https://ensley-nexant.github.io/riweather).

## Installation

Install with pip:

```
pip install riweather
```

To create interactive maps of weather station locations, install the package along with its optional dependencies:

```
pip install riweather[plots]
```

## Usage

Given a latitude and longitude, get a list of weather stations sorted from nearest to farthest from that location.

```pycon
>>> import riweather
>>> station_rank = riweather.rank_stations(39.98, -105.13, max_distance_m=20000)
```

Select the top station (or a different station):

```pycon
>>> station = riweather.select_station(station_rank, rank=0)
```

View information about that station:

```pycon
>>> station.name, station.usaf_id
('ERIE MUNICIPAL AIRPORT', '720534')
```

And pull weather data from that station for a certain year.

```pycon
>>> station.fetch_data(2024, "air_temperature", period="h", temp_scale="F", tz="US/Mountain")
                           air_temperature.temperature_f
2023-12-31 18:00:00-07:00                      33.176848
2023-12-31 19:00:00-07:00                      29.726000
2023-12-31 20:00:00-07:00                      25.415750
2023-12-31 21:00:00-07:00                      22.736750
2023-12-31 22:00:00-07:00                      20.876750
...                                                  ...
2024-12-31 13:00:00-07:00                      34.328000
2024-12-31 14:00:00-07:00                      35.445500
2024-12-31 15:00:00-07:00                      35.640500
2024-12-31 16:00:00-07:00                      34.249250
2024-12-31 17:00:00-07:00                      31.057455
[8784 rows x 1 columns]
```
datarobot-asgi-middleware 0.2.0
A FastAPI/ASGI middleware to simplify development of FastAPI apps on DataRobot
Requires Python: >=3.9

# DataRobot ASGI Middleware


A middleware to simplify front-proxy handling and health checks in
[DataRobot](https://datarobot.com).


## Usage

Simply add to your FastAPI application that you expect to run in DataRobot

```python
from fastapi import FastAPI

from datarobot_asgi_middleware import DataRobotASGIMiddleware

app = FastAPI()
app.add_middleware(DataRobotASGIMiddleware)


@app.get("/")
async def root():
    return {"message": "hello"}

```


Doing so will enable the automatic URLs such as `docs/` and
`openapi.json` to work as expected both in DataRobot and locally.


If you'd like to do proper Kubernetes health checks to let DataRobot
know your application is healthy, the middleware adds a way to tell
DataRobot to use a specific health URL endpoint like:`/health`to validate your app is
working as expected using
[kube-probe](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/).

So, similar to the example above, but this time with `health_endpoint="/health"`:

```python
from fastapi import FastAPI

from datarobot_asgi_middleware import DataRobotASGIMiddleware


app = FastAPI()
app.add_middleware(DataRobotASGIMiddleware, health_endpoint="/health")


@app.get("/")
async def root():
    return {"message": "hello"}


@app.get("/health")
async def health():
    # Check on database connections, memory utilization, etc. If it returns
    # any error code like a 404 or 500, the app is marked as unhealthy
    return {"status": "healthy"}
```


## Development

Development is designed to run with
[uv](https://docs.astral.sh/uv/getting-started/installation/) and
[Taskfile/go-task](https://taskfile.dev/installation/).

You can run tests, linters, etc. by setting these two up to work together


### Testing realistically with Traefic

To test through a DataRobot-like proxy the `examples/basic` folder it contains a basic app and traefik configuration
to start up with `docker-compose -f examples/basic/docker-compose.yml up`  from the repo root folder, and validate by going to `http://localhost:9999/front-proxy` or run the baked-in task for it with:

`task run-example-basic`

Technically DataRobot does a double front-proxy for applications, so
this configuration mimics the double proxy with one traefic instance.