semvec/pypi-packages huggingface dataset:
phrase-translator 0.1.2
A very simple package to translate single words and phrases between different languages.
License: MIT
Requires Python: >=3.7,<4.0

### Phrase Translator

A very simple package to translate single words and phrases between different languages.

[![PyPI Version][pypi-image]][pypi-url]
[![Build Status][build-image]][build-url]
[![Versions][versions-image]][versions-url]

...

<!-- Badges: -->

[pypi-image]: https://img.shields.io/pypi/v/phrase-translator
[pypi-url]: https://pypi.org/project/phrase-translator/
[build-image]: https://github.com/fr2501/phrase-translator/actions/workflows/build.yaml/badge.svg
[build-url]: https://github.com/fr2501/phrase-translator/actions/workflows/build.yaml
[versions-image]: https://img.shields.io/pypi/pyversions/phrase-translator/
[versions-url]: https://pypi.org/project/phrase-translator/
blowtorch-py 0.1.3
A framework for creating Rust machine learning models that are trained in Python.
License: MIT
Requires Python: >=3.9,<4.0

# Blowtorch
Blowtorch is a Python package that allows you to train machine learning models
and run inference in pure Rust. This is done through a specifying the model
once in a JSON file. Blowtorch then exports your specification into Rust and Python 
models. You can train the Python model as you prefer, and Blowtorch can be run again
to share the weights to Rust. 

An example application built with a predecessor of Blowtorch is [ZipNet](https://conzel.github.io/zipnet/), 
which is a neural-network based compression algorithm run entirely in the browser.
We built Blowtorch as we could not find any easily extensible machine learning frameworks
that could be compiled to WebAssembly.

Advantages over similar packages
- Inference is in pure Rust, meaning your model can run anywhere that Rust runs. You can for example compile it to WebAssembly.
- New layers can be implemented very easily, as one just has to write a forward pass in Rust
- Training is completely in Python, meaning you can use whatever training procedures you like
- Complex networks can be built by splitting the architecture into simpler modules, which are combined together by some glue code

Our documentation can be found at https://blowtorch.readthedocs.io/en/latest/.

## Features

- [x] Export and import trained weights
- [ ] Implementations for the following layers:
    - [x] Conv
    - [x] ConvT
    - [x] ReLU
    - [ ] GDN
    - [ ] iGDN
    - [x] Flatten
    - [x] Linear
- [x] Easy-to-use example 
- [x] Possibilities to extend the framework
- [x] Documentation for Python & Rust
patch-antenna 0.1.0
A simple patch antenna design library
License: MIT

# Design Patch Antenna

A simple patch antenna design library

[![status](https://api.travis-ci.com/bhanuchander210/patch_antenna.png)](https://travis-ci.com/github/Bhanuchander210/patch_antenna) [![coverage](https://img.shields.io/codecov/c/github/bhanuchander210/patch_antenna)](https://app.codecov.io/gh/Bhanuchander210/patch_antenna)


## Prerequisite

Python environment

- python=3.10

- Install below packages

```
pip install scipy==1.9.0
pip install gerber_writer==0.3.4
```


## Installation

```
pip install patch_antenna
```

## Design patch antenna

To get the design results of a patch antenna use the method `design(freq, er, h)` by passing your 
**resonant frequency** (Hz), **dielectric constant** and **thickness of the cavity** (m) values as arguments.

### Simple Design and Usage

##### Getting design parameters


```python
import patch_antenna as pa

# resonant frequency in Hz
freq = 2.4 * 10 ** 9

# dielectric constant
er = 4.4

# thickness of the cavity in meter
h = 1.6 * 10 ** -3

result = pa.design_string(freq, er, h)

print(result)

```

##### Output:

```
{'frequency': 2400000000.0, 'patch_width': 0.0380099749575278, 'patch_length': 0.0294215930843705, 'feeder_width': 0.015203989983011122, 'feeder_length': 0.015449608708025277, 'inset_gap_width': 0.007601994991505561, 'inset_length': 0.010914409094654586, 'ground_length': 0.05447120179239577, 'ground_width': 0.06281396494053892, 'input_edge_impedance': 321.50075290241097}
```


##### Write as Gerber file for both feed types

- Normal feed

```python
pa.write_gerber(freq, er, h, 'patch_design_normal_2.4GHz_4.4_er_1.6_h.gbr', 'normal')
```

- Inset feed

```python
pa.write_gerber(freq, er, h, 'patch_design_inset_2.4GHz_4.4_er_1.6_h.gbr', 'inset')
```


### Customize design results

##### Using design object

```python
design = pa.design(freq, er, h)

design.feeder_length *= 1.25

design.feeder_width *= 1.10

pa.write_gerber_design(design, 'custom_patch_normal_design.gbr', 'normal')

pa.write_gerber_design(design, 'custom_patch_inset_design.gbr', 'inset')
```

#### Future:

- Design and gerber generation for patch antenna arrays and including other parameters calculation.


#### Note

Patch antenna design, 3D simulation, and Gerber file facility also published as Web-Live application.

- [Patch antenna util - Web Live Application](https://bhanuchander210.github.io/patch-antenna-util/)
- [Patch antenna util - GitHub](https://github.com/Bhanuchander210/patch-antenna-util)
- [Blog post](https://bhanuchander210.github.io/Design-A-Rectangular-Patch-Antenna-Using-Python/)