semvec/pypi-packages huggingface dataset:
in-toolset 0.1.3
An editor and simulator for industry workflow nets (inets), a model of interorganisational workflows based on petrinets
Requires Python: >=3.6

# in-toolset

in-toolset is an editor and (basic) simulator for industry workflow nets (inets), a model of interorganisational workflows based on petrinets.

Currently, the tool supports editing and manually simulating these industry workflows, and exporting industry nets as PNML petri nets,
but support for checking for bisimilarity using LTSmin and for automatically generating a subset of the language of triggering sequences of an inet in XES is planned, as is a model of "domains" for organisations and messages.

in-toolset has cross-platform support and has been verified to work on linux, MacOS, and windows.
It should work on most systems with python3.6 or newer and pyqt5.
The recommended way to install it is to run `pip install in-toolset`, this makes a command-line tool `in-toolset` available which starts the graphical editor.

The toolset was originally created by: Daniel Otten, Jakob Wuhrer, Julia Bolt, Ricardo Schaaf, and Yannik Marchand, on behalf of Pieter Kwantes of Leiden University.

It is provided here licensed under the GNU General Public License v3.0.

Documentation can be found at https://in-toolset.rtfd.org
mountvfs 0.1.7
SSHFS, NFS clients.
Requires Python: >=3.6

## Description
For the moment there are two classes in the package: `SshfsSaver` and `NfsSaver`. 
They are used to write data to a remote server via passing a writing func to`.save()` 
method. 

Any writing function must require a save path as its first argument, but since a saver 
is initialized with a target directory, there is no need to pass it in the `args`. 

## Usage example
```
import os
from mountvfs import Sshfs


def write(filepath, filename, text):
    with open(os.path.join(filepath, filename), 'w') as ouf:
        ouf.write(file)


MOUNT_PARAMS = {
    'user': 'test_user', 
    'server: 'test_server', 
    'remote_dir': 'path/to/mounted/remote/dir',
    'key': 'path/to/ssh/private/key',
    'target_dir': 'path/to/mounted/local/dir'
}

with Sshfs(**MOUNT_PARAMS) as saver:
     saver.save(write, args=('test_filename', 'test_text')) 

```
pubfisher 2019.11
Query information about scientific publications on the web.
Requires Python: >=3.6

# Pubfisher: Effectively explore scientific publications

Pubfisher is about querying scientific publications from web sources
such as Google Scholar.
These sources often do not offer a convenient, programmable API,
such that complex or comprehensive queries require lots of manual
steps, such as solving Captchas.

Pubfisher offers a simple data model and API that reduces the manual
effort to the minimum and makes complex queries simple to express.
In particular, Pubfisher does not fail when it sees a Captcha:
It shows the captcha to you, you solve the captcha, on goes the query.

Let's say you are interested in the first 200 citations of a paper
according to Google Scholar
Then this could be your query:
```python
from pubfisher.fishers.googlescholar import PublicationGSFisher
from itertools import islice


def my_query():
    fisher = PublicationGSFisher()

    fisher.look_for_key_words('Parachute use to prevent death '
                              'and major trauma related to '
                              'gravitational challenge: '
                              'systematic review of randomised '
                              'controlled trials')

    return islice(fisher.fish_all(), 200)
```

Using one and the same scraper, you can perform lots of queries.
Pubfisher takes care of reusing the session cookies across requests
such that your queries appear natural to the underlying web services.
menulist 0.3
A menu driven package

# menulist - Make your menu driven program

A Helper pip package for menu driven program. This pip package helps you automate your program manage from command line using menu driven. Sam


### Assumptions:

+ Assuming python is installed on your system.

Install `menulist` on your system using : 

```
pip install menulist
```

### Development:

+ Clean ununsed: `rm -rf build/ dist/ *egg* **.pyc __pycache__`
+ Build package: `python setup.py bdist_wheel`
+ deploy package: `python -m twine upload dist/*`
sqlfaker 0.5
A fake sql database generator package

# Data Structure Creation with `sqlfaker`

`sqlfaker` is a python library that can be used to generate relational data structures and fill these structures with fake data.

## Installation

