semvec/pypi-packages huggingface dataset:
AnaviInfraredPhat 0.0.11
AnaviInfraredPhat

# AnaviInfraredPhat

## AnaviInfraredPhat as an application

Publishes temperature, pressure, humidity, luminosity and heat index from your Pi over 0MQ.

```
python3 -m AnaviInfraredPhat --verbose
2019-05-12 10:40:19.192 JST [   DEBUG] __init__ : Logging with global level DEBUG
2019-05-12 10:40:19.196 JST [   DEBUG] __init__ : Sysout logging with level DEBUG
2019-05-12 10:40:19.199 JST [   DEBUG] __init__ : Changing sysout format to logfile
2019-05-12 10:40:19.217 JST [   DEBUG] __init__ : Added TimedRotatingFileHandler to /var/logAnaviInfraredPhat.log with level DEBUG.
2019-05-12 10:40:19.228 JST [   DEBUG] __init__ : Log rotates every D and keeps 15 logs.
2019-05-12 10:40:19.233 JST [    INFO] __main__ : Starting
2019-05-12 10:40:20.093 JST [   DEBUG] __main__ : {"hi": null, "l": 63, "hi_cmt": "No concerns", "h": 42, "p": 1015, "t": 25.8}
```

## AnaviInfraredPhat as a module

The module can be used from a different machine than the Raspberry Pi hosting the Anavi Infrared Phat.

It has a class for each sensor provided with the original Anavi Infrared Phat Kit.

* BH1750
* HTU21D
* BMP180

As well as a class to emit IR codes.

* IRSEND (adapted from Joan's script @ http://abyz.co.uk/rpi/pigpio/code/irrp_py.zip. It uses records files which are to be created with irrp.py)

Some more functions are available as example or boilerplate code:

* report_tphl
* report_tphl_average
* report_tphl_as_text

Please refer to the code.
xsd2shacl 1.1.0
Generates SHACL shapes from XML Schema files
Requires Python: <4.0,>=3.9

# XSD2SHACL

[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![DOI](https://zenodo.org/badge/687035494.svg)](https://zenodo.org/badge/latestdoi/687035494)

A tool to generate SHACL shapes from XSD for RDF graphs validation. 

- The results of comparison and evaluation of supported XSD components are under [comparison folder](https://github.com/dtai-kg/XSD2SHACL/tree/main/comparison).

- The results of validation on two usecases are under [usecases folder](https://github.com/dtai-kg/XSD2SHACL/tree/main/usecases). 

## Installation

- From PyPi package
```bash
pip install xsd2shacl
```

- From source code:
```bash
python -m pip install poetry
poetry update
poetry build
```
## Usage

To translate XSD to SHACL shapes:

```bash
python -m xsd2shacl -x XSD_PATH [-s SHACL_PATH]
```

For example, if you execute the following:

```bash
python -m xsd2shacl -x comparison/pos.xsd
```

The generated shape file will then be located here: comparison/pos.xsd.shape.ttl. 


## Post-adjustment

To adjust the generated SHACL shapes with corresponding RML mapping files to the post-adjusted shapes on two use cases:

- RINF:

```bash
python -m xsd2shacl -i usecases/RINF/RINF-metadata.xsd.shape.ttl -r usecases/RINF/mappings/RINF-contact-line-systems.yml.ttl -a usecases/RINF/RINF-metadata.xsd.shape.RINF-contact-line-systems.adjustment.ttl
```

-  TED:

```bash
python -m xsd2shacl -i usecases/TED/TED_EXPORT_merge.xsd.shape.ttl -r usecases/TED/mappings/F03 -a usecases/TED/TED_EXPORT_merge_F03.shape.adjustment.ttl
```

Run following get the validation results (C_T, R/T, R/T', C_P, R/P, R/P'):

```bash
python usecases/RINF/metrics.py
python usecases/TED/metrics.py
```

## Cite 

To cite our work:
```bib
@inproceedings{duan2023xsd,
    author = {Duan, Xuemin and Chaves-Fraga, David and Dimou, Anastasia},
    title = {{XSD2SHACL: Capturing RDF Constraints from XML Schema}},
    year = {2023},
    isbn = {9798400701412},
    publisher = {ACM},
    doi = {10.1145/3587259.3627565},
    booktitle = {Proceedings of the 12th Knowledge Capture Conference 2023},
    keywords = {Validation, XSD, SHACL, RDF shapes, XML Schema},
    series = {K-CAP '23}
}
```
timod 0.0.17
A PyTorch module wrapper for Taichi kernels
Requires Python: >=3.7

# timod

TaichIMODule, a tiny pytorch module wrapper for differentiable Taichi kernels.

# Install

`pip install timod`

## Usage

Given a taichi kernel `my_kernel` with input and output tensors typed `ti.types.ndarray()`:

```python
from timod import TaichiKernelModule

# Output tensors specifications (since they will be created on the fly)
output_specs = {
    'out1':(<shape>, <dtype>, <needs gradients ?>), 
    'out2':(<shape>, <dtype>, <needs gradients ?>)
    ...}

# Module creation
taichi_module = TaichiKernelModule(my_kernel, output_specs)

# Kernel input args (torch tensors and scalars)
in1 = ...
in2 = ...
...

# Module call
out1, out2, ... = taichi_module(in1, in2, ...) # kwargs of the taichi kernel inputs are supported 

# Loss function
loss = my_loss(out1, out2, ...)

# Gradient computation
loss.backward()

# Gradient descent
lr = 1e-3
in1 -= lr * in1.grad
in2 -= lr * in2.grad
...

```
rml2shacl 1.0.0
Translates RML into SHACL
Requires Python: <4.0,>=3.9

# RML2SHACL 

A tool to generate SHACL shapes from RML mapping files for RDF graphs validation. 


# Installation
- From PyPi package
```bash
pip install rml2shacl
```

- From source code:
```bash
python -m pip install poetry
poetry update
poetry build
```

# Usage

General usage info: 

```
usage: rml2shacl -i MAPPING_PATH [-o SHACL_PATH] [-logLevel LOGLEVEL] 

positional arguments:
  -i,--MAPPING_PATH <arg>           RML mapping path to be converted into SHACL shapes.

optional arguments:
  -o SHACL_PATH <arg>               SHACL output path 
  -h, --help                        show this help message and exit
  -l, --LOG_LEVEL <arg>             Logging level of this script. Possible values: INFO,DEBUG,WARN

```


To generate your shacl shapes: 

```bash 
python3 -m rml2shacl -i <path> [-o <path>]
```

Example:

```bash 
python3 -m rml2shacl -i mapping.rml.ttl -o ./output/
```

The generated SHACL shapes will be located in `./output/mapping-shape.ttl`