semvec/pypi-packages huggingface dataset:
superdense-trading 0.0.1
Proprietary quantum-enhanced trading simulator (Python + Rust). Name reserved.
Requires Python: >=3.8
Keywords: quantum, trading, finance, proprietary, rust

# Superdense Trading

**Copyright (c) 2026 Tanishq Jha. All Rights Reserved.**

This package is a proprietary internal tool for quantum-enhanced trading simulation.
The name is reserved on PyPI for internal dependency management.

There is no public code available in this distribution.
public-data-extractor-for-meetup-com 0.2.1
Public Data Extractor for meetup.com
Requires Python: >=3.10

# Public Data Extractor for Meetup.com

Do you organise an event on meetup.com? Would you like basic details of the event to be available as Open Data for reuse elsewhere?

(Public details only - this does NOT extract any information about the people attending your events.)

This is an unofficial tool not endorsed by Meetup.com - use at your own risk!

## Install

```commandline
pip install public-data-extractor-for-meetup-com
```

## Configure

Log into https://www.meetup.com/ and go to "View Profile".
You'll be at a URL like: https://www.meetup.com/members/123456789/
That number is your member ID.
Set it as the environmental Variable `MEETUP_COM_AUTHORIZED_MEMBER_ID`

Go to https://www.meetup.com/graphql/oauth/list/ and create a new API client.

Set the Client Key as the environmental Variable `MEETUP_COM_YOUR_CLIENT_KEY`