`sqlfaker` can be installed via pip from [pypi.org](https://pypi.org/). Just run the following command in your terminal or command prompt.

```shell
pip install sqlfaker
```

## Class structure

This projet lets you define relational data structures that are build upon the concepts of `Database`, `Table` and `Column`.

A `Database` can have multiple `Table` objects which again can each have multible `Column` objects. There are two classes that inherit from the `Column` class - `ForeignKey` and `PrimaryKey`. These allow you to create key colums.

## Usage example

`sqlfaker` can be used to generate a new database. So far, the `Database` class only supports MySQL/MariaDB syntax (when it comes to SQL-Export). New database types will be implemented over time.

```python
from sqlfaker.database import Database

# add database
my_db = Database(db_name="campusdb")

# add tables
my_db.add_table(table_name="student", n_rows=500)
my_db.add_table(table_name="studyprogram", n_rows=15)
```

`sqlfaker` can be used to also specify the schema of the tables. This is supported by three methods: `add_primary_key`, `add_column` and `add_foreign_key`. Depending on the type of column that should be created, the add methods need different parameters.

> The order of column creation must follow consider their interdependencies (much like in SQL). If you e.g. create a foreign key column, you need to create the referenced primary key column first.

```python
# add columns to studyprogram table
my_db.tables["studyprogram"].add_primary_key(column_name="studyprogram_id")
my_db.tables["studyprogram"].add_column(column_name="shortname", data_type="varchar(50)", data_target="name")
my_db.tables["studyprogram"].add_column(column_name="startdate", data_type="date", data_target="date")

# add columns to student table
my_db.tables["student"].add_primary_key(column_name="student_id")
my_db.tables["student"].add_column(column_name="firstname", data_type="varchar(50)", data_target="first_name")
my_db.tables["student"].add_column(column_name="lastname", data_type="varchar(50)", data_target="last_name")
my_db.tables["student"].add_foreign_key(column_name="studiengang_id", target_table="studiengang", target_column="studiengang_id")
```

As soon as the database structure has been defined, `sqlfaker` can be used to generate data and then export the complete (or also parts of the) sql script to disk. The syntax of all generated SQL scripts follows MySQL/MariaDB.

>`data_target` is used to specify the type of fake data that is generated to fill the respective column. `sqlfaker` uses Python `faker` for fake data generation. You can therefore reference all `faker` data types as `data target`. See `faker`'s [documentation](https://faker.readthedocs.io/en/master/) for more details.

```python
my_db.generate_data()
my_db.export_sql("test.sql")
```
dockship 0.1.4
Run AI models in Docker containers

# dockship

### Installation
You can install dockship from PyPI:

`pip install dockship`

dockship requires python == 3.6 and docker installed.

### How to use
`dockship` is a command line application. It supports two commands:

### run

 Downloads model from Dockship and runs the model in docker container.

 Args:

    modelID (string) : Model's unique id shown at dockship.io
    port (string)    : Port number for running model

### stop

 Stops the already runnng model.

 Args:

    modelID : Model's unique id which needs to be stopped.
aios-lib 0.0.6
aios lib package

## AIOS LIB

Library for AIOS program

#### Build

~~~python
python3 setup.py sdist bdist_wheel
~~~

#### Intallation

~~~shell
pip3 install wheel_file_path
~~~

#### Usage

~~~python
from aios-lib.utils import *

# Obtain data directory from environment variables
data_dir = get_data_dir()
# Obtain model directory from environment variables
model_dir = get_model_dir()
# Report model score to clustar aios server
score = 1
report_score(score)
~~~

#### Acknowledge
sequelize-to-excel 1.0.10
map your sequelize columns to excel
Requires Python: >=3.6
Keywords: Node,excel,Sequelize

# Sequelize to Excel

Why Should I Use This?
----------------------
This library is intended to extract column names , field names , table name and other information from your node model file developed in standard Sequelize format

The excel will help you to have sneak peak of complete file at once , along with the corresponding database field name

This can also be used as standalone app , as well as library

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

.. code-block:: console

    pip install sequelize-to-excel


Using SequelizeToExcel
----------------------

1. Import the package and call the method from initalize object

.. code-block:: console

    from sequelize_to_excel import SequelizeToExcel
    objSeq = SequelizeToExcel("<filename>")
    objSeq.extract_and_export()

2. you will find the generate excel file in the same folder .
    Make sure you provide the input file preferrably in the same folder.