semvec/pypi-packages huggingface dataset:
marklassian 0.1.0
Convert Markdown to Atlassian Document Format (ADF)
Requires Python: >=3.10
Keywords: adf, atlassian, confluence, jira, markdown

# marklassian-py

A lightweight Python library that converts Markdown to the [Atlassian Document Format (ADF)](https://developer.atlassian.com/cloud/jira/platform/apis/document/structure/). Built for easy integration with Atlassian products like Jira and Confluence.

This is a Python port of the excellent [marklassian](https://github.com/jamsinclair/marklassian) JavaScript library by [@jamsinclair](https://github.com/jamsinclair).

## Features

- Convert Markdown to ADF with a single function call
- Support for common Markdown syntax including GFM task lists
- Minimal dependencies (only [mistune](https://github.com/lepture/mistune))
- Full type hints for IDE support
- Python 3.10+

## Installation

```bash
pip install marklassian
```

Or with uv:

```bash
uv add marklassian
```

## Usage

```python
from marklassian import markdown_to_adf

markdown = "# Hello World\n\nThis is **bold** and *italic* text."
adf = markdown_to_adf(markdown)
```

The result is a dictionary that can be serialized to JSON:

```python
import json
print(json.dumps(adf, indent=2))
```

## Supported Markdown Features

- Headings (H1-H6)
- Paragraphs and line breaks
- Emphasis (bold, italic, strikethrough)
- Links and images
- Inline code and code blocks with language support
- Ordered and unordered lists with nesting
- Blockquotes
- Horizontal rules
- Tables
- Task lists (GitHub Flavored Markdown)

## API Reference

### `markdown_to_adf(markdown: str) -> AdfDocument`

Converts a Markdown string to an ADF document object.

### Types

```python
class AdfMark(TypedDict, total=False):
    type: Required[str]
    attrs: dict[str, Any]

class AdfNode(TypedDict, total=False):
    type: Required[str]
    attrs: dict[str, Any]
    content: list[AdfNode]
    marks: list[AdfMark]
    text: str

class AdfDocument(TypedDict):
    version: Literal[1]
    type: Literal["doc"]
    content: list[AdfNode]
```

## Caveats

This library aims to provide a lightweight and mostly accurate conversion from Markdown to ADF.

For complex Markdown documents or strict ADF conformance requirements, consider using the official Atlassian libraries. Note that those are heavier dependencies.

## References

- [Atlassian Document Format Reference](https://developer.atlassian.com/cloud/jira/platform/apis/document/structure/)
- [ADF Interactive Builder](https://developer.atlassian.com/cloud/jira/platform/apis/document/playground/)
- [Original marklassian (JavaScript)](https://github.com/jamsinclair/marklassian)

## Credits

This library is a Python port of [marklassian](https://github.com/jamsinclair/marklassian) by [Jamie Sinclair](https://github.com/jamsinclair). All credit for the original implementation and conversion logic goes to them.

## License

MIT - see [LICENSE](LICENSE) for details.
mrseq 0.260119
(Py)Pulseq-based MRI sequences.
Requires Python: <3.15,>=3.10
Keywords: MRI, Pulseq, PyPulseq, pulse sequence


![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
![Coverage Bagde](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/schuenke/330a0c00b5fa35d89bbc73ea6e8d99be/raw/coverage.json)

# MRseq - MR pulse sequences using Pulseq

MRseq is a collection of several useful functions, kernels and scripts for creating vendor-agnostic MR pulse sequences using the open-source Pulseq format.

- **Source code:** <https://github.com/PTB-MR/mrseq>
- **Bug reports:** <https://github.com/PTB-MR/mrseq/issues>
- **Documentation:** <https://ptb-mr.github.io/mrseq/intro.html>

## Contributing

We are looking forward to your contributions via Pull-Requests.

### Installation for developers

#### Prerequisites for Windows

Before installing MRseq with development dependencies on Windows, you need:

1. **Visual Studio Build Tools**: The MRzeroCore dependency requires Rust compilation with Microsoft Visual C++ linker
   - Download "Build Tools for Visual Studio 2022" from https://visualstudio.microsoft.com/downloads/
   - During installation, select the "C++ build tools" workload
   - Ensure "Windows 10/11 SDK" is included
   - This is required for compiling native Rust extensions

2. **Rust toolchain** (automatically installed by MRzeroCore if not present)

#### Installation steps

1. Clone the MRseq repository
2. Create/select a python environment
3. Install "MRseq" in editable mode including test dependencies: ``` pip install -e ".[dev]" ```
4. Setup pre-commit hook: ``` pre-commit install ```
dask-geomodeling 2.7.0
On-the-fly operations on geographical maps.
Requires Python: >=3.10
Keywords: dask

dask-geomodeling
==========================================

.. image:: https://readthedocs.org/projects/dask-geomodeling/badge/?version=latest
     :target: https://dask-geomodeling.readthedocs.io/en/latest/?badge=latest

.. image:: https://github.com/nens/dask-geomodeling/actions/workflows/test.yml/badge.svg
    :target: https://github.com/nens/dask-geomodeling/actions/workflows/test.yml

.. image:: https://badge.fury.io/py/dask-geomodeling.svg
    :target: https://badge.fury.io/py/dask-geomodeling

.. image:: https://anaconda.org/conda-forge/dask-geomodeling/badges/version.svg
    :target: https://anaconda.org/conda-forge/dask-geomodeling

Dask-geomodeling is a collection of classes that are to be stacked together to
create configurations for on-the-fly operations on geographical maps. By
generating `Dask <https://dask.pydata.org/>`_ compute graphs, these operation
may be parallelized and (intermediate) results may be cached.

Multiple Block instances together make a view. Each Block has the ``get_data``
method that fetches the data in one go, as well as a ``get_compute_graph``
method that creates a graph to compute the data later.

`Read the docs <https://dask-geomodeling.readthedocs.org/>`_ for further information.

## Development on this project itself

The standard command to setup your project using [`uv`](https://docs.astral.sh/uv/) is:

    uv sync --dev       # 'uv.lock' is git-ignored, because this is a library

This project uses GDAL, which requires additional system packages to be available on your
system. On Ubuntu, you can install them with:

    sudo apt-get install gdal-bin libgdal-dev

Then, installation of the GDAL python module is done as follows:

    source .venv/bin/activate
    pip install GDAL[numpy]==$(gdal-config --version) --no-build-isolation

Then run the tests:

    uv run pytest

The tests are also run automatically [on "github actions"](https://github.com/nens/dask-geomodeling/actions) for "master" and for pull requests. So don't just make a branch, but turn it into a pull request right away. On your pull request page, you also automatically get the feedback from the automated tests.


## Release

Make sure you have [zest.releaser](https://zestreleaser.readthedocs.io/en/latest/) installed.

    uv run fullrelease

When you created a tag, it will be uploaded automatically [to pypi](https://pypi.org/project/rana-process-sdk/) by a Github Action.

This project is also available on [conda-forge](https://anaconda.org/conda-forge/dask-geomodeling).
After a release on PyPI is made, a Pull Request is automatically created on https://github.com/conda-forge/dask-geomodeling-feedstock. Merge this
to publish the new version on conda-forge.