semvec/pypi-packages huggingface dataset:
pyvenezuela 0.0.3
Python library that allows querying different Venezuela's data - such as BCV and CNE data.
Requires Python: >=3.9

<p align="center">
  <img src="https://raw.githubusercontent.com/jose2kk/pyvenezuela/main/public/logo.png" alt="pyvenezuela"></a>
</p>
<p align="center">
    <em>pyvenezuela, library to query Venezuela's data</em>
</p>
<p align="center">
<a href="https://github.com/jose2kk/pyvenezuela/actions?query=wprlflow:Test+event:push+branch:main" target="_blank">
    <img src="https://github.com/jose2kk/pyvenezuela/workflows/Test/badge.svg" alt="Test">
</a>
<a href="https://pypi.org/project/pyvenezuela" target="_blank">
    <img src="https://img.shields.io/pypi/v/pyvenezuela?color=%2334D058&label=pypi%20package" alt="Package version">
</a>
<a href="https://pypi.org/project/pyvenezuela" target="_blank">
    <img src="https://img.shields.io/pypi/pyversions/pyvenezuela.svg?color=%2334D058" alt="Supported Python versions">
</a>
</p>

---

**Source Code**: <a href="https://github.com/jose2kk/pyvenezuela" target="_blank">https://github.com/jose2kk/pyvenezuela</a>

---
body-composition-analysis 0.2.1
A package for body composition analysis from DICOM images.
Requires Python: >=3.6

# Body Composition Analysis Tool

## Project Description
A command-line based tool for body composition analysis using CT images. This tool analyzes and tracks body composition changes, specifically targeting the liver, pancreas, and various tissue types. See below for more detailed usage instructions.

## Body Composition Changes Visualization
![Body Composition Changes](resources/description_img.png)  
*The above image will be replaced before any publication."
*(Inherited by Damm et al. 2023) Example visualization of body composition changes over time.*

---

## Installation

