semvec/pypi-packages huggingface dataset:
mdformat-pelican 0.2.2
An mdformat plugin for pelican markdown items
Requires Python: >=3.6
Keywords: mdformat, markdown, markdown-it

# mdformat-plugin

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

An [mdformat](https://github.com/executablebooks/mdformat) plugin for the pelican static site generator.
[Pelican](https://getpelican.com) is a static site generator and uses markdown with a couple of additions,
namely skipping the K:V pairs at the start and the ability to reference:

- tag
- author
- category
- index
- filename
- static
- attach

Note that the `{name}` forms are supported, and the `|name|` forms are converted to the newer form,
as the pipe form has been deprecated.


## Development

This package utilises [flit](https://flit.readthedocs.io) as the build engine, and [tox](https://tox.readthedocs.io) for test automation.

To install these development dependencies:

```bash
pip install tox
```

To run the tests:

```bash
tox
```

and with test coverage:

```bash
tox -e py311-cov
```

The easiest way to write tests, is to edit tests/fixtures.md

To run the code formatting and style checks:

```bash
tox -e py311-pre-commit
```

or directly

```bash
pip install pre-commit
pre-commit run --all
```

To run the pre-commit hook test:

```bash
tox -e py311-hook
```

## Publish to PyPi

Either use flit directly:

```bash
pip install flit
flit publish
```

or trigger the GitHub Action job, by creating a release with a tag equal to the version, e.g. `v0.0.1`.
haut-scanner 0.1.0
Asynchronous scanning utilities for discovering HAUT services, starting with the JWGLXT portal.
Requires Python: >=3.11
Keywords: asyncio, haut, jwglxt, network, scanner

# haut_scanner

An asynchronous toolkit for discovering HAUT services. The initial module targets HAUT JWGLXT portals and records reachable instances for later analysis.

## Installation

```bash
pip install haut_scanner
```

## Usage

Run the bundled command-line interface:

```bash
haut_scan
```

Or integrate the scanner into your own script:

```python
from haut_scanner import JwglxtScanner
import asyncio

async def main():
    scanner = JwglxtScanner()
    await scanner.scan()
    scanner.save_results("jwglxt_urls.json")

asyncio.run(main())
```

The scan writes any discovered portals to `jwglxt_urls.json` by default.

## Development

This project uses Hatch for builds. To produce a wheel and source distribution:

```bash
hatch build
```
vntickers 0.2.0
A Python package for fetching Vietnamese stock market data from multiple sources
Requires Python: >=3.10

# vntickers

A unified Python package for fetching Vietnamese stock market data. This package combines vnstock, vnquant, and vietfin into a single source of truth for retrieving OHLCV (Open, High, Low, Close, Volume) and close prices for stock analysis in the Vietnamese market.

## Installation

### From source (development)

```bash
git clone https://github.com/gahoccode/vntickers.git
cd vntickers
uv sync
```

### Add to your project

```bash
uv add vntickers
```

## Usage

### Using vnstock (VCI source)

```python
from vntickers.loader import VNStockData

stocks = ["VNM", "VCB", "HPG"]
start_date = "2024-01-01"
end_date = "2024-12-31"

df = VNStockData.get_close_prices_vns(
    symbols=stocks,
    start_date=start_date,
    end_date=end_date,
    interval="1D"
)
print(df.head())
```

### Using vnquant

```python
from vntickers.loader import VNStockData

stocks = ["VNM", "VCB", "HPG"]
start_date = "2024-01-01"
end_date = "2024-12-31"

df = VNStockData.get_close_prices_vnq(
    symbols=stocks,
    start_date=start_date,
    end_date=end_date
)
print(df.head())
```

### Using vietfin (Recommended - Modern API)

```python
from vntickers import VietfinLoader
from datetime import date

# Daily data for multiple stocks (DNSE or TCBS)
df = VietfinLoader.get_close_prices(
    symbols=["VNM", "VCB", "HPG"],
    start_date=date(2024, 1, 1),
    end_date=date(2024, 12, 31),
    provider="dnse",  # or "tcbs"
    interval="1d"
)
print(df.head())

# Intraday data - hourly (DNSE only, single symbol, max 90 days)
df_hourly = VietfinLoader.get_close_prices(
    symbols="VNM",  # Single symbol for intraday
    start_date=date(2024, 10, 1),
    end_date=date(2024, 12, 30),  # Max 90 days
    provider="dnse",
    interval="1h"  # Supported: 1m, 15m, 30m, 1h
)
print(df_hourly.head())
```

**Vietfin Provider Support:**
- **DNSE**: Supports `1m`, `15m`, `30m`, `1h`, `1d`
  - Intraday intervals (1m, 15m, 30m, 1h): Single symbol only, max 90 days
  - Daily (1d): Multiple symbols, unlimited range
- **TCBS**: Supports `1d` only (multiple symbols, unlimited range)

All methods return a pandas DataFrame with:
- Index: time/date (datetime)
- Columns: ticker symbols
- Values: close prices (adjusted close for vnquant)

## Requirements

- Python >=3.10
- vnstock >=3.2.6
- vnquant
- vietfin
- pandas
- pydantic

## Publishing to PyPI

### Prerequisites
1. Create a PyPI account at https://pypi.org
2. Create an API token at https://pypi.org/manage/account/token/

### Build and Publish

```bash
# Build the package
uv build

# Publish to PyPI (you'll be prompted for your API token)
uv publish

# Or use token directly
uv publish --token <your-pypi-token>
```
haut-jwglxt-scanner 0.1.0
Asynchronously scan the HAUT JWGLXT network segment for reachable portals.
Requires Python: >=3.11
Keywords: asyncio, haut, jwglxt, network, scanner

# haut_jwglxt_scanner

A lightweight asynchronous scanner that checks the HAUT JWGLXT network segment for reachable portal instances.

## Installation

```bash
pip install haut_jwglxt_scanner
```

## Usage

Run the bundled command-line interface:

```bash
haut_jwglxt_scan
```

Or integrate the scanner into your own script:

```python
from haut_jwglxt_scanner import JwglxtScanner
import asyncio

async def main():
    scanner = JwglxtScanner()
    await scanner.scan()
    scanner.save_results("jwglxt_urls.json")

asyncio.run(main())
```

The scan writes any discovered portals to `jwglxt_urls.json` by default.

## Development

This project uses Hatch for builds. To produce a wheel and source distribution:

```bash
hatch build
```
ticko 1.0.0
Thread-safe stopwatch for measuring elapsed time
Requires Python: >=3.10
Keywords: stopwatch, timer, performance, profiling, benchmark

# ticko

[![CI](https://github.com/NakuRei/ticko/actions/workflows/ci.yml/badge.svg)](https://github.com/NakuRei/ticko/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/NakuRei/ticko/branch/main/graph/badge.svg)](https://codecov.io/gh/NakuRei/ticko)
[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A modern, thread-safe stopwatch library for Python.

## Why ticko?

- **Thread-safe by design** - Use confidently in concurrent applications
- **Type-safe** - Full type hints for excellent IDE support
- **Zero dependencies** - Pure Python, no external requirements
- **Flexible API** - Context managers, decorators, or manual control
- **Production-ready** - Comprehensive test coverage

## Installation

```bash
pip install ticko
```

## Quick Start

```python
from ticko import StopWatch

# Basic usage
with StopWatch() as sw:
    # Your code here
    pass

print(f"Elapsed: {sw.time_elapsed:.2f}s")
```

```python
from ticko import stopwatch

# Decorator for function timing
@stopwatch
def process_data():
    # Your code here
    pass

process_data()  # Automatically prints execution time
```

## Core Features

### Manual Control

```python
sw = StopWatch()
sw.start()
# ... your code ...
elapsed = sw.stop()
```

### Lap Timing

```python
sw = StopWatch()
sw.start()

# Record multiple laps
lap1 = sw.lap()
lap2 = sw.lap()

elapsed =sw.stop()
```

### Custom Callbacks

```python
def log_time(sw: StopWatch):
    logger.info(f"Execution took {sw.time_elapsed:.3f}s")

@stopwatch(exit_callback=log_time)
def my_function():
    pass
```

### Thread Safety

```python
from concurrent.futures import ThreadPoolExecutor

sw = StopWatch()
sw.start()

# Multiple threads can safely share one StopWatch
with ThreadPoolExecutor(max_workers=5) as executor:
    futures = [executor.submit(sw.lap) for _ in range(10)]

elapsed =sw.stop()
```

For more examples, see the [`examples/`](examples/) directory.

## API Overview

### `StopWatch`

**Properties:**
- `is_running: bool` - Current state
- `time_elapsed: float` - Total elapsed time
- `time_last_lap: float` - Last lap duration

**Methods:**
- `start()` - Start timing
- `stop()` - Stop and return elapsed time
- `lap()` - Record lap time
- `reset()` - Reset to initial state

### `@stopwatch`

Decorator for automatic function timing with optional custom callbacks.

## Development

```bash
# Install with dev dependencies
uv sync --dev

# Run tests
pytest tests/

# Run tests with coverage report
pytest tests -v --cov=src --cov-report=term-missing --cov-report=xml:cov.xml

# Type checking
mypy .

# Lint checking
ruff check

# Format checking
ruff format --check --diff
```

## License

MIT License - Copyright (c) 2025 NakuRei

## Contributing

Contributions welcome! Feel free to open issues or submit pull requests.
uncertainAPI 0.1.2.dev0
A Python package for uncertainAPI
Requires Python: >=3.8
Keywords: uncertainAPI, API, Python, AI, Python Framework

# uncertainAPI

A Python package for uncertainAPI.

## Installation

### From PyPI

```bash
pip install uncertainAPI
```

### From source

```bash
git clone https://github.com/Lux-speed-labs/uncertainAPI.git
cd uncertainAPI
make install-dev
```

## Development Setup

This project uses [Poetry](https://python-poetry.org/) for dependency management and Make for task automation.

### Prerequisites

```bash
# Install Poetry (if not already installed)
curl -sSL https://install.python-poetry.org | python3 -
```

### Quick Start

```bash
# Install dependencies and create virtual environment
make install-dev

# Run tests
make test

# Format code
make format

# Run linter
make lint

# Type check
make type-check

# See all available commands
make help
```

## Available Make Commands

### Setup
- `make install` - Install package and create virtual environment
- `make install-dev` - Install with development dependencies

### Development
- `make shell` - Activate virtual environment shell
- `make run` - Run the main application
- `make test` - Run tests
- `make test-cov` - Run tests with coverage report
- `make lint` - Run linter (ruff)
- `make format` - Format code with black
- `make type-check` - Run type checker (mypy)

### Build & Publish
- `make build` - Build distribution packages
- `make publish` - Publish to PyPI

### Cleanup
- `make clean` - Remove build artifacts and cache files

## Usage

```python
import uncertainAPI

# Your code here
```

## Adding Dependencies

```bash
# Add a runtime dependency
poetry add package-name

# Add a development dependency
poetry add --group dev package-name
```

## Manual Poetry Commands

If you prefer to use Poetry directly:

```bash
# Install dependencies
poetry install

# Activate virtual environment
poetry shell

# Run command in virtual environment
poetry run python script.py
```

## License

MIT License - see LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.