semvec/pypi-packages huggingface dataset:
Terminal-Apple-Season 1.2.8
Apple season game for terminal

# Terminal Apple Season

A terminal ASCII recreation of the original [Apple Season](http://www.ferryhalim.com/orisinal/g2/applegame.htm) by Ferry Halim. Check it out on [PyPi](https://pypi.org/project/Terminal-Apple-Season/)

## Installation

### Install Using Git:

```bash
git clone https://github.com/lol-cubes/Terminal-Apple-Season.git
```

### Install Using Pip

```bash
pip install Terminal-Apple-Season
```

## Usage

```python
from apple_season import game
```

## How To Play

Use the arrow keys to move the basket from side to side. Try to catch as many of the falling apples as possible. The game ends after 100 apples have fallen.

## OS Compatability

Terminal-Apple-Season has been tested on OS X and Windows. It should work but has not been tested on Linux.
undefined 0.0.8
a simple package
Requires Python: >=3.4

# Undefined

Ever needed a global object that act as `None` but not quite ?

Like for example key-word argument for function, where `None` make sens, so you need a default value.

One solution is to create as singleton object:

```
mysingleton = object()
```

Though it becomes difficult to track the singleton across libraries,
and teach users where to import this from. 

It's also relatively annoying use this singleton across library. 


Introducing `undefined`:

```
>>> import undefined
>>> from undefined import Undefined
>>> undefined is Undefined
True
```


# behavior

It work (for now) mostly like a singleton object

Though it's neither truthy not falsy

```
>>> if undefined: print(True)
raise NotImplementedError
```

# Casing ?

Because it is a module you can use it lowercase:

```
import undefined
```

Because it looks more like a keyword (`None`, `True`, `False`), you can use it upper case:

```
import undefined as Undefined
```

or

```
from undefined import Undefined
```

I tend to be torn between lowercase, for simplicity, and Uppercase.


# Why not `None`, difference with `None`

`undefined` is likely slower, and as it is a regular Python object there are a few  on purpose (or not difference).

### Unlike `None`, you can assign to it

```
>>> None = 3 
SyntaxError: can't assign to keyword
```

```
>>> undefined = 3
>>> undefned
3
```

### Unlike `None`, `undefined` is mutable

```
>>> undefined.value = 42
>>> undefined.value
42
```

(might be able to fix that with `__get_attr__`

### Unlike `None`, `undefined` is neither true not false.

If you test for boolean value of `undefind` if will raise. 
That is to say: the following will fail:

```
value = undefined
if value:
   pass # will raise before reaching here.
```

You have to check for identity:

```
value = undefined
other = 1
if value is undefined:
    pass # will execute
```

for info, undefined is not `True`,`False`, not undefined with respect to identity

```
>>> undefined is True
False

>>> undefined is False
False

>>>: undefined is None
False
```

### String form

`str(undefined)` raises. `repr(undefined)` is the unicode string `'Undefined'`
ddd-base 0.0.5
DDD base framework for python

DDD Base Framework
==================

|Build Status| |Pypi Status| |Coveralls Status|

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

From source code:

::

    python setup.py install

From pypi:

::

    pip install ddd-base

Usage
-----

::

    from ddd_base.value_object import ValueObject


    class TheValueObject(ValueObject):

        def __init__(self, name):
            super(TheValueObject, self).__init__()
            self.name = name

        def __eq__(self, other):
            if not isinstance(other, ValueObject):
                return NotImplemented

            return self.name == other.name


    def test_value_object_compare():
        a_value_object = TheValueObject("name")
        b_value_object = TheValueObject("name")

        assert a_value_object.same_as(b_value_object)



License
-------

This software is licensed under the `MIT license <http://en.wikipedia.org/wiki/MIT_License>`_

See `License file <https://github.com/sunwei/ddd-base/blob/master/LICENSE>`_

.. |Build Status| image:: https://travis-ci.com/sunwei/ddd-base.svg?branch=master
   :target: https://travis-ci.com/sunwei/ddd-base
.. |Pypi Status| image:: https://badge.fury.io/py/ddd-base.svg
   :target: https://badge.fury.io/py/ddd-base
.. |Coveralls Status| image:: https://coveralls.io/repos/github/sunwei/ddd-base/badge.svg?branch=master
   :target: https://coveralls.io/github/sunwei/ddd-base?branch=master


Changelog
=========

0.0.5
-----

- Add use example

0.0.4
-----

- Friendly readme

0.0.3
-----

- Smart setup

0.0.2
-----

- Minimise description

0.0.1
-----

- Initial public release
pyTCTL 0.1
A package for Timed CTL model checking in Python

# pyTCTL
A package for TCTL model checking in Python

The initial implementation makes use of NetworkX's DiGraph for the representation of Kripke structures.

The provided algorithms implement [Lepri et al.'s](https://doi.org/10.1016/j.scico.2014.06.006) approach to continuous TCTL model checking. 
Thus, this package also implements pointwise TCTL model checking.

The code was originally developed for the [CREST](https://crestdsl.github.io) project, but it seems better to extract the code into its own library.


## Similar Projects

[@albertocasagrande](https://github.com/albertocasagrande) is working on a similar library for (untimed) CTL/LTL/CTL* model checking called [pyModelChecking](https://github.com/albertocasagrande/pyModelChecking/).

> His approach shares some of the ideas of this project. However, it seems that he chooses to implement Kripke structures directly (no networking library) and adds some features that I probably won't implement (e.g. a text parser).
On the other hand, as far as I can see there's only one algorithm hardcoded for each temporal logic.
In comparison, I plan to add the possibility to add and choose between search heuristics.

> I will keep following his project. Maybe we can merge forces once I know more clearly which path the pyTCTL project is going to take.