semvec/pypi-packages huggingface dataset:
signalwave 1.0
A library for creating and analyzing signal wave function models.
Requires Python: >=3.6

# SignalWave

SignalWave is a Python library for creating and analyzing signal wave functions.

## Installation

```sh
pip install signalwave
```

## Usage

```python
from signalwave import SignalWave
import numpy as np

wave = SignalWave([1, 2], [1, 0.5], [0, 0], [0, 0])
t = np.linspace(0, 10, 1000)
waveform = wave.generate_waveform(t)
```

## Features

- Generate signal waveforms using multiple oscillators.
- Analyze wave characteristics.
- Perform Fourier analysis on generated signals.
- Create modulated signals.

## Examples

1. **Basic Usage**: Learn how to generate and visualize a signal wave. [`example_basic.py`](examples/example_basic.py)
2. **Fourier Analysis**: Apply Fourier Transform to analyze the frequency content of a signal wave. [`example_fourier.py`](examples/example_fourier.py)
3. **Modulation**: Create an amplitude-modulated signal using a low-frequency wave. [`example_modulation.py`](examples/example_modulation.py)
dictdeeper 1.2
DictDeeper: Easy traversal of deeply nested dicts.
Requires Python: >=3.9

# DictDeeper: The easy way to manipulate deeply-nested dicts like JSON-style objects.

## What you can do with DictDeeper?

1. You can navigate to any depth with a simple dotted-string key notation.
2. You can even transparently navigate within lists inside dicts.
3. You can do full and partial validate of your dict structure in a declarative way.
4. You can do full and partial value comparison in a declarative way.
5. You can arrange a variety of strategies to merge dicts into a single one.

## How to use it?

To access values nested in an object using a dotted-key notation,
wrap the object using `DeepDict`, then use the standard `dict` interface:

```python
from dictdeeper import DeepDict


request_body = DeepDict(request.json())
is_scheduled = request_body.get("data.attributes.date_scheduled") is not None
```

## How to match the structure of a deeply nested dict?

Use DeepDict to compare the values within a `dict` or `list` against a partial specification.

Both `DeepDict` and `DeepList` objects automatically use deep matching in their `__eq__` method.

When a comparison fails, a `MatcherError` is raised, with the location and context of the mismatch.

Here are the things you can use in the matching spec:

1. **`some_key` in a `dict` exists of any value**: Include `"some_key": ...` in the spec.
2. **Other keys may exist in a `dict`**: Include `...: ...` in the spec.
3. **Matching items in an unordered `list`**: Include `...` as an item in the spec.
4. **Matching a string against a regex**: Use `re.compile("your-regex-here")` as a value in the spec.

Example:

```python
data = {
    "1": "one",
    "2": {
        "a": "A",
        "b": {
            "i": "I",
            "ii": "II",
        },
    },
    "3": ["index0", "index1", "index2"],
    "4": [{"id": 1, "name": "foo"}, {"id": 2, "name": "bar"}, {"id": 3, "name": "baz"}],
}

assert DeepDict(data) == {
    "1": ...,  # [1]
    "3": ["index1", ...],  # [3]
    "4": [{"name": re.compile("ba."), ...: ...,}, ...],  # [4]
    ...: ...,  # [2]
}
```

## Thank you to Routable

[Routable](https://routable.com) sponsored the development of this library.
Working at [Routable](https://routable.com) is an awesome experience, with a developer-first culture that fosters innovation and growth.
If you're interested in joining a dynamic team, [check out our job opportunities here](https://routable.com/careers/)!

## Authors

- Henrique Bastos <henrique@bastos.net>
- Matthew Scott <matt@11craft.com>
scim-sim 0.0.1
A SCIM directory simulator and management tool
Requires Python: >=3.6

# SCIM Directory Simulator CLI

A command-line tool for simulating and managing a SCIM (System for Cross-domain Identity Management) directory. This tool allows you to create and manage users and groups, simulating a real SCIM-compliant identity provider.

## Installation

```bash
brew tap Avinash-Kamath/scim-simulator
brew install scim-sim
```

## Configuration

Before using the tool, you need to set up your SCIM configuration:

```bash
scim-sim config
```

This will prompt you for:
- SCIM Base URL - The endpoint of your SCIM service (e.g., https://api.example.com/scim/v2)
- SCIM Auth Token - Your authentication token

Configuration is stored in `~/.scim_config.json`. You can view your current configuration with:

```bash
scim-sim config
```

## Commands

### User Management

```bash
# Add a new user (generates random user data)
scim-sim add-user

# Remove a user
scim-sim remove-user <user-id>
```

### Group Management

```bash
# Create a new group
scim-sim create-group "Engineering Team"

# Delete a group and its members
scim-sim delete-group <group-id>

# Add user to group
scim-sim add-to-group <user-id> <group-id>

# Remove user from group
scim-sim remove-from-group <user-id> <group-id>
```

### Directory Visualization

```bash
# Show complete directory structure
scim-sim show
```

This will display a tree view of your directory structure, showing all groups and users.

Example output:
```
📂 Directory
├── 👥 Groups
│   ├── Engineering Team │ ID: dirgrp_1234567890123456
│   │    ├── 👤 avinash.kamath@example.com │ ID: dirusr_8913202356420102
│   │    └── 👤 srini.k@example.com │ ID: dirusr_4123456789012345
│   │
│   └── Product Team │ ID: dirgrp_6789012345678901
└── 👤 Ungrouped Users
    └── ravi@example.com │ ID: dirusr_6789012345678901
```

## Available Commands

- `setup` - Configure SCIM settings
- `config` - View current configuration
- `add-user` - Create a new user
- `remove-user` - Delete a user
- `show` - Display directory structure
- `create-group` - Create a new group
- `delete-group` - Delete a group and its members
- `add-to-group` - Add user to group
- `remove-from-group` - Remove user from group