semvec/pypi-packages huggingface dataset:
softsensor 0.1.0rc1
A general toolbox for the development of Vibrational Soft-Sensors
Requires Python: >=3.12

# vibration-soft-sensor   <!-- omit in toc -->

A general toolbox for the development of vibrational softsensors. You can find a lot of functionality for data  preprocessing, model training and evaluation for linear and non linear methods. 
We have also adapt the general approach to a variety of signal types.

The main paper `Stabilised Auto-Regressive Neural Networks (S-Arnns) for Data Driven Prediction of Forced Nonlinear Systems` can be found on http://dx.doi.org/10.2139/ssrn.4720155.

## Table of Contents  <!-- omit in toc -->

- [Content](#content)
- [Maintainers](#maintainers)  
- [License](#license)
- [3rd Party Licenses](#3rd-party-licenses)
  

<a name="content"></a>

## Content

The vibration-soft-sensor library provides comprehensive tools for analyzing vibration data and building soft sensors. Key components include:

### Core Components
- **Model Types**
  - `autoreg_models`: Autoregressive models including ARNN
  - `recurrent_models`: Recurrent neural networks for time series prediction
  - `linear_methods`: Transfer function and other linear methods
  - `model`: Base model implementations (LSTM, CNN)
  - `arx`: Tools for ARX modeling with sliding window approaches

### Analysis Tools
- `frequency_methods`: Frequency domain analysis including FDS (Fatigue Damage Spectrum)
- `visualization`: Extensive plotting utilities for sensitivity analysis and model evaluation
- `eval_tools`: Model evaluation and error computation functionalities

### Data Handling
- `data_gen`: Simulated data generation with various excitation signals (sine, sweep, white noise)
- `meas_handling`: Measurement data preprocessing, including filtering

### Advanced Features
- `stab_scheduler`: Stability scoring and schedulers for neural networks
- `losses`: Custom loss functions including PSD-based losses
- `ensemble_wrappers`: Ensemble model implementations (Sync/AsyncEnsemble)
- `hyperparameter_optimization`: Tools for optimizing model parameters

### Sensitivity Analysis
The library offers multiple sensitivity analysis methods:
- Gradient-based methods
- SmoothGrad
- Integrated gradients
- Perturbation analysis
- Uncertainty quantification


<a name="maintainers"></a>

### Maintainers
[Tobias Westmeier](tobias.westmeier@iee.fraunhofer.de)

[Daniel Kreuter](danielchristopher.kreuter@de.bosch.com)

<a name="license"></a>

### License
`softsensor` is open-sourced under the Apache-2.0 license. See the
[LICENSE](LICENSE) file for details.

For a list of other open source components included in pyLife, see the
file [3rd-party-licenses.txt](3rd-party-licenses.txt).
pluralizer 2.0.0
Singularize or pluralize a given word using a pre-defined list of rules
Requires Python: >=3.10
Keywords: plural, pluralize, singular, singularize

[![PyPI](https://img.shields.io/pypi/v/pluralizer?style=plastic)](https://pypi.org/project/pluralizer/)
[![Codecov](https://img.shields.io/codecov/c/github/weixu365/pluralizer-py?style=plastic)](https://codecov.io/gh/weixu365/pluralizer-py)
[![GitHub Workflow Status](https://github.com/weixu365/pluralizer-py/actions/workflows/pythonpackage.yml/badge.svg)](https://github.com/weixu365/pluralizer-py/actions)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/pluralizer?style=plastic)](https://pypistats.org/packages/pluralizer)

## Why this project?
This repo is simply a Python port of https://github.com/blakeembrey/pluralize which has > 1.4m github usages and 3.5 million downloads per week when I evaluating different libraries.

> This module uses a pre-defined list of rules, applied in order, to singularize or pluralize a given word. There are many cases where this is useful, such as any automation based on user input. For applications where the word(s) are known ahead of time, you can use a simple ternary (or function) which would be a much lighter alternative.

I have compared the following alternatives and found https://github.com/blakeembrey/pluralize is the best one for me (most accurate), so ported it into the Python world.
- TextBlob: https://github.com/sloria/TextBlob
- inflect: https://github.com/jazzband/inflect
- NLTK Wordnet: https://www.nltk.org/howto/wordnet.html


## Installation
```bash
pip install pluralizer
```

## Usage
```python
from pluralizer import Pluralizer

pluralizer = Pluralizer()

assert pluralizer.pluralize('apple', 1, False) == 'apple'
assert pluralizer.pluralize('apple', 1, True) == '1 apple'
assert pluralizer.pluralize('apple', 2, False) == 'apples'
assert pluralizer.pluralize('apple', 2, True) == '2 apples'

assert pluralizer.plural('apple') == 'apples'
assert pluralizer.singular('apples') == 'apple'

assert pluralizer.isPlural('apples') == True
assert pluralizer.isPlural('apple') == False
assert pluralizer.isSingular('apples') == False
assert pluralizer.isSingular('apple') == True
```

## License
MIT

All credits to https://github.com/blakeembrey/pluralize.
pyinternals 0.1.3
A Python object layout visualizer using CPython internals
Requires Python: >=3.7
Keywords: cpython, visualizer, memory, introspection

# pyinternals

A visualizer for Python object layout in CPython.

This package provides tools to directly inspecting Python objects through their C-level structure using `ctypes`.
This is a powerful approach for deep object introspection, especially when you need to examine the internal memory representation of Python objects like `int`, `float`, `str`, `list`, `dict` and custom classes.


## Features

- Inspect memory layout of Python objects.
- Visualize CPython object internals like `__dict__`, `__slots__`, methods, and more.
- Great for learning how CPython manages memory.

## Installation

Install via pip:

```bash
pip install pyinternals
```
## Learning materials

- CPython implementation : https://github.com/python/cpython
- Cpython Internals repository: https://github.com/zpoint/CPython-Internals