semvec/pypi-packages huggingface dataset:
dominion-grpc-proto 0.3.0
gRPC protobuf definitions + generated Python code
License: MIT
Requires Python: >=3.8

# Dominon gRPC proto
[
![PyPI](https://img.shields.io/pypi/v/dominion-grpc-proto.svg)
![PyPI](https://img.shields.io/github/license/the-gigi/dominion-grpc-proto.svg)
](https://pypi.org/project/dominion-grpc-proto/)



The [gRPC](https://grpc.io/) protobuf definitions for the [Dominion](https://github.com/the-gigi/dominion) project

The **dominion.proto** file specifies the Dominion service definition. The Makefile creates two Python modules that can be used by the Dominion server and clients.



# Build and publish

This section is for the Dominion developers. 
If you just want to implement a player or a client library you can stop reading.


## Pre-requisites

- Install [pyenv](https://github.com/pyenv/pyenv) or [pyenv-win](https://github.com/pyenv-win/pyenv-win)
- Install [poetry](https://python-poetry.org/docs/#installation)

Create a Python 3.8.2 environment

```
$ pyenv install 3.8.2
$ pyenv local
$ poetry init
$ poetry env use 3.8.2
$ poetry install
```

Save the following to ~/.pypirc

```
[distutils]
index-servers=
    pypi
    pypitest

[pypitest]
repository = https://test.pypi.org/legacy/
username = <your user name>

[pypi]
repository = https://pypi.org/legacy/
username = <your user name>
```

## Building the gRPC generated code

Just run `make`

## Building the package

Bump the version in the setup.py file

Here is the command to build the package:

```
(🐙)/dominion-grpc-proto
$ poetry run python setup.py bdist_wheel
``` 

The result is tar-gzipped file in the dist subdirectory:

```
(🐙)/dominion-grpc-proto
$ ls dist
dominion_grpc_proto-0.2.0-py3-none-any.whl
```

## Publish the package

Next, we can upload the package using twine to PyPI.

```
(🐙)/dominion-grpc-proto
$ poetry run twine upload -p <redacted> dist/*.whl

Uploading distributions to https://upload.pypi.org/legacy/
Uploading dominion_grpc_proto-0.2.0-py3-none-any.whl
100%|███████████████████████████████████| 10.3k/10.3k [00:02<00:00, 3.54kB/s]

View at:
https://pypi.org/project/dominion-grpc-proto/0.2.0/
```
wiomath 1.0.8
Turkce database modulu
License: MIT
Keywords: database

<br>#wiodb<br>
##Yüklemek İçin
```pip
pip install  wiodb
```

# NEWS
If there is no data, the db.add method automatically creates data with the given parameter.
(only number)

(｡•̀ᴗ-)✧


##Nasıl Kullanılır? || how to use?
```python
import math
```
## Bana ulaşabileceğiniz yerler. || Bugs report
[Discord](https://discord.gg/pSGUsGF)
[İnstagram](https://www.instagram.com/wioenena.q/)
wioenenadb 1.0.8
Turkce database modulu
License: MIT
Keywords: database

<br>#wiodb<br>
##Yüklemek İçin
```pip
pip install  wiodb
```

# NEWS
If there is no data, the db.add method automatically creates data with the given parameter.
(only number)

(｡•̀ᴗ-)✧


##Nasıl Kullanılır? || how to use?
```python
import wiodb
    await db.add('wio',1) # ---> add user data this value
    await db.set('wio','blablabla') # ---> create user data
    await db.delete('wio') # ---> delete user data
    data = await db.fetch('wio') # ---> fetch user data
    
```
## Bana ulaşabileceğiniz yerler. || Bugs report
[Discord](https://discord.gg/pSGUsGF)
[İnstagram](https://www.instagram.com/wioenena.q/)
gnutty 0.0.1
Pure Python REST HTTP Server
License: MIT
Keywords: server,http,rest,api

# GNUTTY
Pure Python HTTP Server

# How do I use this?
So long as you have Python3.4 or higher, there are no
dependencies to worry about. Gnutty uses nothing but Python

To start the example server, run
```
python3 ./srv/gnutty.py
```
From the root of the repository.

You can confirm that it is running by opening
`http://127.0.0.1:8000/` in a browser and checking you
receive the plaintext response of `OK`

You can also run
```bash
curl -v http://127.0.0.1:8000
```
To confirm the response from the Gnutty Server
```
~  curl -v http://127.0.0.1:8000
*   Trying 127.0.0.1...
* TCP_NODELAY set
* Connected to 127.0.0.1 (127.0.0.1) port 8000 (#0)
> GET / HTTP/1.1
> Host: 127.0.0.1:8000
> User-Agent: curl/7.64.1
> Accept: */*
>
* HTTP 1.0, assume close after body
< HTTP/1.0 200 OK
< Server: Gnutty HTTP server 0.1
< Content-Type: text
< Content-Length: 2
<
* Closing connection 0
OK
```
pyramid-htmldoom 0.3
htmldoom rendering library plugin for Pyramid
License: MIT
Keywords: html rendering for pyramid

pyramid_htmldoom
================
[htmldoom](https://github.com/sayanarijit/htmldoom) rendering library plugin for Pyramid

Usage
----
### Install

```bash
pip install pyramid_htmldoom
```

### Plug into Pyramid

#### app.py

```python
from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response
from pyramid.view import view_config

@view_config(route_name="hello_htmldoom", renderer="templates.hello.py")
def hello_htmldoom_view(request):
    """htmldoom rendered view"""
    return {"data": "Hello htmldoom"}


if __name__ == "__main__":
    with Configurator() as config:
        config.scan()

        config.include("pyramid_htmldoom")
        config.add_route("hello_htmldoom", "/")

        app = config.make_wsgi_app()
    server = make_server("localhost", 8080, app)
    server.serve_forever()
```

#### templates/hello.py

```python
from htmldoom import elements as e
from htmldoom import renders

from .layout import render_document


@renders(
    e.body()(
        e.h3()("{contents}"),
        e.a(href="/")("Home"),
    )
)
def render_body(data):
    return {"contents": data["data"]}


def render(data):
    return render_document(data, body_renderer=render_body)
```

#### templates/layout.py

```python
from htmldoom import base as b
from htmldoom import elements as e
from htmldoom import renders

doctype = b.doctype("html")


@renders(e.title()("{doctitle}"))
def render_title(doctitle):
    return {"doctitle": doctitle}


@renders(e.body()("{content}"))
def render_body(data):
    raise NotImplementedError("You are trying to render a layout.")


@renders(doctype, e.html()(e.head()("{title}"), "{body}"))
def render_document(
    data,
    title_renderer=render_title,
    body_renderer=render_body,
):
    return {
        "doctype": doctype,
        "title": title_renderer(doctitle=data["data"]),
        "body": body_renderer(data=data),
    }


def render(data):
    return render_document(data=data)
```

Examples
--------
[Find demo and examples here](https://github.com/sayanarijit/pyramid_htmldoom/blob/master/examples)

### Deploy examples on heroku:

```bash
git push heroku $(git subtree split --prefix examples/2_hackernews master):master
```