semvec/pypi-packages huggingface dataset:
gfdlvitals 3.0.12
Tools for calculating scalar diagnostics from GFDL models
Requires Python: >=3.7
Keywords: climate model analysis scalar diagnostics gfdl AM4 CM4 ESM4 OM4 LM4


**gfdlvitals** is a Python package in the public domain
that provides tools for calculating, storing, and analyzing
scalar diagnostics from GFDL's CM4-class models.

More Information
----------------
- Source code: `<https://github.com/jkrasting/gfdlvitals>`_
- Documentation: `<https://gfdlvitals.readthedocs.io/en/latest/>`_
zeroc-ice 3.7.11
Ice is a comprehensive RPC framework with support for Python, C++, .NET, Java, JavaScript and more.
Requires Python: >=3.10
Keywords: ice, RPC

# Ice for Python

[Getting started] | [Examples] | [Documentation] | [Building from source]

The [Ice framework] provides everything you need to build networked applications,
including RPC, pub/sub, server deployment, and more.

Ice for Python is the Python implementation of the Ice framework.

## Sample Code

```slice
// Slice definitions (Hello.ice)

module Demo
{
    interface Hello
    {
        void sayHello();
    }
}
```

```python
// Client application (client.py)
import sys
import Ice

Ice.loadSlice('Hello.ice')
import Demo

# Ice.initialize returns an initialized Ice communicator, the communicator is destroyed
# once it goes out of scope.
with Ice.initialize(sys.argv) as communicator:
    hello = Demo.HelloPrx.checkedCast(
        communicator.stringToProxy("hello:default -h localhost -p 10000"))
    hello.sayHello()
```

```python
// Server application (server.py)

import signal
import sys
import Ice

Ice.loadSlice('Hello.ice')
import Demo

class Printer(Demo.Hello):
    def sayHello(self, current):
        print("Hello World!")

# Ice.initialize returns an initialized Ice communicator, the communicator is destroyed
# once it goes out of scope.
with Ice.initialize(sys.argv) as communicator:

    # Install a signal handler to shutdown the communicator on Ctrl-C
    signal.signal(signal.SIGINT, lambda signum, frame: communicator.shutdown())
    if hasattr(signal, 'SIGBREAK'):
        signal.signal(signal.SIGBREAK, lambda signum, frame: communicator.shutdown())
    adapter = communicator.createObjectAdapterWithEndpoints("Hello", "default -h localhost -p 10000")
    adapter.add(Printer(), Ice.stringToIdentity("hello"))
    adapter.activate()
    communicator.waitForShutdown()
```

[Getting started]: https://archive.zeroc.com/ice/3.7/hello-world-application/writing-an-ice-application-with-python
[Examples]: https://github.com/zeroc-ice/ice-demos/tree/3.7/python
[Documentation]: https://archive.zeroc.com/ice/3.7
[Building from source]: https://github.com/zeroc-ice/ice/blob/3.7/python/BUILDING.md
[Ice framework]: https://github.com/zeroc-ice/ice
neo4j-etl-lib 0.3.2
Building blocks for ETL pipelines.
Requires Python: >=3.10
Keywords: etl, graph, database

# Neo4j ETL Toolbox

A Python library of building blocks to assemble etl pipelines.

Complete documentation can be found on https://neo-technology-field.github.io/python-etl-lib/index.html

See https://github.com/neo-technology-field/python-etl-lib/tree/main/examples/gtfs 

or 

https://github.com/neo-technology-field/python-etl-lib/tree/main/examples/musicbrainz

for example projects.


The library can be installed via 

```bash
pip install neo4j-etl-lib
```
fenra 0.1.2
FinOps platform for AI cost visibility
Requires Python: >=3.10

<p align="center">
  <img src="https://assets.fenra.io/public/header.png" alt="Fenra" width="100%">
</p>

# Fenra Python SDK

