semvec/pypi-packages huggingface dataset:
sunscreen 0.0.4
What's the UV forecast?

# Sunscreen

Get today's ultraviolet (UV) index forecast for your zipcode

## Install
Using pipsi is recommended, since this is a standalone application.

```
# if necessary
$ pip install pipsi
$ pipsi install sunscreen
```

## Usage

To use sunscreen after installation, just type `sunscreen`:

```bash
▶ sunscreen
Welcome to sunscreen! �� ��
Enter US zipcode [78701]:
Retrieving today's UV data...
Time             UV level
0900 **          2
1000 ****        4
1100 *******     7
1200 *********   9
1300 *********** 11
1400 *********** 11
1500 *********   9
1600 *******     7
1700 ****        4
1800 **          2
```

By default it will use the most recent zip code. If one can't be found, you'll
need to include one on the first run.
pengines 0.1.8
A simple python library for interacting with SWI-Prologs Pengines
Keywords: pengines,pengine,prolog,swipl,swi-prolog,logic programming

Python Pengines
===============

This is a module for interfacing python with the Prolog Pengines
knowledge base.

API
---

Create a basic run pengine server script, and run it with swipl.

::

    :- use_module(library(http/thread_httpd)).
    :- use_module(library(http/http_dispatch)).
    :- use_module(library(pengines)).

    server(Port) :- http_server(http_dispatch, [port(Port)]).

    :- server(4242).

Initialize a basic PengineBuilder

::

    from pengines.Builder import PengineBuilder
    from pengines.Pengine import Pengine

    pengine_builder = PengineBuilder(urlserver="http://localhost:4242")

Create the pengine querying object.

::

    pengine = Pengine(builder=pengine_builder)
    pengine.create()

Make your query -- note the lack of ending period -- Pengine performs
the query like 'ask(member(X, [1,2,3], [])).'

::

    query = "member(X, [1,2,3])"
    pengine.ask(query)
    print(pengine.currentQuery.availProofs)

Iterate through the proofs like this:

::

    while pengine.currentQuery.hasMore:
        pengine.doNext(pengine.currentQuery)
        print(pengine.currentQuery.availProofs)

prologterms library
-------------------

The python library prologterms aims to make it easier to construct
prolog programs and query terms from within python.

For an example of how to use prologterms in conjunction with pengines,
see:

https://pypi.org/project/prologterms/

::

    from pengines.Builder import PengineBuilder
    from pengines.Pengine import Pengine
    from prologterms import TermGenerator, PrologRenderer, Program, Var

    P = TermGenerator()
    X = Var('X')
    Y = Var('Y')
    Z = Var('Z')
    R = PrologRenderer()

    p = Program(
        P.ancestor(X,Y) <= (P.parent(X,Z), P.ancestor(Z,Y)),
        P.ancestor(X,Y) <= P.parent(X,Y),
        P.parent('a','b'),
        P.parent('b','c'),
        P.parent('c','d')
    )

    q = P.ancestor(X,Y)

    factory = PengineBuilder(urlserver="http://localhost:4242",
                             srctext=R.render(p),
                             ask=R.render(q))
    pengine = Pengine(builder=factory, debug=True)
    while pengine.currentQuery.hasMore:
        pengine.doNext(pengine.currentQuery)
    for p in pengine.currentQuery.availProofs:
        print('{} <- {}'.format(p[X.name], p[Y.name]))
hashver 0.0.2
hashver is a python module to derive a unique numeric value from a version string and vice versa

hashver ![Build Status](https://travis-ci.org/ashutoshkumr/python-hashver.svg?branch=master)
=======

Is a python module to derive a unique numeric value from a version string and vice versa, adhering to following constraints:
  - Resultant number must be unique for all possible values of a, b, c and d
  - Each of a, b, c and d needs to be below certain maximum unsigned int guided
    by max possible bits allotted to each version component
  - We should be able to derive unique a.b.c.d back from given number
  - If a.b.c.d => x and p.q.r.s => y then, a.b.c.d < p.q.r.s => x < y

### Usage

After performing **python -m pip install hashver**, execute python code as mentioned below.
```python
>>> from hashver import HashVer
>>> hob = HashVer()
>>> hob.get_num('1.0.6')
4294967302
>>> hob.get_version_str(8590000133)
2.1.5
>>> # if your version is of format a.b.c.d, each of which should be at most 2^16
>>> hob = HashVer(bits_per_component='16.16.16.16')
>>> hob.get_num('9.0.100.10')
2533274796949514
>>> hob.get_version_str(2533274796949514)
9.0.100.10
```

Or if you have curl,
```bash
curl -skL https://raw.githubusercontent.com/ashutoshkumr/python-hashver/master/hashver/hashver.py | python - 1.0.6 8590000133

1.0.6 : 4294967302
8590000133 : 2.1.5
```

### Modification and Testing

If any modification is done to hashver source, use following to validate changes,
```bash
# ensure various combinations of version string or number can be derived from each other
python -B ${hashver-root}/hashver.py 9.0.100.10 2533274796949514 --bpc 16.16.16.16

9.0.100.10 : 2533274796949514
2533274796949514: 9.0.100.10

# or simply add them to the existing test suite in hashver/test_hashver.py and run pytest
cd ${hashver-root} && pytest
```