semvec/pypi-packages huggingface dataset:
amsc 0.0.1
American Science Cloud
Requires Python: <4.0,>=3.10
Keywords: python

# amsc

[![Release](https://img.shields.io/github/v/release/saforem2/amsc)](https://img.shields.io/github/v/release/saforem2/amsc)
[![Build status](https://img.shields.io/github/actions/workflow/status/saforem2/amsc/main.yml?branch=main)](https://github.com/saforem2/amsc/actions/workflows/main.yml?query=branch%3Amain)
[![codecov](https://codecov.io/gh/saforem2/amsc/branch/main/graph/badge.svg)](https://codecov.io/gh/saforem2/amsc)
[![Commit activity](https://img.shields.io/github/commit-activity/m/saforem2/amsc)](https://img.shields.io/github/commit-activity/m/saforem2/amsc)
[![License](https://img.shields.io/github/license/saforem2/amsc)](https://img.shields.io/github/license/saforem2/amsc)

American Science Cloud

- **Github repository**: <https://github.com/saforem2/amsc/>
- **Documentation** <https://saforem2.github.io/amsc/>

## Getting started with your project

### 1. Create a New Repository

First, create a repository on GitHub with the same name as this project, and then run the following commands:

```bash
git init -b main
git add .
git commit -m "init commit"
git remote add origin git@github.com:saforem2/amsc.git
git push -u origin main
```

### 2. Set Up Your Development Environment

Then, install the environment and the pre-commit hooks with

```bash
make install
```

This will also generate your `uv.lock` file

### 3. Run the pre-commit hooks

Initially, the CI/CD pipeline might be failing due to formatting issues. To resolve those run:

```bash
uv run pre-commit run -a
```

### 4. Commit the changes

Lastly, commit the changes made by the two steps above to your repository.

```bash
git add .
git commit -m 'Fix formatting issues'
git push origin main
```

You are now ready to start development on your project!
The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.

To finalize the set-up for publishing to PyPI, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/publishing/#set-up-for-pypi).
For activating the automatic documentation with MkDocs, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/mkdocs/#enabling-the-documentation-on-github).
To enable the code coverage reports, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/codecov/).

## Releasing a new version

- Create an API Token on [PyPI](https://pypi.org/).
- Add the API Token to your projects secrets with the name `PYPI_TOKEN` by visiting [this page](https://github.com/saforem2/amsc/settings/secrets/actions/new).
- Create a [new release](https://github.com/saforem2/amsc/releases/new) on Github.
- Create a new tag in the form `*.*.*`.

For more details, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/cicd/#how-to-trigger-a-release).

---

Repository initiated with [fpgmaas/cookiecutter-uv](https://github.com/fpgmaas/cookiecutter-uv).
swgo-bali 0.2.0
Python bindings for the SWGO Background Library
Requires Python: >=3.9

# Python Bindings for the SWGO Background Library

This are the Python bindings for the SWGO Background Library.
The bindings can be installed with pip:
```
pip install swgo-bali
```
To access the the Background interface, import `libbackground` and create an instance:
```python
import libbackground as libbg

bg = libbg.Background("<path to settings>")
```
The documentation can be accessed with `help(libbg.Background)`.

The photo electron lists generated by `Background.next_chunk()` are C++ objects, but behave like nested python lists:
```python
for channel_id, pe_times in bg.next_chunk(1e-9):
    # channel_id = int
    for time in pe_times:
        # time = float
        ...
```
The full documentation of the SWGO Background Library can be found [here](https://swgo-background-library-6e5922.gitlab.io/).
email-function-whl 1.0.0
Simple email API client and utility functions for Fabric Notebook team
Requires Python: >=3.8

# email-sender

A lightweight internal Python library that provides reusable email-sending utilities for the Fabric Notebook team.

This package is designed to be published as a wheel (.whl) and consumed across internal services.

---

## Features

- Send emails via a simple POST API
- Supports multiple recipients
- Handles 200, 201, 202 as successful response codes
- Minimal dependencies (only `requests`)
- Easy to integrate in notebooks, scripts, or internal pipelines

---

## Installation

Install the wheel file:

```bash
pip install email_sender-0.1.0-py3-none-any.whl

# Creating the wheel file
pip install build       # Install the build tool
python -m build         # Build the .whl file

"""
Usage:
from email_sender import send_email_no_attachment

status, response = send_email_no_attachment(
    {
        "to": ["user1@domain.com", "user2@domain.com"],
        "subject": "Team Update",
        "body": "Hello team!"
    },
    endpoint_url="https://your-mail-endpoint",
    access_token="YOUR_ACCESS_TOKEN"
)

print(status, response)
"""
ag-ui-crewai 0.1.5
Implementation of the AG-UI protocol for CrewAI
Requires Python: <3.14,>=3.10

# ag-ui-crewai

Implementation of the AG-UI protocol for CrewAI.

Provides a complete Python integration for CrewAI flows and crews with the AG-UI protocol, including FastAPI endpoint creation and comprehensive event streaming.

## Installation

```bash
pip install ag-ui-crewai
```

## Usage

```python
from crewai.flow.flow import Flow, start
from litellm import completion
from ag_ui_crewai import (
    add_crewai_flow_fastapi_endpoint,
    copilotkit_stream,
    CopilotKitState
)
from fastapi import FastAPI

class MyFlow(Flow[CopilotKitState]):
    @start()
    async def chat(self):
        response = await copilotkit_stream(
            completion(
                model="openai/gpt-4o",
                messages=[
                    {"role": "system", "content": "You are a helpful assistant."},
                    *self.state.messages
                ],
                tools=self.state.copilotkit.actions,
                stream=True
            )
        )
        self.state.messages.append(response.choices[0].message)

# Add to FastAPI
app = FastAPI()
add_crewai_flow_fastapi_endpoint(app, MyFlow(), "/flow")
```

## Features

- **Native CrewAI integration** – Direct support for CrewAI flows, crews, and multi-agent systems
- **FastAPI endpoint creation** – Automatic HTTP endpoint generation with proper event streaming
- **Predictive state updates** – Real-time state synchronization between backend and frontend
- **Streaming tool calls** – Live streaming of LLM responses and tool execution to the UI

## To run the dojo examples

```bash
cd python/ag_ui_crewai
poetry install
poetry run dev
```
atlus 1.0.1
Translate raw address strings into the OSM tagging scheme.
Requires Python: >=3.10
Keywords: address, geocoding, mapping, openstreetmap, osm

# Atlus

![GitHub License](https://img.shields.io/github/license/whubsch/atlus)
![GitHub last commit](https://img.shields.io/github/last-commit/whubsch/atlus)
![PyPI - Version](https://img.shields.io/pypi/v/atlus)
![Pepy Total Downlods](https://img.shields.io/pepy/dt/atlus)

This Python project translates raw address strings into the OpenStreetMap (OSM) tagging scheme. The package only supports US (and to some extent Canadian) addresses. You can try out the package without installing it at [the Atlus website](https://atlus.dev).

> [!NOTE]
> Use of this package does not absolve you from following OSM's [import guidelines](https://wiki.openstreetmap.org/wiki/Import/Guidelines).

## Table of Contents

- [Features](#features)
- [Usage](#usage)
- [Docs](#docs)
- [License](#license)

## Features

- Expand common street and name abbreviations.
- Parse address parts correctly and reliably.
- Get rid of address junk that is not needed for OpenStreetMap tagging.
- Parse US and Canadian phone numbers into the standard format.

## Usage

This package is meant to work with GeoJSON files containing raw address data, including those produced by the [All the Places](https://alltheplaces.xyz) project or [Overture maps](https://wiki.openstreetmap.org/wiki/Overture).

```console
pip install atlus
```

```python
>>> import atlus
>>> atlus.abbrs("St. Francis")
"Saint Francis"
>>> atlus.get_address("789 Oak Dr, Smallville California, 98765")[0]
{"addr:housenumber": "789", "addr:street": "Oak Drive", "addr:city": "Smallville", "addr:state": "CA", "addr:postcode": "98765"}
>>> atlus.get_phone("(202) 900-9019")
"+1-202-900-9019"
```

## Docs

The documentation for our package is available online at our [documentation page](https://whubsch.github.io/atlus/index.html). We would greatly appreciate your contributions to help improve the auto-generated docs; please submit any updates or corrections via pull requests.

## License

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

## See also

- [OpenStreetMap](https://www.openstreetmap.org/)
- [Atlus](https://wiki.openstreetmap.org/wiki/atlus)
- [All the Places](https://wiki.openstreetmap.org/wiki/All_the_Places)
uniprot-redis 1.8.3
Add your description here
Requires Python: >=3.12

The aim of uniprot-redis is to have a rapid access to uniprot data previously stored in redis instance, and querying them by uniprot protein ids. 

## Start and query uniprot-redis in a python environment with poetry

### 1. Install and start redis

Install redis following the website instruction : https://redis.io/docs/getting-started/

Then run a redis instance (it needs to run constantly so we recommand to use `screen` or equivalent)
```
screen -S redis
redis-server
```
then `ctrl + A + D` to quit the screen. `screen -r redis` if you want to go back to it. 

Be aware that it will created a local "save file" of the instance (dump.rdb) in the directory you launch the command. You will need to launch redis-server in the directory where dump.rdb is stored if you want to retrieve the data later. 

### 2. Install uniprot-redis
uniprot-redis is available as a pip package
``` 
pip install uniprot-redis
```

### 3. Run uniprot-redis and store informations 
You need to store into redis the proteins you want to. uniprot-redis can load xml proteome file downloadable here : https://www.uniprot.org/proteomes?query=* 

Choose your organisms of interest. For example if you want to have access to all human proteins you will need to download UP000005640 proteome file (https://www.uniprot.org/proteomes/UP000005640)
Download => Download all => Format : XML => Download

* Load a proteome into uniprot-redis

1. Through python
```python
from uniprot_redis.store import UniprotStore
store = UniprotStore()
protein_collection = store.load_uniprot_xml(file=<xml file>)
# You can identify this protein collection by keyword in order to retrieve it later
store.save_collection('my_id', protein_collection)
# List all collections
store.list_collection()
```

### 4. Interrogate uniprot-redis

You can now have an easy access to all stored protein through python code

```python
# Access a protein through its uniprot id
store.get_protein('<uniprot id>')
# Iterator through a collection
store.get_protein_collection('<collection id>')
# Iterator through all proteins stored in the database
store.proteins
```

#### 5. Uniprot store gestion

```python
# Wipe all database
store.wipe_all()
# Delete a collection 
store.delete_collection('<collection id>')
```

See [notebooks/uniprot_redis_demo.ipynb](notebooks/uniprot_redis_demo.ipynb) for usage examples