semvec/pypi-packages huggingface dataset:
gateagent-gateway 0.1.6
Local gateway for collecting and managing agent events with Google Sheets integration
Requires Python: >=3.8
Keywords: agent, gateway, tracking, events, google-sheets, fastapi

# Gateagent

The Gateway for your Agents. It acts as a central hub to monitor, track, and visualize the actions performed by your AI agents.

- **PyPI Package**: [gateagent](https://pypi.org/project/gateagent/)
- **Companion Library**: [agent-revert](https://pypi.org/project/agent-revert/)

## Features

-   **Event Tracking**: Receive and store events from agents using `agent-revert`.
-   **Agent Registry**: Keep track of all registered agents.
-   **Visual Dashboard**: A web-based UI to view agent activities, timelines, and affected applications.
-   **Integrations**: View status of external integrations (e.g., Gsuite, Salesforce).

## Installation

```bash
pip install gateagent
```

## Usage

Start the gateway server:

```bash
gateagent start
```

Visit `http://localhost:5173` (or the configured port) to view the dashboard.

## Connecting Agents

Use the `agent-revert` package in your agent code to send events to this gateway.

```python
from agent_revert import register_agent, track_action

register_agent("MyAgent")

@track_action(agent_name="MyAgent")
def do_work():
    pass
```
antipode 0.1.0
Simultaneous integration, differential expression and clustering of single cell RNAseq data using pyro-powered variational inference.
Requires Python: >=3.10

<h1 style="text-align: center;"> scANTIPODE</h1>
<a href="https://en.wikipedia.org/wiki/Antipodes"> 
<div align="center">
  <img src="assets/antipode_logo_alternate.png" alt="antipode logo!" width="200">
</div>
</a>

**S**ingle **C**ell **A**ncestral **N**ode **T**axonomy **I**nference by **P**artitioning **O**f **D**ifferential **E**xpression. The model is an extension of the SCVI paradigm--a structured generative, variational inference model developed for the simultaneous analysis (DE) and categorization (taxonomy generation) of cell types across evolution (or now any covariate) using single-cell RNA-seq data. Long ago it began as a hack of a simplified model of [scANVI](https://pyro.ai/examples/scanvi.html) and is built on the pytorch-based PPL [pyro](https://pyro.ai/). The model acts as an integration method, that learns interpretable differential expression in the process. Note that this means ANTIPODE will fail to integrate datasets of different datasets, or datasets with large disparities in quality or gene mean dispersions.

The complete procedure runs in 3 phases (but can also run fully supervised using only phase 2):

1. **The Fuzzy Phase:** Cells may belong to multiple types sampled from a bernoulli distribution, learns an integrated latent space with covariate effects, but is less straightforward to interpret.

2. **The Supervised Phase:** Discrete clustering is initialized from a supervised initialization (or defaults to a de novo k-means clustering in the latent space). Can take a supervised clustering and/or latent space for cells.

3. **The Free Phase:** All parameters are released for unconstrained learning.


You can read about the generative model in the publication and supplement [here](https://www.biorxiv.org/content/10.1101/2025.10.18.683238v2). You can look at example runs [here](examples/outputs/).


## Installation
First create a conda environment with python >= 3.10, then
```
To install the package from PyPI:
    pip install antipode


For development, clone the repository and run:
    conda create -n antipode -c rapidsai -c conda-forge -c nvidia  \
        rapids=24.12 python=3.12 'cuda-version>=12.0,<=12.5' \
        'pytorch=*=*cuda*'
    git clone https://github.com/mtvector/scANTIPODE.git
    cd scANTIPODE
    conda install jax jaxlib -c conda-forge
    pip install -e .

Optional phylogeny/analysis features:
    pip install antipode[extras]
```




Please reach out to let me know if you try ANTIPODE on a dataset and it works (or doesn't work)...

Note that the model can be VRAM hungry, with parameters scaling by #covariates x #genes x #clusters|#modules... if you run out of vram, you might need to 1. fix a
GPU memory leak, 2. use fewer genes/latent dimensions/clusters/particles, 3. get a bigger GPU

## Future development
- Phylogeny regression
- Parameter variance estimation
- Improved clustering
directory-file-mapping 0.1.0a0
A simple Python class that lets you treat the files in a directory as a mapping object, like a dict.
Requires Python: >=2

# `directory-file-mapping`

> Ever wanted to treat a directory as a Python dict? Now you can!

A simple Python class that lets you treat the files in a directory as a mapping object, like a dict. Filenames are keys,
and file contents (as bytes) are values. Changes you make to the mapping immediately update the actual files in
the filesystem. Yes, this works for reading, writing, listing, and deleting files, all using familiar mapping syntax!

It seems almost obvious in retrospect, but neither `collections`, `pathlib`, nor anyone in the Python community appears
to have shipped a general dict-like view of a directory. But now you never need to write a kludge of manual
`os.listdir`, `open()`, and `os.remove` loops again.

## Features

- **Mapping interface**: Get, set, iterate keys, and delete by key, just like a dict.
- **Filenames as keys**.
- **File contents as values** (bytes).
- **Acts instantly on the filesystem**: Any change is reflected (and visible to other processes) right away.
- **No caching**: Reads contents on every access, always up to date.

## Install

```bash
pip install directory-file-mapping
```

## Usage

```python
from directory_file_mapping import DirectoryFileMapping

# Initialize mapping to a directory
m = DirectoryFileMapping('/tmp/exampledir')

# Write new file
m['foo.txt'] = b'hello world'

# Read file contents
data = m['foo.txt']  # b'hello world'

# Check existence
if 'bar.txt' in m:
    print(m['bar.txt'])

# List filenames
for name in m:
    print(name)

# Delete a file
del m['foo.txt']
```

## Caveats & Limitations

- This mapping is **volatile**: other processes may add, remove, or change files under your feet.
- File names and contents are not cached.
- This mapping only exposes regular files, not subdirectories or special files.
- It does not filter out unusually named files or tamper with binary vs. text.
- No atomicity guarantees: if your coworker is deleting files while you iterate, expect surprises.

## Contributing

Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.

## License

This project is licensed under the [MIT License](LICENSE).