semvec/pypi-packages huggingface dataset:
fb-mcp-bratrax 1.1.2
MCP server for Facebook/Meta Ads API integration enabling programmatic access to Meta Ads data
License: MIT
Requires Python: >=3.8
Keywords: facebook, ads, mcp, server, meta, marketing, api, advertising, insights, campaigns, dbt, bratrax

# FB MCP Bratrax

A Model Context Protocol (MCP) server for Facebook/Meta Ads API integration, enabling programmatic access to Meta Ads data and management features.

## Features

- **Ad Account Management**: List and get details of ad accounts
- **Campaign Analytics**: Retrieve performance insights for campaigns, ad sets, and ads
- **Comprehensive Insights**: Access detailed metrics including impressions, clicks, spend, CTR, and more
- **Flexible Filtering**: Support for date ranges, breakdowns, and custom filtering
- **Pagination Support**: Automatic handling of large result sets

## Installation

```bash
pip install fb-mcp-bratrax
```

## Usage

Set your Facebook access token as an environment variable and run the MCP server:

### Windows (PowerShell):

```powershell
$env:FB_TOKEN = "YOUR_FACEBOOK_ACCESS_TOKEN"
fb-mcp-bratrax
```

### Windows (Command Prompt):

```cmd
set FB_TOKEN=YOUR_FACEBOOK_ACCESS_TOKEN
fb-mcp-bratrax
```

### Linux/macOS:

```bash
export FB_TOKEN=YOUR_FACEBOOK_ACCESS_TOKEN
fb-mcp-bratrax
```

## Requirements

- Python 3.8+
- Valid Facebook/Meta Ads API access token
- `mcp>=1.6.0`
- `requests>=2.32.3`

## Available Tools

The server provides access to Facebook Ads API through various MCP tools including account insights, campaign management, ad set analytics, and creative management.

For detailed documentation and setup instructions, visit the project repository.
tronwalletpy 0.0.1
tronwalletpy library for Python
License: MIT

## How to use

```python
from tronpy import Tron
from tronpy.keys import PrivateKey

client = Tron(network='nile')
# Private key of TJzXt1sZautjqXnpjQT4xSCBHNSYgBkDr3
priv_key = PrivateKey(bytes.fromhex("8888888888888888888888888888888888888888888888888888888888888888"))

txn = (
    client.trx.transfer("TJzXt1sZautjqXnpjQT4xSCBHNSYgBkDr3", "TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA", 1_000)
    .memo("test memo")
    .build()
    .inspect()
    .sign(priv_key)
    .broadcast()
)

print(txn)
# > {'result': True, 'txid': '5182b96bc0d74f416d6ba8e22380e5920d8627f8fb5ef5a6a11d4df030459132'}
print(txn.wait())
# > {'id': '5182b96bc0d74f416d6ba8e22380e5920d8627f8fb5ef5a6a11d4df030459132', 'blockNumber': 6415370, 'blockTimeStamp': 1591951155000, 'contractResult': [''], 'receipt': {'net_usage': 283}}
```

### Async Client

```python
import asyncio

from tronpy import AsyncTron
from tronpy.keys import PrivateKey

# private key of TMisHYBVvFHwKXHPYTqo8DhrRPTbWeAM6z
priv_key = PrivateKey(bytes.fromhex("8888888888888888888888888888888888888888888888888888888888888888"))

async def transfer():
    async with AsyncTron(network='nile') as client:
        print(client)

        txb = (
            client.trx.transfer("TJzXt1sZautjqXnpjQT4xSCBHNSYgBkDr3", "TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA", 1_000)
            .memo("test memo")
            .fee_limit(100_000_000)
        )
        txn = await txb.build()
        print(txn)
        txn_ret = await txn.sign(priv_key).broadcast()
        print(txn_ret)
        # > {'result': True, 'txid': 'edc2a625752b9c71fdd0d68117802860c6adb1a45c19fd631a41757fa334d72b'}
        print(await txn_ret.wait())
        # > {'id': 'edc2a625752b9c71fdd0d68117802860c6adb1a45c19fd631a41757fa334d72b', 'blockNumber': 10163821, 'blockTimeStamp': 1603368072000, 'contractResult': [''], 'receipt': {'net_usage': 283}}

if __name__ == '__main__':
    asyncio.run(transfer())
```

Or close async client manually:

```python
from httpx import AsyncClient, Timeout
from tronpy.providers.async_http import AsyncHTTPProvider
from tronpy.defaults import CONF_NILE


async def transfer():
    _http_client = AsyncClient(limits=Limits(max_connections=100, max_keepalive_connections=20),
                               timeout=Timeout(timeout=10, connect=5, read=5))
    provider = AsyncHTTPProvider(CONF_NILE, client=_http_client)
    client = AsyncTron(provider=provider)
    print(client)

    priv_key = PrivateKey(bytes.fromhex("8888888888888888888888888888888888888888888888888888888888888888"))
    txb = (
        client.trx.transfer("TJzXt1sZautjqXnpjQT4xSCBHNSYgBkDr3", "TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA", 1_000)
        .memo("test memo")
        .fee_limit(100_000_000)
    )
    txn = await txb.build()
    print(txn)
    txn_ret = await txn.sign(priv_key).broadcast()

    print(txn_ret)
    print(await txn_ret.wait())
    await client.close()

if __name__ == '__main__':
    asyncio.run(transfer())
```
mosamatic-cli-macos 1.6.2
A CLI tool for body composition analysis from DICOM CT scans (MacOS version)
License: MIT
Requires Python: <3.12,>=3.11

