semvec/pypi-packages huggingface dataset:
pc-health-check 1.4.1
Monitor de recursos del sistema
Requires Python: >=3.7

## 🚀 Instalación

```bash
pip install pc-health-check
```

---

## 📖 Uso

### Ejecutar el monitor
```bash
pc-health-check
```

### Ejecutar el monitor con comando alternativo si no funciona el primero.
```bash
python3 -m pchealthcheck.main
```

## ✨ Características

- **Monitor de recursos**: Visualiza CPU, RAM, Disco y más

## 🖥️ Sistemas Operativos Soportados

| Sistema | Versión Mínima |
|---------|----------------|
| Windows | 10+ |
| macOS | 10.14+ |
| Linux | Ubuntu 18.04+, Debian 10+ |

—

## 📋 Requisitos

- Python 3.7 o superior
- Conexión a Internet
urlfinderlib 0.19.0
Library to find URLs and check their validity.
Requires Python: >=3.10
Keywords: url, urlfinderlib

# urlfinderlib

This is a Python (3.10+) library for finding URLs in documents and checking their validity.

## Supported Documents

Extracts URLs from the following types of documents:

* Binary files (finds URLs within strings)
* CSV files
* HTML files
* iCalendar/vCalendar files
* PDF files
* Text files (ASCII or UTF-8)
* XML files

Every extracted URL is validated such that it contains a domain with a valid TLD (or a valid IP address) and does not contain any invalid characters.

## URL Permutations

This was originally written to accommodate finding both valid and obfuscated or slightly malformed URLs used by malicious actors and using them as indicators of compromise (IOCs). As such, the extracted URLs will also include the following permutations:

* URL with any Unicode characters in its domain
* URL with any Unicode characters converted to its IDNA equivalent

For both domain variations, the following permutations are also returned:

* URL with its path %-encoded
* URL with its path %-decoded
* URL with encoded HTML entities in its path
* URL with decoded HTML entities in its path
* URL with its path %-decoded and HTML entities decoded

## Child URLs

This library also attempts to extract or decode child URLs found in the paths of URLs. The following formats are supported:

* Barracuda protected URLs
* Base64-encoded URLs found within the URL's path
* Google redirect URLs
* Mandrill/Mailchimp redirect URLs
* Outlook Safe Links URLs
* Proofpoint protected URLs
* URLs found in the URL's path query parameters

