semvec/pypi-packages huggingface dataset:
laser-ethereum 0.17.12
Symbolic Ethereum virtual machine
License: MIT
Requires Python: >=3.5
Keywords: hacking security ethereum


LASER
=======

LASER is a symbolic Ethereum virtual machine.

Installation and setup
----------------------

Install from Pypi:

.. code:: bash

    $ pip install laser-ethereum

Usage
------------------

The easiest way to use LASER is by installing Mythril command line tool:

.. code:: bash

    $ pip install mythril
    $ myth --init-db
    $ myth --fire-laser -a [contract-address]
torchlite 0.2.0.1
A high level library on top of machine learning frameworks
License: MIT
Keywords: development

## Torchlite
![](./docs/sources/img/logo.png)
[![PyPI version](https://badge.fury.io/py/torchlite.svg)](https://badge.fury.io/py/torchlite)

Torchlite is a high level library on top of popular machine learning frameworks such as
sklearn, Pytorch and Tensorflow.
It gives a high layer abstraction of repetitive code used in machine learning for day-to-day data science tasks.

## Installation

```
pip install torchlite
```

or if you want to run this lib directly to have access to the examples clone this repository and run:

```
pip install -r requirements.txt
```

to install the required dependencies.
By default **Pytorch 0.4.0+** and **Tensorflow-GPU 1.8.0+** are installed along with this library but it's recommended
to install them from source from [here](http://pytorch.org/) if you want to use the `torchlite.torch`
package and/or head over to the [Tensorflow install page](https://www.tensorflow.org/install/) if you want to
use the `torchlite.tf` package.

## Documentation

For now the library has no complete documentation but you can quickly get to know how
it works by looking at the examples in the `examples-*` folders. This library is still in
alpha and few APIs may change in the future. The only things which will evolve at the same
pace as the library are the examples, they are meant to always be up to date with
the library.

Few examples will generates folders/files such as saved models or tensorboard logs.
To visualize the tensorboard logs download Tensorflow's tensorboard as well as 
[Pytorch's tensorboard](https://github.com/lanpa/tensorboard-pytorch) if you're interested by
the `torchlite.torch` package. Then execute:
```
tensorboard --logdir=./tensorboard
```

## Packaging the project for Pypi deploy

```
pip install twine
pip install wheel
python setup.py sdist
python setup.py bdist_wheel
```

[Create a pypi account](https://packaging.python.org/tutorials/distributing-packages/#id76) and create `$HOME/.pypirc` with:
```
[pypi]
username = <username>
password = <password>
```

Then upload the packages with:
```
twine upload dist/*
```

Or just:
```
pypi_deploy.sh
```
stldecomposemod 0.0.3
A Python implementation of seasonal trend with Loess (STL) time series decomposition MODIFIED
License: MIT


STL Decompose
=============

This is a relatively naive Python implementation of the "Seasonal and Trend decomposition using Loess" time series decomposition ("STL decomposition," Cleveland et al. 1990 [`pdf <https://www.wessa.net/download/stl.pdf>`_]).  

This implementation is a variation of (and takes inspiration from) the current implementation of the ``seasonal_decompose`` method `in statsmodels <http://www.statsmodels.org/stable/generated/statsmodels.tsa.seasonal.seasonal_decompose.html#statsmodels.tsa.seasonal.seasonal_decompose>`_. In this implementation, the trend component is calculated by substituting a configurable `Loess regression <https://en.wikipedia.org/wiki/Local_regression>`_ for the convolutional method used in ``seasonal_decompose``. It also extends the existing ``DecomposeResult`` from ``statsmodels`` to allow for forecasting based on the calculated decomposition. 


Usage
-----

The ``stldecompose`` package is relatively lightweight. It uses ``pandas.Dataframe`` for inputs and outputs, and exposes only a couple of primary methods - ``decompose()`` and ``forecast()`` - as well as a handful of built-in forecasting functions. 

See `the included IPython notebook <https://github.com/jrmontag/STLDecompose/blob/master/STL%20usage%20example.ipynb>`_ for more details and usage examples.


Installation
------------

A Python 3 virtual environment is recommended.

The preferred method of installation is via ``pip``:

``(env) $ pip install stldecompose``

If you'd like the bleeding-edge version, you can also install from this Github repo::

    (env) $ git clone git@github.com:jrmontag/STLDecompose.git 
    (env) $ cd STLDecompose; pip install . 


More Resources
--------------

- ``statsmodels`` `Time Series analysis <http://www.statsmodels.org/stable/tsa.html>`_ package
- Hyndman's `OTexts reference on STL decomposition <https://www.otexts.org/fpp/6/5>`_
ipyprogressbar 1.0.2
Python-asynchronous progressbar widgets for use in Jupyter/IPython in conjunction with ipywidgets
License: MIT
Keywords: widget jupyter progressbar asynchronous

## IPyProgressBar

[![saythanks](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/WillahScott)

A small package that provides an python-asynchronous progressbar widgets for use in Jupyter/IPython in conjunction with `ipywidgets`.


### Why

Many times, when building a small dashboard on IPython there are functions that take some time to be executed but cannot be split into chunks, in the middle of which we could update a progress bar.

Since we want to give the user feedback that we are actually doing something and now he has to wait for a little, we can simply display the prototypical `Loading...`.

However for some (most?) functions we may actually have a rough estimate of the time of wait and can make the wait a little more visual with a progressbar!


### "Python-Asynchronous"

The progressbar needs to be updated (filled) while python is working on other things. Therefore, we can use a python thread to update the value of the progressbar. That way, our main python process can take care of other code meanwhile.


### Usage

```python
# Create the progress bar object (not the widget)
my_progressbar = AsyncProgressBar(time=2, description='Loading dataset:')

# Return the widget for display
my_progressbar.display()

# ...

# Trigger the progressbar
my_progressbar.run()
```

The object also has a `close()` method (and its inverse `reopen()`), for hiding the progressbar whenever we want:

```python
my_progressbar.run()
function_that_takes_long()
my_progressbar.close(on_finish=True)  # or set close_on_finish=True on creating the progressbar object
```

However,for a typical use case in which we just want a temporal progressbar, we can specify the `close_on_finish` on creation:

```python
# Create the progress bar object (not the widget)
my_progressbar = AsyncProgressBar(time=2, description='Loading dataset:', close_on_finish=True)

# ...

# Trigger the progressbar
my_progressbar.run()  # when done the progress bar will hide
```



### Contact

Created by: [WillahScott](https://github.com/WillahScott/)