semvec/pypi-packages huggingface dataset:
angmom-suite 1.29.1
A package for working with phenomenological spin and angular momentum operators
Requires Python: >=3.6

# angmom_suite

`angmom_suite` is a python package for working with phenomenological spin and angular momentum operators

# Installation via `pip`

Install `angmom_suite` using `pip` (if using a shared machine, add the `--user` argument after `install`)

```
pip install angmom_suite
```

# Updating

Update the code using `pip` (if using a shared machine, add the `--user` argument after `install`)

```
pip install angmom_suite --upgrade
```

# Installation with `pip` editable install

**Only do this if you are developing (i.e. changing) the code.**

Clone a copy of this repository, preferably while within a directory called git

```
mkdir -p git; cd git
git clone https://gitlab.com/chilton-group/angmom_suite
```

Navigate to the package directory

```
cd angmom_suite/packages
```

and install the package in editable mode (if using a shared machine, add the `--user` argument after `install`)

```
pip install -e .
```

When you're done developing (i.e. your changes have been merged to the master), 
or if you just want to use the current release version of the package, uninstall using `pip`

```
pip uninstall angmom_suite
```

and follow the Installation via `pip` instructions above.

# Usage

The `angmom_suite` command line interface can be invoked with 

```
angmom_suite -h
```

which prints a list of available subprograms.

Alternatively, the individual submodules can be imported into a python program or script as per usual.

# Building a `.whl` file (Advanced)

**Only do this if you are told to.**

To build a copy of the `angmom_suite` `.whl` file, move to the `package` directory.

Now run

```
./build_binaries.sh
```

Then install the `.whl` file with `pip` (if using a shared machine, add the `--user` argument after `install`)

```
pip install dist/*.whl
```

# Documentation

The [documentation](https://chilton-group.gitlab.io/angmom_suite/) for this package is hosted by gitlab, and is automatically generated whenever new code is committed to the `main` branch. The automatic generation of this documentation relies on a common layout for comments and docstrings within the code, see [contributing](https://gitlab.com/chilton-group/group-wiki/-/wikis/Contributing:-General) for more information.

# Development

Before making changes to this repository, please follow the steps outlined in the [Chilton group wiki](https://gitlab.com/chilton-group/group-wiki/-/wikis/Contributing:-General).

# Bugs

If you believe you have a bug, *please check that you are using the most up to date version of the code*. 

If that does not fix the problem, please create an issue on GitLab detailing the following:
 - The commands you entered
 - The error message

Remember to simplify the problem as much as possible in order to provide a minimum working example, e.g. an example for a small molecule rather than one with 100000 atoms.

Then, look at the code, try and figure out what you think is wrong if possible, and include this in your issue.
claude-stream 0.1.1
Parse and prettify Claude Code JSONL stream output
Requires Python: >=3.10
Keywords: anthropic, claude, cli, jsonl, stream

# claude-stream

[![PyPI version](https://badge.fury.io/py/claude-stream.svg)](https://pypi.org/project/claude-stream/)

Parse and prettify Claude Code JSONL stream output.

![claude-stream output](screenshots/demo.svg)

## Installation

```bash
pip install claude-stream
```

For file watching support:

```bash
pip install "claude-stream[watch]"
```

---

![claude-stream watch mode](screenshots/demo.gif)

## Usage

```bash
# Read from a file
claude-stream session.jsonl

# Show only last N lines
claude-stream session.jsonl -n 20

# Read from stdin
cat session.jsonl | claude-stream

# Parse the most recent session
claude-stream --latest
claude-stream --latest -n 50              # Last 50 lines

# Find and parse a session by UUID
claude-stream --session abc123
```

### Watch Mode

Watch for new messages in real-time (like `tail -f`):

```bash
# Watch all Claude sessions
claude-stream --watch ~/.claude/projects/

# Watch from any project directory (auto-resolves to Claude path)
claude-stream --watch .
claude-stream --watch ~/myproject

# Watch with initial context (last N lines)
claude-stream --watch . -n 10
```

When given a directory outside `~/.claude`, the path is automatically
converted to Claude's project format (e.g., `/home/user/project` becomes
`~/.claude/projects/-home-user-project`).

### Output Formats

```bash
# ANSI terminal colors (default for TTY)
claude-stream session.jsonl

# Markdown
claude-stream --format markdown session.jsonl > export.md

# Plain text (default when piped)
claude-stream session.jsonl | less
```

Output automatically switches to plain text when piped. Use `--format ansi` to force colors.

### Filtering

```bash
# Show only specific message types
claude-stream --show-type assistant --show-type user session.jsonl

# Show only messages with specific tools
claude-stream --show-tool Bash --show-tool Read session.jsonl

# Grep for patterns
claude-stream --grep "error" session.jsonl

# Exclude patterns
claude-stream --exclude "thinking" session.jsonl
```

### Display Options

```bash
# Hide thinking blocks
claude-stream --hide-thinking session.jsonl

# Hide tool results
claude-stream --hide-tool-results session.jsonl

# Show metadata (UUIDs, timestamps)
claude-stream --show-metadata session.jsonl

# Compact mode (hide thinking, tool results, metadata)
claude-stream --compact session.jsonl

# Show line numbers
claude-stream --line-numbers session.jsonl
```

## Architecture

- **Pydantic models** parse JSON into typed message structures
- **Messages** produce `RenderBlock` lists (flexible rendering primitives)
- **Formatters** convert `RenderBlocks` to output formats (ANSI, Markdown, Plain)

## License

[WTFPL](http://www.wtfpl.net/)
esp-bool-parser 0.2.2
Tools for building ESP-IDF related apps.
Requires Python: >=3.7

# esp-bool-parser

`esp-bool-parser` is a package that provides a way to process boolean statements based on `soc_caps` files in the ESP-IDF.

It helps you locate `soc_headers` files in the ESP-IDF, parse them, and store the parsed values as constants, which are then used in `ChipAttr`.

When you import `esp_bool_parser`, you will gain access to the following functions:

### Key Functions

#### `parse_bool_expr(stmt: str)`

Parses a boolean expression.

- **Parameters:**
    - `stmt` (str): A string containing the boolean expression.

- **Returns:**
    - A parsed representation of the boolean expression.

- **Usage Example:**

  ```python
  stmt_string = 'IDF_TARGET == "esp32"'
  stmt = parse_bool_expr(stmt_string)
  result = stmt.get_value("esp32", "config_name")
  ```

#### `register_addition_attribute(attr: str, action: t.Callable[..., t.Any]) -> None`

Registers an additional attribute for `ChipAttr`.

You can extend the functionality of `ChipAttr` by adding custom handlers for new attributes.
Use the `register_addition_attribute` function to register additional attributes.
When these attributes are encountered, the associated handler function will be called.
Additionally, you can override existing attributes, as the newly registered handler will take priority over the original ones.

- **Parameters:**
  - `attr` (str): The name of the additional attribute.
  - `action` (Callable): A callable that processes `**kwargs`. The `target` and `config_name` parameters will be passed as `kwargs` when the attribute is detected.

- **Usage Example:**

  ```python
  def my_action(target, config_name, **kwargs):
      # Custom logic to handle the attribute
      print(f"Processing {target} with {config_name}")
      return target

  register_addition_attribute("CUSTOM_ATTR", my_action)
  ```