Sure! Here's how you could construct a Partially Ordered Workflow language (`POWL`) model for an `Purchase-to-Pay` process using PM4Py library:

1st step would be creating nodes for different activities like 'Order', 'Receive', 'Process', 'Pay', etc.;
2nd step would define transition between these activities where they are related chronologically.

Firstly create a list of all the transition nodes (activities in Purchase to Pay process):
```python
nodes = [
    # Order the creation, e.g.,
    "Order",
    "Receive",  
    "Process",
    "Pay",
    "Review"   
]
```
Then define how these activities should relate chronologically using the `POWLSpecialModel` class:

```python

from pm4py.objects.powl.obj import POWLModel
from pm4py.objects.powl.properties import get_nodes, set_property_order
from pm4py.objects.powl.impl import POWLOrdered, POWLNode 

# First activity order relation:
powl_order1 = POWLOrdered(nodes=nodes)
powl_order1[POWLOrdered.nodes].index_of("Receive") > powl_order1[POWLOrdered.nodes].index_of("Order")
  
 # 2nd,3rd Activity relation
powl_order2 = POWLOrdered()
# Add node "Process" after order "Receive"
powl_order2.add_edge( "Receive", "Process")

 # Continue to create relations for each activity
powl_order3 = POWLOrdered(nodes=nodes)
# Add edge: "Review" should occur after both Order and Receive have been processed
   
powl_order3.add_edge("Order", "Review")
powl_order3.add_edge("Receive", "Review")

# Final check
print(get_nodes(powl_order1))
print(get_nodes(powl_order2))
print(get_nodes(powl_order3))

```
This will create a 'Directed Acyclic Graph' (`DAG`) for each order relation where the source node must be completed before execution reaches the target node.

Remember this is very basic and doesn't include actual activity actions or conditions. It just includes the order relations between activities.

For creating a `POWL` model with control-flow operators like XORS and LOOPS use similar constructs:

```python