semvec/pypi-packages huggingface dataset:
meyicloud-pw-ui-utils 1.0.1
Meyicloud private Playwright UI automation utilities
License: MIT
Requires Python: >=3.10

# Meyicloud Playwright UI Utils

**Meyicloud Playwright UI Utils** is a centralized automation utility package built on **Playwright**, created to standardize and simplify UI test automation across Meyicloud projects.

It provides reusable actions, assertions, locators, navigation flows, and helper utilities, helping teams write clean, consistent, and maintainable UI automation tests.

---

## Key Benefits

- Reusable utilities shared across projects  
- Standardized automation patterns and best practices  
- Modular and easy to extend  
- Faster test development with less boilerplate  
- Improved maintainability through centralized updates  

---

## Intended Usage

This package is intended to be used across multiple Playwright-based UI test suites within Meyicloud to:

- Reduce code duplication  
- Improve test reliability  
- Promote scalable and reusable automation architecture  

---

## Example Code Snippets

### Importing Utilities

```python
from playwright.sync_api import Page
from meyicloud_pw_ui_utils.actions import click_action, fill_action
from meyicloud_pw_ui_utils.assertions import assert_text_visible
from meyicloud_pw_ui_utils.navigation import go_to_login
from meyicloud_pw_ui_utils.locators import LoginLocators

from playwright.sync_api import sync_playwright
from meyicloud_pw_ui_utils.navigation import go_to_login
from meyicloud_pw_ui_utils.assertions import assert_text_visible

def test_google():
    with sync_playwright() as p:
        page = p.chromium.launch(headless=False).new_page()
        utils = PlaywrightUtils(page)

        go_to_login("https://www.google.com")
        utils.expect_url("https://www.google.com")
pipen-deprecated 1.0.2
Marking pipen processes as deprecated
License: MIT
Requires Python: <4.0,>=3.9

# pipen-deprecated

Marking [pipen](https://github.com/pwwang/pipen) processes as deprecated.

# Installation

```bash
pip install -U pipen-deprecated
```

# Enable/Disable
The plugin is enabled by default after installation. To disable it, either uninstall it or:

```python
from pipen import Proc, Pipen

# process definition

class MyPipeline(Pipen):
    plugins = ["-deprecated"]
```

# Usage

To mark a process as deprecated, use the `@mark(deprecated=...)` decorator.

```python
from pipen import Proc
from pipen.utils import mark

@mark(deprecated=True)
class ProcDeprecatedTrue(Proc):
    ...


@mark(deprecated="This process is deprecated.")
class ProcDeprecatedMessage(Proc):
    ...
```

When a deprecated process is run, a warning message will be logged.

If the process is marked with `deprecated=True`, the message will be:

```
[ProcDeprecatedTrue] is deprecated and will be removed in a future release.
```

If a custom message is provided, it will be used instead:

```
[ProcDeprecatedMessage] This process is deprecated.
```

You can use `proc` in the message as a placeholder for the process class. For example:

```python
@mark(deprecated='"{proc.name}" is deprecated.')
class ProcDeprecatedMessage(Proc):
    ...
```

This will log:

```
"ProcDeprecatedMessage" is deprecated.
```
pipen-diagram 1.1.1
Draw pipeline diagrams for pipen.
License: MIT
Requires Python: <4.0,>=3.9

# pipen-diagram

Draw pipeline diagrams for [pipen][1].

## Features

- Diagram theming
- Hiding processes from diagram

## Configurations

- `diagram_theme`: The name of the theme to use, or a dict of a custom theme.
  - See `pipen_diagram/diagram.py` for the a theme definition
  - See [https://graphviz.org/][2] for theme items
- `diagram_loglevel`: The log level of the diagram
- `diagram_savedot`: Whhether to save the dot file (for debugging purpose)
- `diagram_hide`: Process-level item, whether to hide current process from the diagram

## Installation

```shell
pip install -U pipen-diagram
```

## Enabling/Disabling the plugin

The plugin is registered via entrypoints. It's by default enabled. To disable it:
`plugins=[..., "no:diagram"]`, or uninstall this plugin.

## Usage

`example.py`

```python
from pipen import Proc, Pipen, ProcGroup


class A(Proc):
    """Process A"""
    input = "a"


class B(Proc):
    """Process B"""
    requires = A
    input = "b"
    plugin_opts = {"diagram_hide": True}


class PG(ProcGroup):
    """Process Group"""
    @ProcGroup.add_proc
    def c(self):
        """Process C"""
        class C(Proc):
            input = "c"

        return C

    @ProcGroup.add_proc
    def c1(self):
        """Process C1"""
        class C1(Proc):
            requires = self.c
            input = "c1"
            plugin_opts = {"diagram_hide": True}

        return C1

    @ProcGroup.add_proc
    def d(self):
        """Process D"""
        class D(Proc):
            input = "d"
            requires = self.c1

        return D


pg = PG()
pg.c.requires = B


class E(Proc):
    """Process E"""
    input = "e1,e2"
    requires = pg.d, A


class F(Proc):
    """Process F"""
    input = "f"
    requires = E


Pipen("MyPipeline").set_start(A).run()
# Dark theme
# Pipen("MyPipeline", plugin_opts={"diagram_theme": "dark"}).set_start(A).run()
```

Running `python example.py` will generate `MyPipeline-output/diagram.svg`:

| Default theme | Dark theme | Fancy theme | Fancy dark theme |
| ------------- | ---------- | ----------- | ---------------- |
| ![diagram](./diagram.svg) | ![diagram_dark](./diagram_dark.svg) | ![diagram_fancy](./diagram_fancy.svg) | ![diagram_fancy_dark](./diagram_fancy_dark.svg) |

[1]: https://github.com/pwwang/pipen
[2]: https://graphviz.org/
pipen-lock 1.1.1
Process lock for pipen to prevent multiple runs at the same time
License: MIT
Requires Python: <4.0,>=3.9

# pipen-lock

Process lock for pipen to prevent multiple runs at the same time

## Installation

```bash
pip install -U pipen-lock
```

## Enable/Disable

The plugin is enabled by default. To disable it, either uninstall it or:

```python
from pipen import Proc, Pipen

# process definition

class MyPipeline(Pipen):
    plugins = ["-lock"]

```

## Configuration

- `lock_soft`: Whether to use soft lock. Default: `False`
    non-soft lock is platform dependent while soft lock only watches the existence of the lock file.
    See more details <https://py-filelock.readthedocs.io/en/latest/index.html#filelock-vs-softfilelock>
    for the difference between `FileLock` and `SoftFileLock`
clockwork 0.4.1
Toolkit for time-related operations including scheduling, logging, date manipulation, and more.
License: MIT
Requires Python: <4.0,>=3.8

# clockwork

<div>

[![Package version](https://img.shields.io/pypi/v/clockwork?color=%2334D058&label=pypi)](https://pypi.org/project/clockwork/)
[![License](https://img.shields.io/github/license/zteinck/clockwork)](https://github.com/zteinck/clockwork/blob/master/LICENSE)

</div>


`clockwork` is a Python package that provides a multitude of time-related functionalities, facilitating tasks such as scheduling, logging, date manipulation, and more.


## Installation
```sh
pip install clockwork
```