semvec/pypi-packages huggingface dataset:
CatapultPy 0.0.1
A API Wrapper for Catapult Openfield System
Requires Python: >=3.0

# CatapultPy 

A lightweight Python wrapper for the Catapult Sports OpenField API. This package is modeled after `CatapultR` and is designed to make it easier to pull data into Python for analysis.

---

## Table of Contents

- [Installation](#installation)
- [Basic Functions](#basic-functions)
- [Activity-Based Functions](#activity-based-functions)
- [Aggregated Data](#aggregated-data)
- [10Hz Data](#10hz-data)

---

## Installation

Install via pip:

```
pip install CatapultPy
```

## Basic Functions

### 

```
token = ofCreateToken(api_key, region = "us")
```
Creates the token to call the API. Must include your region name being "us", "eu", "au", "cn".

```
ofGetActivities(token)
```
Returns a pandas dataframe of all of the activities.

```
ofGetAthletes(token)
```
Get a Pandas Dataframe of all the athletes within a dataframe. 

```
ofGetParams(token)
```
Return a Pandas Dataframe of all paramaters.

### Activity based Functions

```
ofGetActivitiesAthletes(token, activity_id)
```
Returns a Pandas dataframe of all the Athletes from within a activity. Must input the activity id.

```
ofGetActivitesPeriod(token, activity_id)
```
Return a Pandas dataframe of all the periods within an activity.

```
ofGetActivitiesTags(token, activity_id)
```
Return a Pandas dataframe of all the tags within a activity.

```
ofGetActivitiesDevices(token, acitvity_id)
```
Return a Pandas Dataframe of all the devices within a activity.

```
ofGetActivityEvents(token, activity_id, athlete_id, events = ["ima_jumps", "baseball_swing"])
```
Return a Pandas Dataframe of all the events for a single athlete in a activity. events must be listed in a list format.

```
ofGetActivityEfforts(token, activity_id, athlete_id, efforts= ['acceleration', 'velocity'])
```
Return a Pandas Dataframe of all the efforts for a single athlete in a activity. Effort can be acceleartion, velocity or both. It is defaulted as both.

### Aggragated data

```
ofGetStats(token,
            params = ["athlete_name", "date", "start_time", "end_time", "position_name", 
                    "total_distance", "total_duration", "total_player_load", "max_vel", 
                    "hsr_efforts", "max_heart_rate", "mean_heart_rate", 
                    "period_id", "period_name", "activity_name"],
            group_by = ["athlete", "period", "activity"],
            filters = {
                "name" : "activity_id",
                "comparison" : "=",
                "values" : ["activity_id_1", "activity_id_2"]
            })
```

Returns a Pandas Dataframe of aggragated stats. params and group_by must be inputed as lists. Filters must be imputed as a dicitonary, values must be implemented as a list of activity_id's.

### 10Hz Data

```
ofGetActivity10hz(token, activity_id, athlete_id)
```

Returns a Pandas Dataframe of 10 Hz data of an athlete from within an activity.
n0elog 1.0.0
elog hilft dir besser und Simpler und einfacher alles zu loggen.
Requires Python: >=3.6

# elog

`elog` ist ein ultraleichtes Python-Logging-Modul, das automatisch alle `print()`-Ausgaben in Logdateien speichert – mit Zeitstempel und eindeutiger ID.

## Verwendung

```python
import elog
print("Hallo Welt!")  # Wird in log gespeichert
hack4u-2 0.5.0
Una biblioteca para consultar cursos de hack4u

# Hack4U Academy Courses Library

Una biblioteca Python para consultar cursios de la academia Hack4U.

## Cursos disponibles:

- Introducion a Linux [15 horas]
- Personalizacion de Linux [3 horas]
- Introducion al Hacking [53 horas]
- Python Ofensivo [35 horas]

## Instalacio

Installa el paquete usando 'pip3':

```python3
pip3 install hack4u
```
## Uso basico

### Listar todos los Cursos

```python3
from hack4u import list_courses

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

### Obtener un curso por nombre

```python3
from hack4u import get_course_by_name

course = get_course_by_name("Introducion a Linux")
print(course)
```

### Calcular duracion total de los Cursos

```python3
from hack4u.utils import total_duration

print(f"Duracion total: {total_duration()} horas")
```
sha256sr 0.1.9
the secure random generator based on SHA256

# Overview
The implementation of secure random generator based on SHA256.
# Build
```
sh build.sh
```
# Use Guide
```
from sha256sr.secure_random import SecureRandom
seed = "this is an example of secure random generator based on sha256"
sr = SecureRandom(seed.encode())
gaussian = sr.next_gaussian()
rand_d = sr.next_float64()
```
gpt-memory 0.0.10
A LLM memory management library
Requires Python: >=3.8

# GPT Memory

GPT Memory is a package that stores historical memory of your LLM conversations and uses these memories to improve subsequent interactions. The system automatically classifies the memories and generates abstracts to behave like how human making conversations.

## Features

- **Historical Memory Storage**: Stores and manages historical chat data.
- **Automatic Classification**: Automatically classifies chat memories for better organization.
- **Abstract Generation**: Generates abstracts of past conversations to enhance GPT's context handling.
- **Mood detection**: Check user emotional status and store in history chat data.
- **Context generation**: Generates context for current message based on historical conversation.

## Installation

To install GPT Memory, use pip:

```bash
pip install gpt_memory
```

## Usage

### Importing and Using the Memory Class

To start using GPT Memory, import the `Memory` class and process a user message:

```python
from gpt_memory import Memory

m = Memory()
response = m.process_message('user_message')
```

## Example

Here’s a simple example of how to use the `Memory` class:

```python
from gpt_memory import Memory

# Initialize the memory system
memory_system = Memory()

# Process a user message
response = memory_system.process_message('Hello, how are you?')

# Print the status and response
print(f"Response: {response}")
```

## Contributing

If you would like to contribute to GPT Memory, please follow these steps:

1. Fork the repository.
2. Create a new branch for your feature or bugfix.
3. Implement your changes.
4. Submit a pull request.

## License

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

## Contact

For any questions or inquiries, please contact [sun@raaslabs.com](mailto:sun@raaslabs.com).
lipomerge 0.1.1
A tool to merge directories containing static libraries or other binaries into universal binaries.
Requires Python: >=3.6

# lipomerge

This package merges two directories containing static libraries for two different architectures into one directory with universal binaries. Files that don't end in ".a" or are mach-O binaries (Typically `.dylib` or executable) will just be copied over from the first directory.

## Installation

To install the package, use:

```
pip install lipomerge
```

## Usage

Run it like this:

```
python3 -m lipomerge <arm64-dir-tree> <x64-dir-tree> <universal-output-dir>
```

## Requirements

- macOS
- `lipo` must be installed on your system.

## License

This project is licensed under the GPL v3 license.

## Resources
* [A blog post on using lipo to build universal binaries](https://www.f-ax.de/dev/2021/01/15/build-fat-macos-library.html)
* [A blog post on building universal binaries with vcpkg](https://www.f-ax.de/dev/2022/11/09/how-to-use-vcpkg-with-universal-binaries-on-macos/)

## Contribute

Style is enforced by pre-commit:

```
pip install pre-commit
pre-commit install
```
openai-trans 0.1.0
A powerful AI-based text translator using ChatGPT API
Requires Python: >=3.8

# GPT Translator

A powerful AI-based text translator using ChatGPT API. This package provides an easy-to-use interface for translating text between different languages while preserving formatting and structure.

## Features

- Automatic language detection
- Support for multiple languages
- Preserves text formatting (Markdown, HTML, JSON, etc.)
- Streaming translation support
- Token usage tracking
- Configurable formality level
- Easy-to-use Python interface

## Installation

```bash
pip install gpt-translator
```

## Usage

First, set up your OpenAI API key in your environment:

```bash
export OPENAI_API_KEY='your-api-key-here'
```

Or create a `.env` file in your project root:

```
OPENAI_API_KEY=your-api-key-here
```

### Basic Usage

```python
from gpt_translator import ai_translator

# Simple translation (auto-detect source language to Persian)
result = ai_translator.translate("Hello, how are you?")
print(result.result)

# Specify source and target languages
result = ai_translator.translate(
    "Hello, how are you?",
    t_from="en",
    t_to="fr"
)
print(result.result)

# Streaming translation
for chunk in ai_translator.stream_translate():
    print(chunk)
```

### Advanced Usage

```python
# Translate with specific formatting
result = ai_translator.translate(
    "Hello, how are you?",
    t_from="en",
    t_to="fr",
    text_format="markdown"
)

# Get token usage information
print(ai_translator.token_usage)
```

## API Reference

### `AITranslator` Class

The main class for translation operations.

#### Methods

- `translate(t_text, model="gpt-4o-mini", t_to=None, t_from=None)`: Translate text
- `stream_translate()`: Stream translation results
- `count_tokens()`: Get token usage information

#### Parameters

- `t_text`: Text to translate
- `model`: OpenAI model to use (default: "gpt-4o-mini")
- `t_to`: Target language code
- `t_from`: Source language code

## License

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

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
goat-sdk-wallet-crossmint 0.1.14
Crossmint wallet implementation for GOAT SDK
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai, crossmint, wallet

# Crossmint Wallet Implementation for GOAT SDK

This package provides Crossmint wallet integration for the GOAT SDK, supporting both EVM Smart Wallets and Solana Custodial Wallets.

## Features

-   EVM Smart Wallet support
-   Solana Custodial Wallet support
-   Async API client for Crossmint interactions
-   Support for multiple authentication methods (email, phone, user ID)
-   Transaction and signature management
-   Balance queries and ENS resolution

## Installation

```bash
poetry add goat-sdk-wallet-crossmint
```

## Usage

```python
from goat_wallets.crossmint import smart_wallet_factory, custodial_factory
from crossmint.common_sdk_base import CrossmintApiClient

# Initialize Crossmint client
crossmint_client = CrossmintApiClient(...)

# Create Smart Wallet
smart_wallet = await smart_wallet_factory(crossmint_client)({
    # Required: One of the following to locate the wallet
    "address": "0x...",  # Wallet address, or use linkedUser instead:
    # "linkedUser": {
    #     "email": "user@example.com",  # Or use phone/userId
    #     # "phone": "+1234567890",
    #     # "userId": "user-id"
    # },
    "chain": "base",  # or "ethereum", etc.
    "signer": {
        "secretKey": "0x..."  # Private key for signing
    },
    "provider": "https://base-mainnet.g.alchemy.com/v2/your-api-key",
    "options": {
        "ensProvider": "https://base-mainnet.g.alchemy.com/v2/your-api-key"  # Optional: For ENS resolution
    }
})

# Create Custodial Solana Wallet
custodial_wallet = await custodial_factory(crossmint_client)({
    "connection": solana_connection,  # Solana RPC connection
    # One of the following for wallet location:
    "email": "user@example.com",
    # "phone": "+1234567890",
    # "userId": "user-id",
    # "address": "solana-address"
})
```

## License

MIT License
MacIDS 1.2
macOS-based Intrusion Detection System using machine learning for adaptive network security
Requires Python: >=3.7

# MacIDS - macOS Intrusion Detection System

MacIDS is a comprehensive network monitoring and intrusion detection system designed specifically for macOS. It provides real-time network traffic analysis, application identification, and visualization tools to help users monitor and secure their network connections.

## Features

- **Real-time Network Monitoring**: Capture and analyze network traffic on your macOS system in real-time
- **Application Identification**: Identify which applications are generating network traffic
- **Website Tracking**: Monitor and analyze websites and domains accessed from your system
- **Geolocation Visualization**: See where your network connections are going on a world map
- **Data Export**: Export connection data for further analysis

## Requirements

- macOS 10.14 or newer
- Python 3.7+
- Administrator privileges (for packet capture functionality)

## Installation

### Using pip

```bash
pip install MacIDS
```

### From source

```bash
git clone https://github.com/Nandhan-KA/MacIDS.git
cd MacIDS
pip install -e .
```

## Usage

### Network Monitor

To start the network monitoring tool:

```bash
sudo macids-netmon
```

Administrator privileges are required for capturing network packets.

You can also run it through Python:

```bash
sudo python -m macids.netmon
```

## How It Works

MacIDS uses Scapy to capture and analyze network packets at the system level. The application identifies processes associated with network connections, resolves domain names, and provides geographical information about connections.

Key components:
- Packet capture engine using Scapy
- Process-connection correlation
- Domain name resolution
- Geolocation services
- Interactive visualization using Matplotlib and Tkinter

## Key Differences from WinIDS

- Uses Scapy for packet capture instead of WinDivert
- Adapted for macOS network stack and process management
- Updated UI to match macOS design patterns
- Modified packet handling for macOS network architecture

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Acknowledgments

- Original WinIDS project by Nandhan K
- MaxMind for GeoLite2 geolocation data
- Scapy project for packet manipulation tools
- Matplotlib for visualization components