semvec/pypi-packages huggingface dataset:
pelican-minify 2.0.1
Pelican plugin to minify HTML, CSS and Javascript
License: MIT
Requires Python: >=3.10
Keywords: pelican, plugin, minify, minification, html, css, javascript

Minify: A Plugin for Pelican
============================

[![Build Status](https://img.shields.io/github/actions/workflow/status/pelican-plugins/minify/main.yml?branch=main)](https://github.com/pelican-plugins/minify/actions)
[![PyPI Version](https://img.shields.io/pypi/v/pelican-minify)](https://pypi.org/project/pelican-minify/)
[![Downloads](https://img.shields.io/pypi/dm/pelican-minify)](https://pypi.org/project/pelican-minify/)
![License](https://img.shields.io/pypi/l/pelican-minify?color=blue)

This Pelican plugin can compress HTML & CSS files as well as inline CSS and JavaScript in HTML files.

Requirements
------------

Because this plugin depends on the [`minify-html`](https://pypi.org/project/minify-html) Python package, which in turn utilizes the Rust-based [`minify-html`](https://github.com/wilsonzlin/minify-html) project, you must have Cargo (the Rust package manager) installed and available on your `PATH`. Rust and Cargo can be installed on Mac systems via Homebrew:

    brew install rust

Alternatively, Rust and Cargo can be installed via your particular system’s package manager or via: <https://rustup.rs/>

Installation
------------

This plugin can be installed via:

    python -m pip install pelican-minify

As long as you have not explicitly added a `PLUGINS` setting to your Pelican settings file, then the newly-installed plugin should be automatically detected and enabled. Otherwise, you must add `minify` to your existing `PLUGINS` list. For more information, please see the [How to Use Plugins](https://docs.getpelican.com/en/latest/plugins.html#how-to-use-plugins) documentation.

Usage
-----

By default, all HTML and CSS files will be compressed, including inline JavaScript and CSS rules in `<script>` and `<style>` tags.

To configure the behavior of the plugin, add the following variables in your Pelican settings file (values shown here are the default values):

```python
CSS_MIN = True
JS_MIN = True
HTML_MIN = True
INLINE_CSS_MIN = True
INLINE_JS_MIN = True
```

Please note that `INLINE_CSS_MIN` and `INLINE_JS_MIN` require that `HTML_MIN` be enabled.

Contributing
------------

Contributions are welcome and much appreciated. Every little bit helps. You can contribute by improving the documentation, adding missing features, and fixing bugs. You can also help out by reviewing and commenting on [existing issues][].

To start contributing to this plugin, review the [Contributing to Pelican][] documentation, beginning with the **Contributing Code** section.

[existing issues]: https://github.com/pelican-plugins/minify/issues
[Contributing to Pelican]: https://docs.getpelican.com/en/latest/contribute.html

License
-------

This project is licensed under the MIT license.
epicstore-api-fcorz 0.2.1
An API wrapper for Epic Games Store written in Python
License: MIT
Requires Python: >=3.7

# epicstore_api

[![Current pypi version](https://img.shields.io/pypi/v/epicstore-api.svg)](https://pypi.org/project/epicstore-api/)
[![Supported py versions](https://img.shields.io/pypi/pyversions/epicstore-api.svg)](https://pypi.org/project/epicstore-api/)
[![Downloads](https://pepy.tech/badge/epicstore-api)](https://pypi.org/project/epicstore-api/)

An unofficial library to work with Epic Games Store Web API.
**The library works with `cloudscraper` under the hood to battle the anti-bot protections, please be careful with the amount of requests you do, as this is not a silver bullet.**

## About This Fork

This is a customized fork of the original `epicstore_api` library with additional features and improvements:

- Added `get_store_config()` method to retrieve store configuration for products by sandbox ID
- Implemented support for persisted GraphQL queries with hash caching mechanism
- Added configurable hash endpoint for fetching GraphQL operation hashes
- Enhanced performance with caching for sha256Hash values
- Improved error handling and flexibility for API interactions

## Installing

**Python 3.6 or higher is required**

To install the library you can just run the following command:

``` sh
# Linux/macOS
python3 -m pip install -U epicstore_api

# Windows
py -3 -m pip install -U epicstore_api
```


### Quick Example

``` py
api = EpicGamesStoreAPI()
namespace, slug = next(iter(api.get_product_mapping().items()))
first_product = api.get_product(slug)
offers = [
    OfferData(page['namespace'], page['offer']['id'])
    for page in first_product['pages']
    if page.get('offer') and 'id' in page['offer']
]
offers_data = api.get_offers_data(*offers)
for offer_data in offers_data:
    data = offer_data['data']['Catalog']['catalogOffer']
    developer_name = ''
    for custom_attribute in data['customAttributes']:
        if custom_attribute['key'] == 'developerName':
            developer_name = custom_attribute['value']
    print('Offer ID:', data['id'], '\nDeveloper Name:', developer_name)
```

### New Feature: Get Store Configuration

```python
from epicstore_api import EpicGamesStoreAPI

# Initialize API
api = EpicGamesStoreAPI(locale="zh-CN")

# Get store configuration for a product by sandbox ID
sandbox_id = "b4bb52a95d0b43d9af543c6ec3c54e04"  # Example sandbox ID
config = api.get_store_config(sandbox_id)
print(config)
```

You can find more examples in the examples directory.

### Contributing
Feel free to contribute by creating PRs and sending your issues

## Links
* [Documentation](https://epicstore-api.readthedocs.io/en/latest/)

## License
MIT
dagster-clt-queued-run-coordinator 1.10.0
Code Location Tagging (CLT) QueuedRunCoordinator – a custom Dagster run coordinator that automatically injects code-location tags before queuing.
License: MIT
Requires Python: >=3.9

# Dagster CLTQueuedRunCoordinator 

`CLTQueuedRunCoordinator` (Code-Location Tagging Queued Run Coordinator) is a custom Dagster run coordinator that automatically tags every run with its code-location name. Each run receives a tag in the following format:

```
code_location:{code_location_name}
```

`CLTQueuedRunCoordinator` helps you enforce tag-based concurrency limits for each code server (code location), allowing you to cap the number of Dagster runs on Kubernetes. It inherits from `QueuedRunCoordinator`, so it supports all of the same configuration options.

## How to use

To use the `CLTQueuedRunCoordinator`, you must configure the Dagster daemon, the Dagster web server, and the Dagster code-location server.

### Daemon

```yaml
dagsterDaemon:
  enabled: true

  image:
    repository: "ghcr.io/ssup2/dagster-clt-queued-run-coordinator"
    tag: "1.10.5"
    pullPolicy: Always

  runCoordinator:
    enabled: true

    type: CustomRunCoordinator
    config:
      customRunCoordinator:
        module: clt_queued_run_coordinator.coordinator
        class: CLTQueuedRunCoordinator
        config:
          dequeue_interval_seconds: 5
          dequeue_use_threads: true
          dequeue_num_workers: 4
          tag_concurrency_limits:
            - key: "code_location"
              value: "code-location-a"
              limit: 10
            - key: "code_location"
              value: "code-location-b"
              limit: 20
```

Set the run coordinator to CustomRunCoordinator, and configure CLTQueuedRunCoordinator with the values below:

* Container Image : `ghcr.io/ssup2/dagster-clt-queued-run-coordinator:<release-version>`
* Coordinator Module :  `clt_queued_run_coordinator.coordinator`
* Coordinator Class : `CLTQueuedRunCoordinator`
* Config : Uses the same settings as `QueuedRunCoordinator`, but all option names are in **snake_case** rather than **PascalCase** (e.g., `DequeueIntervalSeconds` → `dequeue_interval_seconds`).
  * With the `tag_concurrency_limits` option, you can define per-code-location concurrency limits by using the `code_location` tag.

### Web Server

```yaml
dagsterWebServer:
  enabled: true

  image:
    repository: "ghcr.io/ssup2/dagster-clt-queued-run-coordinator"
    tag: "1.10.5"
    pullPolicy: Always
```

Set the web server image to the same image as the daemon.

* Container Image : `ghcr.io/ssup2/dagster-clt-queued-run-coordinator:<release-version>`

### Code Location Server

```shell
# pip
pip install dagster-clt-queued-run-coordinator

# uv
uv add dagster-clt-queued-run-coordinator
```

Code Location Server must install the `dagster-clt-queued-run-coordinator` python package.