semvec/pypi-packages huggingface dataset:
vcfempy 0.0.14
A Python package for the Voronoi Cell Finite Element Method
Requires Python: >=3.8

README
======

A Python package implementing the Voronoi Cell Finite Element Method (VCFEM)
for analysis of problems in geomechanics.

.. _Brandon Karchewski: brandon.karchewski@ucalgary.ca
.. _GitHub: https://github.com/karcheba1/vcfempy/
.. _RTD: https://vcfempy.readthedocs.io/en/latest/

For information on how to install the package and to read the documentation,
visit the RTD_ page. For information about the project, to view source code,
and to report issues visit the project repo page on GitHub_. For more
information and to discuss collaboration contact `Brandon Karchewski`_.
pycogent 0.0.3
Post-processing tools for COGENT plasma simulation code

# PyCOGENT

This Python package is for post-processing results from plasma simulation code [COGENT](https://github.com/LLNL/COGENT).

## Installation 

Run the following command to install:

```python
pip install pycogent
```

## Usage

```python
import pycogent as pc

# import data from COGENT 4D-output file with adress 
# "folder/fileName.4d.hdf5", and save it to variable data
data = pc.importData4D("folder/fileName.4d.hdf5")

```

## Help with developing

Tools required to develop pycogent and run tests can be installed with command:

```python
pip install pycogent[dev]
```
phrase-hunter 0.1.1
A simple game where you guess the letters of a phrase, similar to hangman
Requires Python: >=3.6

# Phrase Hunter

This is a simple game for guessing the letters of a phrase, similar to hangman.

Install it with

`$ pip install phrase-hunter`

Run it with

`$ phrase-hunter`

## Source code

Majority of the code can be found in the classes in the included `phrasehunter`
package. This is my Unit 3 submission for my Treehouse Python Development TechDegree
so any and all feedback is welcome!
effpassphrase 0.1.1
Uses the EFF's long word list to generate a high entropy passphrase.
Requires Python: >=3.6

# effpassphrase
Uses the [EFF's](https://www.eff.org/) [long word list](https://www.eff.org/deeplinks/2016/07/new-wordlists-random-passphrases) to generate a high entropy passphrase.

# Installation

```console
pip install effpassphrase
```

# Usage

```console
$ effpassphrase --help
Usage: effpassphrase [OPTIONS]

Options:
  -c, --count INTEGER   Number of words in the passphrase.
  -s, --separator TEXT  Separator used between words in the passphrase.
  --help                Show this message and exit.
```

```console
$ effpassphrase
unfounded-zips-decorator-expectant-starch-variable
```
blocksim-hwil 0.12.0
A library to simulate a closed-loop system
Requires Python: >=3.8

=================
blocksim_hwil
=================


.. image:: https://img.shields.io/pypi/v/blocksim_hwil.svg
        :target: https://pypi.python.org/pypi/blocksim_hwil

.. image:: https://readthedocs.org/projects/blocksim_hwil/badge/?version=latest
        :target: https://blocksim_hwil.readthedocs.io/en/latest/?badge=latest
        :alt: Documentation Status

.. image:: https://gitlab.com/manawenuz/blocksim_hwil/badges/master/pipeline.svg
   :target: https://gitlab.com/manawenuz/blocksim_hwil/pipelines

.. image:: https://codecov.io/gl/manawenuz/blocksim_hwil/branch/master/graph/badge.svg
  :target: https://codecov.io/gl/manawenuz/blocksim_hwil

.. image:: https://img.shields.io/pypi/dm/blocksim_hwil
  :target: https://pypi.python.org/pypi/blocksim_hwil


A set of components to support signal in space simulations

Free software: MIT license

Development
-----------

In your virtual env::

    python setup.py develop

Features
--------

* TODO
mypy-typing-asserts 0.1.1
Adds the ability to _assert_ types when typechecking to mypy
Requires Python: >=3.7,<4.0
Keywords: mypy

# mypy-typing-asserts

Adds the ability to _assert_ types when typechecking to `mypy`.

```python
assert_type[MyType[tuple[int, ...]]](myobject.attribute)
```

## Support

`mypy-typing-asserts` is supported in `mypy >= 0.700`.

For similar functionality in `pyright`, use `reveal_type(expression, expected_type=...)`. (See [this discussion](https://github.com/python/typing/discussions/1030#discussioncomment-1988476)). (Supported in version 1.1.211+)

For similar functionality in `pytype`, use `assert_type`. (See [the docs](https://google.github.io/pytype/faq.html#can-i-find-out-what-pytype-thinks-the-type-of-my-expression-is))

## Installation

`mypy-typing-asserts` should be installed in to the same environment as your typechecker.

It can be installed by running `pip install mypy-typing-asserts`.

Alternatively if you're using `poetry`, `poetry add -D mypy-typing-asserts`.

## Usage

To use, just call `assert_type` providing a type-parameter and an argument. This will assert that
the type of the argument is __exactly__ the same type as the type-parameter (type-hierarchies are
not traversed) when typechecking (assuming you have enabled this functionality).

```python
from mypy_typing_asserts import assert_type

...

assert_type[MyType](my_expression)

# `assert_type` also returns the argument (but does no runtime checking)
var = assert_type[int](my_function())
```

Note that you may need to hide your import and usage behind `if typing.TYPE_CHECKING` if the
environment you're running the code in isn't the same that you typecheck in.

```python
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from mypy_typing_asserts import assert_type

...

if TYPE_CHECKING:
    assert_type[MyType](my_expression)
```

### Pitfalls

This plugin only gets executed for code that is being typechecked. Dependening on your configuration,
yopur typechecker might be skipping function bodies (e.g. `mypy` will skip unannotated function bodies
by default unless `--check-untyped-defs` is enabled).

If you're putting the `assert_type` calls inside a `pytest` test, make sure to annotate the `-> None`
return type to avoid this!

### Enabling the `mypy` plugin

In your mypy config, add `mypy_typing_asserts.mypy_plugin` to your `plugins` declaration.

See [mypy's documentation](https://mypy.readthedocs.io/en/stable/extending_mypy.html#configuring-mypy-to-use-plugins)


## Alternatives

All of the alternatives today ensure types are deduced correctly by running `mypy` in a subprocess,
which isn't always feasible or ideal. These include:

- [mypy-test](https://github.com/orsinium-labs/mypy-test) - standalone `mypy` wrapper
- [pytest-mypy-plugins](https://github.com/typeddjango/pytest-mypy-plugins) - pytest plugin, test cases described in a YAML file.
- [pytest-mypy-testing](https://github.com/davidfritzsche/pytest-mypy-testing) - pytest plugin, tests are described like pytest test cases (but they actually don't get run).