semvec/pypi-packages huggingface dataset:
daily-mantra 0.1.0
A CLI tool that displays Hindu mantras and shlokas, rotating by day-of-week to deity
Requires Python: >=3.9
Keywords: mantra, hindu, shloka, cli, dharma, sanskrit

# daily-mantra

A CLI tool that displays Hindu mantras and shlokas, rotating by day-of-week to deity, with colorful terminal output.

## Install

### pip (Python)

```bash
pip install daily-mantra
```

### npm (Node.js)

```bash
npm install -g daily-mantra
```

## Usage

```bash
# Show today's verse (deity based on day of week)
daily-mantra

# Show today's verse with English translation
daily-mantra --translate

# Show a verse for a specific deity
daily-mantra --deity shiva
daily-mantra --deity krishna --translate

# Filter by source text
daily-mantra --source gita
daily-mantra --source chalisa --translate

# List all available deities
daily-mantra --list-deities
```

## Day-to-Deity Schedule

| Day       | Deity(s)                        |
|-----------|---------------------------------|
| Monday    | Shiva                           |
| Tuesday   | Hanuman                         |
| Wednesday | Ganesha, Vitthala               |
| Thursday  | Vishnu, Sai Baba, Krishna       |
| Friday    | Lakshmi, Santoshi Mata          |
| Saturday  | Hanuman, Shani                  |
| Sunday    | Surya                           |

## Deities & Verse Counts

| Slug           | Name            | Verses |
|----------------|-----------------|--------|
| shiva          | Lord Shiva      | 6      |
| hanuman        | Lord Hanuman    | 7      |
| ganesha        | Lord Ganesha    | 5      |
| vitthala       | Lord Vitthala   | 2      |
| vishnu         | Lord Vishnu     | 6      |
| sai_baba       | Shri Sai Baba   | 3      |
| krishna        | Lord Krishna    | 3      |
| lakshmi        | Goddess Lakshmi | 4      |
| santoshi_mata  | Santoshi Mata   | 2      |
| shani          | Lord Shani      | 3      |
| surya          | Lord Surya      | 5      |
agentic-brain 0.2.0
Portable binary graph memory for AI agents
Requires Python: >=3.10
Keywords: agent, ai, graph, llm, memory

# AgenticMemory Python SDK

Python SDK for AgenticMemory — portable binary graph memory for AI agents.

## Install

```bash
pip install agentic-brain
```

### With LLM integrations

```bash
pip install agentic-brain[anthropic]   # Claude
pip install agentic-brain[openai]      # GPT
pip install agentic-brain[ollama]      # Local models
pip install agentic-brain[all]         # All providers
```

## Quick Start

```python
from agentic_memory import Brain

brain = Brain("my_agent.amem")
brain.add_fact("User is a Python developer", session=1)
brain.add_decision("Recommended FastAPI for REST APIs", session=1)

print(brain.facts())
print(brain.info())
```

## With LLM Integration

```python
from agentic_memory import Brain, MemoryAgent
from agentic_memory.integrations import AnthropicProvider

brain = Brain("my_agent.amem")
agent = MemoryAgent(brain, AnthropicProvider())

response = agent.chat("My name is Alice. I work on ML systems.", session=1)
response = agent.chat("What do I work on?", session=2)
```

## Requirements

- Python >= 3.10
- `amem` binary (Rust core engine) — install via `cargo install amem`

## Documentation

- [API Reference](../docs/api-reference.md)
- [Integration Guide](../docs/integration-guide.md)
- [Full README](../README.md)

## License

MIT
mergeron 2026.739659.5
Python for analyzing merger enforcement policy
Requires Python: <4.0,>=3.12
Keywords: merger enforcement policy, merger guidelines, merger screening, enforcement presumptions, concentration standards, diversion ratio, upward pricing pressure, GUPPI

mergeron: Python for analyzing merger enforcement policy
========================================================


.. image:: https://img.shields.io/pypi/v/mergeron
   :alt: PyPI - Package Version
   :target: https://pypi.python.org/pypi/mergeron/
.. image:: https://img.shields.io/pypi/pyversions/mergeron
   :alt: PyPI - Python Version
   :target: https://pypi.python.org/pypi/mergeron/
.. image:: https://img.shields.io/pypi/status/mergeron
   :alt: PyPI - Package status
   :target: https://pypi.python.org/pypi/mergeron/
.. image:: https://github.com/capeconomics/mergeron/actions/workflows/documentation.yml/badge.svg
   :alt: documentation
   :target: https://github.com/capeconomics/mergeron/actions/workflows/documentation.yml
.. image:: https://github.com/capeconomics/mergeron/actions/workflows/packaging.yml/badge.svg
    :alt: CI
    :target: https://github.com/capeconomics/mergeron/actions/workflows/packaging.yml

|

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json
   :target: https://github.com/astral-sh/uv
.. image:: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
   :target: https://python-poetry.org/
.. image:: https://www.mypy-lang.org/static/mypy_badge.svg
   :target: https://mypy-lang.org/
