semvec/pypi-packages huggingface dataset:
easy-ai-module 0.1.2
A simple module for making AI requests to Gemini API
Requires Python: >=3.7

# Easy AI Module

A simple Python package for personal use that makes it easy to interact with Google's Gemini AI API.

## Installation

```bash
pip install -e .
```

## Usage

First, replace the API_KEY in `easy_ai_module/gemini_client.py` with your actual Gemini API key.

### Text Generation

```python
from easy_ai_module import GeminiAI

ai = GeminiAI()  # Defaults to gemini-2.0-flash

# Generate text from a prompt
response = ai.generate_text("Write a short story about a robot")
print(response)

# Customize parameters
response = ai.generate_text(
    prompt="Write a haiku about the moon",
    max_tokens=100,
    temperature=0.3  # Lower temperature for more focused output
)
print(response)
```

### Image Analysis

```python
from easy_ai_module import GeminiAI

ai = GeminiAI()

# Analyze an image (requires valid image URL)
image_url = "https://example.com/image.jpg"
response = ai.generate_with_image("What's in this image?", image_url)
print(response)
```

## Models

You can specify different Gemini models:

```python
# Use Gemini 1.5 Flash
ai = GeminiAI(model="gemini-1.5-flash")

# Use Gemma 3
ai = GeminiAI(model="gemma-3")

# Use Gemini 2.0 Flash (default)
ai = GeminiAI(model="gemini-2.0-flash")

# Use Gemini 2.0 Flash-Lite
ai = GeminiAI(model="gemini-2.0-flash-lite")
```

## Model Selection Guide

The package includes a helpful guide to select the right model for your needs:

```python
# Show general help on model selection
from easy_ai_module import GeminiAI
GeminiAI.help()

# Get recommendation for a specific use case
GeminiAI.help('reasoning')  # For complex reasoning tasks
GeminiAI.help('speed')      # For fastest response times
GeminiAI.help('budget')     # For cost-effective usage
GeminiAI.help('creative')   # For creative content generation
GeminiAI.help('image')      # For image analysis tasks
GeminiAI.help('local')      # For models that can run locally
```

## Detailed Model Information

For detailed information about model capabilities, strengths, and pricing:

```python
from easy_ai_module import print_model_guide

# Show information about all models
print_model_guide()

# Show information about a specific model
print_model_guide('gemini-2.0-flash')
```

## Testing Tools

The package includes tools for testing and benchmarking models:

```bash
# Run a simple test with the default model
python model_demo.py

# Show the detailed guide for all models
python model_demo.py --guide

# Show help for a specific use case
python model_demo.py --show-help --use-case creative

# Run benchmarks on all models
python model_demo.py --benchmark

# Test a specific model with a custom prompt
python model_demo.py --model gemini-2.0-flash-lite --prompt "Explain quantum computing"

# Run all tests (help menu, benchmarks, and model guide)
python model_demo.py --test-all --verbose
```

## Note

This package is for personal use only and contains a hardcoded API key. Do not share it with others.
mkdocstrings-typescript 0.1.0
A Typescript handler for mkdocstrings.
Requires Python: >=3.10

# mkdocstrings-typescript

