semvec/pypi-packages huggingface dataset:
gradientmodel 0.0.2
Calculate the surface impedance of a rough metal surface using the Gradient Model (GM)
License: MIT

Gradient Model
==============

[![PyPI version](https://badge.fury.io/py/gradientmodel.svg)](https://badge.fury.io/py/gradientmodel)
[![ci](https://github.com/garrettj403/GradientModel/actions/workflows/ci.yml/badge.svg)](https://github.com/garrettj403/GradientModel/actions/workflows/ci.yml)
[![flake8](https://github.com/garrettj403/GradientModel/actions/workflows/linter.yml/badge.svg)](https://github.com/garrettj403/GradientModel/actions/workflows/linter.yml)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5608414.svg)](https://doi.org/10.5281/zenodo.5608414)

*Calculate the surface impedance of a rough metal surface using the Gradient Model (GM)*

Example: Surface Impedance of Gold
----------------------------------

Surface impedance of gold (conductivity: 4.1e7 S/m) between 280 GHz and 360 GHz:

<p align="center">
<img src="https://raw.githubusercontent.com/garrettj403/GradientModel/main/examples/results/wr3p0-surface-impdance-300k.png" width="800">
</p>

To use these results in HFSS, select `Assign boundary > Impedance...` and then copy/paste these values into the dialog box:

```
50 nm surface roughness:
   Real:       -1.6644e-25 * Freq^2 + 5.1199e-13 * Freq^1 + 6.1107e-02
   Imaginary:  -3.4813e-25 * Freq^2 + 2.2603e-12 * Freq^1 + 7.2291e-02
   ur:         -1.3448e-23 * Freq^2 + 5.0514e-11 * Freq^1 + 3.9464e+00

75 nm surface roughness:
   Real:       -1.5186e-25 * Freq^2 + 6.0379e-13 * Freq^1 + 5.8012e-02
   Imaginary:  -4.5447e-25 * Freq^2 + 3.0960e-12 * Freq^1 + 7.9819e-02
   ur:         -2.5105e-23 * Freq^2 + 9.6127e-11 * Freq^1 + 5.8256e+00

100 nm surface roughness:
   Real:       -1.4427e-25 * Freq^2 + 7.0489e-13 * Freq^1 + 5.5407e-02
   Imaginary:  -5.6445e-25 * Freq^2 + 3.8871e-12 * Freq^1 + 8.8834e-02
   ur:         -3.9840e-23 * Freq^2 + 1.5236e-10 * Freq^1 + 8.0508e+00
```

References
----------

Gradient model:

   - G. Gold and K. Helmreich, “A Physical Surface Roughness Model and Its Applications,” IEEE Trans. Microw. Theory Tech., vol. 65, no. 10, pp. 3720–3732, Oct. 2017, doi: [10.1109/TMTT.2017.2695192](https://doi.org/10.1109/TMTT.2017.2695192).

   - K. Lomakin, G. Gold, and K. Helmreich, “Analytical Waveguide Model Precisely Predicting Loss and Delay Including Surface Roughness,” IEEE Trans. Microw. Theory Tech., vol. 66, no. 6, pp. 2649–2662, Jun. 2018, doi: [10.1109/TMTT.2018.2827383](https://doi.org/10.1109/TMTT.2018.2827383).

Closed-form solution:

   - D. N. Grujic, “Closed-Form Solution of Rough Conductor Surface Impedance,” IEEE Trans. Microw. Theory Tech., vol. 66, no. 11, pp. 4677–4683, 2018, doi: [10.1109/TMTT.2018.2864586](https://doi.org/10.1109/TMTT.2018.2864586).
pytsviz 0.1.0
A suite of tools to quickly analyze and visualize time series data.
License: MIT
Requires Python: >=3.8,<4.0
Keywords: python,data visualization,time series,data science

# pytsviz

![GitHub](https://img.shields.io/github/license/xtreamsrl/pytsviz)
![GitHub issues](https://img.shields.io/github/issues/xtreamsrl/pytsviz)
[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/xtreamsrl/pytsviz/blob/master/docs/source/notebooks/data_visualization_examples.ipynb)
[![Downloads](https://pepy.tech/badge/pytsviz)](https://pepy.tech/project/pytsviz)
[![Documentation Status](https://readthedocs.org/projects/pytsviz/badge/?version=latest)](https://pytsviz.readthedocs.io/en/latest/?badge=latest)
![GitHub Workflow Status](https://img.shields.io/github/workflow/status/xtreamsrl/pytsviz/CI?label=tests)

*pytsviz* is a suite of tools to quickly analyze and visualize time series data. It is partially based on the [*tsviz*](https://github.com/xtreamsrl/tsviz) R package.

The *utils* module contains a set of useful utilities, not strictly related to visualization, we often use (e.g. harmonics computation).

The *viz* module contains functions for plotting univariate time series, as well as performing quick qualitative analyses such as decompositions, correlations and so on.

Some visualizations mimic the R packages *ggplot2* and *forecast*, as presented in the textbook *Forecasting: principles and practice* by Rob J. Hyndman and George Athanasopoulos.
The online version of the text can be found [here](https://otexts.com/fpp3/).

## Install

The preferred way to install the package is using pip, but you can also download the code and install from source

To install the package using pip:

```shell
pip install pytsviz
```

## Develop

After cloning, you need to install and setup Poetry. See [instructions](https://github.com/python-poetry/poetry#installation).

Then, inside the project directory, run:

```shell
poetry install
pre-commit install
```

Then, you're good to go.

You're free to submit your pull requests. Just make sure they follow [conventional commit rules](https://www.conventionalcommits.org/en/v1.0.0/#specification). This can be enforced by the [*commitizen*](https://commitizen-tools.github.io/commitizen/) tool, which is also included among the package dependencies.

Please also make sure that function documentation is consistent. We are currently using [Sphinx docstrings](https://sphinx-rtd-tutorial.readthedocs.io/en/latest/docstrings.html).


## Who we are
<img align="left" width="80" height="80" src="https://avatars2.githubusercontent.com/u/38501645?s=450&u=1eb7348ca81f5cd27ce9c02e689f518d903852b1&v=4">
A proudly 🇮🇹 software development and data science startup.<br>We consider ourselves a family of talented and passionate people building their own products and powerful solutions for our clients. Get to know us more on <a target="_blank" href="https://xtreamers.io">xtreamers.io</a> or follow us on <a target="_blank" href="https://it.linkedin.com/company/xtream-srl">LinkedIn</a>.
tadmap 0.1.2
Consensus layout of topologically associating domains (TADs) and utilities for RNA-seq analysis
License: MIT

Topologically associating domains (TADs) are contiguous segments of the genome where the genomic elements are in frequent contact with each other. The TAD Map provides a consensus estimate, aggregated from multiple experimental datasets, of this layout in human and mouse. It also provides tools to map any single-cell RNA-seq dataset to TAD signatures, with gene expression mapped to TAD activation probabilities in each cell
pyfrigg 0.4.0
High level data loading utils
License: MIT
Keywords: data,Elasticsearch,MySQL,requests

# Welcome to pyfrigg 🕸️
[![Codestyle: Black](https://img.shields.io/badge/codestyle-black-black.svg)](https://github.com/psf/black)
[![Codecheck: Flake8](https://img.shields.io/badge/codecheck-flake8-blue.svg)](https://gitlab.com/pycqa/flake8)

## Description

High level wrappers of various python db and web libraries for loading data with maximum result and less effort.
Supports asynchronous requests with interaction Elasticsearch, MySQL, and more!

## Modules

* `elasticsearch`: wrapper of `elasticsearch`
* `mysql`: wrapper of `mysql-connector-python`
* `requests`: wrapper of `requests` and `aiohttp`

## Authors

* Nick Kuzmenkov
* Dmitry Bulychev
validatable 0.4.0
Validatable provides a single class definition for data validation and SQL table representation
License: MIT
Requires Python: >=3.6.1

<p align="center">
<img  width="150" height="150" src="https://raw.githubusercontent.com/dcruzf/validatable/main/docs/img/logo.svg">
</p>

<h1 align="center">Validatable</h1>

_Data validation and SQL Toolkit using Python type hints._

[![CI](https://github.com/dcruzf/validatable/actions/workflows/tests.yml/badge.svg)](https://github.com/dcruzf/validatable/actions/workflows/tests.yml)
[![pre-commit](https://github.com/dcruzf/validatable/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/dcruzf/validatable/actions/workflows/pre-commit.yml)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/validatable)](https://pypi.org/project/validatable/)
[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/dcruzf/validatable.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/dcruzf/validatable/context:python)
[![PyPI - License](https://img.shields.io/pypi/l/validatable)](https://raw.githubusercontent.com/dcruzf/validatable/main/LICENSE)
[![codecov](https://codecov.io/gh/dcruzf/validatable/branch/main/graph/badge.svg?token=ZLNIQPL1UC)](https://codecov.io/gh/dcruzf/validatable)
[![coverage.py report](https://img.shields.io/badge/dynamic/json?color=success&labelColor=gray&label=coverage-html&logo=github&query=%24.totals.percent_covered_display&suffix=%25&url=https%3A%2F%2Fdcruzf.github.io%2Fvalidatable%2Fcov%2Fcoverage.json)](https://dcruzf.github.io/validatable/cov/)

## Introduction

Validatable provides a single class definition for data validation and SQL table representation. It uses Pydantic and SQLAlchemy Core.

## Getting Started

### Installation

You can install Validatable like this:

```
pip install validatable
```

### Simple Example

```py
from datetime import datetime
from typing import Optional
from uuid import uuid4

from sqlalchemy.dialects.postgresql import dialect
from sqlalchemy.schema import CreateTable

from validatable import UUID4, BaseTable, EmailStr, Field, ForeignKey, MetaData


class Base(BaseTable):
    metadata = MetaData()


class User(Base):
    id: UUID4 = Field(sa_primary_key=True, default_factory=uuid4)
    name: str
    email: EmailStr
    created_ts: datetime = Field(default_factory=datetime.now)
    friends: Optional[UUID4] = Field(sa_fk=ForeignKey("user.id"))


ddl = CreateTable(User.__sa_table__).compile(dialect=dialect())
print(ddl)

# CREATE TABLE "user" (
#         id UUID NOT NULL,
#         name VARCHAR NOT NULL,
#         email VARCHAR(320) NOT NULL,
#         created_ts TIMESTAMP WITHOUT TIME ZONE,
#         friends UUID,
#         PRIMARY KEY (id),
#         FOREIGN KEY(friends) REFERENCES "user" (id)
# )
```

## License

This project is licensed under the terms of the MIT license - see the LICENSE.txt file for details.
marsworks 0.7.0
An API Wrapper around NASA's Mars Rover Photos API written in Python; providing sync and async support.
License: MIT
Requires Python: >=3.7,<4.0
Keywords: Mars Photos,Api-Wrapper,Async,NASA

<img src=https://www.nasa.gov/sites/default/files/styles/full_width_feature/public/thumbnails/image/pia23378-16.jpg class="center">

<p align="center">
 <img alt="Python" src="https://img.shields.io/badge/python-%2314354C.svg?style=for-the-badge&logo=python&logoColor=white">

 <img alt="PyPI version" src="https://badge.fury.io/py/marsworks.svg" height=28>


<img src="https://img.shields.io/pypi/l/marsworks" height=28>

 <img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg" height=28>
</p>


# Welcome!

Hi! Welcome to my repository Marsworks! (Name
inspired from fate franchise ofc ;) ).

So, Marsworks is a fast and lightweight API wrapper around
[Mars Rover Photos API](https://api.nasa.gov/) written in Python.

Let's see why you should or shouldn't use this wrapper in next sections.

### Advantages

- Sync & Async support with Async utilizing async-await syntax.
- Fast, lightweight; and memory optimized.
- Provides API request handling at really low as
well as high level.
- 100% API coverage.
- Pagination supported.
- Minimal dependency of just 1 for both sync & async support.

### Disadvantages

- No Caching.
- No Ratelimit handling or request quering.
- Not well tested.

*Currently this project is under development and possibilities of
breaking changes in near future is huge until 1.x release.*

## Usage

#### Async. usage

###### Getting photos on a particular sol taken by this rover, asynchronously.

```py

import asyncio

import marsworks


client = marsworks.AsyncClient()


async def main(rover_name, sol) -> list:
    images = await client.get_photo_by_sol(rover_name, sol)  # You can pass camera too.
    return images


imgs = asyncio.run(main("Curiosity", 956))
print(imgs[0].img_src)
print(imgs[0].photo_id)
# and many more attributes!
```

#### Sync. usage

###### Getting photos on a particular sol taken by this rover, synchronously.

```py

import marsworks


client = marsworks.SyncClient()


def main(rover_name, sol) -> list:
    images = client.get_photo_by_sol(rover_name, sol)  # You can pass camera too.
    return images


imgs = main("Curiosity", 956)
print(imgs[0].img_src)
print(imgs[0].photo_id)
# and many more attributes!
```


# Links

- #### Marsworks [Documentation](https://mooncell07.github.io/Marsworks/).

- #### Marsworks PyPi [Page](https://pypi.org/project/marsworks/).

- #### NASA APIs [Page](https://api.nasa.gov/).

- #### Thanks to [Andy](https://github.com/an-dyy) for his contribution.