semvec/pypi-packages huggingface dataset:
pipeline-dsl 0.3.0
A Python Pipeline DSL for Concourse
Requires Python: >=3.6

# Pipeline DSL for [Concourse](https://concourse-ci.org/) 

[![downloads](https://static.pepy.tech/badge/pipeline-dsl/month)](https://pypi.org/project/pipeline-dsl/)
[![python](https://img.shields.io/badge/python-3.6-blue.svg)](https://pypi.org/project/pipeline-dsl/)
[![pypi](https://img.shields.io/pypi/v/pipeline-dsl.svg)](https://pypi.org/project/pipeline-dsl/)
[![license](https://img.shields.io/pypi/l/pipeline-dsl.svg)](https://pypi.org/project/pipeline-dsl/)

## Features

* Develop complete Concourse pipelines in plain Python
* Test Pipelines inside Concourse without pushing them to github 
* Test Pipelines locally


## Installation

Installation from [PyPI](https://pypi.org/project/pipeline-dsl/)
```bash
pip3 install pipeline-dsl
```

Installation from GitHub
```bash
pip3 install --upgrade git+https://github.com/sap/pipeline-dsl.git@main
```

## Example

```python
from pipeline_dsl import Pipeline, GitRepo

with Pipeline("c21s") as pipeline:
    pipeline.resource("shalm", GitRepo("https://github.com/wonderix/shalm"))
    with pipeline.job("create-cluster") as job:
        shalm = job.get("shalm")
        cluster_name = "test"

        @job.task()
        def create_shoot():
            print(f"Create cluster {cluster_name}")
            return cluster_name

        @job.task(secrets={"home": "HOME"})
        def install_shalm(home=None):
            print("HOME=" + home)
            print(f"Installing shalm {shalm.path} into {create_shoot()}")
            return "Hello"
```


## Documentation

* [Users guide](/doc/user.md)
* [Reference guide](/doc/reference.md)
* [Contribution guidelines](/doc/contributing.md)
* [Examples](examples)
quants-veltzer-doron 1.0.0
ANN based learning of quantifiers
Requires Python: >=3.8

# quants package

Package for Artifical Neural Network (**ANN**) based learning of quantifiers.

It contains definition of scenes of elements and classes for both quantifier sampling and NN simple example package.


## Classes

### Quantifer classes
These classes are a quantifier hierarchy with methods and definitions for:
* *Scenes* that are composed of world *elements* pertaining to use of a sentence of the form "**q as are bs**".
* Construction of quantifier if parameters (such as in the case of ExactlyN for instance) are required.
* Static method for generation of a completely random scene.
* Generation of permuted prototype scenes that are evaluated as true under the given quantifier q.
* Evaluation of a given scene (returns **TRUE** for scenes generated by the same quantifier q in the previous method).

### Classifier class approach
This approach assumes that quantifiers are learned as a group, essentially each quantifier q **TRUE** *scene* is a negative example for all other quantifiers q'.
There is of course many scenes for which more than one quantifier is evaluated as **TRUE**, for instance if "Both students are eating" is **TRUE** then "Some students are eating" is also **TRUE**, this can be mitigated by implicatures which we do not address.

The classifier is in effect a solver for which q makes the sentence "**q as are bs**" most likely given an input *scene* s.

This enables us to use not only the quantifier quantify evaluation methods but the classifier in order to generate a teacher-student scheme.

### AE approach
The AE approach tries to let an AE look at *scenes* where a given quantifier q was used by a teacher (language speaker), this is repeated many times till whatever structure typical to scenes **TRUE** under the quantifier q are encoded in the AE hidden values' represented structure. When learning is complete and when we are given a scene we use the AE as an anomaly detector to decide whether the scene is True under the quantifier q. The idea is that after seeing many q **TRUE** scenes a non q **TRUE** scene will have relatively high reconstruction errors.
ubuf 0.0.2
Generate protocols for C++ and JS
Requires Python: >=3.7

# μBuf

## Introduction

Have you ever needed to create your own network protocol for several languages?
Rewriting every change in multiple languages is tedious and introduces bugs!

When I tried to use protobuf, the resulting code was daunting and I observed that the message size was far from optimal.

This is why I created a simplistic protocol generator: **μBuf**.

It takes a simple YAML file as input and produces compatible serialization and deserialization code for several languages.

Currently, C++ and Javascript are supported as target languages.

## Usage

1. Write your protocol in a YAML file (`protocol.yml` for example)
2. Generate the code with:
   - `ubuf protocol.yml --lang js > protocol.js`
   - `ubuf protocol.yml --lang cpp > protocol.hpp`
3. Put the `io` libraries in the same place as the protocol files.
4. Profit!

## Example

This is the config file that defines my protocol for a simple game:

```yml
types:
  coord_t: double
  Pos:
    x: coord_t
    y: coord_t
  UserId: string

messages:
  ClientRegisterMsg:
    name: string
  ServerRegisterMsg:
  ClientUpdateMsg:
    pos: Pos
  ServerUpdateMsg:
    user_id: UserId
    name: string
    pos: Pos
  ServerDeleteMsg:
    user_id: UserId
```

As you can see, it is divided in two sections, `types` and `messages`. The first define data types that can be used in messages.

### Write

From JS:

```js
import * as Proto from "./protocol.js";

const msg = new Proto.ClientUpdateMsg({ x: 4.2, y: 6.9 });

const buf: Uint8Array = msg.serialize();
```

From C++:

```c++
#include "protocol.hpp"

ClientUpdateMsg msg{4.2, 6.9};

string buf = serialize(msg);
```

### Read

From JS:

```js
import * as Proto from "./protocol.js";

const buf = new Proto.InBuffer(data);
const type = buf.readChar();
if (type == Proto.ServerUpdateMsg.id) {
  const msg = buf.readServerUpdateMsg();
  // msg is a standard JS object that can be intuitively accessed:
  // msg.user_id, msg.name, msg.pos.x, msg.pos.y
} else if (type == Proto.ServerDeleteMsg.id) {
  const msg = buf.readServerDeleteMsg();
  // do something
} else {
  console.log("unknown message type", type);
}
```

From C++:

```c++
#include "protocol.hpp"

std::string_view msg;

InBuffer buffer(msg);

if(type == ClientRegisterMsg::id_) {
    ClientRegisterMsg msg;
    buffer >> msg;
    std::string name = msg.name;
    // do other things
}
```

## Supported primitive types

- char
- string
- double