## Basic usage

    from urlfinderlib import find_urls
    
    with open('/path/to/file', 'rb') as f:
        print(find_urls(f.read())

### base_url Parameter

If you are trying to find URLs inside of an HTML file, the paths in the URLs are often relative to their location on the server hosting the HTML. You can use the *base_url* parameter in this case to extract these "relative" URLs.

    from urlfinderlib import find_urls
    
    with open('/path/to/file', 'rb') as f:
        print(find_urls(f.read(), base_url='http://example.com')
claude-code-relay 0.0.9
Local proxy that exposes Claude CLI as an OpenAI-compatible API server
Requires Python: >=3.10
Keywords: api, claude, llm, openai, proxy

# claude-code-relay

OpenAI-compatible API server that wraps your local Claude CLI.

![Demo](https://raw.githubusercontent.com/DreamTeamMobile/claude-code-relay/main/assets/claude-code-relay-demo.png)

## Why?

Creating API keys is friction when you just want to experiment. You already pay for Claude Code subscription - use it.

## Quick Start

### Node
```bash
bunx claude-code-relay serve          # easiest
npx claude-code-relay serve           # npm alternative
npm i -g claude-code-relay && claude-code-relay serve  # global install
```

### Python
```bash
uvx claude-code-relay serve           # easiest
pipx run claude-code-relay serve      # pipx alternative
pip install claude-code-relay && claude-code-relay serve  # global install
```

Server runs at `http://localhost:52014/v1`

## Usage

```python
from openai import OpenAI
client = OpenAI(base_url="http://localhost:52014/v1", api_key="x")
client.chat.completions.create(model="sonnet", messages=[{"role": "user", "content": "Hi"}])
```

```typescript
import OpenAI from "openai";
const client = new OpenAI({ baseURL: "http://localhost:52014/v1", apiKey: "x" });
await client.chat.completions.create({ model: "sonnet", messages: [{ role: "user", content: "Hi" }] });
```

## Models

| Model | Aliases |
|-------|---------|
| `sonnet` | `claude-3-sonnet`, `claude-sonnet-4` |
| `opus` | `claude-3-opus`, `claude-opus-4` |
| `haiku` | `claude-3-haiku` |

**Default**: unrecognized models (e.g., `gpt-4`) map to `sonnet`

## Options

```
claude-code-relay serve [options]
  -p, --port <port>      Port (default: 52014)
  --host <host>          Host (default: 127.0.0.1)
  --claude-path <path>   Claude CLI path
  --timeout <seconds>    Timeout (default: 300)
  -v, --verbose          Verbose logging
```

Environment: `CLAUDE_CLI_PATH`, `CLAUDE_CODE_RELAY_PORT`, `CLAUDE_CODE_RELAY_HOST`, `CLAUDE_CODE_RELAY_TIMEOUT`, `CLAUDE_CODE_RELAY_VERBOSE`

## Limitations

- `usage` tokens always `0`
- `temperature`, `max_tokens`, `top_p` ignored
- No tools/functions support

## Examples

See [`examples/`](examples/) for Node and Python demos.

## License

MIT. Unofficial - comply with Anthropic ToS.
cdef-pil-080126-2052 0.1.0
Parental income loss analysis pipeline.
Requires Python: >=3.9

# Parental Income Loss

## Stacked Event-Study Outputs
The stacked example writes results to:
- `output/stacked_event_study/stacked_results.csv`
- `output/stacked_event_study/stacked_results.parquet`

Each row contains:
- `sample`, `chapter`, `component` (event_time or horizon_*),
- `reference_year`, `target_year`, `event_time`,
- `att`, `se`, `conf_low`, `conf_high`,
- `n_pairs`, `n_treated`, `n_control`, `convergence`,
- `bucket_periods`, `horizon_start`, `horizon_end`, `horizon_label`, `bucket_weight`.

Bucket weighting defaults to treated-weighted (`n_treated`). Override with:
- `STACKED_BUCKET_WEIGHT=pairs`

## Quickstart: Custom Components
- Implement one or more of: `PopulationAssembler`, `CohortSelector`, `ExposureDetector`, `MatchingEngine`.
- Wire them into the pipeline with `CohortWorkflow::with_components`.
- Use `docs/component_contracts.md` to ensure required columns are present.

Example wiring:
```rust
let workflow = CohortWorkflow::with_components(builder, selector, matcher);
let outputs = workflow.run(sources, &detector, &registries, &plan, None)?;
```

## Stacked Event Study CLI
- Run the standalone stacked event-study on a parquet file:
  `cargo run -- --stacked-input path/to/stacked_inputs.parquet --did-outcome perindkialt13`
- Optional flags: `--stacked-samples`, `--stacked-chapter-col`, `--stacked-icd-col`,
  `--stacked-output-dir`, plus the existing `--stacked-*` config flags.

## Docs
- Component contracts: `docs/component_contracts.md`
- Custom component example: `crates/pil/examples/custom_components.rs`
- Custom selector example: `crates/pil/examples/custom_selector.rs`
- Custom matcher example: `crates/pil/examples/custom_matcher.rs`
- Custom detector example: `crates/pil/examples/custom_detector.rs`
pdf-manager-gui 0.3.0
Visually compress and OCR PDF files.
Requires Python: >=3.12

# PDF-Manager-GUI

<image src="https://raw.githubusercontent.com/ioasjfopas/pdf-manager/main/PDF-Manager-GUI.png" width="500">

A simple tool that allows you to run [OCRmyPDF](https://github.com/ocrmypdf/OCRmyPDF) and [GhostScript](https://www.ghostscript.com/) on PDFs visually.

## Requirements

### Debian:
```sh
sudo apt-get install ghostscript
`````

### Mac:
```sh
brew install ghostscript
```

### Windows:

Install from [here](https://ghostscript.com/releases/gsdnld.html).

> [!IMPORTANT]  
> Make sure that `gs` is in the `PATH` and available.

## Install:

```sh
pip install pdf-manager-gui
```

or, even better, use [PipX](https://pipx.pypa.io/latest/)

```sh
pipx install pdf-manager-gui
```
quazydb 1.3.6
Powerful yet simple Python ORM
Requires Python: >=3.10
Keywords: ORM, database, postgres, model, data

quazydb
#######

.. image:: https://raw.githubusercontent.com/zergos/quazydb/master/docs/source/images/logo_mini.png

Powerful yet simple asynchronous Python ORM

Let's combine all modern ORMs with business essence into something intuitive and simple.

Example:
========

..  code-block:: python

    import random

    from quazy import DBFactory, DBTable


    class Product(DBTable):
        name: str
        price: float
        description: str = None


    if __name__ == "__main__":
        db = DBFactory.postgres("postgresql://quazy:quazy@127.0.0.1/quazy")
        db._debug_mode = True
        db.use_module()

        db.clear()
        db.create()

        for i in range(100):
            db.insert(Product(name=f'Product #{i + 1}', price=random.randint(1, 1000) / 100))

        q = Product.query().filter(lambda x: x.price >= 5)
        print("Total amount:", q.fetch_count())
        print("Average price:", q.fetch_avg("price"))
        print("Products:")
        for x in q:
            print(x.name, "->", x.price)

Or code in async:

..  code-block:: python

    import asyncio
    import random

    from quazy import DBFactoryAsync, DBTable

    class Product(DBTable):
        name: str
        price: float
        description: str = None


    async def main():
        db = DBFactoryAsync.postgres("postgresql://quazy:quazy@127.0.0.1/quazy")
        db._debug_mode = True
        db.bind_module()

        await db.clear()
        await db.create()

        for i in range(100):
            await db.insert(Product(name=f'Product #{i + 1}', price=random.randint(1, 1000) / 100))

        q = Product.query().filter(lambda x: x.price >= 5)
        print("Total amount:", await q.fetch_count())
        print("Average price:", await q.fetch_avg("price"))
        print("Products:")
        async for x in q:
            print(x.name, "->", x.price)

    if __name__ == "__main__":
        asyncio.run(main())


Documentation
=============

https://quazydb.readthedocs.io/en/latest/
phenosentry 0.3.1
A tool and library for quality control and validation of GA4GH Phenopackets.
Requires Python: >=3.10

# phenosentry

A Python package for ensuring data quality in phenopackets and collections of phenopackets.

## Features
- Validate phenopacket with quality checks

## Installation

Install with [Poetry](https://python-poetry.org/):

```bash
poetry add phenosentry
```
or with pip:

```bash
pip install phenosentry
```

## Usage

Phenosentry can be used as a library.

See [example.py](examples/example.py) for an example usage.


# Development
Run tests with:

```bash
poetry run pytest
```

Format the code with:

```bash
poetry run ruff format
```

Run linting with:

```bash
poetry run ruff check phenosentry
```

# License 
MIT License
stygian-compressor 1.0.0
LZMA compression for stygian
Requires Python: >=3.10
Keywords: asphodel, suprock, apd

# Stygian_compressor

## About
Stygian_compressor is a wrapper around several compression tools (especially 7-zip) to provide a unified LZMA compression interface for Stygian.

## License
Stygian_compressor is licensed under the ISC license.

The ISC license is a streamlined version of the BSD license, and permits usage in both open source and propretary projects.

## Pronunciation
Commonly pronounced as "STIJ-ee-uhn" in English. The word comes from Greek mythology, where "Stygian" means "of the Styx". The Styx is one of the five rivers in the underworld.