semvec/pypi-packages huggingface dataset:
dicomslide 0.7.2
Library for reading whole slide images and derived information in DICOM format.
License: MIT
Requires Python: >=3.6

[![Build Status](https://github.com/herrmannlab/dicomslide/actions/workflows/run_unit_tests.yml/badge.svg)](https://github.com/herrmannlab/dicomslide/actions)
[![PyPi Distribution](https://img.shields.io/pypi/v/dicomslide.svg)](https://pypi.python.org/pypi/dicomslide/)
[![Python Versions](https://img.shields.io/pypi/pyversions/dicomslide.svg)](https://pypi.org/project/dicomslide/)

# dicomslide

A Python library for reading whole slide images and derived information in DICOM format from local files or over network via a unified application programming interface.

## Documentation

Please refer to the online documentation at [dicomslide.readthedocs.io](https://dicomslide.readthedocs.io), which includes installation instructions, a user guide with examples, a developer guide, and complete documentation of the application programming interface of the `dicomslide` package.
dicom-image-tools 24.2.1
Python package for managing DICOM images from different modalities
License: MIT

[![ci](https://github.com/rvbCMTS/PySkinDose/actions/workflows/ci.yml/badge.svg)](https://github.com/BwKodex/dicomimagetools/actions/workflows/python-package.yml) [![codecov](https://codecov.io/gh/BwKodex/dicomimagetools/branch/master/graph/badge.svg?token=2O32UO12V6)](https://codecov.io/gh/BwKodex/dicomimagetools)

# Dicom Image Tools 
The dicom image tools package was created for giving a framework handling DICOM image data. Adding functionality often used for programmatic image analysis.

The package is still in early development and more features will be added.

# Install Dicom Image Tools

Install using pipenv by running:

``
$ pipenv install dicom-image-tools
``

Install using pip by running:

``
$ pip install dicom-image-tools
``

Only **Python 3.10+** is supported.

See project wiki for more detailed documentation

# Usage

When you've installed the package you import it as any other package using 
 
```python 
import dicom_image_tools 
``` 

## Importing DICOM images
There are two functions for importing DICOM images, ``import_dicom_file(file: pathlib.Path)`` and ``import_dicom_from_folder(folder: pathlib.Path, recursively: bool = True)``.

The latter function has an optional input argument for specifying if the folder given should be searched for DICOM files recursively, default = ``True`` 

Both will return the image/-s in ``DicomStudy`` objects, the ``import_dicom_from_folder`` function returns a dictionary with the _Study Instance UID_ as the _key_ and the corresponding ``DicomStudy`` object as _value_.

You can then add additional files to the ``DicomStudy`` object through the ``DicomStudy.add_file`` which takes the file path as a ``pathlib.Path`` object as input.

The ``DicomStudy.Series`` is a list of all series belonging to the study that has been imported. Each ``DicomStudy.Series`` item is an object containing the image/image volume and metadata for each image. The image/image volume is accessed through the ``ImageVolume`` attribute of the ``DicomStudy.Series`` item, and the metadata in the ``CompleteMetadata`` attribute.
imputepy 1.0.1
Impute missing values using Lightgbm
License: MIT
Requires Python: >=3.9,<4.0

# imputepy

Impute missing values using Lightgbm.

## Installation

```bash
pip install imputepy
```

## Features

- **Automated Imputation:** Utilizes LightGBM models to impute missing values, selecting between regression and classification models based on the column's data type.
- **Flexible Column Exclusion:** Allows specific columns to be excluded from the imputation process.
- **Dynamic Filtering for Categorical Columns:** Filters categorical columns based on a specified upper limit of unique values to enhance efficiency.
- **Customizable Thresholds for Categorical Detection:** Enables setting custom thresholds for unique value counts to refine which columns are considered categorical.
- **Comprehensive Imputation Strategy:** Combines missing value identification, column type determination, and the application of LightGBM models for effective imputation.
- **Direct Imputation into Original DataFrame:** Imputes missing values directly into the original DataFrame, maintaining the data structure for seamless data preprocessing integration.


## Usage

```
from imputepy import LGBMimputer
import pandas as pd
import numpy as np

df = pd.read_csv('data/df.csv')
df_imp = LGBMimputer(df, filter=True, exclude=None, filter_upper_limit=50, unique_count_limit=15)
```

## Contributing

Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.

## License

`imputepy` was created by Sam Fo. It is licensed under the terms of the MIT license.

## Credits

`imputepy` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).
flakemaker 1.0.0.post1
Create snowflakes with encoded data in them.
License: MIT
Keywords: SNOWFLAKE,ID

# flakemaker

The `flakemaker` library offers a straightforward approach to generating unique, time-based identifiers similar to Discord's snowflake IDs, but repurposing the worker and process IDs into a generalized "parameter".

## Features

- Generates 64-bit snowflake IDs.
- Customizable epoch.
- Includes a user-defined parameter at snowflake generation. *Note that this replaces the worker and process ids!*

## Quickstart

### Generating a Snowflake

To generate a snowflake, create an instance of `SnowflakeGenerator` and call the `generate` method with your parameter.

```python
from flakemaker import SnowflakeGenerator

generator = SnowflakeGenerator() # you can put a time here in milliseconds since 1970
snowflake = generator.generate(42) # or any value from 0-1023
print(f"Generated snowflake: {snowflake}")
# Generated snowflake: 17359567945990144
```

### Parsing a Snowflake

To parse an existing snowflake and extract its creation time and parameter, use the `parse` method.

```python
dt, parameter = generator.parse(snowflake)
print(f"Timestamp: {dt}, Parameter: {parameter}")
# Timestamp: datetime.datetime(2024, 2, 17, 13, 49, 13, 466377), Parameter: 42
```

This method returns the timestamp of the snowflake as a `datetime` object in UTC and the parameter encoded within the snowflake.