semvec/pypi-packages huggingface dataset:
simplefbchat 0.0.4
Simple Facebook Chat library for students.

# SimpleFbChat

Simple Facebook Chat library for students. Do not use at production.

Example:

```
from simplefbchat import SimpleFbChat

login = "example@tfbnw.net"
password = "passw0rd"

fb = SimpleFbChat(login, password)

while True:
    received_message = fb.receive()

    text = received_message.text

    received_message.reply("Hello: " + text)
```
reviewboard-ipynb 0.2.6
Display ipynb in a better format

# Reviewboard Extension for review jupyter notebook

- This extension renders jupyter notebook so that it is easier to code review jupyter notebook.
- The extension use nbconvert locally for render, there's no need to convert the notebook to different format by yourself.
- The template kept the javascript definition, namely, if your jupyter notebook is using external library (plotly, MathJax), it will still show it for you.


## Limitiation:
- Due to the limitation of reviewboard plugin, this only render the file attachement

## TODO:
- Add tests
- Better support for diff (probably use nbdime) instead of the current built-in differ.


## Screenshot:
- render ipynb
![Render Ipynb](https://github.com/lydian/reviewboard-ipynb/blob/master/screenshots/comment.png?raw=true "Render Ipynb")
- comment
![Comment](https://github.com/lydian/reviewboard-ipynb/blob/master/screenshots/comment.png?raw=true "Comment")
- diff
![diff](https://github.com/lydian/reviewboard-ipynb/blob/master/screenshots/diff.png?raw=true "diff")
analyze-objects 0.3.0
Contains command line tools and python functions to search symbols in object files (.o, .obj).
Requires Python: >=3.6

analyze_objects
===============

*analyze_objects* contains command line tools that analyze compile object files (.o, .obj). It is a wrapper around the
platform specific tools ``nm`` (linux) or ``dumpbin`` (windows).

Currently, it consists of the single shell command ``find_symbols``.

Installing
----------

Install from pip::

    python -m pip install analyze_objects

Usage
-----

If binaries of installed python packages are added to the PATH, you can call ``find_symbols`` directly from the shell::

    find_symbols

Otherwise, it can be invoked using python::

    python -m analyze_objects.find_symbols

Examples
--------

Use the following command to search the object files ``foo.o`` and ``bar.o`` for undefined symbols that match the
regular expression ``"foo"``::

    find_symbols --undef_regex foo foo.o bar.o

Using this command requires that ``nm`` (linux) or ``dumpbin`` (windows) are available in the PATH. If that is not the
case, you can use the ``--nm_exe`` or ``--dumpbin_exe`` arguments to pass their location to ``find_symbols``. For
convenience, you may pass ``--store_config`` in addition to ``--nm_exe`` or ``--dumpbin_exe``, so that this path will be
used in all subsequent calls to ``find_symbols``. The stored configuration can be cleared using ``--clear_config``.

Use ``--def_regex`` instead of ``--undef_regex`` to search for defined symbols. It is
possible to combine both arguments and search for both defined and undefined symbols.

The ``find_symbols`` command accepts an arbitrary number of object files. It is possible to use placeholders ``**`` and
``*`` in the object file paths.
gramutil 0.0.2
A utility package for editing grammars (CFG, PDA, etc)

# gramutil

GramUtil is a utility for grammars in computer science. Currently, context-free grammars (CFG) and pushdown automatas (PDA) are supported.

## Installation

```
pip install gramutil
```

## Overview

### ContextFreeGrammar

This class provides initialization and methods for a context free grammar. Common operations are demonstrated below:

```python
from gramutil import cfg

grammarString = """
S -> 0 S 0 | T
T -> 1 T 1
  -> $
"""

# Create the grammar from the string
grammar = cfg.ContextFreeGrammar(grammarString)

# Simplify the grammar (simplifies using basic rules)
grammar.simplify()

# Removes any duplicate productions from any state
grammar.removeDuplicates()

# Converts the grammar to a pushdown automata object
pda = grammar.toPDA()

# Prints a textual representation of the grammar
print(grammar)
```

The rules for a grammar string are as follows:
* Start state must be `S`
* Multiple productions for one state may be separated by the `|` character
* Multiple productions for one state may also be on multiple lines, as shown above
* The epsilon (empty string) character is signified with a `$`
* Terminals may be an underscore or lowercase alphanumeric
* Nonterminals have the same rules, but must start with an uppercase character and allow uppercase throughout
* All terms (terminals and nonterminals) must be space-separated

### PushdownAutomata

This class provides initialization and method for a pushdown automata. Currently, creation is only supported from a `ContextFreeGrammar`.

```python
from gramutil import cfg

grammar = cfg.ContextFreeGrammar('S -> 0 S 0 | $')

# Two options for creating the PDA
pda = cfg.PushdownAutomata(grammar)
pda = grammar.toPDA()

# Prints a textual representation of the PDA
print(pda)

# Converts the PDA back to a CFG
grammar = pda.toCFG()
grammar.simplify()
print(grammar)
```

## Examples

Check out `examples/convert.py` for an example use