semvec/pypi-packages huggingface dataset:
cli-tasker 1.0.2
A simple CLI task tracker
Requires Python: >=3.6

# cli-tasker
Thsi is a [python roadmap project](https://roadmap.sh/projects/task-tracker)

## Description:
cli-tasker is a project used to track and manage tasks.

## Features

cli-tasker can help user:

1. Add a Task: Users can add a new task to their task list by providing a description. Each task is assigned a unique ID and is initially set to the "todo" status.
2. Delete a Task: User can removed from the tasks by specifying their unique ID. After delete the task, you can choose whether to rearrange the task id or not.
3. Update a Task: Users can update the description of an existing task. This requires the task's ID and the new description.
4. List Tasks: Users can list all tasks (default) or filter them by any user defined status.
5. Mark Task with user-defined status: Tasks can be marked as "on-going" by providing their ID.
6. Mark Task as Done: Tasks can be marked as "done" by specifying their ID. After mark as done, you can choose to leave the task on the list or delete it.

# How to use

1. open terminal

2. copy following code `$pip3 install cli-tasker` on the terminal

3. After install successly, you can manege your task!
forthright-django 0.0.6
A Django app to call server functions directly from the client.
Requires Python: >=3.9


# forthright-django


forthright-django is a Django app to allow developers to directly call server functions from the client. 

## Quick start

1. `pip install forthright-django`


2. Add forthright-django to INSTALLED_APPS in your django project settings.py:

    ```
    INSTALLED_APPS = [
        ...,
        'forthright_django',
    ]
    ```

3. Include the forthright-django URLconf in your django project urls.py:

    ```
    urlpatterns = [
        path('forthright/', include('forthright_django.urls')),
        ...,
    ]
    ```

4. Instantiate a forthright_server object and export your server functions. For example, place [examples/server_functions.py](./examples/server_functions.py) in your django project folder, and import this file in urls.py

    `from . import server_functions`


5. Now you can instantiate a forthright_client object on the client and directly call the server functions that you exported. For example, [examples/client.py](./examples/client.py)


All together, here's an example django project:

<div float="left">
    <img src="./examples/example_django_project.png" alt="example_django_project" height="400">
</div>
<br>

And corresponding client:

<div float="left">
    <img src="./examples/example_client.png" alt="example_client" height="133">
</div>
<br>


## Limitations

You can only pass arguments by value, not by reference. For example, if an argument is a list, the server function will receive a copy of that list.

If an argument is a custom object, the class definition must be present in both the client code and the server code.

Warning: By default, this code deserializes pickled data on the server which is unsafe. There is an optional Safe Mode to instead send data with json, but this will prevent you from sending custom objects. To turn on Safe Mode, set `safe_mode=True` when instantiating both forthright_server and forthright_client:

`frs = forthright_server(safe_mode=True)`

`frc = forthright_client(url, safe_mode=True)`
pygdbstub-neo 0.0.1.2
Another GDB stub implemented in Python3
Keywords: gdb, stub, python

# Another GDB stub implemented in Python3

## Setup
```sh
# Install and compile urjtag (for Microwatt)
apt install libusb-1.0-0-dev libftdi1-dev python3-dev
git clone -b ftdi-arty https://github.com/shingarov/urjtag.git
cd urjtag/urjtag
PYTHON=python3 ./configure --enable-python --without-ftd2xx
make -j$(nproc)
cd ../..

# Clone this repository
git clone https://github.com/janvrany/pygdbstub.git
cd pygdbstub

# Create virtual environment for pygdbstub
virtualenv --prompt "pygdbstub" .venv
echo "export LD_LIBRARY_PATH=$(realpath ../urjtag/urjtag/src/.libs)" >> .venv/bin/activate
source .venv/bin/activate

# Install dependencies
pip3 install -r requirements-dev.txt
pip3 install ../urjtag/urjtag/bindings/python

# Setup pre-commit and pre-push hooks (if you want)
pre-commit install -t pre-commit
pre-commit install -t pre-push
```

## Usage examples

### Using TCP port

```
.venv/bin/python -m pygdbstub -t microwatt -b Genesys2 -p 7000
```

* run *pygdbstub* (`-m pygdbstub`)
* connect to Microwatt on Digilent Genesys2 FPGA boatd (`-t microwatt -b Genesys2`)
* listen on localhost, port 7000 (`-p 7000`)

Then in GDB, connect to stub like:

```
(gdb) set arch powerpc:common64
(gdb) target remote :7000
```

### Starting *pygdbstub* directly from GDB

```
(gdb) set arch powerpc:common64
(gdb) target remote | .venv/bin/python -m pygdbstub -t microwatt
```

* run *pygdbstub* (`-m pygdbstub`)
* connect to Microwatt on Arty FPGA (`-t microwatt`, Arty is default board for Microwatt target)
* use stdio to communicate with GDB (default)

## For developers

### Running tests

To run tests, just run:

```
pytest
```

### Debugging communication

Some hints to help debugging communication between GDB and pygdbstub:

 * In GDB, turn on remote protocol debugging:

   ```
   set debug remote 1
   ```

 * If you really want to see the exact bytes going back and forth, run
   stub using `socat`:

   ```
   socat -v tcp4-listen:7007,reuseaddr,fork 'exec:python3 -m pygdbstub'
   ```

   and then in GDB, connect to port 7007:

   ```
   target remote :7007
   ```
forthright 0.0.6
Allows you to seemingly call a server function directly from the client.
Requires Python: >=3.9


# forthright

forthright is a Remote Procedure Call (RPC) package that uses Flask to allow you to call server functions from the client. It saves you the hassle of needing to pack your arguments into a json and unpack them on the server. 


## A simple example
```
# backend.py
from forthright import forthright_server
from flask import Flask

app = Flask(__name__)
frs = forthright_server(app)

def add_and_sub(numA, numB):
    return numA + numB, numA - numB

frs.register_functions(add_and_sub)

if __name__ == '__main__':
    app.run(port=8000)
```

```
# client.py
from forthright import forthright_client

url = 'http://127.0.0.1:8000'
frc = forthright_client(url)

sum, diff = frc.add_and_sub(8, 2)
print('%d %d' %(sum, diff)) # -> 10 6
```

## Installation

`pip install forthright`

## Limitations

You can only pass arguments by value, not by reference. For example, if an argument is a list, the server function will receive a copy of that list. 

If an argument is a custom object, the class definition must be present in both the client code and the server code. 

Warning: By default, this code deserializes pickled data on the server which is unsafe. There is an optional Safe Mode to instead send data with json, but this will prevent you from sending custom objects. To turn on Safe Mode, set `safe_mode=True` when instantiating both forthright_server and forthright_client:

`frs = forthright_server(app, safe_mode=True)`

`frc = forthright_client(url, safe_mode=True)`
scholar-spark-observability 0.8.0
A Python package for monitoring and observability in Apache Spark applications
Requires Python: <4.0,>=3.8
Keywords: spark, observability, monitoring, opentelemetry

# ScholarSparkObservability

A Python package for monitoring and observability in Apache Spark applications.


## Installation

You can install the package using pip:

```bash
pip install scholarSparkObservability
```

Or using Poetry:

```bash
poetry add scholarSparkObservability
```

## Usage

Here's a simple example of how to use the package:

```python
from scholarSparkObservability import ScholarSparkObservability

client = ScholarSparkObservability()
result = client.example_method()
print(result)
```

## Features

## Features

### OpenTelemetry Integration
- Full OpenTelemetry support for distributed tracing and metrics collection
- Configurable exporters for different observability backends (e.g., Jaeger, Zipkin)
- Automatic context propagation across Spark jobs and stages

### Comprehensive Monitoring
- Real-time metrics collection for Spark executors and tasks
- Custom span creation for detailed performance tracking
- Exception tracking and error reporting with detailed attributes
- Resource utilization metrics (CPU, memory, I/O)

### Flexible Configuration
- Singleton pattern for consistent telemetry setup across your application
- Environment-aware configuration (production, staging, development)
- Customizable export intervals and batch processing
- Debug mode for detailed logging and troubleshooting

### Enterprise-Ready
- Low-overhead implementation suitable for production workloads
- Batch span processing for efficient telemetry data export
- Support for multiple exporters and monitoring backends
- Robust error handling and logging capabilities

### Easy Integration
- Simple API for creating spans and recording metrics
- Automatic service name and version tracking
- Built-in support for custom attributes and tags
- Seamless integration with existing Spark applications

## Development

To contribute to this project:

1. Clone the repository:
```bash
git clone https://github.com/pouyaardehkhani/ScholarSparkObservability.git
cd ScholarSparkObservability
```

2. Install dependencies:
```bash
# Using poetry (recommended)
poetry install

# Using pip
pip install -r requirements.txt
```

3. Run tests:
```bash
# Using poetry
poetry run pytest

# Using pytest directly
pytest tests/
```

4. Set up pre-commit hooks:
```bash
pre-commit install
```

5. Create a new branch for your feature:
```bash
git checkout -b feature/your-feature-name
```

### Development Guidelines
- Follow PEP 8 style guidelines
- Write tests for new features
- Update documentation as needed
- Add type hints to all new functions
- Ensure all tests pass before submitting PR

### Building Documentation
```bash
# Generate documentation
poetry run sphinx-build -b html docs/source docs/build
```

## 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.

# Authors
Pouya Ataei- Initial work
powermon 1.0.18
Package to communicate with Solar inverters and BMSs
Requires Python: <3.13,>=3.11

# Powermon #
## Python based Power Device Access Package ##

- minimum python supported 3.11


Python package with reference library of commands (and responses)
designed to get information from inverters and other solar inverters and power devices

Currently has support for:
- MPP-Solar and similar inverters, e.g.
  - PIP-4048MS
  - IPS-4000WM
  - Voltronic Axpert MKS 5KVA Off-grid Inverter-Chargers
  - LV5048
- JK BMS
- Victron VE Direct Devices:
  - tested on SmartShunt 500A
- Daly BMS

## Install ##
- `pip install powermon` (minimal install)
- `pip install powermon[api]` (install web api)


## Documentation ##
- [See the wiki for documentation](https://github.com/jblance/powermon/wiki)
- [or github io documentation - wip](https://jblance.github.io/powermon/index.html)

## Support ##
If you want to tip me for this work, you can now buy me a coffee

[![buymeacoffee1](https://user-images.githubusercontent.com/1266998/225745276-54d6a4d4-a1ed-44f9-a1f2-e99eb1aa2812.png)](https://www.buymeacoffee.com/jblance)