semvec/pypi-packages huggingface dataset:
anyio-typer 0.2.0
Combines anyio and typer together for writing asynchronous commandlines
Requires Python: >=3.10

# AnyioTyper
Wraps In Typer with Anyio, unlike `Async-Typer` AnyioTyper's goal is to allow customization 
with different eventloops 

```python
from anyio_typer import AnyioTyper, Option
from typing import Annotated
app = AnyioTyper()

# This example uses a library called cyares you can install it with `pip install cyares`

# NOTE: winloop is supported by default if your on a windows operating system
@app.uvloop_command()
async def uvloop(
    host:str,
    rt:Annotated[str, Option(help="A Type of record to uncover", show_default=True)] = "A" 
    ):
    """Use Uvloop or Winloop for DNS Resolving"""
    
    from cyares.aio import DNSResolver

    async with DNSResolver(["8.8.8.8", "8.8.4.4"]) as resolver:
        result = await resolver.query(host, rt)
    print(result)

@app.trio_command()
async def trio(
    host:str,
    rt:Annotated[str, Option(help="A Type of record to uncover", show_default=True)] = "A" 
    ):
    """Use Trio for DNS Resolving"""
    from cyares.trio import DNSResolver

    async with DNSResolver(["8.8.8.8", "8.8.4.4"]) as resolver:
        result = await resolver.query(host, rt)
    print(result)


if __name__ == "__main__":
    app()
```
emcenvchainer 0.3.2
A TUI utility for creating test installations using Spack environment chaining
Requires Python: >=3.8
Keywords: spack, hpc, scientific-computing

# EMCEnvChainer

![unit tests](https://github.com/AlexanderRichert-NOAA/EMCEnvChainer/actions/workflows/unit-tests.yml/badge.svg)

The EMCEnvChainer utility allows NOAA developers to build their own copies of packages (i.e., model app dependencies) on top of existing spack-stack installations. It does so using Spack's environment chaining feature. Only the specifically requested package(s) and corresponding dependents need to be rebuilt, therefore as much of the existing installation as possible is reused, thereby reducing overall installation time and minimizing configuration differences (versions, build options) between the base and user software stacks.

The utility will automatically identify which platform (RDHPCS systems + Acorn) it is running on, and identify available base spack-stack installations, including the ones associated with the UFS Weather Model head of develop.

## Installation & usage

To use the utility, install it, invoke the `emcenvchainer` command, and follow the prompts:
```console
pip3 install emcenvchainer
emcenvchainer
```
After the installation is complete, instructions are provided for accessing the hybrid (base+user) stack. In short, Lmod module files and spack-stack metamodules for accessing the base and user packages are installed in a single location in the user's space (i.e., `$MODULEPATH` should not include the original spack-stack installation, only the one associated with the user's newly built spack-stack environment).

> [!NOTE]
> This utility relies on Spack's built-in environment chaining capabilities. The ability to chain environments with Spack/spack-stack in some circumstances depends on using the same Python version/installation as the one that generated the main spack-stack installation. The Python versions/installations used to install each spack-stack environment on each platform are not particularly well documented or necessarily consistent. If you find in the concretization output that Spack does not reuse existing packages from the base installation in cases where it should (`[^]` in the concretization output indicates successful reuse of a package from the upstream/base installation), please reach out to the spack-stack maintainers for your HPC platform (typically EPIC; see https://spack-stack.readthedocs.io/en/latest/PreConfiguredSites.html) or create a spack-stack issue: https://github.com/JCSDA/spack-stack/issues/new/choose.

To override the automatic platform detection, export the SITE_OVERRIDE environment variable:
```console
SITE_OVERRIDE=ursa emcenvchainer
```

> [!IMPORTANT]
> xterm support must be enabled (such as for PuTTY, Tectia/sshg3, SecureCRT) or the utility will immediately fail with an error.
mapflpy 1.1.8
Fast field line tracing for spherical vector fields
Requires Python: >=3.10
Keywords: solar physics, space physics, heliophysics, magnetohydrodynamic, science, mas, predsci, psi, modeling, fortran

.. |psi| image:: https://predsci.com/doc/assets/static/psi_logo.png
   :target: https://predsci.com
   :alt: Predictive Science Inc.
   :width: 20px

.. |pypi| image:: https://img.shields.io/pypi/v/mapflpy?logo=pypi&logoColor=white
   :target: https://pypi.org/project/mapflpy
   :alt: PyPI

