semvec/pypi-packages huggingface dataset:
smmo 0.0.4
Scattering-Matrix method for multilayer optics
Requires Python: >=3.6

**SMMO** (**S**cattering-**M**atrix method for **M**ultilayer **O**ptics) is scattering matrix method [1-3] implementation for python.

### Installation

```python
pip install smmo
```

### Parameters

`config`

-   `wavenumber`: The wavenumber of refractive index (or absorption coefficient) of layers. The unit is inverse centimeter (cm<sup>-1</sup>).
-   `incidence`: Angle of incidence ($0\leqq\theta<90$). The unit is arc degree.
-   `polarization`: Polarization of the incidence light. `s` is s-polarization and `p` is p-polarization.

`layer`

-   `n`: Refractive index of the layer
-   `k`: Absorption coefficient of the layer
-   `thickness`: Thickness of the layer. The unit is centimeter (cm).
-   `coherence`: Coherence in the layer. `True` is coherence and `False` is incoherence.

### Example

```python
import numpy as np
from smmo import make_config, make_layer, SMMO

config = make_config(
    wavenumber=np.arange(0, 10000, step=1000),
    incidence=0,
    polarization="s"
)

layers = [
    make_layer(
        n=np.full(10, 1),
        k=np.full(10, 0),
        thickness=0,
        coherence=False
    ),
    make_layer(
        n=np.full(10, 1.5),
        k=np.full(10, 0),
        thickness=0.01,
        coherence=True
    ),
    make_layer(
        n=np.full(10, 2),
        k=np.full(10, 0),
        thickness=0.05,
        coherence=False
    ),
    make_layer(
        n=np.full(10, 1),
        k=np.full(10, 0),
        thickness=0,
        coherence=False
    )
]

output = SMMO(layers, config)()
```

```python
>>> print(output)
{'T': array([0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8]),
 'R': array([0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2])}
```

### Citation

```python
@article{lee2022machine,
  title={Machine learning analysis of broadband optical reflectivity of semiconductor thin film},
  author={Lee, Byeoungju and Yu, Kwangnam and Jeon, Jiwon and Choi, EJ},
  journal={Journal of the Korean Physical Society},
  pages={1--5},
  year={2022},
  publisher={Springer}
}
```

### Reference

[[1](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.38.9945)] Ko, D. Yuk Kei, and J. C. Inkson., Physical Review B 38.14 9945 (1988)  
[[2](https://www.osapublishing.org/josaa/abstract.cfm?uri=josaa-5-11-1863)] Ko, D. Yuk Kei, and J. R. Sambles., JOSA A 5.11 1863-1866 (1988)  
[[3](https://spie.org/Publications/Proceedings/Paper/10.1117/12.862566?SSO=1)] Dyakov, Sergey A., et al., International Conference on Micro-and Nano-Electronics 2009 (2010)
pyrunp 0.0.3
pyrunp exports Python functions from files to the command line

runp
====

.. image:: https://travis-ci.org/vascop/runp.svg
    :target: https://travis-ci.org/vascop/runp

.. image:: https://coveralls.io/repos/vascop/runp/badge.svg?branch=master&service=github
  :target: https://coveralls.io/github/vascop/runp?branch=master


runp exports Python functions from files to the command line. 
You don't need to change your existing code.

If you have a file named myfile.py with::

    def foo():
        """beeps a lot"""
        print "beep beep"

    def bar(text):
        """Prints things

        Args:
            text (str): The text to print
        """
        print text

And you want to run it in the command line just do::

    $ runp myfile.py foo
    beep beep

You can also pass arguments to your functions::

    $ runp myfile.py bar:"this is sweet!"
    this is sweet!

Functions with names starting with _ are hidden. 

You can list available functions with::

    $ runp myfile.py -l
    Available functions:
    foo    beeps a lot
    bar    Prints things

And get info on a specific function::

    $ runp myfile.py -d bar
    Displaying docstring for function bar in module myfile

    bar(text)
        Prints things
    
        Args:
            text (str): The text to print

Syntax for calling functions is::
    
    $ runp myfile.py function_name:arg1value,arg2=arg2value


The concept, syntax for commands and initial code are heavily inspired by fabric's task system.
piperider-cli 0.1.3.12
PiperRider CLI
Requires Python: >=3.6

# PipeRider

For data practitioner who wants to trust their data by:  
- Defining the shape of data, so they can **make sure the data will be expected in the future** 
- Save time on debugging data,**easily discover & discuss any data problems from upstream**
- Socially **collaborate across teams on the dataset through data catalog and data insights**

# Install

```bash
$ pip install piperider-cli
```

### Install with connectors

By default, we support the built-in sqlite connector, there are extra connectors:

* snowflake
* postgres

Install with postgres connector:

```
pip install piperider-cli[postgres]
```

It could be more than one connector with comma:


```
pip install piperider-cli[postgres,snowflake]
```


# Command

## Attach piperider to a dbt project
```bash
$ piperider-cli init
```
This command creates `/.piperider` under a dbt project root and generate necessary configurations.


## Scan models
```bash
$ piperider-cli run
```
This command scans the models from datasource and create assessment results in `/.piperider/output`

## Generate reports
```bash
$ piperider-cli generate-report <piperider result file>
```
generate a static html report under current path.