# mosamatic-cli
Command-line tool for running processing tasks on medical images

# To-do
- NumPy to NIFTI conversion

- Create PNG images from DICOM files

- Slice selection using either Total Segmentator or MOOSE

  What you can do is first create spinal segmentations of a CT scan. Then
  you can use that data to pick a segmentation, e.g., the L3 vertebra and
  select the middle slice. In terms of commands/tasks, this would mean a
  command/task:
  - SegmentAnatomyTS: with option to output a specific segmentation object
  - SegmentAnatomyMOOSE: with option to output a specific segmentation 
    object
  - SelectSlice: Given a CT scan and a segmentation object, select the 
    middle or other slice

- CT/MRI registration using ANTsPy

- Total Segmentator liver segmentation CT + MRI (Dixon H2O)

- IMAT analysis

  Discuss with Leroy how to detect fat inside muscle (either as SAT or 
  black pixels). If pixels inside muscle are black, what does that mean?
  Can I overlay the mask on top of the image and check the pixel gray
  values and then determine (using the Alberta threshold range) whether
  these pixels are fat or not?

- Calculate muscle PDFF maps from Dixon MRI after registering with CT

# Commands
- numpy2nifti
- createpngsfromdicomfiles
- selectvertebralslice --engine=ts,moose --vertebra=l3,t4 --position=all,top,middle,bottom
- registerl3 --modalities=ct/dixon,ct/t1,ct/t2
- segmentanatomy --engine=ts,moose --masks=all,spine,l3,t4,liver,vessels
- segmentmusclefatl3[tensorflow] --imat=true,false
- calculatepdffmap2d --inphase=/path/to/image --outphase=/path/to/image --water=/path/to/image --mask=/path/to/mask (muscle and fat)
- calculatepdffmap3d --inphase=/path/to/series --outphase=/path/to/series --water=/path/to/series --mask=/path/to/mask (liver)

# Next action
- Implement slice selection with Total Segmentator
langgraph-deploy 0.2.3
Adds a `deploy` subcommand to langgraph CLI to deploy Docker images to Cloud Run.
License: MIT
Requires Python: >=3.10

# langgraph-deploy

A lightweight wrapper that adds a **`langgraph deploy`** subcommand to ship your built Docker image to **Google Cloud Run**.

## Quick start

```bash
# 1) Install alongside langgraph CLI (prefer venv or pipx)
pip install langgraph-cli
pip install langgraph-deploy

# 2) Build your app image as usual
langgraph build -t langgraph-app:latest

# 3) Deploy to Cloud Run
# gloud auth login  # If you are not logged in
langgraph deploy \
  --service my-agent \
  --project my-gcp-project \
  --region asia-northeast1 \
  --allow-unauthenticated
```

If `langgraph deploy` doesn’t find the local image tag, it will run `langgraph build` for you.

## Requirements

- `gcloud` CLI installed and authenticated
- Permission to push to Artifact Registry and deploy Cloud Run (e.g. `roles/run.admin`, `roles/artifactregistry.writer`)
- Docker installed and running

## Config resolution

By default this tool looks for `langgraph.json` and tries to resolve the image tag:

- `--image` flag (highest precedence)
- `LG_IMAGE` env
- first entry of `docker_image_tags` in `langgraph.json`
- fallback: `langgraph-app:latest`

Optional custom keys in `langgraph.json` (not required):

```jsonc
{
  "graphs": {"app": "./src/app.py:graph"},
  "dependencies": ["."],
  "python_version": "3.11",
  "dockerfile_lines": [],

  // used by this wrapper for defaults
  "docker_image_tags": ["langgraph-app:latest"]
}
```

## How it works

This package registers a **`langgraph`** console script that intercepts only the `deploy` subcommand.
For every other subcommand, it delegates to the official CLI by executing `python -m langgraph` (and falls back to the `langgraph` binary if needed).

## Notes & caveats

- Because this wrapper shadows the official entry point, ensure that your PATH resolves this script **before** the official one (e.g. install into an isolated venv and activate it).
- If delegation ever loops (unlikely), we set `LANGGRAPH_DEPLOY_WRAPPER_BYPASS=1` to ensure the official CLI is called directly.
- You can safely uninstall this package to remove the `deploy` subcommand without touching the official CLI.

## Security

- Prefer CI with Workload Identity Federation or service-account impersonation to avoid long-lived credentials.
- Review `--allow-unauthenticated` usage; omit it for private services.

## License

MIT