semvec/pypi-packages huggingface dataset:
universal-history 0.1.2
A library for creating, maintaining, and utilizing Universal Histories across multiple domains
Requires Python: >=3.8

# Universal History

A library for creating, maintaining, and utilizing Universal Histories across multiple domains.

## Overview

The Universal History library provides a standardized framework for recording, analyzing, and retrieving historical information about any subject across various domains. Whether you're tracking educational progress, medical history, employment records, or any other domain-specific information, this library offers a unified approach to managing that data.

## Key Features

- **Multi-domain support**: Track histories across education, health, work, finance, and other domains
- **Event recording**: Capture individual events with rich context and metadata
- **Trajectory synthesis**: Generate summaries and analyses from sequences of events
- **State document**: Maintain an up-to-date representation of the subject's current state
- **Domain catalogs**: Define and standardize domain-specific terminology and metrics
- **LLM integration**: Optimize historical data for use as context with language models
- **Multiple storage backends**: Store data in memory, files, or MongoDB

## Installation

```bash
pip install universal-history
```

For MongoDB support:

```bash
pip install universal-history[mongodb]
```

For LLM integration:

```bash
pip install universal-history[llm]
```

## Quick Start

```python
from universal_history import UniversalHistoryClient

# Initialize a client with file storage
client = UniversalHistoryClient(storage_dir="./data")

# Create an event
event = client.create_event(
    subject_id="student123",
    domain_type="education",
    event_type="exam",
    content="Student scored 92/100 on Algebra final exam.",
    source_type="institution",
    source_id="school001",
    source_name="Springfield High School",
    metrics={"score": 92, "max_score": 100},
    tags=["math", "algebra", "exam"]
)

# Update the state document with information from events
client.update_state_from_events(
    subject_id="student123",
    domain_type="education"
)

# Get LLM-optimized context
context = client.get_llm_context("student123")
print(context)
```

## Architecture

The Universal History system consists of several key components:

- **Event Record (RE)**: The basic unit of information, capturing specific events or observations
- **Trajectory Synthesis (ST)**: Analysis and summary of multiple events over a period of time
- **State Document (DE)**: Real-time representation of the current state of a subject
- **Domain Catalog (CDD)**: Semantic framework for interpreting information in a specific domain
- **Universal History (HU)**: Container for all components related to a specific subject

## Documentation

For detailed documentation, visit [https://universal-history.readthedocs.io/](https://universal-history.readthedocs.io/)

## License

This project is licensed under the MIT License - see the LICENSE file for details.
obfuscation-detection 1.0.0
Python module for obfuscation classification in command line executions
Requires Python: >=3.10

# Command Obfuscation Detection

This project currently only supports cmd.exe command obfuscation detection on Windows. In a previous iteration of this project, we used deep learning. Now, we have shifted the approach towards XGBoost instead.

- Blog post: https://medium.com/adobetech/using-deep-learning-to-better-detect-command-obfuscation-965b448973e0
- Pip package: https://pypi.org/project/obfuscation-detection/

## Quick Installation

You can install our package through pip!
```
pip install obfuscation-detection
```

This is a basic usage of our package:
```
from obfuscation_detection import ObfuscationDetectionClassifier

model = ObfuscationDetectionClassifier()
commands = ['cmd.exe /c "echo Invoke-DOSfuscation"',
            'cm%windir:~ -4, -3%.e^Xe,;^,/^C",;,S^Et ^^o^=fus^cat^ion&,;,^se^T ^ ^ ^B^=o^ke-D^OS&&,;,s^Et^^ d^=ec^ho I^nv&&,;,C^Al^l,;,^%^D%^%B%^%o^%"',
            'cat /etc/passwd']
y = model.predict(commands)
y_prob = model.predict_proba(commands)

# 1 is obfuscated, 0 is non-obfuscated
print(y) # [0, 1, 0]
print(y_prob)
```

## Usage
1. Install python dependencies: `pip install -r requirements.txt`

2. For quick usage, give a .csv file with column `commands` and you can run the commands through the model: `python obfuscation_detection/main.py --filename commands.csv`

3. You can also write your own scripts to use the model class directly: `python obfuscation_detection/model.py`

### Contributing

Contributions are welcomed! Read the [Contributing Guide](./CONTRIBUTING.md) for more information.

### Licensing

This project is licensed under the Apache V2 License. See [LICENSE](LICENSE) for more information.
texas-hold-em-utils 0.1.17
A package containing the logic for a Texas Hold 'Em game, along with some related utilities.
Requires Python: >=3.8

# texas-hold-em

A package containing the logic for a Texas Hold 'Em game, along with some related utilities.

[Docs](https://github.com/amarkules1/texas-hold-em/blob/main/texas_hold_em_utils/texas_hold_em_utils.md)
match-video 0.1.5
A Python library that simplifies working with video from soccer matches.
Requires Python: <4.0.0,>=3.9.0
Keywords: soccer, football, match, video

# Match Video

This is a Python library that simplifies working with video from soccer matches. It allows match video to be selected intuitively by period number and clock, instead of absolute video time.

To accomplish this the start of each period is set as a chapter in the match video's metadata. Clips from the video can then be selected by period number and clock. ffmpeg handles both reading and writing the video chapter metadata and clip selection.

## Installation

### Requirements
- Python 3.9 or newer
- [ffmpeg](https://ffmpeg.org)

```shell
pip install match-video
```

## Usage

Before the video can be used, the start time of each half needs to be set.

```shell
match-video set-half-starts path/to/video.mp4 0:04 63:20
```

Then it is easy to select match video by period and clock!

```python
import match_video as mv

# get the third minute of the match
clip = mv.get_clip("path/to/video.mp4", period=1, start_clock=180, end_clock=240)

# get the start of each half and concatenate them
clip_clocks = [
    {"period": 1, "start_clock": 0, "end_clock": 30},
    {"period": 2, "start_clock": 0, "end_clock": 30},
]
clips = mv.get_clips("path/to/video.mp4", clip_clocks)
```

See the [examples](https://gitlab.com/grantwenzinger/match-video/-/tree/main/examples) to see how to save or display video clips.

## Support

<grantwenzinger@gmail.com>

## License

[MIT](https://choosealicense.com/licenses/mit/)