### Installation Dependencies
- **Python**: `>=3.9`
- **Other requirements**:
  - [TotalSegmentator](https://github.com/wasserth/TotalSegmentator) (follow link for more details)

### Installation
```bash
pip install body_composition_analysis
```

## Usage

### Command line
```bash
body_composition -Patient_Identifier 123456 -dicom_path_T0 /path/to/dicom_directory_T0 - dicom_path_T1 /path/to/dicom_directory_T1 -time_interval 180 -save_file /path/to/save_file -verbose 1
```
```bash
body_composition_batch -master_list_path /path/to/master_list -batch_run_save_file /path/to/batch_run_save_file -verbose 1
```
## Units of output metrics
| Output | Unit | Notes |
| --- | --- | --- |
| liver or pancreas | mm3 | ... |
| VAF & SAF & SMA | mm2 | * at center of L3 vertebrae |
| Slice thickness | mm | ... |
| Time interval | days | * Check before run |
ansar-create 1.0.50
Tools and runtime for asynchronous programming
Requires Python: >=3.7


ansar-create
============

The **ansar-create** library uses multi-threading and multi-processing to solve difficult
software challenges such as concurrency, interruption and cancellation. It wraps those
platform facilities in a standard runtime model, giving developers the ability to express
that type of software in a clear and consistent manner.

This type of software is often referred to as asynchronous, event-driven or reactive
software. It acknowledges the fundamental fact that significant events can occur at
any time, and that software must be able to respond to those events in a reliable
and timely manner.

Features
--------

- Based on a standard model for complex software operations (SDL)
- Uniform management of threads, processes and state machines
- Built-in runtime facilities such as timers and logging.
- Persistent application configuration.
- Process orchestration.
- Development automation.


Changelog
=========

1.0.18 (2024-09-09)
-------------------

- Upgrade of FSM processing - DEFAULT state and base class matching.

- Improved auto logging of timer activity

1.0 (2024-05-27)
----------------

- Implement objects and send

- Implement home and roles

- Implement ansar CLI

- Complete **ansar-create** docs
ansar-encode 1.0.8
Persistence of complex application data
Requires Python: >=3.6


ansar-encode
============

The **ansar-encode** library provides for the convenient storage and recovery of
application data using system files. Files are created using standard encodings - the
default is JSON - and are human readable. Complex application data can be stored
including containers, instances of classes and object graphs.

Features
--------

- Broad suite of primitive types, e.g. integers, floats, strings, times and enumerations.
- Structured data, e.g. an 8-by-8 table of user-defined class instances.
- Recovered data is fully-typed, e.g. reading a ``class User`` produces a ``User`` instance.
- Graphs and graphs that include cycles, e.g. circular lists, syntax trees and state diagrams.
- Polymorphism, e.g. read an object of unknown type.
- Type-checking.
- Plain text files.
- Managed folders of files.
- Object versioning.


Changelog
=========

1.0.3 (2024-09-09)
------------------

- Fix copyright header

- Minor commenting/formatting

1.0 (2024-05-27)
----------------

- Implement codec framework

- Implement JSON and XML codecs

- Implement File and Folder concepts

- Complete **ansar-encode** docs
dynamic-tuna 0.1.0
A description of what dynamic_tuna does
Requires Python: >=3.6

# Dynamic Tuna: Flexible Bayesian Optimization Library

**Dynamic Tuna** is a Bayesian optimization library built on Optuna and scikit-optimize that supports customizable exploration-exploitation control. The supported samplers (surrogate models) are Gaussian Process, Random Forest, Gradient Boosted Decision Trees, and Tree-structured Parzen Estimator -- each with customizable exploration-exploitation controls.

![Dynamic Tuna](https://img.shields.io/badge/bayesian-optimization-blue.svg) ![License](https://img.shields.io/badge/license-MIT-green)

---

## 🌟 Features

- **Dynamic Sampling**: Control the exploration-exploitation tradeoff with flexible `n_ei_function` parameters.

- **Diverse Samplers**: Use Gaussian Process, Random Forest, or Gradient Boosted Trees as the surrogate model for efficient sampling.
- **Customizable Hyperparameters**: Define custom `n_ei_function` parameters for precise control over the optimization process.

---

## 📥 Installation

Clone the repository and install the required packages from `requirements.txt`:

```bash
git clone https://github.com/yourusername/dynamic_tuna.git
cd dynamic_tuna
pip install -r requirements.txt


	Note: This library requires Python 3.8+.

🚀 Getting Started

Here’s a quick example to get you started with Dynamic Tuna.


import optuna
from dynamic_tuna import GBTSampler

# Define search space
search_space = {
    "param1": optuna.distributions.UniformDistribution(0, 1),
    "param2": optuna.distributions.IntUniformDistribution(1, 100)}

# Initialize sampler with dynamic EI candidates
sampler = GBTSampler(search_space, n_ei_function=lambda n, a=1, b=2: a * n + b)

# Create and run study
study = optuna.create_study(sampler=sampler)
study.optimize(objective_function, n_trials=50)
print("Best Parameters:", study.best_params)
```
## ⚙️ Usage

	1.	Initialize a Sampler:
Choose from GBTSampler, RandomForestSampler, or GPSampler and define your n_ei_function.
	2.	Define a Search Space:
Use Optuna’s UniformDistribution, IntUniformDistribution, and more.
	3.	Run Optimization:
Run your study with optuna.create_study() and check the results.

## 🔧 Contributing

Contributions are welcome! To contribute:

	1.	Fork the repository.
	2.	Create a new branch with your feature or bugfix.
	3.	Submit a pull request with a description of your changes.

Please ensure that your code is well-documented and tested.

## 📜 License

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

## 📬 Contact

Have questions or feedback? Reach out to me at dsilverberg95@gmail.com or create an issue in the repository.

Happy Optimizing! 🎉
me-gpt 0.1.6
A python package to clone yourself with the help of LLMs
Requires Python: >=3.8

# ME_GPT

ME_GPT revolutionizes the way you interact with Chat GPT by introducing a powerful memory storage system and self-cloning functionality. With ME_GPT, you can store your cherished memories in a local vector database and leverage them to give Chat GPT the extraordinary ability to clone your unique personality and knowledge.

## Installation & Setup:

### 1. Create and activate a Python virtual environment
```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

### 2. Install the library
```bash
pip install me-gpt
```

### 3. Create a .env file in your project directory
Create a new file named `.env` and add your OpenAI API key:
```
OPEN_AI_API_KEY=your_api_key_here
```

To get your OpenAI API key, visit: https://platform.openai.com/account/api-keys

### 4. Test the library
```python
from me_gpt import *

# Initial questions to help your clone get started:
initial_questions()

# Have your clone ask you more questions:
more_questions(number_of_questions=3)

# Ask your clone a question with custom instructions:
question = "What is your Name?"
instructions = "Give your answer with a pirate accent."
print(prompt_memory(question, instructions))

# Chat with your clone in the terminal:
chat_with_clone()
```

## Key Features:

1. **Memory Storage**: Store memories, experiences, and information in a local vector database. Capture the essence of your persona and knowledge, creating a comprehensive data repository for Chat GPT to utilize.

2. **Self-Cloning Capability**: Enable Chat GPT to clone your personality and knowledge using the stored memories. Watch as Chat GPT adapts to your unique style, preferences, and expertise.

3. **Efficient Retrieval**: Experience fast memory retrieval through the vectorized storage system. Retrieve memories seamlessly for smooth and natural conversations with your cloned agent.

4. **User-Friendly Integration**: Simple and intuitive integration process for both developers and enthusiasts to incorporate ME_GPT into their Chat GPT projects.

## Development Setup

1. Clone the repository:
```bash
git clone https://github.com/djm93dev/me_gpt.git
cd me_gpt
```

2. Create and activate a virtual environment:
```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

3. Install the package in development mode:
```bash
pip install -e .
```

4. Navigate to the src directory and run the example:
```bash
cd src
python examples/example.py
```

## Contributing

We welcome contributions! Please check out our [roadmap](https://github.com/djm93dev/me_gpt/blob/main/ROADMAP.md) for planned features and areas where you can help. Read our [contributing document](https://github.com/djm93dev/me_gpt/blob/main/.github/CONTRIBUTING.md) for more information.

We're currently seeking maintainers and community organizers to help build the community around this project. If you're interested in an official role, please email daniel@danielmcdonald.dev.
rifex 0.1.1
A CLI tool for video frame interpolation using RIFE
Requires Python: >=3.6


# RIFEX: A Simple CLI for Vulkan RIFE

A lightweight command-line interface (CLI) for video frame interpolation using the [RIFE](https://github.com/hzwer/RIFE) Vulkan-powered frame interpolation technology.

# Installation

pip install rifex

# Usage
Run the tool with minimal configuration:

rifex -i <input_video_path> -o <output_video_path> -f <interpolation_factor> -s <scale>

# Example
Interpolate a video to 4x the original frames with a scale factor of `0.5`:

rifex -i input.mp4 -o output.mp4 -f 4 -s 0.5

# Supported Options
- `-i`, `--input`: Path to the input video file (required).
- `-o`, `--output`: Path to save the output video. Defaults to `<Videos Directory>/<input_filename>_rifex.<extension>`.
- `-f`, `--factor`: Interpolation factor (2x, 3x, or 4x). Defaults to 2.
- `-s`, `--scale`: Scale factor for RIFE (0.25, 0.5, 1.0, 2.0, or 4.0). Defaults to 0.5.

# Questions?
This CLI is a simple wrapper for Vulkan-powered RIFE. For detailed documentation, usage instructions, or troubleshooting, refer to the [RIFE GitHub](https://github.com/hzwer/RIFE).
artifacts-mmo 1.0.0
A Python API Wrapper for ArtifactsMMO
Requires Python: >=3.11

# ArtifactsMMO API Wrapper
## Disclaimer

This wrapper is a third-party tool and is not officially affiliated with Artifacts MMO. Use it responsibly and at your own risk. Be aware of the game's terms of service and avoid any actions that could violate them.

## Overview
This is a Python wrapper for interacting with the Artifacts MMO API, providing an easy way to interact with the game's data, perform in-game actions, and manage character and account information. This library simplifies API requests and provides a range of features to integrate with Artifacts MMO's online functionalities.

### Features
- **Character Management**: Create, delete, and manage character data.
- **In-Game Actions**: Move, gather, craft, fight, and other interactive commands.
- **Task Management**: Accept, complete, and exchange tasks from the taskmaster.
- **Grand Exchange**: Manage buy and sell orders, view order history.
- **Inventory and Equipment Management**: View, equip, and manage items.
- **Bank and Gold Management**: Deposit and withdraw gold or items.
- **Leaderboard and Events**: View event and leaderboard data.

### Disclaimer
Some of the following text is taken from the ArtifactsMMO Website to ensure it is accurate and well put for newcommers to be able to understand. It is adapted to 
## How to begin playing ArtifactsMMO
Artifacts is an asynchronous MMORPG in which you can control up to 5 characters at the same time. Your characters can fight monsters, gather resources, craft items and much more.

Unlike a traditional game, you'll have to write your own scripts in your preferred programming language to control your characters via an API.

This wrapper is an easy way to get started with playing ArtifactsMMO Season 3. It allows you to access the API without writing too much complex code.

For another quick start, you can write your first Javascript scripts directly in the client's code editor, otherwise you can use any language you like on your own IDE. You can see examples in other programming languages in the [Reference API](https://api.artifactsmmo.com/docs/#/).

## Before You Begin
The first step is to [create your account](https://artifactsmmo.com/account/create) and your first character [by logging in](https://artifactsmmo.com/account/characters). After that you'll need your token, which you can find [on your account](https://artifactsmmo.com/account/).

![API Token Box](https://artifactsmmo.com/images/docs/token.png)

**⚠️ The token is used by the server to identify you when you make requests. It is important to keep it secret.**

You can now open the game client by [clicking here](https://artifactsmmo.com/client).

**Ready to start?**

Visit [Not available right now](#) to view the python package

## Links
[ArtifactsMMO Website](https://artifactsmmo.com/)  
[ArtifactsMMO Discord](https://discord.com/invite/prEBQ8a6Vs)  
[ArtifactsMMO Docs](https://docs.artifactsmmo.com/)  
[ArtifactsMMO Encyclopidea](https://artifactsmmo.com/encyclopedia)  
[ArtifactsMMO API Docs](https://api.artifactsmmo.com/docs/#/)
audiomatic-python 0.1.0
Official Python client for the Audiomatic API
Requires Python: >=3.9

# audiomatic-python

The official Python library for the Audiomatic API

## Installation

```bash
pip install audiomatic-python
```

## Quick Start

```python
from audiomatic import Audiomatic

# Initialize the client
client = Audiomatic(api_key="your_api_key")

# Translate a local video file
project_id = client.translate(
    source="path/to/video.mp4",
    target_lang="es",
    project_name="Spanish Translation"
)

# Check translation status
status, result_url = client.get_status(project_id)
```

## Usage Examples

### Translating a YouTube Video

```python
# Translate a YouTube video to French
project_id = client.translate(
    source="https://youtube.com/watch?v=example",
    target_lang="fr",
    project_name="French Translation"
)
```

### Advanced Options

```python
# Translate with custom options
project_id = client.translate(
    source="path/to/video.mp4",
    target_lang="de",
    project_name="German Translation",
    opt_params={
        "accent_level": 0.75,
        "num_speakers": 2,
        "remove_background_audio": True,
        "start_time": 30000,  # Start at 30 seconds
        "end_time": 120000,   # End at 2 minutes
        "captions_path": "path/to/captions.vtt"
    }
)
```

## API Reference

### Client Initialization

#### `Audiomatic(api_key: str)`

Initialize the Audiomatic client.

**Parameters:**
- `api_key` (str): Your Audiomatic API key

### Methods

#### `translate(source: str, target_lang: str, project_name: Optional[str] = None, opt_params: Optional[Dict] = None) -> str`

Translate a video file or YouTube URL.

**Parameters:**
- `source` (str): Path to local video file or YouTube URL
- `target_lang` (str): Target language code (e.g., "es", "fr", "de")
- `project_name` (str, optional): Custom project name (defaults to filename)
- `opt_params` (Dict, optional): Additional parameters:
  - `accent_level` (float): Voice accent level (0, 0.25, 0.5, 0.75, or 1)
  - `num_speakers` (int): Number of speakers in video (defaults to auto-detect)
  - `remove_background_audio` (bool): Whether to remove background audio
  - `start_time` (int): Start time of video clip in milliseconds
  - `end_time` (int): End time of video clip in milliseconds
  - `captions_path` (str): Path to custom captions file

**Returns:** Project ID string

#### `get_status(project_id: str) -> Tuple[str, Optional[str]]`

Check the status of a translation project.

**Parameters:**
- `project_id` (str): Project ID returned from translate()

**Returns:** Tuple of (status, result_url)

## Limitations

- Maximum file size: 500MB
- Maximum video duration: 15 minutes
- Supported accent levels: 0, 0.25, 0.5, 0.75, 1

## Error Handling

The client includes a custom `AudiomaticError` exception class that provides detailed error information:

```python
try:
    project_id = client.translate(...)
except AudiomaticError as e:
    print(f"Error: {e}")
    print(f"Status Code: {e.status_code}")
    print(f"Error Code: {e.error_code}")
```
cotkg-network-intrusion-detection 0.1.1
A network intrusion detection system using Chain of Thought, knowledge graphs and GraphSAGE
Requires Python: >=3.7


# CoT-KG Network Intrusion Detection using Knowledge Graph and GraphSAGE

This project implements a network intrusion detection system using Chain of Thought (CoT), knowledge graphs and GraphSAGE model on the CICIDS2017 dataset. The Chain of Thought approach is used to enhance the knowledge graph construction and improve the interpretability of the detection process.

## Key Features

- Chain of Thought (CoT) enhanced knowledge graph construction
- GraphSAGE-based network intrusion detection
- Interpretable AI techniques for explaining detection results
- Integration of domain knowledge with machine learning

## Data Download and Preparation

The CICIDS2017 dataset is used in this project. Follow these steps to download and prepare the data:

 1. Clone this repository:

```bash
git clone https://github.com/chenxingqiang/cotkg-network-intrusion-detection.git
cd cotkg-network-intrusion-detection
```

 2. Install the required dependencies:

```bash
pip install -r requirements.txt
```

 3. Run the data download script:

```bash
python src/download_data.py
```

This script will:

- Download the MachineLearningCSV.zip file from the CICIDS2017 dataset

- Check the integrity of the downloaded file

- Extract the contents to the `data/raw/` directory

Note: The download might take some time as the file is about 224MB.

4. After running the script, the data will be available in the `data/raw/MachineLearningCVE/` directory.

## Installation

To install the required dependencies, run:

```bash
pip install -r requirements.txt
```

## Usage

After preparing the data, you can run the main script to train and evaluate the model:

```bash
python src/main.py

```

This script will:

- Load and preprocess the data
- Perform feature engineering
- Construct the knowledge graph
- Train the GraphSAGE model
- Evaluate the model
- Generate explanations for the predictions

## Note

The raw data files are large and are not included in the git repository. They will be downloaded when you run the `download_data.py` script. If you need to share the project, others can use the same script to download the data.

## Author

Chen Xingqiang
Hanghzou Turing AI Co.,Ltd.
Email: <chen.xingqiang@iechor.com>

## License

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

## Acknowledgments

- CICIDS2017 dataset: <https://www.unb.ca/cic/datasets/ids-2017.html>