semvec/pypi-packages huggingface dataset:
pyedu 0.1.2
Leaning Python interactively
License: MIT

PyEDU
=====

The Python Educational Suite (PyEDU) is a flask application for guided Python exercise creation and completion. It
was created for the Python I and Python II lectures at the Chair for remote sensing and landscape information systems
at the Univeristy of Freiburg, but will however work with other exercises as well.

The application is meant to be run from the localhost so that the exercise code is run in a local Python environement.
Before running it on a remote server, one has to make sure that no harmful code is included in the exercises before
running the code. However, the local application can connect to a local or remote database. For Python I and II these
remote connections are already included in an encrypted file. As the user has the decryption key, the connection can
be used. In the supplementary folder is Jupyter notebook which can create such a file for other remote locations.

Installation
~~~~~~~~~~~~

Although the project will be on PyPI, the installation using git favored. One of the next updates will included
a version check and auto-update function, which will be based on git and might not work when PyEDU is installed
using pip. It can be installed using:

.. code-block:: bash

    git clone https://github.com/mmaelicke/pyedu.git
    cd pyedu
    pip install -r requirements.txt
    python setup.py install


Using remote connections
~~~~~~~~~~~~~~~~~~~~~~~~

In order to use a remote connection you'll need a file with the decryption key in it. The connection and keys are in the
pyedu/enc folder. To use a remote connection as default, rename the .enc file you wish to use to 'remote.enc' and
place the key as 'remote.key' into the enc folder. Then the default flask settings will use this connection as
the default connection.
For one of the next updates, there will be the possibility to enter the cleartext key during the start process. Then
the user cannot manually decrypt the enc file anymore.

Starting the application
~~~~~~~~~~~~~~~~~~~~~~~~

In order to start the application, in the pyedu/pyedu folder use:

.. code-block:: bash

    python manage.py runserver

If you like to use another flask configuration, like with enabled debug mode or a local connection, you can use the -c
(--config) flag:

.. code-block:: bash

    python manage.py -c local_dev runserver

Once the server is running, the application can be accessed with your browser and activated Javascript at:

.. code-block::

    http://locahost:5000

With one of the next versions, the application will be able to create a shortcut on Windows or a executable symlink on
Linux for starting the application.


Security
~~~~~~~~

Please note, that this application is not made for remote usage and still under active development. If you decide to
run this application with a remote database, please note that it is possbile to read the database connection and
connect externally. To come around external assingment injection, the application will include a different assign
route with a future release, that will shift the solution check to a remote REST API and therefore make the student
db user a read only db user.
jsontableschema-sql 0.8.0
Generate SQL tables, load and extract data, based on JSON Table Schema descriptors.
License: MIT
Keywords: frictionless data

jsontableschema-sql-py
======================

| |Travis|
| |Coveralls|
| |PyPi|
| |SemVer|
| |Gitter|

Generate and load SQL tables based on JSON Table Schema descriptors.

    Version ``v0.3`` contains breaking changes:

-  renamed ``Storage.tables`` to ``Storage.buckets``
-  changed ``Storage.read`` to read into memory
-  added ``Storage.iter`` to yield row by row

Getting Started
---------------

Installation
~~~~~~~~~~~~

.. code:: bash

    pip install jsontableschema-sql

Storage
~~~~~~~

Package implements `Tabular
Storage <https://github.com/frictionlessdata/jsontableschema-py#storage>`__
interface.

SQLAlchemy is used as sql wrapper. We can get storage this way:

.. code:: python

    from sqlalchemy import create_engine
    from jsontableschema_sql import Storage

    engine = create_engine('sqlite:///:memory:', prefix='prefix')
    storage = Storage(engine)

Then we could interact with storage:

.. code:: python

    storage.buckets
    storage.create('bucket', descriptor)
    storage.delete('bucket')
    storage.describe('bucket') # return descriptor
    storage.iter('bucket') # yield rows
    storage.read('bucket') # return rows
    storage.write('bucket', rows)

Mappings
~~~~~~~~

::

    schema.json -> SQL table schema
    data.csv -> SQL talbe data

Drivers
~~~~~~~

SQLAlchemy is used - `docs <http://www.sqlalchemy.org/>`__.

API Reference
-------------

Snapshot
~~~~~~~~

https://github.com/frictionlessdata/jsontableschema-py#snapshot

Detailed
~~~~~~~~

-  `Docstrings <https://github.com/frictionlessdata/jsontableschema-py/tree/master/jsontableschema/storage.py>`__
-  `Changelog <https://github.com/frictionlessdata/jsontableschema-sql-py/commits/master>`__

Contributing
------------

Please read the contribution guideline:

`How to Contribute <CONTRIBUTING.md>`__

Thanks!

.. |Travis| image:: https://img.shields.io/travis/frictionlessdata/jsontableschema-sql-py/master.svg
   :target: https://travis-ci.org/frictionlessdata/jsontableschema-sql-py
.. |Coveralls| image:: http://img.shields.io/coveralls/frictionlessdata/jsontableschema-sql-py/master.svg
   :target: https://coveralls.io/r/frictionlessdata/jsontableschema-sql-py?branch=master
.. |PyPi| image:: https://img.shields.io/pypi/v/jsontableschema-sql.svg
   :target: https://pypi.python.org/pypi/jsontableschema-sql
.. |SemVer| image:: https://img.shields.io/badge/versions-SemVer-brightgreen.svg
   :target: http://semver.org/
.. |Gitter| image:: https://img.shields.io/gitter/room/frictionlessdata/chat.svg
   :target: https://gitter.im/frictionlessdata/chat
gbn 0.4.3
Greenlet BottleNeck profiler.
License: MIT

Greenlet BottleNeck profiler.

Measures time precisely using "greenlet.settrace" to pause/continue counting time on switch from/to original greenlet.

May count wall-clock time too. Also counts step calls and context switches.

Usage::

    gbn_attach()

    gbn('step1')
    step1()

    gbn('step2')
    step2()

    wall = gbn('step3')
    step3()

    wall = gbn('step4', wall=wall)
    step4()

    gbn('step5', wall=wall)
    step5()

    gbn()
    does_not_count_this()

    log.info(gbn_report_and_reset())
    # OR
    spawn(gbn_report_and_reset, each=60, log=log.info)

See `help(gbn) <https://github.com/denis-ryzhkov/gbn/blob/master/gbn.py#L152>`_ for detailed docs.

Additional tools:

* `gxray <https://github.com/denis-ryzhkov/gbn/blob/master/gxray.py>`_ - Heavy profiler when you don't know where to profile.
* `gswitched <https://github.com/denis-ryzhkov/gbn/blob/master/gswitched.py>`_ - Checks if greenlet switched.