semvec/pypi-packages huggingface dataset:
hack4u-Randyn 0.1.1
Una biblioteca para consultar cursos de hack4u

# Hack4u Academy Courses library

Biblioteca de Python para filtar por los cursos de hack4u

## Cursos disponibles

- Introduccion a linux \[15 horas\]
- Personalizacion de linux \[3 horas\]
- Introduccion al hacking \[53 horas\]
- Python ofensivo \[35 horas\]

## Instalacion
Instalando con el uso de 'pip3':
```python3
pip3 install hack4u-Randyn
```

## Uso basico

### Listar los cursos

```python3
from hack4u import list_courses

for course in list_courses():
    print(course)
```

### Encontrar curso por su nombre

```python3
from hack4u import find_course_by_name

print(find_course_by_name("Introduccion al hacking"))
```

### Calcular duracion total de todos los cursos
```python3
from hack4u import total_duration

total_duration()
```
apal-client 0.1.0
Python client library for APAL secure P2P communication platform
Requires Python: >=3.8

# APAL Python Client

A Python client library for the APAL secure P2P communication platform.

## Installation

```bash
pip install apal-client
```

## Quick Start

```python
import asyncio
from apal_client import APALClient
from uuid import UUID

async def main():
    # Initialize client
    client = APALClient(
        base_url="http://localhost:8000",
        email="your@email.com",
        password="your-password"
    )
    
    # Register a new business account
    account = await client.register(
        email="business@example.com",
        password="secure-password",
        business_name="Example Business"
    )
    
    # Send a message
    message = await client.send_message(
        receiver_id=UUID("receiver-uuid"),
        content={
            "type": "payment",
            "data": {
                "amount": 100.00,
                "currency": "USD",
                "payment_method": "bank_transfer",
                "reference_id": "PAY-123456"
            }
        }
    )
    
    # List messages
    messages = await client.list_messages()
    
    # Get message status
    status = await client.get_message_status(message["id"])

if __name__ == "__main__":
    asyncio.run(main())
```

## Features

- Asynchronous API client
- Automatic authentication handling
- Message encryption/decryption
- Error handling and validation
- Support for all APAL API endpoints

## Environment Variables

The client can be configured using environment variables:

- `APAL_API_KEY`: Your API key
- `APAL_EMAIL`: Your registered email
- `APAL_PASSWORD`: Your password
- `APAL_BASE_URL`: API base URL (default: http://localhost:8000)

## Error Handling

The client raises custom exceptions for different error cases:

```python
from apal_client import (
    APALError,
    ValidationError,
    AuthenticationError,
    MessageError,
    APIError
)

try:
    await client.send_message(...)
except ValidationError as e:
    print(f"Message validation failed: {e}")
except AuthenticationError as e:
    print(f"Authentication failed: {e}")
except MessageError as e:
    print(f"Message processing failed: {e}")
except APIError as e:
    print(f"API error: {e}")
```

## License

MIT License
graphid-db 1.0.0
A database project for graph identification and processing
Requires Python: <4.0,>=3.9

# GraphID DB

## Installation

### From pypi (in progress)

### From github
```
git clone git@github.com:kmu/graphid-db.git
conda create -n graphid-db python=3.11
conda activate graphid-db
python -m build
pip install dist/*.whl
```
mcp-server-zf 0.1.0
test
Requires Python: >=3.13

# mcp-server-zf MCP server

test

## Components

### Resources

The server implements a simple note storage system with:
- Custom note:// URI scheme for accessing individual notes
- Each note resource has a name, description and text/plain mimetype

### Prompts

The server provides a single pr ompt:
- summarize-notes: Creates summaries of all stored notes
  - Optional "style" argument to control detail level (brief/detailed)
  - Generates prompt combining all current notes with style preference

### Tools

The server implements one tool:
- add-note: Adds a new note to the server
  - Takes "name" and "content" as required string arguments
  - Updates server state and notifies clients of resource changes

## Configuration

[TODO: Add configuration details specific to your implementation]

## Quickstart

### Install

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```
  "mcpServers": {
    "mcp-server-zf": {
      "command": "uv",
      "args": [
        "--directory",
        "/Users/guozhifeng/myCode/zf-server/mcp-server-zf",
        "run",
        "mcp-server-zf"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "mcp-server-zf": {
      "command": "uvx",
      "args": [
        "mcp-server-zf"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory /Users/guozhifeng/myCode/zf-server/mcp-server-zf run mcp-server-zf
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
youtube-collector 0.0.5
A Python library for collecting YouTube data including channel videos, hashtag videos, keyword search, comments, and channel profiles
Requires Python: >=3.7

# YouTube Collector

A Python library for collecting YouTube data including channel videos, hashtag videos, keyword search, comments, and channel profiles.

## Features

- Collect posts by hashtag
- Collect tagged posts for a user
- Collect posts from brand accounts
- Collect comments from posts
- Support for multiple API providers (RocketAPI and SocialAPI4)
- Rate limiting and error handling
- Pagination support
- Time-based filtering

## Installation

```bash
pip install youtube-collector
```

## Usage

### Collecting Channel Videos

```python
from youtube_collector import YouTubeBrandCollector

collector = YouTubeBrandCollector(api_key="your_api_key")
videos = collector.collect_brand_posts(channel_id="your_channel_id")
print(videos)
```

### Collecting Hashtag Videos

```python
from youtube_collector import YouTubeHashtagCollector

collector = YouTubeHashtagCollector(api_key="your_api_key")
videos = collector.collect_posts_by_hashtag(hashtag_key="your_hashtag")
print(videos)
```

### Collecting Keyword Videos

```python
from youtube_collector import YouTubeKeywordCollector

collector = YouTubeKeywordCollector(api_key="your_api_key")
videos = collector.collect_posts_by_keyword(keyword="your_keyword")
print(videos)
```

### Collecting Comments

```python
from youtube_collector import YouTubeCommentCollector

collector = YouTubeCommentCollector(api_key="your_api_key")
comments = collector.collect_comments(video_id="your_video_id")
print(comments)
```

### Collecting Channel Profile

```python
from youtube_collector import YouTubeProfileCollector

collector = YouTubeProfileCollector(api_key="your_api_key")
profile = collector.collect_profile(channel_id="your_channel_id")
print(profile)
```

### Collecting Recent Videos

```python
from youtube_collector import YouTubeRecentPostCollector

collector = YouTubeRecentPostCollector(api_key="your_api_key")
videos = collector.collect_recent_posts(channel_id="your_channel_id")
print(videos)
```

## Configuration

The library supports various configuration options:

- `max_hashtag_post_retry`: Maximum retries for hashtag posts (default: 3)
- `max_tagged_post_retry`: Maximum retries for tagged posts (default: 3)
- `max_brand_post_retry`: Maximum retries for brand posts (default: 3)
- `max_comment_retry`: Maximum retries for comments (default: 3)

## Error Handling

The library includes built-in error handling and retry mechanisms:

- Automatic retry on API failures
- Rate limiting to prevent API throttling
- Time-based filtering to limit data collection
- Exception handling for malformed responses

## Contributing

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

## License

This project is licensed under the MIT License - see the LICENSE file for details.