semvec/pypi-packages huggingface dataset:
edwh-sshfs-plugin 0.2.2
sshfs project with a plugin to be discovered from the edwh package
Requires Python: >=3.10

# edwh-sshfs-plugin

[![PyPI - Version](https://img.shields.io/pypi/v/edwh-sshfs-plugin.svg)](https://pypi.org/project/edwh-sshfs-plugin)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/edwh-sshfs-plugin.svg)](https://pypi.org/project/edwh-sshfs-plugin)

-----

**Table of Contents**

- [Installation](#installation)
- [Local Mounts](#creating-local-mounts)
- [Remote Mounts](#creating-remote-mounts)
- [License](#license)

## Installation

```shell
pip install edwh-sshfs-plugin
```

But probably you want to install the whole edwh package:

```shell
pipx install edwh[sshfs]
```
or
```shell
pipx install edwh[plugins,omgeving]
```

Also you will be required to run these commands
```shell
edwh sshfs.setup
# OR:
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install openssh-client
sudo apt install openssh-server
sudo systemctl enable ssh
sudo apt install sshfs
sudo ufw allow ssh
sudo init 6 #optional for reboot
```

## creating remote mounts
**usage**
```shell
edwh -h {server} sshfs.remote-mount -w {local_dir} -s {server_dir}
```
The remote_mount function is an asynchronous Python task that allows you to mount a remote directory 
on your local machine using SSHFS (SSH Filesystem). It establishes a secure connection to a remote server, 
forwards a port, and mounts the remote directory on the local machine.

**Parameters**
- `workstation_dir`: The local directory path where the remote directory will be mounted to the server_dir.
- `server_dir`: The remote directory path that will become a mount
- `queue`: An optional parameter representing the queue object for synchronization (default: None).

## creating local mounts
**Usage**
```shell
edwh -h {server} sshfs.local-mount -w {local_dir} -s {server_dir}
```

**Arguments**
- `workstation_dir(-w)`: The local directory path That will become a mount
- `server_dir(-s)`: The remote directory path That will be mounted onto the workstation directory
- `queue`: An optional parameter representing the queue object for synchronization (default: None).

## License

`edwh-sshkey-plugin` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
mkdocs-coverage 2.0.0
MkDocs plugin to integrate your coverage HTML report into your site.
Requires Python: >=3.9

# MkDocs Coverage Plugin

[![ci](https://github.com/pawamoy/mkdocs-coverage/workflows/ci/badge.svg)](https://github.com/pawamoy/mkdocs-coverage/actions?query=workflow%3Aci)
[![documentation](https://img.shields.io/badge/docs-mkdocs-708FCC.svg?style=flat)](https://pawamoy.github.io/mkdocs-coverage/)
[![pypi version](https://img.shields.io/pypi/v/mkdocs-coverage.svg)](https://pypi.org/project/mkdocs-coverage/)
[![gitter](https://img.shields.io/badge/matrix-chat-4DB798.svg?style=flat)](https://app.gitter.im/#/room/#mkdocs-coverage:gitter.im)

MkDocs plugin to integrate your coverage HTML report into your site.

## Installation

```bash
pip install mkdocs-coverage
```

```bash
python3.8 -m pip install --user pipx
pipx install mkdocs-coverage
```

## Usage

```yaml
# mkdocs.yml
nav:
- Coverage report: coverage.md

plugins:
- coverage:
    page_path: coverage  # default
    html_report_dir: htmlcov  # default
```

The page path can be nested:

```yaml
# mkdocs.yml
nav:
- Coverage report: dev/reports/coverage.md

plugins:
- coverage:
    page_path: dev/reports/coverage
```

If the page doesn't exist, it will be created. If the page exists, the coverage report will be appended at the end.
You can choose *where* to insert the coverage report in the page thanks to the `placeholder` setting:

```yaml
# mkdocs.yml
nav:
- Coverage report: dev/coverage.md  # existing page

plugins:
- coverage:
    page_path: dev/coverage
    placeholder: "[INSERT REPORT HERE]"
```

In your page:

```md
# Some page

Some text.

## Coverage report

[INSERT REPORT HERE]
```

The plugin will replace any such string with the coverage report. **The default placeholder is `<!-- mkdocs-coverage -->`**.

Now serve your documentation,
and go to http://localhost:8000/coverage/
to see your coverage report!

![coverage index](https://user-images.githubusercontent.com/3999221/106802970-f4376a80-6663-11eb-8665-e9e09f0f4ac0.png)
![coverage module](https://user-images.githubusercontent.com/3999221/106803017-fe596900-6663-11eb-9df9-973755c5b63e.png)
scm203lab267112755 0.1.2
Numerical methods: root finding and ODE solvers (Secant, False Position, Runge-Kutta).
Requires Python: >=3.7

# mypackage

`scm203lab267112755` is a lightweight Python package that provides numerical methods
for solving **roots of equations** and **initial value problems (ODEs)**.
It is designed mainly for learning purposes and as an example of Python packaging.

---

## Features
- **lab2mod167112755.py**: Secant method, False Position method  
- **lab2mod267112755.py**: 2nd-order Runge-Kutta (Heun), 3rd-order Runge-Kutta  

---

## Installation

You can install the package directly from PyPI:

---
### Example
if __name__ == "__main__":

    #input example for secant method
    f = lambda x: ...
    root_secant = secant(f, x0, x1)
    print(f"\nRoot (Secant): {root_secant:.6f}")

    #input example for false_position method
    root_false_pos = false_position(f, a, b)
    print(f"\nRoot (False Position): {root_false_pos:.6f}")

    ##input example for 
    f = lambda t, y:...
    # Runge-Kutta 2nd order
    runge_kutta2(f, t0, y0, h, n)
    # Runge-Kutta 3rd order
    runge_kutta3(f, t0, y0, h, n)

```bash
pip install scm203lab267112755
classic-signals 0.1.1
Simple signals and handlers
Requires Python: >=3.10

# Classic Signals

Библиотека предоставляет способ инверсии контроля через сигналы и реакции.

По сути, это паттерн Observer и немного сахара сверху. 
В одном месте программы мы объявляем сигналы, пользуясь декоратором 
signal, в других местах приложения пишем реакции на этих сигналов.
Реакции - это любой вызываемый объект, принимающий один аргумент - инстанс 
сигнала. Это может быть и просто функция или метод, для удобства завернутый
в декоратор reaction. Последнее, что нужно, это инстанс класса Hub. В Hub 
перед началом работы можно зарегистрировать реакции, потом можно вызвать у него
метод notify, передав в него инстанс сигнала, и Hub вызовет все реакции, 
относящиеся к сигналу.

Реакции исполняются последовательно в единственном текущем потоке.
Не рекомендуется создавать новые потоки из сигналов. Этот механизм
предназначается для связки разных частей кода с инверсией зависимости, не для 
распараллеливания задач.

Пример:

```python
from classic.components import component
from classic.signals import reaction, Hub, signal


@signal
class SomethingHappened:
    """Под капотом сигналы - на самом деле датаклассы"""
    some_field: int


@signal
class SomethingAnotherHappened:
    some_field: int


@component
class SomeHandlers:

    @reaction
    def on_something_happened(self, signal: SomethingHappened):
        print(f'Что-то произошло: {signal}')

    @reaction
    def on_something_another_happened(self, signal: SomethingAnotherHappened):
        print(f'Что-то еще произошло: {signal}')


hub = Hub()
SomeHandlers(signals=hub)


signal_1 = SomethingHappened(some_field=0)
signal_2 = SomethingAnotherHappened(some_field=0)

hub.notify(signal_1, signal_2)
```