Create a new signing key for the client (Make sure you save the private certificate as you won't see it again!)
Set it as the environmental Variable `MEETUP_COM_PRIVATE_SIGNING_KEY`

## Run

Run:

```commandline
python -m publicdataextractorformeetupcom extractgroup your_group_slug output_directory
```

The output directory will then hold files with public information that you can publish.

## Run & Host on GitHub

You can run this automatically and host it on GitHub.

Make a new public GitHub repository, selecting the "Add Readme" option.

In settings, Secrets and Variables, Actions, add the following repository secrets:

* MEETUP_COM_AUTHORIZED_MEMBER_ID
* MEETUP_COM_YOUR_CLIENT_KEY
* MEETUP_COM_PRIVATE_SIGNING_KEY

The values should be as described in the "Configure" section above.

In settings, Secrets and Variables, Actions, add the following repository variables:

* MEETUP_COM_GROUP_URL_NAME - The group you want to import, from the https://www.meetup.com/group_name/ URL. Just the `group_name` part.

Go to Settings, GitHub pages and change the source to "GitHub Actions".

Create a file `.github/workflows/build.yml` and copy the contents of the `github_workflow.yml` file into it. Commit this file and push it to GitHub.

Go to Actions in the repository, and make sure the first run finishes successfully. It can take a few minutes for it to actually start.

You should now be able to view `out.json` on your GitHub pages URL. (Go back to Settings, GitHub pages to find the URL.)

## For Developers

The GraphQL Playground at https://www.meetup.com/graphql/playground/#graphQl-playground is very handy to explore.
dark-matter 7.1.12
Python library and utility scripts for working with genetic sequence data.
Requires Python: <3.14,>=3.10

[![PyPI](https://img.shields.io/pypi/v/dark-matter.svg)](https://pypi.org/project/dark-matter/)
[![Python Version](https://img.shields.io/pypi/pyversions/dark-matter.svg)](https://pypi.org/project/dark-matter/)
[![Downloads](https://img.shields.io/pypi/dm/dark-matter.svg)](https://pypi.org/project/dark-matter/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Build Status](https://app.travis-ci.com/acorg/dark-matter.svg?branch=master)](https://app.travis-ci.com/acorg/dark-matter)

## Dark matter

A collection of Python tools for filtering and visualizing
[Next Generation Sequencing](https://en.wikipedia.org/wiki/DNA_sequencing#Next-generation_methods)
reads.

## Installation

On Linux (at least) you will need to first:

```sh
sudo apt install zlib1g-dev libbz2-dev liblzma-dev
```

Then you should be able to install via

```sh
$ pip install dark-matter
```

Some additional information is available for
[Linux](doc/linux.md), [OS X](doc/mac.md), and [Windows](doc/windows.md).

## Optional dependencies

Not all of the following are mandatory. It depends which part of the
dark-matter code you try to use.

### Picard

`run-bowtie2.py` can use [Picard](https://broadinstitute.github.io/picard/)
to mark duplicates.

### GATK

`run-bowtie2.py` uses [gatk](https://gatk.broadinstitute.org) if you call
it with `--markDuplicatesGATK` or `--callHaplotypesGATK`. If you want to do
this you'll need to download the `gatk` zip file, unzip it, and either put
the directory where you unzip it into your shell's path or else move the
contents of the zip file into a directory already in your path.

### bcftools

You'll need
[bcftools](http://samtools.github.io/bcftools/howtos/index.html) if you
want to make consensuses using the `make-consensus.py` script. Either
follow
[the installation instructions](http://samtools.github.io/bcftools/howtos/install.html)
or, if you use [brew](https://brew.sh/) (or Linux brew), `brew install bcftools`.

### samtools

The `run-bowtie2.py` and `run-bwa.py` scripts both make use of
[samtools](https://www.htslib.org/).

### EMBOSS

The `compare-sequences.py` script (if called with `--align`) requires the
`needle` and (possibly) `stretcher` from
[EMBOSS](http://emboss.sourceforge.net/).

### iPython Notebook

If you are using dark matter in an
[iPython Notebook](https://ipython.org/notebook.html), you should install
the requirements in `requirements-ipynb.txt`.

## Development

If you are using dark matter as a developer, you should install the
requirements in `requirements-dev.txt`.
iflow-mcp_unionai-oss-union-mcp 0.1.2
An MCP server to connect to Union resources and services.
Requires Python: <3.13,>=3.11

# Union MCP

An MCP server to use Union tasks, workflows, and apps as tools.

## Deployment Guides

Union MCP supports both Union v1 and v2. The following guides provide instructions
for deploying the MCP server for each version:

- [Union v1 MCP deployment](./guides/deployment_v1.md)
- [Union v2 MCP deployment](./guides/deployment_v2.md)
tracked-dict 0.1.0
Dict/list wrappers that track key access for reporting unconsumed data
Requires Python: >=3.10

# tracked-dict

Dict and list wrappers that track key access for reporting unconsumed data.

Wrap a parsed JSON/YAML/TOML structure in `TrackedDict`, read what you need
through normal dict access, then call `unaccessed()` to get dotted paths for
every key that was never touched.

## Install

```bash
pip install tracked-dict
```

## Usage

```python
import json
from tracked_dict import TrackedDict

with open("config.json") as f:
    data = TrackedDict(json.load(f))

name = data["project"]["name"]
version = data["project"]["version"]

for path in data.unaccessed():
    print(f"  unhandled: {path}")
```

## API

### `TrackedDict(data: dict, _path: str = "")`

- `d[key]` / `d.get(key, default)` — read access; marks `key` as accessed
- `key in d`, `len(d)`, `bool(d)`, `iter(d)` — standard container ops (do **not** mark accessed)
- `d.keys()` — returns keys (does **not** mark accessed)
- `d.values()` / `d.items()` — iterate with wrapping; marks all keys accessed
- `d.raw` — the underlying plain `dict`
- `d.mark_accessed(*keys)` — explicitly mark keys
- `d.mark_all_accessed()` — mark every key at this level
- `d.unaccessed()` — sorted list of dotted paths for all unaccessed keys, recursively
- `d.accessed_keys()` — set of keys accessed at this level

Nested dicts are automatically wrapped in `TrackedDict`, nested lists in `TrackedList`.

### `TrackedList(data: list, _path: str = "")`

- `lst[i]`, `len(lst)`, `bool(lst)`, `iter(lst)` — standard access
- `lst.raw` — the underlying plain `list`
- `lst.unaccessed()` — collects unaccessed paths from wrapped children

## How it works

When you access a key via `[]` or `.get()`, `TrackedDict` records that key.
Nested dicts and lists are lazily wrapped on first access so their keys are
tracked too. After your parser finishes, `unaccessed()` walks the tree and
returns dotted paths (e.g. `"server.timeout"`, `"users[0].email"`) for
anything never read.

This catches both parser omissions (data present but ignored) and unknown
user-supplied fields — without maintaining a separate list of expected keys.

## License

MIT