semvec/pypi-packages huggingface dataset:
smart-news-organizer 0.1.5
Program to organize news, this program makes use of AI to give summaries.
Requires Python: >=3.8
Keywords: writing, translate

# smart-news-organizer

Program to organize news, this program makes use of AI to give summaries.

![logo](https://raw.githubusercontent.com/trucomanx/SmartNewsOrganizer/main/screenshot.png)

## 1. Installing

To install the package from [PyPI](https://pypi.org/project/smart-news-organizer/), follow the instructions below:


```bash
pip install --upgrade smart-news-organizer
```

Execute `which smart-news-organizer` to see where it was installed, probably in `/home/USERNAME/.local/bin/smart-news-organizer`.

### Using

To start, use the command below:

```bash
smart-news-organizer
```
## 2. More information

If you want more information go to [doc](https://github.com/trucomanx/SmartNewsOrganizer/blob/main/doc) directory.

## 3. Buy me a coffee

If you find this tool useful and would like to support its development, you can buy me a coffee! 
Your donations help keep the project running and improve future updates.  

[☕ Buy me a coffee](https://ko-fi.com/trucomanx) 

## 4. License

This project is licensed under the GPL license. See the `LICENSE` file for more details.
typer-shell 1.0.3
A shell for typer apps with autocompletion and history
Requires Python: >=3.9.0

# Typer Shell!

Beautiful command-line shell with [Typer](https://github.com/tiangolo/typer)!

This is just an update to [click-shell](https://github.com/clarkperkins/click-shell) for typer.

I also added some features like:
- better help by default
- support for typer default functions (just name one of your commands 'default' and it will be triggered when nothing else is recognized)
- easily drop into an ipython terminal with the local context loaded with 'shell'
- rich sample commands for file operations, tables, progress bars, and more

[See it in action!](https://asciinema.org/a/xdYelspxaxpiJ9AhiekNLZtRI)

And checkout [the demo script](./demo.py):

To run the demos, you can execute them with `uv run`:

```bash
uv run python demo/demo.py
uv run python demo/simple_demo.py
```

Or use the convenient just commands:
```bash
just demo
just simple-demo
```

There are also sample helper functions in `typer_shell/samples.py` that you can use in your own applications. These include:

### Sample Commands
- **File Operations**: `ls`, `cat`, `pwd` - basic file system navigation
- **Rich UI**: `table`, `progress`, `panel` - demonstrate rich formatting capabilities  
- **Interactive**: `ask` - prompt for user input with rich styling
- **System**: `env`, `date` - show environment variables and current time
- **Development**: `shell` - drop into IPython with current context

Add them to your shell with:
```python
from typer_shell.samples import add_sample_commands
add_sample_commands(app)
```

## Using Callbacks

Because `typer-shell` uses Typer's callback mechanism to launch the interactive shell, you cannot use the standard `@app.callback()` decorator, as it will conflict and prevent the shell from loading.

If you need to run code before the shell launches (for example, to set up state), you can pass a function to the `user_callback` parameter in `make_typer_shell`.

Your function will be called with the `Typer.Context` object before the shell starts.

```python
import typer
from typer_shell import make_typer_shell

def my_setup_logic(ctx: typer.Context):
    print("This runs before the shell starts!")
    # You can access and modify the context object here
    ctx.obj.my_value = 42

app = make_typer_shell(user_callback=my_setup_logic)

@app.command()
def my_command(ctx: typer.Context):
    print(f"my_value is: {ctx.obj.my_value}")

if __name__ == "__main__":
    app()
```

## Development

This project uses [uv](https://docs.astral.sh/uv/) for dependency management and [ruff](https://docs.astral.sh/ruff/) for linting/formatting.

```bash
# Setup development environment
uv sync

# Run demos
just demo
just simple-demo

# Code quality
just format  # Format code
just lint    # Check for issues
just fix     # Auto-fix issues

# Build and publish
just build
just publish
```
swatoutpy 0.1.2
A Python package to read SWAT model output files (.rch, .sub, .hru)
Requires Python: >=3.7

# swatoutpy

A lightweight Python package to read SWAT model (Rev 681) output files: `.rch`, `.sub`, and `.hru`.

## How to install

```bash
pip install swatoutpy
```

## How to use

For `*.rch` files

```bash
from swatoutpy.reader import read_rch

df = read_rch("output.rch", timestep="monthly")
print(df.head())
```

For `*.sub` files

```bash
from swatoutpy.reader import read_sub

df = read_sub("output.sub", timestep="annual")
print(df.head())
```

For multiple files

```bash
from swatoutpy.reader import read_multiple_rch

scenarios = [
    ("./sce1/output.rch", "Sce-1"),
    ("./sce1/output.rch", "Sce-2")
]

df = read_multiple_rch(scenarios, timestep="monthly")
print(df.head())
```
types-libtorrent 2.0.11.20250816
Type stubs for python-libtorrent
Requires Python: >=3.8
Keywords: typing, stubs, libtorrent, bittorrent

# types-libtorrent

Type stubs for [python-libtorrent](https://pypi.org/project/python-libtorrent/) 2.0.11

This package provides type stubs for the python-libtorrent library, enabling static type checking and improved IDE support when working with libtorrent in Python.

## Installation

```bash
pip install types-libtorrent
```

## Usage

After installation, type checkers like mypy, PyCharm, or VS Code will automatically use these stubs when working with the `libtorrent` module.

```python
import libtorrent as lt

# Now with full type support
session = lt.session()
```

## Compatibility

This stub package is compatible with:
- python-libtorrent 2.0.11.*
- Python 3.8+

## Version Scheme

The version number follows the pattern: `{libtorrent_version}.{stub_date}`
- `2.0.11` - Compatible with libtorrent 2.0.11.*
- `20250815` - Stubs created/updated on August 15, 2025

## License

MIT License
clio-monitoring 0.1.10
Playwright automation monitoring SDK
Requires Python: >=3.8
Keywords: automation, monitoring, playwright, testing

# Clio SDK

Python SDK for Clio - Playwright automation monitoring service.

## Installation

```bash
pip install clio_monitoring
```

## Quick Start

```python
from playwright.async_api import async_playwright
from clio import ClioMonitor

# Initialize Clio
monitor = ClioMonitor(api_key="your-api-key")

async def test_example():
    async with async_playwright() as p:
        browser = await p.chromium.launch()

        # Create context with video recording enabled
        context = await browser.new_context(
            record_video_dir="./videos",
            record_video_size={"width": 1280, "height": 720}
        )

        # Start monitoring this test
        await monitor.start_run(
            context=context,
            automation_name="User Login Test",
            success_criteria="User successfully logs in and sees dashboard",
            playwright_instructions="Navigate to login page, enter credentials, verify dashboard loads"
        )

        # Your test code here
        page = await context.new_page()
        await page.goto("https://example.com/login")
        # ... rest of your test

        # Videos and traces are automatically uploaded when context closes
        await context.close()
        await browser.close()
```

## Configuration

```python
monitor = ClioMonitor(
    api_key="your-api-key",
    base_url="https://api.cliomonitoring.com",  # Optional: for self-hosted instances
    retry_attempts=3,                  # Optional: number of upload retry attempts
    raise_on_error=False              # Optional: raise exceptions on errors
)
```

## Features

- **Automatic Upload**: Videos and traces are automatically uploaded when the browser context closes
- **Retry Logic**: Failed uploads are automatically retried
- **Rate Limiting**: Respects your organization's monthly rate limits
- **Error Handling**: Configurable error handling (log or raise exceptions)

## Requirements

- Python 3.8+
- Playwright 1.40+

## License

MIT
configure-with-sudo 1.0.0.dev0
A Python class to handle executing system commands using sudo
Requires Python: >=3.10

# `configure_with_sudo`

## Description

A Python module to handle executing system commands using sudo.

## Usage

Extend `GenericConfigure`, setting at a minimum an appropriate `argv` command & argument list.

## Example

The following class will check if `pip` is installed and, if not, install it system-wide using `sudo easy_install pip`:

```Python
from configure_with_sudo import GenericConfigure

class InstallPip(GenericConfigure):

    def __init__(self, kill_sudo_cred=True):
        # Initial argv is simply to check if 'pip' is installed
        argv = ["/usr/local/bin/pip", "-V"]
        super(InstallPip, self).__init__(
            argv, use_sudo=True, kill_sudo_cred=kill_sudo_cred)

        try:
            # Execute to check if pip is already installed
            # if it is, self.configured will be set to True
            # and subsequent calls to execute() will do nothing
            self.execute(use_sudo=False)

        except Exception:
            # If pip -V failed, assume pip is not installed.
            # Replace self.argv with the installation command.
            self.argv = ["/usr/bin/easy_install", "pip"]

pip_installer = InstallPip()
pip_installer.execute()
```

The following example will capture the output of `sudo ls -l /private/var/root`, and print it line-by-line:

```Python
class DirectoryLister(GenericConfigure):

    def __init__(self, path):
        argv = ["ls", "-l", path]
        super().__init__(argv, use_sudo=True)

path = "/private/var/root"
lister = DirectoryLister(path)
output = lister.execute(return_output=True)

for line in output:
    print(line)
```