semvec/pypi-packages huggingface dataset:
py-level-fleet 0.1.1
A Vue.js-like templating engine using Jinja2 for Python
Requires Python: >=3.7
Keywords: vue, jinja2, templating, html, template-engine

# Py Level Fleet

A powerful Vue.js-like templating engine for Python using Jinja2. This package provides a familiar Vue.js syntax while leveraging the robust features of Jinja2.

## Features

- Vue.js-like template syntax with `p-` directives
- Full Jinja2 template engine capabilities
- Support for async rendering
- Sandboxed environment for security
- I18N support
- BeautifulSoup4 for HTML parsing
- Template caching for better performance

## Installation

```bash
pip install py_level_fleet
```

## Quick Start

```python
from py_level_fleet import render_template

template = """
<div p-if="show">
    <p p-text="message"></p>
</div>
<ul>
    <li p-for="item in items" p-key="item.id">{{ item.name }}</li>
</ul>
"""

data = {
    'show': True,
    'message': 'Hello, World!',
    'items': [{'id': 1, 'name': 'Item 1'}, {'id': 2, 'name': 'Item 2'}]
}

output = render_template(template, data)
print(output)
```

## Available Directives

- `p-if`: Conditional rendering
- `p-else-if`: Alternative condition
- `p-else`: Fallback content
- `p-for`: List rendering
- `p-key`: Unique key for list items
- `p-bind`: Dynamic attribute binding
- `p-text`: Text content binding
- `p-html`: HTML content binding
- `p-show`: Conditional display
- `p-on`: Event handling
- `p-model`: Two-way data binding
- `p-pre`: Skip compilation
- `p-once`: Render once
- `p-cloak`: Hide until compiled

## Advanced Usage

### Async Rendering

```python
from py_level_fleet import VueJinjaEngine

engine = VueJinjaEngine(enable_async=True)
output = await engine.render_template_async(template, data)
```

### Sandboxed Environment

```python
from py_level_fleet import VueJinjaEngine

engine = VueJinjaEngine(sandboxed=True)
output = engine.render_template(template, data)
```

### I18N Support

```python
from py_level_fleet import VueJinjaEngine
from babel.support import Translations

translations = Translations.load('locale', ['en'])
engine = VueJinjaEngine(i18n_translations=translations)
output = engine.render_template(template, data)
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Author

Vishnu Prasad - [GitHub](https://github.com/vishnuprasad)

## Acknowledgments

- [Jinja2](https://jinja.palletsprojects.com/)
- [BeautifulSoup4](https://www.crummy.com/software/BeautifulSoup/)
- [Vue.js](https://vuejs.org/)
timezone-tools 0.1.0.post1
Tools for working with timezone-aware datetimes.
Requires Python: >=3.10

# timezone-tools

Helpers for working with timezone-aware date-times.

This package provides:

- `TimezoneConverter`
  for making date-times timezone-aware
  and converting between timezones.
- `Clock`
  for getting the current time/date
  in a specific timezone.

## `TimezoneConverter`

This converter object can be used
to create timezone-aware `datetime` objects,
to make a naive `datetime` timezone-aware,
and to localize other timezone-aware `datetime` objects.

The converter also provides utilities
for converting a `datetime` into a `date` in the converter's timezone,
calculating dates and time relative to a `datetime`,
and rounding a `datetime` to the nearest increment of time
(e.g. to the nearest half-hour).

Create an instance of the timezone converter
by passing it an IANA time zone name.

```python
from timezone_tools import TimezoneConverter

paris_time = TimezoneConverter("Europe/Paris")
```

For more information about timezone support in Python,
see the [documentation for the `zoneinfo` module](https://docs.python.org/3/library/zoneinfo.html).

## `Clock`

This clock object can be used
to access the system clock
and provides timezone-aware dates and times.

The clock also provides utilities
for calculating dates and time relative to the current moment.

Create an instance of the clock
by passing it an IANA time zone name.

```python
from timezone_tools import Clock

