semvec/pypi-packages huggingface dataset:
weasyprint 68.1
The Awesome Document Factory
Requires Python: >=3.10
Keywords: html, css, pdf, converter

**The Awesome Document Factory**

WeasyPrint is a smart solution helping web developers to create PDF
documents. It turns simple HTML pages into gorgeous statistical reports,
invoices, tickets…

From a technical point of view, WeasyPrint is a visual rendering engine for
HTML and CSS that can export to PDF. It aims to support web standards for
printing. WeasyPrint is free software made available under a BSD license.

It is based on various libraries but *not* on a full rendering engine like
WebKit or Gecko. The CSS layout engine is written in Python, designed for
pagination, and meant to be easy to hack on.

* Free software: BSD license
* For Python 3.10+, tested on CPython and PyPy
* Documentation: https://doc.courtbouillon.org/weasyprint
* Examples: https://weasyprint.org/#samples
* Changelog: https://github.com/Kozea/WeasyPrint/releases
* Code, issues, tests: https://github.com/Kozea/WeasyPrint
* Code of conduct: https://www.courtbouillon.org/code-of-conduct
* Professional support: https://www.courtbouillon.org
* Donation: https://opencollective.com/courtbouillon

WeasyPrint has been created and developed by Kozea (https://kozea.fr/).
Professional support, maintenance and community management is provided by
CourtBouillon (https://www.courtbouillon.org/).

Copyrights are retained by their contributors, no copyright assignment is
required to contribute to WeasyPrint. Unless explicitly stated otherwise, any
contribution intentionally submitted for inclusion is licensed under the BSD
3-clause license, without any additional terms or conditions. For full
authorship information, see the version control history.
netfshare 0.6
A simple flask-based file sharing / distribution service
Requires Python: >=3.10

# netfshare

A flask-based local network file sharing tool.

**Not for production environements. Use with care.**

## Installation and use

1. Install the `netfshare` python package:

    ```py -m pip install netfshare```

2. Navigate to the directory that you want to share the contents of. 

3. (OPTIONAL) To secure your WSGI application, set a custom `SECRET_KEY` environment variable, or create a `.env` file in the shared
   directory defining the `SECRET_KEY`:

        SECRET_KEY=my_secret_key
    
4. Run `netfshare` to start the sharing service:
   
   ```py -m netfshare```

The service cam+n be accessd at `<your-local-ip>:5000`. 

Make sure your machine is discoverable in the local network and that the required firewall rules are active.

### Admin access

The `netfshare` app automatically recognizes a client that's accessing the app from the host (machine running the app) as admin.

If you're having issues with admin access (e.g. you're not recognized as admin despite accessing the app from your local machine), try accessing the app directl at:

```
http://127.0.0.1:<port>
```

## Sharing settings

Visit the service website Admin interface from the machine running the service to manage the sharing settings.

`netfshare` supports downloading the contents (subdirectories) of your shared folder, as well as uploading clients' content to selected directories inside the shared folder.

Only downloads of *whole subdirectories* are supported, as `.zip` archives. To make files available for downalod, they must be placed inside a subdirectory of the sharedfolder, and the appropriate sharing mode must be set for this subdirectory in the Admin web interface. 

Currently, the supported sharing modes are:
 - `read_only`: whole subdirectories of the shared folder can be downloaded as a `.zip` archive.
 - `upload_only`: clients can upload their data into a selected subdirectory of the shared folder. The uploaded content is placed inside a subfolder with the user's selected name. Currently, only a *single upload* by each user is allowed.

 
## Localization

netfshare supports localization using [flask-babel]([s](https://python-babel.github.io/flask-babel/)).

The client-facing routes of the app are translated into English and Slovenian.

To update the translations after adding / modifying app text, run the following to get new text to bt translated and update the Slovenian translation file,:


    pybabel extract -F babel.cfg -o messages.pot .
    pybabel update -i messages.pot -d netfshare/translations


Now edit / add new translations in `translations/sl/LC_MESSAGES/messages.po` and compile the new translations:

    pybabel compile -d netfshare/translations
imspy-search 0.4.0
Database search functionality for timsTOF proteomics data using sagepy.
Requires Python: <3.14,>=3.11

# imspy-search

Database search functionality for timsTOF proteomics data using sagepy.

## Installation

```bash
pip install imspy-search
```

## Features

- **Database Search**: SAGE-based database search for timsTOF DDA data
- **PSM Rescoring**: Machine learning-based rescoring of peptide-spectrum matches
- **FDR Control**: Target-decoy competition and q-value estimation
- **MGF Support**: Parse and search Bruker DataAnalysis MGF files
- **CLI Tools**: Command-line interfaces for common workflows

## Quick Start

```python
from imspy_search import (
    extract_timstof_dda_data,
    get_searchable_spec,
    generate_balanced_rt_dataset,
    generate_balanced_im_dataset,
)

# Extract DDA data for database search
fragments = extract_timstof_dda_data(
    path="path/to/data.d",
    num_threads=16,
)
```

## CLI Tools

### imspy-dda
Full DDA search pipeline with intensity prediction and rescoring:
```bash
imspy-dda /path/to/data /path/to/fasta.fasta --config config.toml
```

### imspy-ccs
Extract CCS values from DDA data for machine learning:
```bash
imspy-ccs --raw_data_path /path/to/data --fasta_path /path/to/fasta.fasta
```

### imspy-rescore-sage
Rescore SAGE search results with deep learning features:
```bash
imspy-rescore-sage results.tsv fragments.tsv /output/path
```

## Submodules

- **utility**: Core utility functions for database search
- **sage_output_utility**: SAGE output processing and rescoring
- **mgf**: MGF file parsing for sagepy queries
- **rescoring**: PSM rescoring with deep learning features
- **dda_extensions**: TimsDatasetDDA extensions for sagepy
- **cli/**: Command-line interface tools

## Dependencies

- **imspy-core**: Core data structures (required)
- **imspy-predictors**: ML predictors for CCS, RT, intensity (required)
- **sagepy**: SAGE database search framework (required)
- **mokapot**: Machine learning for PSM scoring (required)

## Related Packages

- **imspy-core**: Core data structures and timsTOF readers
- **imspy-predictors**: ML-based predictors
- **imspy-simulation**: Simulation tools for timsTOF data
- **imspy-vis**: Visualization tools

## License

MIT License - see LICENSE file for details.
imspy-vis 0.4.0
Lightweight visualization tools for timsTOF proteomics data.
Requires Python: <3.14,>=3.11

# imspy-vis

Lightweight visualization tools for timsTOF proteomics data.

## Installation

```bash
pip install imspy-vis
```

For Jupyter notebook support:

```bash
pip install imspy-vis[notebook]
```

## Features

- **Frame Rendering**: DDA and DIA frame visualization with annotation overlays
- **Point Cloud Visualization**: Interactive 3D visualization using Plotly
- **Video Generation**: Generate preview videos from timsTOF datasets
- **Jupyter Integration**: Interactive widgets for notebook-based exploration

## Quick Start

### Frame Rendering

```python
from imspy_vis import DDAFrameRenderer, DIAFrameRenderer, generate_preview_video

# Generate a quick preview video
generate_preview_video(
    '/path/to/data.d',
    '/path/to/output.mp4',
    mode='dda',
    max_frames=100,
    fps=10
)

# Or use the renderer directly
renderer = DDAFrameRenderer('/path/to/data.d')
renderer.render_to_video('/path/to/output.mp4', max_frames=50)
```

### Point Cloud Visualization (Jupyter)

```python
from imspy_vis import DDAPrecursorPointCloudVis

# In a Jupyter notebook
visualizer = DDAPrecursorPointCloudVis(precursor_data)
visualizer.display_widgets()
```

## Modules

- **pointcloud**: Interactive 3D point cloud visualization using Plotly
- **frame_rendering**: Frame-by-frame rendering and video generation

## Dependencies

- **imspy-core**: Core data structures (required)
- **plotly**: Interactive plotting
- **matplotlib**: Static plotting and frame rendering
- **imageio**: Video generation
- **ipywidgets**: Jupyter notebook widgets

## Related Packages

- **imspy-core**: Core data structures and timsTOF readers
- **imspy-predictors**: ML-based predictors
- **imspy-simulation**: TimSim simulation tools
- **imspy-search**: Database search functionality

## License

MIT License - see LICENSE file for details.