.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
   :target: https://github.com/astral-sh/ruff/
.. image:: https://img.shields.io/badge/License-MIT-yellow
   :alt: License: MIT
   :target: https://opensource.org/licenses/MIT/


*Visualize* the sets of mergers falling within specified concentration and diversion-ratio thresholds.  *Analyze* merger investigations data published by the U.S. Federal Trade Commission in various reports on extended merger investigations (Second Requests) during 1996 to 2011.
*Generate* data under specified distributions of firm counts, market shares, price-cost margins, and prices, optionally imposing equilibrium conditions for Bertrand oligopoly with MNL demand and restrictions implied by statutory filing thresholds. *Compute* intrinsic enforcement rates or intrinsic clearance rates using generated data, with bounds for
concentration;
diversion ratio;
gross upward pricing pressure (GUPPI);
critical marginal cost reduction (CMCR); and
illustrative price rise (IPR).

Installation
------------

To install the package, use the following shell command:

.. code:: bash

    pip install mergeron


Documentation
-------------

Usage guide and API reference are `available <https://capeconomics.github.io/mergeron/>`_.
afm-langchain 0.1.3
AFM LangChain execution backend
Requires Python: >=3.11

# AFM LangChain Backend

[![PyPI version](https://img.shields.io/pypi/v/afm-langchain.svg)](https://pypi.org/project/afm-langchain/)
[![Python version](https://img.shields.io/pypi/pyversions/afm-langchain.svg)](https://pypi.org/project/afm-langchain/)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

LangChain execution backend for [Agent-Flavored Markdown (AFM)](https://github.com/wso2/agent-flavored-markdown) agents.

This package implements the `AgentRunner` protocol from `afm-core`, providing LLM orchestration using the LangChain framework.

## Features

- **AgentRunner Protocol Implementation**: Pluggable backend for AFM agents
- **LLM Provider Support**: OpenAI and Anthropic models
- **MCP Tool Integration**: Connect external tools via Model Context Protocol
- **Conversation Management**: Session history and state management
- **Plugin Registration**: Auto-discovered via Python entry points

## Installation

This package is typically installed as part of `afm-cli`. For LangChain-specific use:

```bash
pip install afm-langchain
```

## Supported Providers

### OpenAI

```yaml
model:
  provider: openai
  name: gpt-4o  # or other OpenAI models
```

Requires: `OPENAI_API_KEY` environment variable

### Anthropic

```yaml
model:
  provider: anthropic
  name: claude-sonnet-4-5  # or other Claude models
```

Requires: `ANTHROPIC_API_KEY` environment variable

## Development

### Setup

This project uses [uv](https://docs.astral.sh/uv/) for dependency management.

```bash
# Clone the repository
git clone https://github.com/wso2/reference-implementations-afm.git
cd python-interpreter

# Install dependencies
uv sync

# Activate the virtual environment
source .venv/bin/activate
```

### Running Tests

```bash
# Run afm-langchain tests
uv run pytest packages/afm-langchain/tests/

# Run with coverage
uv run pytest packages/afm-langchain/tests/ --cov=afm_langchain
```

### Code Quality

```bash
# Format code
uv run ruff format

# Lint code
uv run ruff check
```

### Project Structure

```text
packages/afm-langchain/src/afm_langchain/
├── __init__.py
├── backend.py          # LangChainRunner implementation
├── model_factory.py    # LLM provider factory
├── mcp_manager.py      # MCP tool management
└── tools_adapter.py    # Tool calling adapter
```

## Usage

The LangChain backend is automatically registered and used when you run an AFM agent:

```python
from afm.runner import get_runner

# Get the LangChain runner
runner = get_runner("langchain")

# Run an agent
result = await runner.run(agent, user_input)
```

## Documentation

For comprehensive documentation, see the [project README](https://github.com/wso2/reference-implementations-afm/tree/main/python-interpreter).

## License

Apache-2.0
afm-cli 0.2.9
AFM CLI metapackage: installs afm-core and afm-langchain
Requires Python: >=3.11

# AFM CLI

[![PyPI version](https://img.shields.io/pypi/v/afm-cli.svg)](https://pypi.org/project/afm-cli/)
[![Python version](https://img.shields.io/pypi/pyversions/afm-cli.svg)](https://pypi.org/project/afm-cli/)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

A command-line interface for running [Agent-Flavored Markdown (AFM)](https://github.com/wso2/agent-flavored-markdown) agents.

This package provides everything you need to run AFM agents, including:
- **afm-core**: Parser, validation, and interface implementations
- **afm-langchain**: LangChain-based execution backend with support for OpenAI and Anthropic

## Installation

```bash
pip install afm-cli
```

## Quick Start

### 1. Set your API key

```bash
export OPENAI_API_KEY="your-api-key-here"
# or
export ANTHROPIC_API_KEY="your-api-key-here"
```

### 2. Create an AFM file

Create a file named `agent.afm.md`:

```markdown
---
name: Friendly Assistant
interfaces:
  - type: consolechat
model:
  provider: openai
  name: gpt-4o

---
# Role
You are a helpful and friendly AI assistant.

# Instructions
- Be concise but thorough in your responses
- If you don't know something, say so honestly
- Always be polite and professional
```

### 3. Run the agent

```bash
afm run agent.afm.md
```

This will start an interactive console chat with your agent.

## Usage

### `afm run <file>`

Run an AFM agent file and start its configured interfaces.

```bash
# Run with default settings
afm run agent.afm.md

# Run on a specific port (for web interfaces)
afm run agent.afm.md --port 8080
```

### `afm validate <file>`

Validate an AFM file without running it.

```bash
afm validate agent.afm.md
```

### `afm framework list`

List available execution backends.

```bash
afm framework list
```

## Configuration

### Environment Variables

- `OPENAI_API_KEY` - Required for OpenAI models
- `ANTHROPIC_API_KEY` - Required for Anthropic models

### CLI Options

- `-p, --port PORT` - Port for web interfaces (default: 8000)
- `--help` - Show help message

## Features

### Interface Types

AFM agents can expose multiple interfaces simultaneously:

- **consolechat**: Interactive terminal-based chat (default)
- **webchat**: HTTP API with built-in web UI
- **webhook**: Webhook endpoint for event-driven agents

### MCP Tool Support

Agents can use external tools via Model Context Protocol (MCP).

For more examples and detailed documentation, see [AFM Examples](https://wso2.github.io/agent-flavored-markdown/examples/).

## Docker

You can also run agents using Docker:

```bash
# Build the image
docker build -t afm-langchain-interpreter .

# Run with an AFM file mounted
docker run -v $(pwd)/agent.afm.md:/app/agent.afm.md \
  -e OPENAI_API_KEY=$OPENAI_API_KEY \
  -p 8000:8000 \
  afm-langchain-interpreter afm /app/agent.afm.md
```

## Documentation

For more detailed documentation, see the [project README](https://github.com/wso2/reference-implementations-afm/tree/main/python-interpreter).

## License

Apache-2.0
afm-core 0.1.6
AFM (Agent-Flavored Markdown) core: parser, CLI, protocols, and interfaces
Requires Python: >=3.11

# AFM Core

[![PyPI version](https://img.shields.io/pypi/v/afm-core.svg)](https://pypi.org/project/afm-core/)
[![Python version](https://img.shields.io/pypi/pyversions/afm-core.svg)](https://pypi.org/project/afm-core/)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

Core library for [Agent-Flavored Markdown (AFM)](https://github.com/wso2/agent-flavored-markdown) - providing parsing, validation, and interface implementations.

## Features

- **AFM File Parser**: Extracts YAML frontmatter and Markdown content (Role, Instructions sections)
- **Pydantic Models**: Type-safe validation of AFM schema for agents, interfaces, and tools
- **Interface Implementations**: Console chat, web chat, and webhook interfaces
- **AgentRunner Protocol**: Pluggable backend system for different execution frameworks
- **CLI Framework**: Entry point for the `afm` command with validation and run commands

## Installation

This package is typically installed as part of `afm-cli`. For development or custom integrations:

```bash
pip install afm-core
```

## Usage

```python
from afm.parser import parse_afm_file

# Parse an AFM file (returns an AFMRecord)
record = parse_afm_file("agent.afm.md")

# Access parsed data
print(f"Agent: {record.metadata.name}")
print(f"Model: {record.metadata.model.provider}/{record.metadata.model.name}")
print(f"Interfaces: {[i.type for i in record.metadata.interfaces]}")
print(f"Role: {record.role}")
print(f"Instructions: {record.instructions}")
```

## Development

### Setup

This project uses [uv](https://docs.astral.sh/uv/) for dependency management.

```bash
# Clone the repository
git clone https://github.com/wso2/reference-implementations-afm.git
cd python-interpreter

# Install dependencies
uv sync
```

### Running Tests

```bash
# Run all tests
uv run pytest packages/afm-core/tests/

# Run with coverage
uv run pytest packages/afm-core/tests/ --cov=afm
```

### Code Quality

```bash
# Format code
uv run ruff format

# Lint code
uv run ruff check
```

### Project Structure

```text
packages/afm-core/src/afm/
├── __init__.py
├── cli.py              # CLI entry point
├── exceptions.py       # Custom exceptions
├── models.py           # Pydantic models
├── parser.py           # AFM file parsing
├── runner.py           # AgentRunner protocol and runner utilities
├── schema_validator.py # Schema validation
├── templates.py        # Prompt templates
├── update.py           # Update checker
├── variables.py        # Variable substitution
└── interfaces/         # Interface implementations
    ├── __init__.py
    ├── base.py         # Interface utilities (get_interfaces, get_http_path)
    ├── console_chat.py
    ├── web_chat.py
    └── webhook.py
```

## Documentation

For comprehensive documentation, see the [project README](https://github.com/wso2/reference-implementations-afm/tree/main/python-interpreter).

## License

Apache-2.0