semvec/pypi-packages huggingface dataset:
flaminkit 0.0.6
A toolkit for the FLAMINGO simulation suite
Requires Python: <3.12,>=3.7

Flaminkit
=========

A toolkit for the FLAMINGO cosmological hydrodynamical simulation suite

.. note::

    Currently only works with HBT+ catalogs.

Installation
------------

Flaminkit can be installed through ``pip``: ::

    pip install flaminkit


See the `documentation <https://flaminkit.readthedocs.io/en/latest/>`_ for more details.
py-person-detector 0.0.1
A high level API for detecting and tracking people.
Requires Python: >=3.10

# Person Detector

## Highly performant, and accurate, real-time person tracking with YOLOv10 and ByteTrack

### Command-Line Interface

#### Clone repo and navigate to project directory

```bash
git clone git@github.com:k3y5tr0k3/person-detector.git && cd person-detector
```

#### Install requirements

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

#### Example usage

##### Detections from Image

```bash
python -m src.main --image 'path/to/image.jpg' --detection --show
```

##### Detections from Video

```bash
python -m src.main --video 'path/to/video.mp4' --detection --show
```

##### Trajectory Tracking from Video
```bash
python -m src.main -video 'path/to/video.mp4' --tracking --show
```

##### For more info, use the help flag

```bash
python -m src.main --help
```

### Utility Functions

#### Convert video to images

```bash
python -m src.main --video2images 'path/to/video.mp4
```

### Generate Developer Documentation (Optional)

```bash
pdoc ./src
```

### Performance
person-detector-k3t5tr0k3 0.0.1
A high level API for detecting and tracking people.
Requires Python: >=3.10

# Person Detector

## Highly performant, and accurate, real-time person tracking with YOLOv10 and ByteTrack

### Command-Line Interface

#### Clone repo and navigate to project directory

```bash
git clone git@github.com:k3y5tr0k3/person-detector.git && cd person-detector
```

#### Install requirements

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

#### Example usage

##### Detections from Image

```bash
python -m src.main --image 'path/to/image.jpg' --detection --show
```

##### Detections from Video

```bash
python -m src.main --video 'path/to/video.mp4' --detection --show
```

##### Trajectory Tracking from Video
```bash
python -m src.main -video 'path/to/video.mp4' --tracking --show
```

##### For more info, use the help flag

```bash
python -m src.main --help
```

### Utility Functions

#### Convert video to images

```bash
python -m src.main --video2images 'path/to/video.mp4
```

### Generate Developer Documentation (Optional)

```bash
pdoc ./src
```

### Performance
pt42api-wrapper 1.0.8
A python package that simplifies the process of making API requests to 42 Portugal's API.
Requires Python: >=3.8

# pt42api_wrapper

A python package that simplifies the process of making API requests to 42 Portugal's API. With this package, developers can quickly and easily access the API's functionality, without having to deal with the complexities of working directly with it.

## How to install

```shell
pip install pt42api-wrapper
```

## Making a simple request

- Have a `.env` file that looks like this:

```shell
export API_ENDPOINT=''
export AUTH_URL=''
export CLIENT_ID=''
export CLIENT_SECRET=''
```

- Use the following code to make a simple request:

```python
import pt42api_wrapper as pt42api

api = pt42api.ApiWrapper()
api.get(url='campus/')
```

## Using in Django Projects

```python
# settings.py
...
PT42API_WRAPPER = {
    'base_url': os.environ.get('API_ENDPOINT'),
    'auth_url': os.environ.get('AUTH_URL'),
    'client_id': os.environ.get('CLIENT_ID'),
    'client_secret': os.environ.get('CLIENT_SECRET'),
}
```

```python
from django.conf import settings

import pt42api_wrapper as pt42api

(...)

api = pt42api.ApiWrapper(**settings.PT42API_WRAPPER)
url = f'{self.request_url}{data.get("id")}/'
response = api.delete(url, data)
return http.JsonResponse(response.json(), status=response.status_code)

(...)
```

## Configure Api log level

```python
from pt42-wrapper import ApiWrapper

(...)

api = ApiWrapper(log_level=logging.DEBUG)

(...)
```

## Running tests

```shell
python3 tests.py
```
magql 1.1.1
The magical GraphQL framework that generates an API for your data.
Requires Python: >=3.10

Magql
=====

Magql is a [GraphQL] framework for Python. It's pronounced "magical", and it is!

Magql wraps the [GraphQL-Core] library to make it easier to work with. Magql
provides three big features over GraphQL-Core:

-   The schema is mutable. It can be defined (or generated) then modified to
    add/remove/change behavior before finalizing.
