semvec/pypi-packages huggingface dataset:
pyfunmath 0.1.0
A lightweight Python library for fundamental number theory operations
Requires Python: >=3.6

PyFunMath 🔢

PyFunMath is a lightweight and beginner-friendly Python library designed to perform fun and fundamental number theory operations. Whether you're a student, hobbyist, or Python learner, this library offers handy utilities to explore properties of numbers like primality, digit patterns, and mathematical characteristics.

---

✨ Features

- Check if a number is prime  
- Identify Armstrong numbers  
- Detect palindromes (numeric or string)  
- Check for perfect numbers  
- Count total number of digits in an integer  
- Calculate sum of digits  
- Check if a number is a happy number  
- List all divisors of a number  

---

In your Python project:

from pyfunmath import (
    is_prime,
    is_armstrong,
    count_digits,
    is_palindrome,
    is_perfect_number,
    sum_of_digits,
    is_happy_number,
    divisors,
)

---

How to Use

1. is_prime(n)  
   Checks if a number is prime.  
   Example:  
   is_prime(7)  # True

2. is_armstrong(n)  
   Checks if a number is an Armstrong number (e.g., 153 = 1³ + 5³ + 3³).  
   Example:  
   is_armstrong(153)  # True

3. count_digits(n)  
   Returns the total number of digits in a number.  
   Example:  
   count_digits(12345)  # 5

4. is_palindrome(x)  
   Checks if a number or string is a palindrome. Case-insensitive and ignores non-alphanumeric characters.  
   Example:  
   is_palindrome("Madam")  # True  
   is_palindrome(121)      # True

5. is_perfect_number(n)  
   Checks if a number is perfect (equal to the sum of its proper divisors).  
   Example:  
   is_perfect_number(28)  # True

6. sum_of_digits(n)  
   Returns the sum of all digits in a number.  
   Example:  
   sum_of_digits(123)  # 6

7. is_happy_number(n)  
   Determines if a number is a happy number.  
   Example:  
   is_happy_number(19)  # True

8. divisors(n)  
   Returns a list of all divisors of the number.  
   Example:  
   divisors(12)  # [1, 2, 3, 4, 6, 12]

---

🧑‍💻 Developer

Siva Naga Lakshmi Somepalli  
Artificial Intelligence & Data Science
kickstart-mcp 0.1.3
Kickstart-mcp is tutorial for using mcp, making your own mcp server/client. We'll guide you through every step of your MCP journey
Requires Python: >=3.8

# kickstart-mcp

An interactive tutorial for learning Model Context Protocol (MCP). From setting up MCP hosts to building your own servers and clients, we'll guide you through every step of your MCP journey.

![AvailableTutorial](./docs/images/available_tutorial.png)

## Features

- Interactive tutorials for MCP setup and development
- Step-by-step guides for different MCP hosts (Claude, Cursor, Custom)
- Comprehensive coverage of MCP concepts:
  - Host configuration
  - Server development
  - Client implementation
- Built-in verification for each tutorial step
- Cross-platform support (macOS, Windows)

## Dependencies

For package management, we recommend using UV:

```bash
brew install uv
```

The build tool used in the instructions is Hatch, so you'll need to install it as well:

```bash
brew install hatch
```

## Installation

### Quick Start (Recommended)

```bash
uvx kickstart-mcp -l ko
```

Since v0.1.0, you can use the `-l` option to specify your preferred language.
Currently supported languages:

| Code | Language |
| ---- | -------- |
| en   | English  |
| ko   | Korean   |
| zh   | Chinese  |
| ja   | Japanese |

### Development Installation

```bash
# Clone the repository
git clone https://github.com/nolleh/kickstart-mcp.git
cd kickstart-mcp

# Install dependencies and run
uv run kickstart-mcp
```

## Usage

1. Start the tutorial:

   ```bash
   uvx kickstart-mcp
   ```

2. Follow the interactive prompts to:
   - Choose your preferred MCP host
   - Complete each tutorial step
   - Verify your progress
   - Learn MCP concepts hands-on

> While it's recommended to follow the tutorials in order, if you want to quickly learn server development,
> you can start with FastMcp in the McpServer tutorial.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

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

## Feedback

Have feedback or suggestions? Visit our [GitHub repository](https://github.com/nolleh/kickstart-mcp) to:

- Open an issue
- Submit a pull request
- Start a discussion
compyre 0.1.0
Fully configurable unpacking and comparison logic for arbitrary objects
Requires Python: >=3.11

# compyre

## What is this?

`compyre` provides container unpacking and elementwise equality comparisons for arbitrary objects using their native functionality. It offers convenient defaults, while being fully configurable.

!["X all the Y" meme with "compyre all the things" as text](docs/images/meme.png "compyre meme")

## Why do I need it?

Have you ever found yourself in a situation where you needed to test a potentially nested container of values against a reference? [`pytest`](https://docs.pytest.org), the de facto standard test framework for Python, features awesome [failure reporting](https://docs.pytest.org/en/stable/example/reportingdemo.html) for builtin types such as dictionaries, lists, integers, strings, and so on.

But what about other common types that come with their own comparison logic, e.g. [`numpy.ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray) and [`numpy.testing.assert_allclose`](https://numpy.org/doc/stable/reference/generated/numpy.testing.assert_allclose.html)? How do you compare a dictionary or worse a dataclass of these?

- Did you ever skip writing a proper test in such a situation and opted to write a simple, but incomplete one instead?
- If not, did you write the test as loop over the individual elements, and later spend more time debugging, because you have no way of knowing for which element the test failure happened?
- If not, is manually writing out all the assertions and maintaining them keeping you from working on the stuff that actually matters for your application or library?

If you have answered "yes" for any of the questions above, `compyre` was made for you.

## How do I get started?

Most basic cases can be covered by `compyre.equal` or `compyre.assert_equal`. The former provides a boolean check, while the latter raises an `AssertionError` with information what elements mismatch and why.

```python
import dataclasses

import numpy as np

import compyre

@dataclasses.dataclass
class MyObject:
    id: str
    data: list[np.ndarray]

expected = MyObject(
    id="foo",
    data=[np.array([1, 2]), np.array([3, 4])],
)

actual = MyObject(
    id="bar",
    data=[np.array([1, 2]), np.array([3, 5])],
)

compyre.assert_equal(actual, expected)
```

```
AssertionError: comparison resulted in 2 error(s):

id
    AssertionError: 'bar' != 'foo'
data.1
    AssertionError: 
    Not equal to tolerance rtol=1e-07, atol=0

    Mismatched elements: 1 / 2 (50%)
    Max absolute difference among violations: 1
    Max relative difference among violations: 0.25
     ACTUAL: array([3, 5])
     DESIRED: array([3, 4])
```

## How do I learn more?

Please have a look at the [documentation](https://compyre.readthedocs.io/en/stable/).