[![ci](https://github.com/mkdocstrings/typescript/workflows/ci/badge.svg)](https://github.com/mkdocstrings/typescript/actions?query=workflow%3Aci)
[![documentation](https://img.shields.io/badge/docs-mkdocs-708FCC.svg?style=flat)](https://mkdocstrings.github.io/typescript/)
[![pypi version](https://img.shields.io/pypi/v/mkdocstrings-typescript.svg)](https://pypi.org/project/mkdocstrings-typescript/)
[![gitter](https://badges.gitter.im/join%20chat.svg)](https://app.gitter.im/#/room/#typescript:gitter.im)

A Typescript handler for mkdocstrings.

WARNING: **Still in prototyping phase!**
Feedback is welcome.

## Installation

```bash
pip install mkdocstrings-typescript
```

## Usage

Add these [TypeDoc](https://typedoc.org/) configuration files to your repository:

```tree hl_lines="4 5"
./
    src/
        package1/
    typedoc.base.json
    typedoc.json
```

```json title="typedoc.base.json"
{
  "$schema": "https://typedoc.org/schema.json",
  "includeVersion": true
}
```

```json title="typedoc.json"
{
  "extends": ["./typedoc.base.json"],
  "entryPointStrategy": "packages",
  "entryPoints": ["./src/*"]
}
```

Update the entrypoints to match your file layout so that TypeDoc can find your packages. See [TypeDoc's configuration documentation](https://typedoc.org/options/configuration/).

Then in each of your package, add this TypeDoc configuration file:

```tree hl_lines="4"
./
    src/
        package1/
            typedoc.json
    typedoc.base.json
    typedoc.json
```

```json title="typedoc.json"
{
  "extends": ["../../typedoc.base.json"],
  "entryPointStrategy": "expand",
  "entryPoints": ["src/index.d.ts"]
}
```

Again, update entrypoints to match your file and package layout. See [TypeDoc's configuration documentation](https://typedoc.org/options/configuration/).

**Your packages must be built for TypeDoc to work.**

You are now able to use the TypeScript handler to inject API docs in your Markdown pages by referencing package names:

```md
::: @owner/packageName
    handler: typescript
```

You can set the Typescript handler as default handler:

```yaml
plugins:
- mkdocstrings:
    default_handler: typescript
```

By setting it as default handler you can omit it when injecting documentation:

```md
::: @owner/packageName
```
EvATive7Encrypter 1.2.1
Definition, specification, implementation and toolkit of EvATive7ENC
Requires Python: >=3.6

<div align="center">

# EvATive7Encrypter

Definition, specification, implementation and toolkit of EvATive7ENC

[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/EvATive7/EvATive7Encrypter/package.yml)](https://github.com/EvATive7/EvATive7Encrypter/actions)
[![Python](https://img.shields.io/pypi/pyversions/EvATive7Encrypter)](https://pypi.org/project/EvATive7Encrypter)
[![PyPI version](https://badge.fury.io/py/EvATive7Encrypter.svg)](https://pypi.org/project/EvATive7Encrypter)

</div>

## Install

1. `pip install EvATive7Encrypter`

## Usage

### CLI

- using `evative7enc --help` or `7enc --help` to see help
- `Write-Output "This is a test" | evative7enc v1 enc` (in PowerShell), `echo This is a test | evative7enc v1 enc` (in bash or cmd)
- ...

### As a library

```python
import logging
from pathlib import Path

from evative7enc import *

logging.basicConfig(level=logging.DEBUG)

alg = EvATive7ENCv1

input_text = Path(".cache/txt/text.txt").read_text("utf-8")
key = alg.key()
encrypted = alg.encrypt_to_evative7encformatv1(key, input_text)
decrypted = alg.decrypt_from_evative7encformatv1(encrypted)

Path(".cache/txt/encrypted.txt").write_text(encrypted, "utf-8")
Path(".cache/txt/decrypted.txt").write_text(decrypted, "utf-8")

```
osu 1.4.13
A python library that emulates the osu! stable client
Keywords: osu, osugame, python, bancho

# osu.py

[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
[![License](https://img.shields.io/badge/license-MIT-green)](https://github.com/Lekuruu/osu.py/blob/main/LICENSE)

osu.py is a python library that emulates part of the online functionality of the osu! stable client.

**IMPORTANT:**
Use this library at your own risk! I am not responsible for any unexpected behavior of the client or anything that can happen to your account. If you want to test it out on a custom server, you can set the `server` attribute when initializing the client.

You can install this package with pip:

```shell
pip install osu
```

Or build it manually:

```shell
git clone https://github.com/Lekuruu/osu.py.git
cd osu.py
pip install setuptools
python setup.py install
```

## Features

- [x] Receiving player stats
- [x] Sending/Receiving chat messages
- [x] Spectating
- [x] Avatars
- [x] Comments
- [x] Replays
- [x] Scores/Leaderboards
- [x] Tournament client behaviour
- [x] Direct Search
- [x] Direct Download
- [ ] Multiplayer
- [ ] Documentation

## Example

Here is a small example of how to use this package:

```python
from osu.bancho.constants import ServerPackets
from osu.objects import Player
from osu import Game
import logging

# Enable extended logging
logging.basicConfig(
    level=logging.INFO,
    format='[%(asctime)s] - <%(name)s> %(levelname)s: %(message)s'
)

# Initialize the game class
game = Game(
  USERNAME,
  PASSWORD
)

# Simple message handler
@game.events.register(ServerPackets.SEND_MESSAGE)
def on_message(sender: Player, message: str, target: Player):
  if message.startswith('?ping'):
    sender.send_message('pong!')

# Run the game
game.run()
```

You can also run tasks, independent of server actions:

```python
# Example of a task, running every minute
@game.tasks.register(minutes=1, loop=True)
def example_task():
  ...
```

For a more in-depth example, please view [this project](https://github.com/lekuruu/osu-recorder).

---

If you have any questions, feel free to contact me on discord: `lekuru`
django-dynamic-smtp 0.0.8
Configure email settings in the admin
Requires Python: >=3.7

# Django dynamic SMTP

Configure email configuration in the admin.

## Usage

1. Install with `pip install django-dynamic-smtp`

2. Add `dynamic_smtp` and some dependencies to `INSTALLED_APPS`:

```python
INSTALLED_APPS = [
    ...,
    "django_object_actions",
    "tinymce",
    "dynamic_smtp",
]
```

3. Configure your email backend:

```python
EMAIL_BACKEND = (
    "django.core.mail.backends.console.EmailBackend"
    if DEBUG
    else "dynamic_smtp.email.DynamicSMPTEmailBackend"
)
```

4. Migrate: `./manage.py migrate`
5. Configure `tinymce`. Example:

```python
TINYMCE_JS_URL = "https://cdnjs.cloudflare.com/ajax/libs/tinymce/7.0.1/tinymce.min.js"
TINYMCE_DEFAULT_CONFIG = {
    "theme": "silver",
    "height": 600,
    "width": 700,
    "resize": "both",
    "plugins": "advlist,autolink,lists,link,image,charmap,print,preview,anchor,"
    "searchreplace,visualblocks,code,fullscreen,insertdatetime,media,table,paste,"
    "help,wordcount",
    "license_key": "gpl",
}
```

See [django-tinymce's documentation](https://django-tinymce.readthedocs.io/en/latest/)
for more options.

6. Access you admin and configure your SMTP settings

### Customize model model admin

1. Don't let our app register the default model admin, and register your
   new model as the holder of email configurations.

```python
# settings.py

...
DYNAMIC_SMPT_REGISTER_ADMIN = False
DYNAMIC_SMPT_EMAIL_CONFIGURATION_MODEL = "myapp.EmailConfiguration"
```

2. Create your custom model

```python
# myapp/models.py

from dynamic_smtp.models import AbstractEmailConfiguration

class EmailConfiguration(AbstractEmailConfiguration):
    pass

```

3. Create your custom model admin

```python
# myapp/admin.py

from django.contrib import admin
from dynamic_smtp.models import AbstractEmailConfiguration

from .models import Emailconfiguration


@admin.register(EmailConfiguration)
class CustomModelAdmin(EmailConfigurationAdmin):
    class Media:
        css = {"all": ["myapp/style.css"]}

```

## Dependencies

This package needs quite a few dependencies, considering its simplicity.

- `Django`
- `beautifulsoup4` and `lxml`: prepare text version of HTML emails
- `django-object-actions`: Button for email test
- `django-tinymce`: HTML editing for signature
- `django-solo`: Use singleton model

## Contributing

All contributions are welcome! To setup you environment:

1. `pip install -r dev.requirements.txt`
2. `pre-commit install`
deeply-env-vault-cli 0.1.0
Cli for managing deeply env
Requires Python: >=3.12

# Deeply CLI

`dotenv-vault`와 유사한 환경 변수 관리 CLI 도구입니다. 프로젝트의 `.env` 파일들을 중앙 서버에 안전하게 관리하고 팀원들과 공유할 수 있습니다.

## 설치 방법

```bash
# 개발 모드로 설치
pip install -e .

# 또는 일반 설치
pip install .
```

## 사용 방법

### 프로젝트 초기화

```bash
# 현재 디렉토리를 프로젝트로 초기화
deeply init

# 특정 볼트 이름으로 초기화
deeply init --vault my-project
```

### 로그인

```bash
# 서버에 로그인
deeply login

# 다른 서버 주소 지정
deeply login --server https://env.example.com
```

### 볼트 생성

```bash
# 새로운 볼트 생성
deeply new my-project

# 설명과 함께 볼트 생성
deeply new my-project --description "내 프로젝트 환경 변수" --kms-key-id "키ID"
```

### 환경 파일 목록 조회

```bash
# 로컬 환경 파일 목록 조회
deeply list

# 서버에 저장된 환경 목록 조회
deeply list --remote
```

### 환경 파일 업로드

```bash
# development 환경 파일 업로드
deeply push

# production 환경 파일 업로드
deeply push production

# 모든 환경 파일 업로드
deeply push --all

# 특정 파일만 업로드
deeply push --file .env.staging --file server/api/.env.staging
```

### 환경 파일 다운로드

```bash
# development 환경 파일 다운로드
deeply pull

# production 환경 파일 다운로드
deeply pull production

# 다른 디렉토리에 다운로드
deeply pull production --output ./config

# 기존 파일 덮어쓰기
deeply pull production --force
```

## 설정 파일

프로젝트 루트에 `.env.vault.yml` 파일이 생성되며, 다음과 같은 설정을 포함합니다:

```yaml
vault: my-project
server: http://localhost:8000
environments:
  - development
  - production
  - staging
token: YOUR_API_TOKEN
```

## 보안

- 모든 환경 변수는 서버에서 암호화되어 저장됩니다.
- API 토큰은 로컬에 저장되며, 절대 공유하지 마세요.
- AWS KMS를 사용하여 높은 수준의 보안을 제공합니다.