-   Types can be referenced by name, rather than using large lambda functions to
    resolve forward references.
-   Robust input validation can be applied anywhere in arbitrary input
    structures, and errors in the result can be matched back to those arbitrary
    locations.

[GraphQL]: https://graphql.org
[GraphQL-Core]: https://graphql-core-3.readthedocs.io
yt-rss-dl 0.0.2
A YouTube RSS Video Downloader
Requires Python: >=3.6

# yt-rss-dl

# YouTube RSS Video Downloader

This Python script allows you to download videos from YouTube channels using their RSS feeds. The script organizes the downloaded videos by channel name and year, and names each video using the format `[Upload date] - 'Name' - [Video ID]`.

## Features

- **Automatic Download**: Fetches and downloads videos from specified YouTube channels via their RSS feeds.
- **Organized Storage**: Videos are sorted into directories based on channel name and upload year.
- **Avoid Duplicate Downloads**: Tracks downloaded videos in a `downloaded.dat` file to prevent re-downloading the same video.
- **Customizable Naming Convention**: Each video is named according to the format `[Upload date] - 'Name' - [Video ID]`.

## Prerequisites

- Python 3.6+
- [`yt-dlp`](https://github.com/yt-dlp/yt-dlp) installed (`pip install yt-dlp`)
- feedparser

## Installation

1. Clone the repository:
   ```sh
   git clone https://github.com/yourusername/yt-rss-dl.git
   cd yt-rss-dl```

2. Install the required dependencies:
   ```pip install -r requirements.txt```

## Setup

1. Add Channel IDs: Create a channel_ids.txt file in the root directory. Add the YouTube channel IDs, each on a new line. For example:
```
UCCWLtpQNoq7gbiHqssF4rPg
UC_x5XG1OV2P6uZZ5FSM9Ttw
```
2. Run the Script:
```
python yt-rss-dl.py
```

## How It Works
1. The script reads the YouTube channel IDs from channel_ids.txt.
2. It fetches the latest videos for each channel using their RSS feed.
3. The script checks if a video has already been downloaded (tracked in downloaded.dat).
4. If not downloaded, the video is downloaded using yt-dlp, saved in a directory structure organized by channel name and year.
5. The script renames the video according to the format [Upload date] - 'Name' - [Video ID].

## Example Output Structure
```
downloaded_videos/
â””â”€â”€ Channel Name [Channel ID]/
    â”œâ”€â”€ 2023/
    â”‚   â”œâ”€â”€ 2023-05-12 - Example Video 1 - [dQw4w9WgXcQ].mp4
    â”‚   â””â”€â”€ 2023-06-15 - Example Video 2 - [yPYZpwSpKmA].mp4
    â””â”€â”€ 2024/
        â””â”€â”€ 2024-07-11 - Example Video 3 - [zZZ5FSM9Ttw].mp4
```
ruffly 0.0.3
Cli tool to add common config to pyroject.toml
Requires Python: >=3.10

# Ruffly

### Usage

Cli tool to add common config to pyroject.toml.

Basic usage:
```commandline
cd/project/with/pyrojecttoml ruffly
```
will add default config to pyproject.toml found in working directory.

Additional arguments:

- ```--dst``` The path to the target pytroject.toml to modify
- ```--src``` The path to the source pytroject.toml to copy from (can be url)
- ```--only-existing``` Only copies config for tools that exist int the target pyproject.toml
- ```--tools``` A list of tools to copy config for
- ```--dry-run``` Only prints the changes that would be made

Current tools supported:
- ruff
- mypy
- pytest
- coverage
- poe (poethepoet)

### Installation

```commandline
pip install ruffly
```

### Development
To setup the development environment and run linting and testing:

```commandline
python -m venv .venv
source .venv/Scripts/activate  # or .venv/bin/activate on linux
pip install -e .[dev]
poe all
```

To test the install with pipx ```pipx install . --force```

To build the package: ```python -m build --wheel```
crimson-file-loader 0.1.5
Load files in one folder.
Requires Python: >=3.9

## Python Package Setup

### Setup Base

To install required pip modules for `generate_toml.py`, run
``` bash
source scripts/setup_base.sh
```

### User Setup

- go to `generate_toml.py` file, and complete the setup in the `User Setup` session.

```python
options = Options(
    # Will you use the discussion session in your repo?
    discussion=False
)

# Define the general information of your package
kwargs = Kwargs(
    name_space="None",
    module_name="None",
    description="None",
)
```

If you wrote all the information, run
```
python generate_toml.py
```

#### Template

If you want to understand the generation process, check the `template` variable in `generate_toml.py`.

### Setup Env

#### Prerequisite

Finish [User Setup](#user-setup) first.
Of course, conda command must be available.

#### Setup Env

Run
``` bash
source scripts/setup_env.sh
```

steps
- create an conda environment named as your $MODULE_NAME
- activate the environment.
- install requirements.txt

## Workflows

Not documented yet.
logged-hypixeloffical 0.2
A custom logging package
Requires Python: >=3.8

# Logged.py
A custom logging package with advanced features including color-coded console output, log rotation, and compression.

## Installation
To install the package you can run this command in your command prompt or powershell.

```bash
pip install logged
```

## Usage
### Importing the Package
```python
import logged
```

### Creating a Logger
Create a Logger instance with the desired output type and format.

```python
logger = logger.Logger(output_type='console', format='<bold><gray>/d</gray> <type>/t</type></bold>       /m')
```
**output_type:** Specify "console" for console output or "file" for file output.

**format:** Define the log message format using custom tags (e.g., /d for date, /t for type, /m for message).

**file:** If you chose output type as "file" this is a required parameter which must include the log file path.

### Logging Messages
You can use different methods to log messages at various levels:

```python
logger.trace("This is a trace message.")
logger.debug("This is a debug message.")
logger.info("This is an info message.")
logger.warn("This is a warning message.")
logger.error("This is an error message.")
logger.fatal("This is a fatal message.")
logger.all("This is a message for all levels.")
```
### Features
- **Customizable Formatting:** Use ANSI color codes and custom tags in log messages.
- **Log Rotation with Compression:** Automatically rotates log files and compresses old logs into ZIP archives.
- **Flexible Output Options:** Choose between console and file output.

### API Reference
<class>Logger
A class for logging messages.

#### Constructor:

**<str>output_type:** "console" or "file". Default is "console".
**<str>format:** Log message format. Default is "<bold><gray>/d</gray> <type>/t</type></bold> /m".
**<str?>file:** File path for file output.

#### Methods:

**<None>trace(message: str):** Logs a trace message.

**<None>debug(message: str):** Logs a debug message.

**<None>info(message: str):** Logs an info message.

**<None>warn(message: str):** Logs a warning message.

**<None>error(message: str):** Logs an error message.

**<None>fatal(message: str):** Logs a fatal message.

**<None>all(message: str):** Logs a message for all levels.


#### Example:
```python
import logger

# Initialize logger
logger = logger.Logger(output_type='file', format='<bold><gray>/d</gray> <type>/t</type></bold>       /m', file='logfile.txt')

# Log messages
logger.info("This is an info message.")
logger.error("This is an error message.")
```

## License

This package is licensed under the MIT License. See the [LICENSE](https://github.com/hypixeloffical/logged-py/blob/main/LICENSE) file for details.
userfolders 0.2.0
Cross-platform access to a user's special folders
Requires Python: >=3.12
Keywords: documents folder, images folder, downloads folder, user folders, userpaths, winpaths, csidl, xdg, freedesktop, folders

The **userfolders** module provides cross-platform access to a user's special folders (or directories) like My Documents, Desktop, and Application Data. It is primarily intended to simplify development of desktop application software.

A quick usage example:

```python
# Get the user's My Documents folder
import userfolders
my_docs = userfolders.get_my_documents()
```

Both Windows and Unix platforms are supported (untested on Mac, currently accepting contributions).

## Fork Notice

This project is a fork of Benjamin Johnson's [userpaths](https://github.com/bmjcode/userpaths) with enhanced Linux Support and modern Python features.


## API Reference

Function | Description
-------- | -----------
`get_appdata()` | Return the current user's roaming Application Data folder.
`get_desktop()` | Return the current user's Desktop folder.
`get_downloads()` | Return the current user's Downloads folder.
`get_local_appdata()` | Return the current user's local Application Data folder.
`get_my_documents()` | Return the current user's My Documents folder.
`get_my_music()` | Return the current user's My Music folder.
`get_my_pictures()` | Return the current user's My Pictures folder.
`get_my_videos()` | Return the current user's My Videos folder.
`get_profile()` | Return the current user's profile folder.

The userfolders API was inspired by, and is partly compatible with, Ryan Ginstrom's [winpaths](http://ginstrom.com/code/winpaths.html). However, userfolders is not intended as a direct replacement for that module.


## Compatibility Note

The userfolders module was originally designed from a Windows-centric perspective. Because of the many differences between the two systems, there are some Windows paths that do not have a direct equivalent on Unix, and vice versa. In these cases, userfolders attempts to return the nearest functional equivalent, but it is up to the user to ensure their application is using the appropriate path for what it seeks to do.