.. |license| image:: https://img.shields.io/pypi/l/mapflpy?logo=apache&logoColor=white
   :target: https://opensource.org/license/apache-2-0/
   :alt: License

.. |pyversions| image:: https://img.shields.io/pypi/pyversions/mapflpy.svg?logo=python&label=python&logoColor=white
   :target: https://pypi.org/project/mapflpy
   :alt: Python Versions

.. |deps| image:: https://img.shields.io/librariesio/github/predsci/mapflpy?logo=Libraries.io&logoColor=white
   :target: https://github.com/predsci/mapflpy/blob/main/pyproject.toml
   :alt: Libraries.io

.. |publish| image:: https://github.com/predsci/mapflpy/actions/workflows/publish.yml/badge.svg?
   :target: https://github.com/predsci/mapflpy/actions/workflows/publish.yml
   :alt: Publish workflow

.. |docs| image:: https://github.com/predsci/mapflpy/actions/workflows/docs.yml/badge.svg?
   :target: https://predsci.com/doc/mapflpy
   :alt: Docs workflow

|pypi|
|license|
|pyversions|
|deps|
|publish|
|docs|

|psi| **MAPFLPY** | *field line tracing for spherical vector fields*
--------------------------------------------------------------------

**mapflpy** is a python package for tracing field lines using the
`MapFL <https://github.com/predsci/MapFL>`_ Fortran tracer developed by
Predictive Science Inc.

The goal of **mapflpy** is to provide fast and accurate tracing capabilities for
spherical vector fields inside a convenient Python interface. **mapflpy** is
designed to work natively with the staggered meshes produced by Predictive Science
Inc.'s codes for simulating the solar corona, and inner heliosphere (*e.g.*
`MAS <https://www.predsci.com/mas>`_ or `POT3D <https://github.com/predsci/POT3D>`_),
but it should be generally compatible with any global vector field that can be
described on a rectilinear grid in spherical coordinates.

To get started with **mapflpy**, visit the
`User Guide <https://predsci.com/doc/mapflpy/guide/>`_ for installation instructions,
an overview of features, and development/contribution guidelines; a gallery of
`examples <https://predsci.com/doc/mapflpy/gallery/>`_ is also available, showcasing
various use cases and functionalities of the package. Please direct any questions or
issues to the `issue tracker <https://github.com/predsci/mapflpy/issues>`_,
or `contact <https://www.predsci.com/portal/contact.php>`_ Predictive Science Inc. directly.

----

`Predictive Science Inc. <https://predsci.com>`_ |
`Repository <https://github.com/predsci/mapflpy>`_ |
`Documentation <https://predsci.com/doc/mapflpy>`_ |
`Distribution <https://pypi.org/project/mapflpy>`_
sieve-mcp 0.1.2
From company name to investment decision. Sieve scores startups across 7 dimensions so you know who's worth a meeting.
Requires Python: >=3.10
Keywords: ai, due-diligence, mcp, sieve, startup, vc, venture-capital

[![PyPI version](https://badge.fury.io/py/sieve-mcp.svg)](https://pypi.org/project/sieve-mcp/)
[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-green.svg)](https://modelcontextprotocol.io)

# Sieve MCP Server

From company name to investment decision. Sieve scores startups across 7 dimensions so you know who's worth a meeting.

An [MCP](https://modelcontextprotocol.io) server that brings AI-powered startup due diligence into Claude, Cursor, Windsurf, and any MCP-compatible assistant. Screen any startup, get a quantified Sieve Score (0-140), and a clear Take Meeting / Pass recommendation.

## Quick Start

### Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "sieve": {
      "command": "uvx",
      "args": ["sieve-mcp"],
      "env": {
        "SIEVE_API_KEY": "your-api-key"
      }
    }
  }
}
```

### Claude Code

```bash
claude mcp add sieve -- uvx sieve-mcp
```

Then set your API key in the environment:

```bash
export SIEVE_API_KEY="your-api-key"
```

### Cursor / Windsurf

Add to your MCP settings:

```json
{
  "mcpServers": {
    "sieve": {
      "command": "uvx",
      "args": ["sieve-mcp"],
      "env": {
        "SIEVE_API_KEY": "your-api-key"
      }
    }
  }
}
```

## Environment Variables

| Variable | Required | Default | Description |
|----------|----------|---------|-------------|
| `SIEVE_API_KEY` | Yes | — | Your Sieve API key. Get one at [app.sieve.arceusxventures.com/settings](https://app.sieve.arceusxventures.com/settings) |
| `SIEVE_API_URL` | No | `https://api.sieve.arceusxventures.com` | API base URL (override for self-hosted) |

