semvec/pypi-packages huggingface dataset:
regfmt 0.9.1
A command line utility to generate SVG diagrams for control register-style data formats.
Requires Python: >=3.9

# regfmt

**regfmt** is a command line utility to generate SVG diagrams for control register-style data formats. It is inspired by the *dformat* command from the *troff* family of tools, however re-imagined using contemporary (circa 2022) file formats.

Example output SVG:

![example svg](http://yummymelon.com/images/example_0001-github.svg)

# Features

-   SVG output
-   Modern configuration input file formats
    -   YAML for register configuration
    -   CSS for styling SVG output

# Usage

    usage: regfmt [-h] [-v] [-o OUTPUT] [-s STYLE] [-t {yaml,css,yamlcss}] [input]
    
    regfmt - generate SVG diagrams of control register-style data formats
    
    positional arguments:
      input                 input register format YAML file (default: input.yaml)
    
    options:
      -h, --help            show this help message and exit
      -v, --version         print version information and exit
      -o OUTPUT, --output OUTPUT
                            output file (default: '-' for stdout)
      -s STYLE, --style STYLE
                            CSS style file
      -t {yaml,css,yamlcss}, --template {yaml,css,yamlcss}
                            Generate template YAML and/or CSS files
transforge 0.2.1
A library for type inference and graph production.
Requires Python: >=3.9

# transforge

[![](https://img.shields.io/pypi/v/transforge)](https://pypi.org/project/transforge/)

A transformation language is used to describe *processes*, like the ones 
implicit in workflows or software tools, as *transformations between 
types*. These types do not necessarily denote a concrete data structure, 
and the descriptions may be independent from any particular 
implementation. The goal is only to capture some properties that are 
deemed *conceptually* relevant, as a form of *procedural metadata*.

`transforge` facilitates defining a transformation language and parsing 
its expressions into semantic graphs. It is written in pure Python with 
few dependencies.

In order to reason about about transformations, it also implements a 
[type inference](https://en.wikipedia.org/wiki/Type_inference) module, 
which accommodates both 
[subtype-](https://en.wikipedia.org/wiki/Subtyping) and 
[parametric](https://en.wikipedia.org/wiki/Parametric_polymorphism) 
polymorphism.

Expressions of a transformation language can be turned into 
transformation graphs. Such graphs can be serialized into 
[RDF](https://en.wikipedia.org/wiki/Resource_Description_Framework), or 
converted to [SPARQL](https://en.wikipedia.org/wiki/SPARQL) queries and 
matched against other graphs. This enables flexible searching through 
processes.

**The library is still in development. Interfaces might change without 
warning.**


### Usage

This package was developed for the [CCT](https://github.com/quangis/cct) 
algebra for geographical information, which may act as an example.

Click here for a [tutorial](docs/tutorial.md).
pyLaCentrale 1.0.0
LaCentrale wrapper for python
Requires Python: >=3.6
Keywords: python,LaCentrale api,python lacentrale,python car

# Vinted-Api-Wrapper
Simple python package that uses the Vinted API to search new posts.

## Install
Simpely install package using pip :
```
pip install pyVinted
```
## Example

```py
from pyVinted import Vinted

vinted = Vinted()

# search(url, number_of_items, page_number)
items = vinted.items.search("https://www.vinted.fr/vetement?order=newest_first&price_to=60&currency=EUR",10,1)
#returns a list of objects: item

```
You can access Item attributes as shown here:
```py
item1 = items[0]
#title
item1.title
#id
item1.id
#photo url
item1.photo
#brand
item1.brand_title
#price
item1.price
#url
item1.url
#currency
item1.currency
```