semvec/pypi-packages huggingface dataset:
ZapMail 1.0.2
A simple, intuitive Gmail SMTP email library
Requires Python: >=3.7

# ZapMail

`ZapMail` is a simple Python library to send emails via Gmail's SMTP server. It supports plain text, HTML content, attachments, and CC/BCC fields.

## Installation

```bash
pip install ZapMail
```


```python
from ZapMail.emailer import Emailer

emailer = Emailer(
    sender_email="your_email@gmail.com",
    password="your_app_password"
)

success = emailer.send_email(
    recipient=["recipient1@example.com", "recipient2@example.com"],
    subject="ZapMail Feature Demo",
    body_text="This is a plain text body.",
    body_html="""
        <h1>ZapMail Demo</h1>
        <p>This email demonstrates <b>ZapMail</b> features.</p>
        <img src="cid:demoimg">
    """,
    attachments=["/path/to/attachment.pdf"],
    cc="ccperson@example.com",
    bcc=["bcc1@example.com", "bcc2@example.com"],
    reply_to="replyto@example.com",
    inline_images={"demoimg": "/path/to/image.png"},
    custom_headers={"X-Custom-Header": "ZapMailDemo"}
)

if success:
    print("Email sent successfully!")
else:
    print("Failed to send email.")

```
svllm 0.3.3
serve your llm
Requires Python: >=3.9

# svllm

Create a OpenAI-Compatible API Server for your LLM.

## Usage

## Install

```
$ pip install svllm
```

## Prepare

svllm provided following HTTP APIs:

* chat: `/v1/chat/completions`
* complete: `/v1/completions`
* embed: `/v1/embeddings`
* models: `/v1/models`

You only need to implement the `chat`, `complete`, `embed` function (or part of them).

Set `__model__`, `__owner__` for these functions can affect `/v1/models` API.

See `src/protocol.py` for more information.

Then you can use svllm in the following two ways:

### CLI

If you have a `demo.py` file that implements a `chat` function, you can start it like this:

~~~bash
$ svllm --chat demo:chat
$ svllm-cli # client
~~~

Run `svllm --help` and `svllm-cli --help` for more information.

### Library

You can also use svllm as a library. (also see `demo.py`)

~~~python
import uvicorn
import svllm

if __name__ == '__main__':
    svllm.set_chat(svllm.examples.chat)
    svllm.set_complete(svllm.examples.complete)
    svllm.set_embed(svllm.examples.embed)

    app = svllm.create_app()
    uvicorn.run(app, host='0.0.0.0', port=5261)
~~~
metisos-arc-core 1.2.8
Adaptive Recursive Consciousness (ARC) Core - A framework for continual learning AI systems
Requires Python: >=3.8
Keywords: artificial intelligence, deep learning, transformers, continual learning, lora, neural networks, reasoning, memory

# ARC Core

Adaptive Recursive Consciousness (ARC) Core is a framework for building continual learning AI systems that can learn and reason over time. It features:

- **Continual Learning**: Real-time learning with LoRA adapters
- **Reasoning Engine**: Graph-based reasoning and pattern recognition
- **Biological Learning**: Implements biological learning mechanisms
- **Model Agnostic**: Works with various transformer architectures

## Installation

```bash
pip install arc-core
```

## Quick Start

```python
from arc_core import LearningARCConsciousness, ARCCore, ARCTrainer  # All aliases for the same class

# Initialize with a base model
arc = LearningARCConsciousness(model_name="gpt2")

# Learn from interactions
arc.learn_from_experience("The sky appears blue due to Rayleigh scattering")

# Generate responses
response = arc.generate("Why is the sky blue?")
print(response)
```

## Features

- **Dynamic LoRA Adapters**: Automatically adapts to different model architectures
- **Reasoning Graph**: Maintains a knowledge graph of learned concepts
- **Biological Learning**: Implements contextual gating and cognitive inhibition
- **Persistence**: Saves learning progress between sessions

## Documentation

For detailed documentation, see [ARC Core Documentation](https://github.com/yourusername/arc-core).

## License

MIT
pydantic-autotag 1.0.0
Create Pydantic tagged unions without the boilerplate
Requires Python: >=3.10

# pydantic-autotag

A lightweight Python library that simplifies working with tagged unions in
Pydantic by automatically adding discriminator fields to your models and
annotating union types. Using discriminators makes deserializing union types
dramatically faster since it only has to deserialize the value as the correct
type without trying all the other possible types.

## Installation

Install from PyPI:

```bash
uv add pydantic-autotag
```

or

```bash
pip install pydantic-autotag
```

## Features

- **Automatic tagging**: Add discriminator fields to Pydantic models with a simple decorator
- **Tagged unions**: Convert regular unions to Pydantic tagged unions with a single function call
- **Custom field names**: Use any field name for discrimination (defaults to "type")
- **Custom tags**: Use any function to generate the tag value for each class

## Usage

```python
from typing import TypeAlias, TYPE_CHECKING
from pydantic import BaseModel
from pydantic_autotag import autotagged_union

class Foo(BaseModel):
    ...

class Bar(BaseModel):
    ...

# Calling functions is not allowed in type definitions so this won't be accepted:
# FooOrBar = autotagged_union(Foo | Bar)
# Instead, define the union and then apply autotagging only when not type checking.
FooOrBar: TypeAlias = Foo | Bar

if not TYPE_CHECKING:
    FooOrBar = autotagged_union(FooOrBar)
```

You can also decorate model classes directly:

```python
from pydantic import BaseModel
from pydantic_autotag import autotag

@autotag
class Foo(BaseModel):
    ...
```

## Customization

By default, each class has a `type` field added to it and the field's value is the class name.
This can be customized by passing `field_name` and/or `tag_value` keyword arguments to `autotagged_union` or `autotag`:

```python
@autotag(field_name="name", tag_value="Happy")
class PositiveEmotion(BaseModel):
    ...
```

is equivalent to:

```python
class PositiveEmotion(BaseModel):
    name: Literal["Happy"] = Field(init=False, default="Happy", repr=False, frozen=True)
    ...
```

For unions, you must pass a function that returns the tag value for a given class:

```python
FooOrBar = autotagged_union(FooOrBar, field_name="which", tag_value=lambda c: c.__name__.lower())
```

## Type Safety

If you need to directly access the generated field and don't want your type checker to be unhappy, you can declare the field either as a `str` or as a `Literal["ExpectedTagValue"]`
and autotag will replace it at runtime just like it would if the field didn't exist. One
easy way to do this is with a base class:

```python
class MyBase(BaseModel):
    type: str

class A(MyBase):
    ...

class B(MyBase):
    ...


AorB: TypeAlias = A | B

if not TYPE_CHECKING:
    AorB = autotagged_union(AorB)
```
phrlibrary 1.0.3
A demo library
Requires Python: >=3.6

﻿PHRLibrary, A demo library
--------------------------------
Version: 1.0.3
--------------------------------
  Functions:
    fun hello_world() -> str
    fun calculate_sum(a, b) -> int or float
    fun __python__() -> None
    fun upload_file(url, file_path) -> int
  Classes:
    cls DataProcessor:
      fun process(x) -> int or float
    cls GamePy:
      cls Game:
        fun init() -> None
        fun run() -> None
        cls Window:
          fun caption(title) -> None
          fun icon(iconfile) -> None
          fun update() -> None
          fun render(R, G, B) -> None
          fun flip() -> None
        cls Event:
          fun handle_events(game) -> None
        cls Time:
          fun set_fps(fps) -> None
          delay(ms) -> None
    cls game:
      fun test(width, height, title, R, G, B) -> None
--------------------------------