semvec/pypi-packages huggingface dataset:
powsolver 0.1.7
Proof of Work solver mainly for CTF challenges
License: MIT

# PoWSolver (WIP)

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)



A proof of work puzzle solver mainly for CTF challenges and whatnot.


## Getting Started

You can get started using `powsolver` by installing it through pip.

```
pip install powsolver
```

## Usage

The main component of the powsolver package is the `PoWSolver` class which encapsulates the main functionality.

Here is a basic usage example of the powsolver:

```python
from powsovler import PoWSolver

solver = PoWSolver()
solver.parse(
    "Please submit a printable string X, such that {alg}(X)[{start:d}:] = {target} and len(X) = {len}",
    "Please submit a printable string X, such that sha256(X)[-6:] = 86d113 and len(X) = 11"
)
sol = solver.sol()
```

Exampled of more elaborated usage can be found in the [examples](./examples/)  folder.

## Running the tests

### :TODO:

## Contributing

Any PRs are welcome!

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/apogiatzis/powsolver/tags). 

## Authors

* **Antreas Pogiatzis** - *Initial work* 

See also the list of [contributors](https://github.com/apogiatzis/powsolver/contributors) who participated in this project.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details
pythons 0.1.1
Yet another snake game written in Python
License: MIT
Requires Python: >=3.7,<4.0
Keywords: snake,game,pygame

PYTHONS
=======

Yet another Snake game written in Python.

.. |img1| image:: https://raw.githubusercontent.com/julianolf/pythons/master/img/game_start.png
    :width: 320px

.. |img2| image:: https://raw.githubusercontent.com/julianolf/pythons/master/img/game_play.png
    :width: 320px

.. |img3| image:: https://raw.githubusercontent.com/julianolf/pythons/master/img/game_over.png
    :width: 320px

+--------+--------+--------+
| |img1| | |img2| | |img3| |
+--------+--------+--------+

Requirements
------------

* Python >= 3.7, < 3.8

Installing
----------

Use ``pip`` to download and install the game. ::

    $ pip install pythons

Running
-------

Just type ``pythons`` to run the game. ::

    $ pythons
subpixel-edges 0.1.1
Pure Python implementation of subpixel edge location algorithm based on partial area effect
License: MIT
Requires Python: >=3.0

# subpixel-edges

A pure Python implementation of the subpixel edge location algorithm from https://doi.org/10.1016/j.imavis.2012.10.005

The reference implementation can be found on from https://it.mathworks.com/matlabcentral/fileexchange/48908-accurate-subpixel-edge-location


# Installation

`pip install subpixel-edges`

# Quick start

For a quick overview of the code functionalities, install the following packages first:

```bash
$ pip install subpixel-edges
$ pip install opencv-python
$ pip install matplotlib
```

Then go into the directory you want to use and copy the image you want to analyze (let's say `lena.png`). 
Now open a Python console and execute the following commands:

```python
import cv2
import matplotlib.pyplot as plt

from subpixel_edges import subpixel_edges

# (optional) 
help(subpixel_edges) 

img = cv2.imread("lena.png")
img_gray = (cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)).astype(float)
edges = subpixel_edges(img_gray, 25, 0, 2)

plt.imshow(img)
plt.quiver(edges.x, edges.y, edges.nx, -edges.ny, scale=40)
plt.show()
```

## Development

```
git clone https://github.com/gravi-toni/subpixel-edges.git
pip install -e .
```

To run the tests (includes OpenCV):

`pip install -e .[tests]`

To run the examples (includes OpenCV):

`pip install -e .[examples]`
pycopy-uurequests 0.8.4
uurequests module for Pycopy
License: MIT

HTTP clients in pycopy-lib
==========================

pycopy-lib currently offers 4 HTTP client modules:

* ``urllib.urequest``
* ``urequests``
* ``uurequests``
* ``uaiohttpclient``

This README is intended to describe differences among them and help
to choose the right module for a particular use.

* ``urllib.urequest`` implements a subset of API CPython standard library
  module urllib.request. This module is intended to be the most minimal
  of all three and provide an efficient, stream-based API. It doesn't
  support automatic redirects or chunked transfer encoding.
* ``urequests`` implements a subset of API of the popular 3rd-party package
  ``requests``. ``requests`` brags itself as "HTTP for Humans", which
  means that its API is not ideal, and implementation is inefficient.
  ``urequests`` implements only a subset of it, and tries to mend some
  poor defaults of the prototype module. Still, it's less efficient
  than ``urllib.urequest``. Redirects are handled, but not chunked
  transfer encoding.
* ``uurequests`` is capture of the version 0.8 of ``urequests``, before
  opening the door for adding more features to the latter. It's provided
  for very small systems which still would like requests-like API.
* ``uaiohttpclient`` is an HTTP client for ``uasyncio`` module. It's
  the only of all 3 which supports chunked transfer encoding.

Thus, the selection guide:

* Whenever possible, use ``urllib.urequest``.
* If you write a once-off, throw-away app where you don't care about
  efficiency, you can use ``urequests``.
* If you wrote that for very small system and above didn't work, can
  give ``uurequests`` a try.
* If you devel an async app, use ``uaiohttpclient``.
* If you need support for more HTTP protocol features, use
  ``uaiohttpclient`` and write an async app.

Future of the modules:

* ``urllib.urequest`` is intended to stay minimal and unlikely will get more
  features (it's suitable for ~80% of possible usage scenarios).
* ``urequests`` has bloat in its DNA, so likely will slowly grow more features
  to match the upstream module, which will make it even less suitable for
  low-memory targets.
* ``uurequests`` was snapshotted to address concern of such low-memory systems
  support. It's static, and only critical bugfixes are intended to be applied.
* ``uaiohttpclient`` may get updated as needed.