[![PyPI](https://img.shields.io/pypi/v/fenra.svg)](https://pypi.python.org/pypi/fenra)
[![Python](https://img.shields.io/pypi/pyversions/fenra.svg)](https://pypi.python.org/pypi/fenra)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

FinOps platform for AI cost visibility

## Usage

Install the package:

```bash
pip install fenra
```

Initialize and start tracking:

```python
import fenra
from openai import OpenAI

fenra.init(api_key="your-fenra-api-key")

# Use as normal - costs are tracked automatically
client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}]
)
```

Works with Anthropic (Claude) and Google (Gemini) the same way.

Set context for cost attribution:

```python
fenra.set_context(
    billable_customer_id="cust_123",  # recommended
    environment="production",
    feature="chat",
)
```

For custom providers or manual tracking:

```python
fenra.track(
    provider="custom",
    model="my-model",
    input_tokens=100,
    output_tokens=50,
)
```

To disable auto-tracking:

```bash
export FENRA_DISABLE_AUTO_TRACK=1
```

To enable debug logging:

```python
import logging
logging.getLogger("fenra").setLevel(logging.DEBUG)
```

## Support

- [Documentation](https://docs.fenra.io)
- [Contact](mailto:hello@fenra.io)

## Privacy

Fenra is privacy-first by default. No prompts or responses are stored unless explicitly enabled.

## License

The Fenra Python SDK is licensed under the [Apache 2.0](http://apache.org/licenses/LICENSE-2.0.txt) License.
pyfb-kit 0.1.0
A wrapper for the facebook-sdk which provides an ergonomic way to manage common interactions using the facebook-sdk
Requires Python: >=3.14

# PyFB-kit

A Python wrapper for the Facebook Graph API that provides convenient abstractions for managing and moderating Facebook pages and comments.

## Installation

Install the package using pip:

```bash
pip install pyfb-kit
```

Or using uv (recommended):

```bash
uv add pyfb-kit
```

## Prerequisites

Before using this library, you need to obtain a long-lived user access token with the appropriate permissions:

1. Create a Facebook developer application at [developers.facebook.com/apps](https://developers.facebook.com/apps/)
2. Add the following permissions to your application:
   - `pages_manage_engagement`
   - `pages_read_engagement`
   - `pages_read_user_content`
   - `pages_show_list`
3. Generate a short-lived user access token via the Graph API Explorer with the above permissions
4. Exchange it for a long-lived token (valid for up to 60 days) using the following request:

```python
import requests

params = {
    "grant_type": "fb_exchange_token",
    "client_id": "<YOUR_APP_ID>",
    "fb_exchange_token": "<SHORT_LIVED_TOKEN>",
    "client_secret": "<YOUR_APP_SECRET>",
}

response = requests.get("https://graph.facebook.com/v24.0/oauth/access_token", params=params)
long_lived_token = response.json()["access_token"]
```

## Usage

### Basic Setup

```python
from pyfb_kit import Client, Account, Post, Comment

# Initialize the client with your user access token
client = Client(user_access_token="your_long_lived_token_here")
```

### Managing Accounts

Retrieve all Facebook pages associated with your account:

```python
# Get all accessible accounts/pages
accounts = client.get_accounts()

# Print account information
for account in accounts:
    print(f"Page Name: {account.name}, ID: {account.id}")
```

### Working with Posts

Fetch posts from a specific page:

```python
# Get posts from a specific account
first_account = accounts[0]
posts = client.get_posts(first_account)

# Print post information
for post in posts:
    print(f"Post ID: {post.id}, Message: {post.message[:50]}...")
```

### Comment Management

Interact with comments on posts:

```python
# Get comments from a specific post
first_post = posts[0]
comments = client.get_comments(first_account, first_post)

# Print comment information
for comment in comments:
    print(f"Comment by {comment.from_info.name}: {comment.message[:50]}...")

# Post a new comment on a post
client.put_comment(first_account, first_post, "This is a new comment!")

# Reply to an existing comment
first_comment = comments[0]
client.reply_comment(first_account, first_comment, "Thanks for your comment!")
```

### Advanced Comment Operations

Retrieve replies to a specific comment:

```python
# Get all replies to a specific comment
replies = client.get_comment_replies(first_account, first_comment)

for reply in replies:
    print(f"Reply by {reply.from_info.name}: {reply.message[:50]}...")
```
github-streak 0.1.1
CLI tool to track your GitHub contribution streaks
Requires Python: >=3.7

# ghstreak

A simple CLI tool to track your GitHub contribution streaks.

## Installation

```bash
pip install github-streak
```

## Usage

```bash
ghstreak <github_username>
```

Example:

```bash
ghstreak deven367
```

## Authentication

For higher API rate limits, set your GitHub token as an environment variable:

```bash
export GITHUB_TOKEN=your_token_here
```

You can create a personal access token at: <https://github.com/settings/tokens>

## Output

The tool displays:

- Your current contribution streak (consecutive days with contributions)
- Your previous streak (if applicable) and when it ended

## Requirements

- Python >= 3.7
- requests >= 2.25.0
- python-dotenv >= 0.19.0
dkist-sphinx-theme 2.0.5
The sphinx theme for the DKIST documentation.
Requires Python: >=3.10

# DKIST Sphinx Theme

[![codecov][codecov-badge]][codecov-url]

The DKIST documentation theme

In your sphinx `conf.py` file you will need to put the following:

```python
html_theme = "dkist"
```

This theme is based on the [sunpy theme](https://github.com/sunpy/sunpy-sphinx-theme).

[codecov-badge]: https://codecov.io/bb/dkistdc/dkist-sphinx-theme/graph/badge.svg?token=45gmgWTSLn
[codecov-url]: https://codecov.io/bb/dkistdc/dkist-sphinx-theme
powerplatform-management 2.0.3317.207
Microsoft Power Platform Management SDK
Requires Python: >=3.8

# Microsoft Power Platform Management SDK

Integrate the Microsoft [Power Platform API](https://learn.microsoft.com/rest/api/power-platform/) into your project!

## Installation
To install the client library via pip install:

Search for powerplatform-management in the pypi.org, or
Type `pip install powerplatform-management`.

## Getting started
1. Register your application
Register your application to use Power Platform API using following the [Authentication](https://learn.microsoft.com/power-platform/admin/programmability-authentication-v2) instructions.

2. Follow a tutorial
We provide a number of tutorials today across various tools/SDKs.  Feel free to use one as an easy way to learn how to leverage the .NET SDK and automate to your heart's content!

* [Create a daily capacity report](https://learn.microsoft.com/en-us/power-platform/admin/programmability-tutorial-create-daily-capacity-report?tabs=Azure)
* [Install an application to a target environment](https://learn.microsoft.com/en-us/power-platform/admin/programmability-tutorial-install-application-environment?tabs=Azure)
* [Allocate add-ons to environments](https://learn.microsoft.com/en-us/power-platform/admin/programmability-tutorial-allocate-capacity-addons?tabs=PPAC)
* [Create cross tenant isolation reports](https://learn.microsoft.com/en-us/power-platform/admin/programmability-tutorial-cross-tenant-reporting?tabs=Automate)
* [Create, update, and list Environment Management Settings](https://learn.microsoft.com/en-us/power-platform/admin/programmability-tutorial-environmentmanagement-settings)