workpeg 0.5.2__tar.gz → 0.6.0__tar.gz

{workpeg-0.5.2/src/workpeg.egg-info → workpeg-0.6.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: workpeg
-Version: 0.5.2
+Version: 0.6.0
 Summary: Workpeg function runtime and SDK
 Author-email: Workpeg <support@workpeg.com>
 License: MIT
-Project-URL: Homepage, https://gitlab.com/workpeg/workpeg-sdk
-Project-URL: Repository, https://developers.workpeg.com
+Project-URL: Homepage, https://developers.workpeg.com
+Project-URL: Repository, https://gitlab.com/workpeg/workpeg-sdk
 Keywords: workpeg,serverless,functions,runtime
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -19,22 +19,24 @@ Dynamic: license-file
 
 # Workpeg SDK
 
-Python SDK and CLI for building Workpeg Pegs and execution workloads.
+Python SDK and CLI for building Workpeg Pegs and runtime-backed micro-apps.
 
-Workpeg is a platform for developing portable micro-apps called Pegs. Pegs can be packaged, executed, distributed through the PegStore, and integrated into the broader Workpeg ecosystem.
+Workpeg is a platform for developing portable applications called Pegs. Pegs can be packaged, executed, distributed through the PegStore, and integrated into the broader Workpeg ecosystem.
 
-The SDK currently focuses on function-based Peg development and local runtime tooling, while the CLI architecture is designed to expand into additional capabilities such as client applications, Peg packaging, registry tooling, runtime orchestration, and deployment infrastructure.
+The SDK currently focuses on function-based Peg development, runtime tooling, Docker packaging, and asset distribution, while the CLI architecture is designed to expand into additional capabilities such as client applications, Peg packaging, orchestration, deployment infrastructure, and registry tooling.
 
 ## Current capabilities
 
 * Peg scaffolding
-* Function-based execution model
+* Function-based runtime model
 * Fast local runtime
 * Persistent Docker runtime
 * Docker image packaging
 * Registry submission
+* Public CDN asset uploads
 * Runtime configuration
 * Warm container execution
+* Docker networking support
 
 ## Repository
 
@@ -46,19 +48,19 @@ The SDK currently focuses on function-based Peg development and local runtime to
 
 Install from PyPI:
 
-```bash id="0d2m52"
+```bash
 pip install workpeg
 ```
 
 Or install locally from source:
 
-```bash id="4d9q9q"
+```bash
 pip install -e .
 ```
 
 Verify installation:
 
-```bash id="56gg0t"
+```bash
 workpeg --version
 ```
 
@@ -68,15 +70,16 @@ workpeg --version
 
 Workpeg uses a namespace-oriented CLI inspired by tools like Docker.
 
-Current namespace:
+Current namespaces:
 
-```bash id="m0u9jj"
+```bash
 workpeg function ...
+workpeg cdn ...
 ```
 
 Future namespaces may include:
 
-```bash id="8itvsl"
+```bash
 workpeg client ...
 workpeg peg ...
 workpeg registry ...
@@ -85,9 +88,10 @@ workpeg runtime ...
 
 Get help:
 
-```bash id="q3x8r2"
+```bash
 workpeg --help
 workpeg function --help
+workpeg cdn --help
 ```
 
 ---
@@ -98,13 +102,13 @@ workpeg function --help
 
 Create a new function project:
 
-```bash id="kcnw5d"
+```bash
 workpeg function new hello
 ```
 
 Generated structure:
 
-```text id="v6m8d4"
+```text
 hello/
 ├── app/
 │   ├── __init__.py
@@ -118,7 +122,7 @@ hello/
 
 Example function:
 
-```python id="h6e3xs"
+```python
 def main(context, payload):
     return {
         "message": "Hello from Workpeg",
@@ -132,14 +136,14 @@ def main(context, payload):
 
 For rapid iteration without Docker:
 
-```bash id="rrl4su"
+```bash
 echo '{"context": {}, "payload": {"name":"world"}}' \
   | workpeg function runtime
 ```
 
 Example response:
 
-```json id="uohm9u"
+```json
 {
   "status": "success",
   "result": {
@@ -157,19 +161,19 @@ Example response:
 
 Run the runtime as a warm HTTP server:
 
-```bash id="1n1n3x"
+```bash
 workpeg function runtime --server
 ```
 
 Default endpoint:
 
-```text id="07ubrq"
+```text
 http://0.0.0.0:8000
 ```
 
 Invoke:
 
-```bash id="4z1s1l"
+```bash
 curl -X POST http://localhost:8000/invoke \
   -H "Content-Type: application/json" \
   -d '{"context": {}, "payload": {"hello":"world"}}'
@@ -177,7 +181,7 @@ curl -X POST http://localhost:8000/invoke \
 
 Health check:
 
-```bash id="lc3bxr"
+```bash
 curl http://localhost:8000/healthz
 ```
 
@@ -187,13 +191,13 @@ curl http://localhost:8000/healthz
 
 Build a Peg runtime image:
 
-```bash id="l8z59k"
+```bash
 workpeg function build
 ```
 
 Specify custom tag:
 
-```bash id="ofm9pp"
+```bash
 workpeg function build --tag my-image
 ```
 
@@ -205,20 +209,20 @@ The build process produces a portable runtime container for the Peg.
 
 Run a warm containerized runtime:
 
-```bash id="rbvt3p"
+```bash
 workpeg function run --with docker
 ```
 
 This:
 
 * Builds the image (unless disabled)
-* Starts a persistent runtime container
+* Starts a detached persistent runtime container
 * Exposes HTTP endpoints
 * Enables warm execution
 
 Default endpoint:
 
-```text id="ghp23n"
+```text
 http://localhost:8000
 ```
 
@@ -228,7 +232,7 @@ http://localhost:8000
 
 Attach runtimes to a Docker network:
 
-```bash id="2rx4ji"
+```bash
 workpeg function run \
   --with docker \
   --network workpeg_net
@@ -236,12 +240,77 @@ workpeg function run \
 
 Useful for inter-Peg communication and local ecosystem development:
 
-```text id="pwnmql"
+```text
 http://peg-name:8000
 ```
 
 This enables multiple Peg runtimes to coexist without port collisions.
 
+Example:
+
+```bash
+workpeg function run \
+  --with docker \
+  --network workpeg_net \
+  --name calendar
+```
+
+Then other containers can reach it at:
+
+```text
+http://calendar:8000
+```
+
+---
+
+# CDN Asset Uploads
+
+Upload public Peg assets to the CDN:
+
+Single file:
+
+```bash
+workpeg cdn submit logo.png
+```
+
+Directory:
+
+```bash
+workpeg cdn submit ./dist
+```
+
+Current directory:
+
+```bash
+workpeg cdn submit .
+```
+
+Custom CDN path:
+
+```bash
+workpeg cdn submit ./dist --path assets
+```
+
+Upload archive exactly without extraction:
+
+```bash
+workpeg cdn submit ./dist \
+  --path archives/dist.tar.gz \
+  --exact
+```
+
+Authentication uses:
+
+```bash
+export WORKPEG_PK=<your-token>
+```
+
+Default registry:
+
+```text
+https://repo.workpeg.com
+```
+
 ---
 
 # Detached Warm Runtime Model
@@ -257,9 +326,9 @@ This enables:
 * Internal networking
 * Future orchestration support
 
-Example execution model:
+Execution progression:
 
-```text id="z3q4z1"
+```text
 Function → Runtime Container → Peg → PegStore
 ```
 
@@ -276,7 +345,7 @@ Workpeg supports multiple execution backends.
 
 Select backend:
 
-```bash id="f94kq8"
+```bash
 workpeg function run --with docker
 ```
 
@@ -292,13 +361,13 @@ Runtime resolution order:
 
 Optional project configuration:
 
-```text id="u2pq39"
+```text
 workpeg.json
 ```
 
 Example:
 
-```json id="9cv47i"
+```json
 {
   "runtime": {
     "default": "docker",
@@ -323,14 +392,14 @@ Example:
 
 Functions implement:
 
-```python id="9a3e3r"
+```python
 def main(context: dict, payload: dict):
     return {...}
 ```
 
 Input:
 
-```json id="xgcw6e"
+```json
 {
   "context": {...},
   "payload": {...}
@@ -339,7 +408,7 @@ Input:
 
 Success output:
 
-```json id="zptc4l"
+```json
 {
   "status": "success",
   "result": {...}
@@ -348,7 +417,7 @@ Success output:
 
 Error output:
 
-```json id="c8z1k6"
+```json
 {
   "status": "error",
   "error_type": "...",
@@ -362,13 +431,13 @@ Error output:
 
 Default entrypoint:
 
-```text id="e0nbql"
+```text
 app.main:main
 ```
 
 Override:
 
-```bash id="v42ihq"
+```bash
 FUNCTION_ENTRYPOINT=app.main:handler \
   workpeg function runtime
 ```
@@ -379,7 +448,7 @@ FUNCTION_ENTRYPOINT=app.main:handler \
 
 Required for:
 
-```bash id="p7wvdn"
+```bash
 workpeg function build
 workpeg function run --with docker
 ```
@@ -392,7 +461,7 @@ Requirements:
 
 When running inside another container:
 
-```bash id="qho4i4"
+```bash
 -v /var/run/docker.sock:/var/run/docker.sock
 ```
 
@@ -400,18 +469,18 @@ When running inside another container:
 
 # Philosophy
 
-Workpeg is designed around composable executable applications.
+Workpeg is designed around portable executable applications.
 
 Core progression:
 
-```text id="i8n38r"
+```text
 Function → Runtime → Peg → PegStore → Ecosystem
 ```
 
-* Functions provide isolated execution units
+* Functions provide isolated runtime units
 * Pegs package functionality into portable micro-apps
-* PegStore enables distribution
-* Workpeg provides the runtime and orchestration foundation
+* PegStore enables discovery and distribution
+* Workpeg provides runtime, packaging, and orchestration foundations
 
 The long-term direction is a platform where developers can build, distribute, and execute intelligent applications inside a unified ecosystem.