semvec/pypi-packages huggingface dataset:
imessage-exporter 0.2.0
A tool to export and search iMessages from local chat.db
Requires Python: >=3.7

# iMessage Exporter

A Python tool to search and export iMessages from your local macOS `chat.db`.

## Installation

1. Clone this repository.
2. Install in editable mode:
   ```bash
   pip install -e .
   ```

## Usage

The tool provides a CLI command `imessage-exporter`.

### List Recent Chats
```bash
imessage-exporter --list-chats
```

### Search Messages
Search for a specific term:
```bash
imessage-exporter --search "hello"
```

### Filter by Date
Get messages from today:
```bash
imessage-exporter --today
```

Get messages from a specific date:
```bash
imessage-exporter --date 2023-10-27
```

### Combine Filters
Search for "meeting" in messages from today:
```bash
imessage-exporter --search "meeting" --today
```

## Permissions

This tool requires **Full Disk Access** for the terminal or IDE running it, as it reads directly from `~/Library/Messages/chat.db`.
geometor-divine 0.3.5
An analysis engine for identifying golden sections and harmonic ranges.
Requires Python: >=3.13

GEOMETOR • divine
=================

.. image:: https://img.shields.io/pypi/v/geometor-divine.svg
   :target: https://pypi.python.org/pypi/geometor-divine
.. image:: https://img.shields.io/github/license/geometor/divine.svg
   :target: https://github.com/geometor/divine/blob/main/LICENSE

An analysis engine for identifying golden sections and harmonic ranges.

Overview
--------

**geometor.divine** provides tools to identify deep geometric relationships within a model. It specifically focuses on the "Divine Proportion" (Golden Ratio) and harmonic ranges, revealing the hidden structure in geometric constructions.

Key Features
------------

- **Golden Section Analysis**: Automatically detects points that divide segments in the golden ratio.
- **Harmonic Ranges**: Identifies harmonic relationships between points on a line.
- **Pattern Recognition**: Groups related elements into chains and families.

Usage
-----

**divine** is primarily designed to work with `geometor.model` and is integrated directly into `geometor.explorer`.

You can also run the analysis script directly:

.. code-block:: bash

    divine

Or use it as a library:

.. code-block:: python

    from geometor.model import Model
    from geometor.divine import analyze_model

    model = Model("example")
    # ... perform constructions ...
    
    analysis = analyze_model(model)
    print(analysis.golden_sections)

Resources
---------

- **Source Code**: https://github.com/geometor/divine
- **Issues**: https://github.com/geometor/divine/issues

Related Projects
----------------

- `GEOMETOR Model <https://github.com/geometor/model>`_: The core symbolic engine.
- `GEOMETOR Explorer <https://github.com/geometor/explorer>`_: Interactive visualization.
mjxml 0.2.3
Utilities to programatically create MuJoCo XML configuration files
Requires Python: >=3.13

# mjxml

Programmatic, type-checked helpers for composing MuJoCo XML. Define assets and worldbody elements in Python (with Pydantic validation), serialize to XML, and write files you can load in MuJoCo.

## Highlights

- Strong typing and validation via Pydantic v2.
- Easy XML serialization: `to_xml()`, `to_xml_str()`, `write()`.
- Assets: `TextureAsset`, `MeshAsset`, `HFieldAsset`, `ModelAsset`.
- Bodies: `Geom` (with many MuJoCo attributes), `WorldBody` base.
- Utilities: `Defaults` blocks, rotation helpers, and runtime type protocols.

## Requirements

- Python >= 3.13
- Runtime deps: `numpy`, `pydantic`

## Install

From PyPI:

```bash
pip install mjxml
```

## Development

This project relies on `uv`. To setup a virtual environment, just do:

```bash
uv sync --dev
export PYTHONPATH=src
```

## Quickstart

The snippets below sketch a typical flow: create assets, place them in the worldbody, and export a MuJoCo XML file.

### 1. Define assets with validation

```python
from mjxml.asset.texture import TextureAsset
from mjxml.asset.mesh import MeshAsset

texture = TextureAsset(
    name="tex_grid",
    file="albedo.png",
    type="2d",
    colorspace="srgb",
    content_type="image/png",
    nchannel=3,
)

mesh = MeshAsset(
    name="m_cube",
    file="cube.obj",
    content_type="model/obj",
    scale=[1.0, 1.0, 1.0],
    inertia="exact",
)
```

Each asset only emits the attributes you set; Pydantic validators ensure parameters such as `nchannel` or `scale` stay within MuJoCo’s requirements.

### 2. Create bodies and geoms

```python
from mjxml.body import Body, Geom

body = Body(name="torso")
body.add(
    Geom(
        name="box1",
        type="box",
        size=[0.5, 0.5, 0.5],
        material=None,
        rgba=[0.8, 0.2, 0.2, 1.0],
        friction=[0.5, 0.1, 0.01],
    )
)
```

Geoms automatically infer fields such as `condim` from the friction vector length and warn when MuJoCo would ignore an attribute.

### 3. Assemble a complete `MujocoModel`

```python
from mjxml.model import MujocoModel

model = MujocoModel(name="demo")
model.add_asset(texture)
model.add_asset(mesh)
model.add_body(body)

root = model.to_xml()
print(model.to_xml_str())
model.write("scene.xml")
```

`MujocoModel` deduplicates identical assets, appends worldbody, actuator, and contact sections, and returns a ready-to-save ElementTree root.

## Testing

Run the unit tests with `pytest`.

```bash
pytest -q -s
```

## Status

This repository is under active development; expect minor API adjustments. A high-level `MujocoModel` aggregator is planned but not yet included.

## Roadmap

- [✅] **High-level Wrapper**: `MujocoModel` class to aggregate assets, worldbody, and other sections.
- [✅] **Body Elements**: Support for `joint`, `site`, `camera`.
- [=] **Sections**: Support for `actuator`, `sensor`, `equality`, `contact`, `tendon`.
- [❌] **IO**: Parsing existing XML files for round-trip editing.
- [❌] **Docs**: Comprehensive API documentation and more examples.