paris_time = Clock("Europe/Paris")
```

For more information about timezone support in Python,
see the [documentation for the `zoneinfo` module](https://docs.python.org/3/library/zoneinfo.html).
ethnicities 0.0.2
Easily return a list of ethnicities
Requires Python: >=3.8

Thought for a couple of seconds


````markdown
# Ethnicities

A lightweight Python package providing lists of the world’s most common ethnicities, organized by region and frequency. All keys are normalized to snake_case (lowercase ASCII, words joined with underscores).

## Installation

```bash
pip install ethnicities
````

## Usage

```python
from ethnicities import all_ethnicities, common, by_region, common_and_by_region

# List all 100 normalized ethnicity names
print(all_ethnicities[:5])
# → ['nigerian', 'ethiopian', 'congolese', 'egyptian', 'south_african']

# Get the “common” subset (e.g. top 20 by global population)
print(common)

# Look up by world region
print(by_region['Europe'])
# → ['russian', 'german', 'french', …, 'icelandic']

# Combined filter: ethnicities that are both “common” and in a given region
print(common_and_by_region['Asia'])
```

## API

* **all\_ethnicities**
  List of all 100 normalized ethnicity identifiers.

* **common**
  Subset of `all_ethnicities` representing the top \~20 by global population.

* **by\_region**
  Dictionary mapping region names (e.g. `"Africa"`, `"Asia"`, `"Europe"`, etc.) to lists of normalized identifiers.

* **common\_and\_by\_region**
  Dictionary mapping region names to the intersection of `common` and `by_region[region]`.

## Normalization Rules

* All identifiers are ASCII lowercase.
* Spaces, hyphens, and punctuation are replaced with underscores.
* No diacritics or non-English characters.

> *Example*: “South African” → `south_african`

## Contributing

1. Fork the repository
2. Add or update entries in `data/…` (YAML or JSON).
3. Run `make build` to regenerate `all_ethnicities.py`, `by_region.py`, etc.
4. Submit a pull request with tests and documentation updates.

## License

Distributed under the MIT License. See `LICENSE` for details.

```

**Q1:** Would you like to include a code snippet demonstrating a reverse lookup (display name → normalized key)?  
**Q2:** Should we add a CLI command (e.g. `ethnicities validate`) to enforce normalization rules on new entries?  
**Q3:** Would embedding population metadata or external data-source links into the package enrich your use cases?
```
eknowledge 2025.5.21720
A Python package for executing graph generation from textual inputs.
Requires Python: >=3.6

[![PyPI version](https://badge.fury.io/py/eknowledge.svg)](https://badge.fury.io/py/eknowledge)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/eknowledge)](https://pepy.tech/project/eknowledge)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

# eknowledge

`eknowledge` is a Python package designed to facilitate the generation of knowledge graphs from textual inputs. It leverages language models to parse text and extract relationships between entities, organizing these relationships into a structured graph format. This tool is ideal for developers, researchers, and anyone interested in structured knowledge extraction from unstructured text.

## Installation

Install `eknowledge` using pip:

```bash
pip install eknowledge langchain_llm7
```

## Usage

Here's a simple example to get you started with `eknowledge`. This example demonstrates how to generate a knowledge graph from a given text input using the package.

### Example

```python
from eknowledge import execute_graph_generation
from langchain_llm7 import ChatLLM7

# Initialize the language model
MODEL = "deepseek-r1"
llm = ChatLLM7(model=MODEL)

# Define your input text
input_text = "The quick brown fox jumps over the lazy dog."

# Generate the graph
graph = execute_graph_generation(
    text=input_text,
    llm=llm,
    chunk_size=100,
    verbose=True
)

# Output the graph
print(graph)
# > Splitting text into 1 chunks of size 100 words.
# > Processing chunk 1/1...
# > Nodes successfully processed in chunk 1/1.
# > [{'from': 'quick brown fox', 'relationship': 'interacts_with', 'to': 'lazy dog'}]
```

This script will output a knowledge graph based on the relationships identified in the text.

## Contributing

Contributions are welcome! Please open issues or submit pull requests for any bugs, features, or improvements you would like to see.

## License

`eknowledge` is MIT licensed, as found in the [LICENSE](https://opensource.org/licenses/MIT) file.