semvec/pypi-packages huggingface dataset:
nfem 4.1.8
NFEM Teaching Tool
License: MIT
Requires Python: >=3.7,<4.0

# NFEM Teaching Tool

![PyPI](https://img.shields.io/pypi/v/nfem) ![PyPI - Downloads](https://img.shields.io/pypi/dm/nfem) [![Coverage Status](https://coveralls.io/repos/github/StatikTUM/nfem/badge.svg?branch=master&service=github)](https://coveralls.io/github/StatikTUM/nfem?branch=master) ![CI](https://github.com/StatikTUM/nfem/workflows/CI/badge.svg) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/StatikTUM/nfem/master?filepath=examples) [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/StatikTUM/nfem/)

This is a lightweight python tool build for teaching non linear FEM analysis of 3D truss structures.

## Installation

Install [Anaconda](https://www.anaconda.com/distribution/), open the Anaconda console and execute the following command:

```shell
pip install nfem
```
sciebo-rds-cli 0.1.6
Script for install sciebo RDS in sciebo
License: MIT
Requires Python: >=3.8,<4.0

[![PyPI version](https://badge.fury.io/py/sciebo-rds-cli.svg)](https://badge.fury.io/py/sciebo-rds-cli)

Status: not for production, yet

# Sciebo RDS CLI

This is a helper tool to install sciebo RDS to your owncloud instances. It supports ssh and kubectl.

## Usage

You need python3 (>= 3.10) and pip to use this tool.

```bash
pip install sciebo-rds-cli
sciebords --help
```

If you prefer the sourcecode way:

```bash
git clone https://github.com/Heiss/Sciebo-RDS-Install.git && cd Sciebo-RDS-Install
pip install -r requirements.txt
chmod +x sciebo_rds_install/main.py
sciebo_rds_install/main.py --help
```

If you have poetry installed, you can use it, too. So the installation will not rubbish your local python environment, because it uses virtualenv on its own.

```bash
git clone https://github.com/Heiss/Sciebo-RDS-Install.git && cd Sciebo-RDS-Install
poetry install
poetry shell
sciebords --help
```

The application will look for a `values.yaml`, which is needed for the sciebo RDS helm supported installation process. So you only have to maintain a single yaml file. Just append the content of `config.yaml.example` to your `values.yaml`. But you can also set your config stuff for this tool in a separated `config.yaml` with `--config` flag. For options for the configuration, please take a look into the `config.yaml.example`, because it holds everything with documentation you can configure for this app. Also you should take a look into the help parameter, because it shows, what the tool can do for you.

## Developer installation

This project uses [poetry](https://python-poetry.org/docs/#installation) for dependencies. Install it with the described methods over there in the official poetry documentation.

Then you need to install the developer environment.

```bash
poetry install --with dev
poetry shell
```

After this you can run the application in this environment.

```bash
sciebords --help
```

If you add or update the dependencies, you have to generate a new requirementst.txt for easier user installations.

```bash
poetry export -f requirements.txt --output requirements.txt
```
slack-blocks-wrapper 0.2.6
A python3 wrapper for the slack block kit framework
License: MIT

# Slack Blocks Wrapper

Slack blocks wrapper is a python3 wrapper around the slack blocks framework. It provides a simple way to create and send blocks to slack.

## Installation

```bash
pip install slack-blocks-wrapper
```

Slack blocks wrapper has no dependencies outside python3. Currently, it is only supported and tested on python3.9.

## Usage

You can use the wrapper to create blocks in a few different ways.

Here's an example of a section with a multi-static select menu:

```python
from slack_blocks_wrapper import section, elements

multistatic_select_node = section.multi_static_select(
    text="Select a color",
    action_id="color_select",
    options=[
        elements.text_element(
            text="Red",
            text_type=elements.TextType.PLAIN_TEXT,
            value="red"
        ),
        elements.text_element(
            text="Green",
            text_type=elements.TextType.PLAIN_TEXT,
            value="green"
        ),
        elements.text_element(
            text="Blue",
            text_type=elements.TextType.PLAIN_TEXT,
            value="blue"
        )
    ]
)
```

You can use this element with the Bolt framework to create a multi-static select menu as follows:

```python
import logging
import os
from flask import Flask, request
from slack_bolt import App

from slack_bolt.adapter.flask import SlackRequestHandler
from slack_blocks_wrapper import section, elements

block_element = section.multi_static_select(
    text="Select a color",
    action_id="color_select",
    options=[
        elements.text_element(
            text="Red",
            text_type=elements.TextType.PLAIN_TEXT,
            value="red"
        ),
        elements.text_element(
            text="Green",
            text_type=section.TextType.PLAIN_TEXT,
            value="green"
        ),
        elements.text_element(
            text="Blue",
            text_type=section.TextType.PLAIN_TEXT,
            value="blue"
        )
    ]
)
app = Flask(__name__)
logging.basicConfig(level=logging.DEBUG)
bolt_app = App()
handler = SlackRequestHandler(bolt_app)


@bolt_app.command("/hello-world")
def hello(ack):
    ack(blocks=[block_element])

    
@app.route("/slack/events", methods=["POST"])
def slack_events():
    return handler.handle(request)


# Only for local debug
if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 3000)))

```

Thus far, the following block kit builder elements are supported:

1. Section - All section elements are supported.
2. Actions - All action elements are supported.
3. Context - All context elements are supported.
4. Divider - All divider elements are supported.
5. Image - All image elements are supported.
6. Input - All input elements are supported.
7. Header - All header elements are supported.
8. Divider - All divider elements are supported.

Better documentation and implementation improvements are coming soon.
dj-plotly-dash 0.18.1
A Python framework for building reactive web-apps. Developed by Plotly.
License: MIT
Requires Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*

# dj-plotly-dash

[![CircleCI](https://img.shields.io/circleci/project/github/pikhovkin/dj-plotly-dash.svg)](https://circleci.com/gh/pikhovkin/dj-plotly-dash)
[![PyPI](https://img.shields.io/pypi/v/dj-plotly-dash.svg)](https://pypi.org/project/dj-plotly-dash/)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dj-plotly-dash.svg)
[![framework - Django](https://img.shields.io/badge/framework-Django-0C3C26.svg)](https://www.djangoproject.com/)
![PyPI - Django Version](https://img.shields.io/pypi/djversions/dj-plotly-dash.svg)
[![PyPI - License](https://img.shields.io/pypi/l/dj-plotly-dash.svg)](./LICENSE)


#### Dash is a Python framework for building analytical web applications. No JavaScript required.

It's fork of Plotly [Dash](https://github.com/plotly/dash).

Here’s [a example of view of Django Dash App](https://gist.github.com/pikhovkin/6ec23d425b12b720651942fd6a5cdf13) ([original example with Flask](https://gist.github.com/chriddyp/3d2454905d8f01886d651f207e2419f0)) that ties a Dropdown to a D3.js Plotly Graph.
As the user selects a value in the Dropdown, the application code dynamically
exports data from Google Finance into a Pandas DataFrame.

![Sample Dash App](https://user-images.githubusercontent.com/1280389/30086128-9bb4a28e-9267-11e7-8fe4-bbac7d53f2b0.gif)

Dash app code is declarative and reactive, which makes it easy to build complex apps that contain many interactive elements. Here’s an example ([original example with Flask](https://gist.github.com/chriddyp/9b2b3e8a6c67697279d3724dce5dab3c)) with 5 inputs, 3 outputs, and cross filtering. This app was composed in just 160 lines of code, all of which were Python.

![crossfiltering dash app](https://user-images.githubusercontent.com/1280389/30086123-97c58bde-9267-11e7-98a0-7f626de5199a.gif)

Dash uses [Plotly.js](https://github.com/plotly/plotly.js) for charting. Over 35 chart types are supported, including maps.

Dash isn't just for dashboards. You have full control over the look and feel of your applications. Here's a Dash app that's styled to look like a PDF report.

To learn more about Dash, read the [extensive announcement letter](https://medium.com/@plotlygraphs/introducing-dash-5ecf7191b503) or [jump in with the user guide](https://plot.ly/dash).

### Usage

See examples of usage in `tests/django_project`

### Installation

```bash
$ pip install dj-plotly-dash[all]
$ pip install "dash_core_components>=0.40.2" --no-deps
$ pip install "dash_html_components>=0.14.0" --no-deps
```

### Documentation

View the [Dash User Guide](https://plot.ly/dash). It's chock-full of examples, pro tips, and guiding principles.

### License

MIT
ctrader-open-api 0.9.1
A Python package for interacting with cTrader Open API
License: MIT
Requires Python: >=3.8,<4.0

# OpenApiPy


[![PyPI version](https://badge.fury.io/py/ctrader-open-api.svg)](https://badge.fury.io/py/ctrader-open-api)
![versions](https://img.shields.io/pypi/pyversions/ctrader-open-api.svg)
[![GitHub license](https://img.shields.io/github/license/spotware/OpenApiPy.svg)](https://github.com/spotware/OpenApiPy/blob/main/LICENSE)

A Python package for interacting with cTrader Open API.

This package uses Twisted and it works asynchronously.

- Free software: MIT
- Documentation: https://spotware.github.io/OpenApiPy/.


## Features

* Works asynchronously by using Twisted

* Methods return Twisted deferreds

* It contains the Open API messages files so you don't have to do the compilation

* Makes handling request responses easy by using Twisted deferreds

## Insallation

```
pip install ctrader-open-api
```

# Usage

```python

from ctrader_open_api import Client, Protobuf, TcpProtocol, Auth, EndPoints
from ctrader_open_api.messages.OpenApiCommonMessages_pb2 import *
from ctrader_open_api.messages.OpenApiCommonMessages_pb2 import *
from ctrader_open_api.messages.OpenApiMessages_pb2 import *
from ctrader_open_api.messages.OpenApiModelMessages_pb2 import *
from twisted.internet import reactor

hostType = input("Host (Live/Demo): ")
host = EndPoints.PROTOBUF_LIVE_HOST if hostType.lower() == "live" else EndPoints.PROTOBUF_DEMO_HOST
client = Client(host, EndPoints.PROTOBUF_PORT, TcpProtocol)

def onError(failure): # Call back for errors
    print("Message Error: ", failure)

def connected(client): # Callback for client connection
    print("\nConnected")
    # Now we send a ProtoOAApplicationAuthReq
    request = ProtoOAApplicationAuthReq()
    request.clientId = "Your application Client ID"
    request.clientSecret = "Your application Client secret"
    # Client send method returns a Twisted deferred
    deferred = client.send(request)
    # You can use the returned Twisted deferred to attach callbacks
    # for getting message response or error backs for getting error if something went wrong
    # deferred.addCallbacks(onProtoOAApplicationAuthRes, onError)
    deferred.addErrback(onError)

def disconnected(client, reason): # Callback for client disconnection
    print("\nDisconnected: ", reason)

def onMessageReceived(client, message): # Callback for receiving all messages
    print("Message received: \n", Protobuf.extract(message))

# Setting optional client callbacks
client.setConnectedCallback(connected)
client.setDisconnectedCallback(disconnected)
client.setMessageReceivedCallback(onMessageReceived)
# Starting the client service
client.startService()
# Run Twisted reactor
reactor.run()

```

Please check documentation or samples for a complete example.

## Dependencies

* <a href="https://pypi.org/project/twisted/">Twisted</a>
* <a href="https://pypi.org/project/protobuf/">Protobuf</a>