## Available Tools

| Tool | Description | Read-only |
|------|-------------|-----------|
| `sieve_screen` | Run a Quick Screen on a startup | No |
| `sieve_status` | Check analysis progress | Yes |
| `sieve_summary` | Get full results of a completed analysis | Yes |
| `sieve_usage` | Check API usage for current billing period | Yes |

## Example Usage

A typical workflow in any MCP-compatible AI assistant:

1. **Screen a startup:**
   > "Run a Sieve screen on Acme Corp at acme.com"

2. **Poll for progress** (analysis takes 2-5 minutes):
   > "Check the status of that Sieve analysis"

3. **Get results:**
   > "Show me the Sieve summary for that analysis"

4. **Check usage:**
   > "How many Sieve screens do I have left this month?"

## Running with Docker

```bash
docker build -t sieve-mcp .
docker run -p 8080:8080 -e SIEVE_API_KEY=your-key sieve-mcp
```

## Development

```bash
# Install locally
pip install -e .

# Run in stdio mode (for MCP clients)
sieve-mcp

# Run in HTTP mode (for remote/container deployment)
sieve-mcp http
```

## License

MIT
poetry-azure-artifacts-plugin 0.2.0
Poetry plugin to handle Azure Artifacts authentication
Requires Python: >=3.10

# Poetry Azure Artifacts Plugin

[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
[![GitHub license](https://img.shields.io/github/license/NathanVaughn/poetry-azure-artifacts-plugin)](https://github.com/NathanVaughn/poetry-azure-artifacts-plugin/blob/main/LICENSE)
[![PyPi versions](https://img.shields.io/pypi/pyversions/poetry-azure-artifacts-plugin)](https://pypi.org/project/poetry-azure-artifacts-plugin)
[![PyPi downloads](https://img.shields.io/pypi/dm/poetry-azure-artifacts-plugin)](https://pypi.org/project/poetry-azure-artifacts-plugin)

---

This is a [Poetry](https://python-poetry.org/) plugin that transparently takes
care of authentication with Azure Artifacts feeds. This is heavily based on
[semgrep/poetry-codeartifact-plugin](https://github.com/semgrep/poetry-codeartifact-plugin).

## Usage

This plugin requires Python 3.9+ which is a bit less lenient than Poetry itself.

Install this plugin with

```bash
poetry self add poetry-azure-artifacts-plugin
```

or

```bash
pipx inject poetry poetry-azure-artifacts-plugin
```

In your `pyproject.toml` file, add your Azure Artifacts feed URL as a source.

```toml
[[tool.poetry.source]]
name = "ado"
url  = "https://pkgs.dev.azure.com/{organization}/_packaging/{feed}/pypi/simple/"
priority = "primary"
```

Now, when running `poetry install`, or `poetry lock`, Poetry will automatically
fetch credentials for your Azure Artifacts feed, utilizing
[artifacts-keyring](https://github.com/microsoft/artifacts-keyring).
Note: `artifacts-keyring` requires `dotnet` to be installed and available
in your PATH.

This works by recognizing authentication failures to URLs containing
`pkgs.dev.azure.com` or `pkgs.visualstudio.com`. If you have an on-premises
Azure DevOps server that works with `artifacts-keyring`, instead make the
source name include the text `azure-artifacts`:

```toml
[[tool.poetry.source]]
name = "azure-artifacts-feed"
url  = "https://devops.mydomain.com/{organization}/_packaging/{feed}/pypi/simple/"
priority = "primary"
```

## Development

Use the provided [devcontainer](https://containers.dev/)
or run the following for local development:

```bash
# Install uv
# https://docs.astral.sh/uv/getting-started/installation/
uv tool install vscode-task-runner
vtr install
```
kraken-ai 0.0.2
AI agent harness platform
Requires Python: >=3.12
Keywords: ai, agents, orchestration, llm, mcp, guardrails, observability, platform

# Kraken AI

The Python SDK for Kraken OS, an AI agent harness platform.

Kraken OS provides the infrastructure layer for deploying, securing, observing, and governing AI agents in production. The SDK gives developers the tools to define agents, connect data sources, and integrate with the platform.

This package is in active development and will be available soon.

## License

Apache 2.0