semvec/pypi-packages huggingface dataset:
Flask-AA 0.1.0
Flask extension for authentication and authorization
Requires Python: >=3.10

# Flask-AA

Flask extension for authentication and authorization.

It can be used as an alternative for Flask-Login.

Apart from base functionality for user session management it provides also routes for login (it renders auth/login.html template) and logout.
Users can be checked against external TACACS+ server (the Flask app config should have `TACACS_SERVER` and `TACACS_SECRET_KEY` keys).

There is also a UserMixin model class with the following fields (username, remote, password_hash, first_name, last_name, email, active, admin, created, last_login).


## Installation

```bash
$ pip install Flask-AA
```


## Usage

First create the `auth` object:

```python
from flask_auth import Auth
auth = Auth()
```

Then initialize it using init_app method:

```python
auth.init_app(app, db, User, wtf)
# app is your Flask app instance
# db is your Flask-Alchemist instance
# User is your User model
# wtf is your Flask-Formist instance for handling forms
```


## License

`Flask-AA` was created by Rafal Padkowski. It is licensed under the terms
of the MIT license.
Flask-Formist 0.1.0
Flask extension for working with WTForms
Requires Python: >=3.10

# Flask-Formist

Flask extension for working with WTForms.

It can be used as an alternative for Flask-WTF.

It provides BaseForm for working with CSRF tokens (the Flask app config should have `CSRF_SECRET_KEY` and `CSRF_TIME_LIMIT` keys).

There is also a handle_form function for dealing with forms:
you provide form class, template to be rendered, on_success function to be called when the form is valid, cancel url and object to be edited.


## Installation

```bash
$ pip install Flask-Formist
```

## Usage

First create the `wtf` object:

```python
from flask_formist import Formist
wtf = Formist()
```

Then initialize it using init_app method:

```python
wtf.init_app(app)  # app is your Flask app instance
```


## License

`Flask-Formist` was created by Rafal Padkowski. It is licensed under the terms
of the MIT license.
knapsack-algorithm 1.0.0
A python implementation of the Knapsack problem using dynamic programming.
Requires Python: >=3.6

## Knapsack Algorithm

knapsack_algorithm is a Python package that provides a simple and efficient solution for the 0/1 knapsack problem.

### Features

- **Dynamic Programming Solution**: Utilizes dynamic programming to solve the 0/1 knapsack problem efficiently.
- **Error Handling**: Provides comprehensive error handling for input validation.
- **Easy to Use**: Offers a user-friendly interface for solving knapsack problems with given values, weights, and capacity.

### Installation:

You can install KnapsackAlgorithm using pip:

pip install knapsack_algorithm

#### Usage:

Here's an example of how you can use knapsack_algorithm:

from knapsack_algorithm import knapsack

#### Documentation
For detailed documentation and additional options, refer to the official documentation.

#### License
This project is licensed under the MIT License - see the LICENSE file for details.

#### Contributing
If you would like to contribute or report issues, please check our contribution guidelines.
#### Example usage:

```bash
values = [60, 100, 120]  # The values of the items

weights = [10, 20, 30]  # The weights of the items

capacity = 50  # The maximum capacity

result = knapsack(values, weights, capacity)

if result is not None:

      print("Maximum value in the knapsack:", result)
flask-firebase 1.7
Google Firebase integration for flask. Forked from klokantech/flask-firebase
Requires Python: >=3.8

# Flask-Firebase

Google Firebase integration for Flask. At this moment,
only the authentication subsystem is supported.

The extension works in two modes: development and production.
In development, there is no communication with the Firebase
system, accounts sign-in with a simple email form. The mode
depends on the `Flask.debug` variable.

## Configuration

- `FIREBASE_API_KEY`: The API key.
- `FIREBASE_PROJECT_ID`: The project identifier, eg. `foobar`.
- `FIREBASE_AUTH_SIGN_IN_OPTIONS`: Comma-separated list of enabled providers.

## Providers

- `email`
- `facebook`
- `github`
- `google`
- `twitter`

## Sample code

```python
from flask import Flask, request
from flask_firebase import FirebaseAuth
from flask_login import LoginManager, UserMixin, login_user, logout_user
from flask_sqlalchemy import SQLAlchemy


app = Flask(__name__)
app.config.from_object(...)

db = SQLAlchemy(app)
auth = FirebaseAuth(app)
login_manager = LoginManager(app)

app.register_blueprint(auth.blueprint, url_prefix='/auth')


class Account(UserMixin, db.Model):

    __tablename__ = 'accounts'

    account_id = db.Column(db.Integer, primary_key=True)
    firebase_user_id = db.Column(db.Text, unique=True)
    email = db.Column(db.Text, unique=True, nullable=False)
    email_verified = db.Column(db.Boolean, default=False, nullable=False)
    name = db.Column(db.Text)
    photo_url = db.Column(db.Text)


@auth.production_loader
def production_sign_in(token):
    account = Account.query.filter_by(firebase_user_id=token['sub']).one_or_none()
    if account is None:
        account = Account(firebase_user_id=token['sub'])
        db.session.add(account)
    account.email = token['email']
    account.email_verified = token['email_verified']
    account.name = token.get('name')
    account.photo_url = token.get('picture')
    db.session.flush()
    login_user(account)
    db.session.commit()


@auth.development_loader
def development_sign_in(email):
    login_user(Account.query.filter_by(email=email).one())


@auth.unloader
def sign_out():
    logout_user()


@login_manager.user_loader
def load_user(account_id):
    return Account.query.get(account_id)


@login_manager.unauthorized_handler
def authentication_required():
    return auth.url_for('widget', mode='select', next=request.url)
```
Flask-Auxs 0.1.0
Flask extension for providing auxiliary components to be used by different projects
Requires Python: >=3.10

# Flask-Auxs

Flask extension for providing auxiliary components to be used by different projects.


## Installation

```bash
$ pip install Flask-Auxs
```

## Usage

First create the `auxs` object:

```python
from flask_auxs import Auxs
auxs = Auxs()
```

Then initialize it using init_app method:

```python
auxs.init_app(app)  # app is your Flask app instance
```

## Content

Components automatically installed:
- context processor for injecting redir_path to templates
- dtformat jinja filter for date and time formatting

Components to be directly imported on demand:
- error handler error_obj_not_found
- exceptions: NotAllowed, PermissionDenied for crud validation
- url helpers: get_cancel, get_next, valid_url


## License

`Flask-Auxs` was created by Rafal Padkowski. It is licensed under the terms
of the MIT license.
flask-firebase-fork 0.0.2
Google Firebase integration for flask. Forked from klokantech/flask-firebase
Requires Python: >=3.8

# Flask-Firebase

Google Firebase integration for Flask. At this moment,
only the authentication subsystem is supported.

The extension works in two modes: development and production.
In development, there is no communication with the Firebase
system, accounts sign-in with a simple email form. The mode
depends on the `Flask.debug` variable.

## Configuration

- `FIREBASE_API_KEY`: The API key.
- `FIREBASE_PROJECT_ID`: The project identifier, eg. `foobar`.
- `FIREBASE_AUTH_SIGN_IN_OPTIONS`: Comma-separated list of enabled providers.

## Providers

- `email`
- `facebook`
- `github`
- `google`
- `twitter`

## Sample code

```python
from flask import Flask, request
from flask_firebase import FirebaseAuth
from flask_login import LoginManager, UserMixin, login_user, logout_user
from flask_sqlalchemy import SQLAlchemy


app = Flask(__name__)
app.config.from_object(...)

db = SQLAlchemy(app)
auth = FirebaseAuth(app)
login_manager = LoginManager(app)

app.register_blueprint(auth.blueprint, url_prefix='/auth')


class Account(UserMixin, db.Model):

    __tablename__ = 'accounts'

    account_id = db.Column(db.Integer, primary_key=True)
    firebase_user_id = db.Column(db.Text, unique=True)
    email = db.Column(db.Text, unique=True, nullable=False)
    email_verified = db.Column(db.Boolean, default=False, nullable=False)
    name = db.Column(db.Text)
    photo_url = db.Column(db.Text)


@auth.production_loader
def production_sign_in(token):
    account = Account.query.filter_by(firebase_user_id=token['sub']).one_or_none()
    if account is None:
        account = Account(firebase_user_id=token['sub'])
        db.session.add(account)
    account.email = token['email']
    account.email_verified = token['email_verified']
    account.name = token.get('name')
    account.photo_url = token.get('picture')
    db.session.flush()
    login_user(account)
    db.session.commit()


@auth.development_loader
def development_sign_in(email):
    login_user(Account.query.filter_by(email=email).one())


@auth.unloader
def sign_out():
    logout_user()


@login_manager.user_loader
def load_user(account_id):
    return Account.query.get(account_id)


@login_manager.unauthorized_handler
def authentication_required():
    return auth.url_for('widget', mode='select', next=request.url)
```
sdypy-FRF 0.1.0
Frequency response function as used in structural dynamics.
Requires Python: >=3.10
Keywords: Frequency response function,MIMO,SIMO/MISO,SISO,structural dynamics

sdypy-FRF
=========

Frequency response function as used in structural dynamics.
-----------------------------------------------------------

The ``sdypy-FRF`` is a namespace project of the ``sdypy`` framework and is a direct link
to the ``pyFRF`` package.

Use the ``sdypy`` package to convieniently access the functionallity of the
`pyFRF <https://github.com/ladisk/pyFRF>`_ package through its namespace (see example below). 

Other functionalities of the ``sdypy`` framework include:

- `sdypy-EMA <https://github.com/sdypy/sdypy-EMA>`_: Experimental Modal Analysis
- `sdypy-io <https://github.com/sdypy/sdypy-io>`_: Input/Output operations (LVM files, UFF files)


For more information check out the showcase examples and see documentation_.

Basic ``sdypy-FRF`` usage:
--------------------------

Import the module:
~~~~~~~~~~~~~~~~~~~

.. code:: python

    from sdypy import FRF

Make an instance of ``FRF`` class:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

.. code:: python

    a = FRF.FRF(
        sampling_freq,
        exc=None,
        resp=None,
        exc_type='f', resp_type='a',
        window='none',
        weighting='linear',
        fft_len=None,
        nperseg=None,
        noverlap=None,
        archive_time_data=False,
        frf_type='H1',
        copy=True
    )

Adding data:
~~~~~~~~~~~~
We can add the excitation and response data at the beginning through ``exc`` and ``resp`` arguments, otherwise, the excitation and response 
data can be added later via ``add_data()`` method:

.. code:: python

    a.add_data(exc, resp)

Computing FRF:
~~~~~~~~~~~~~~
Preferable way to get the frequency response functions is via ``get_FRF()`` method:

.. code:: python

    frf = a.get_FRF(type="default", form="receptance")

We can also directly get the requested FRF via other methods: ``get_H1()``, ``get_H2()``, ``get_Hv()`` and, ``get_ods_frf()``:

.. code:: python

    H1 = a.get_H1()
    H2 = a.get_H2()
    Hv = a.get_Hv()
    ods_frf = a.get_ods_frf()

.. _documentation: https://pyfrf.readthedocs.io/en/latest/

|pytest|

|binder| to test the *Showcase.ipynb*.

.. |binder| image:: https://mybinder.org/badge_logo.svg
   :target: https://mybinder.org/v2/gh/ladisk/pyFRF/main
.. |pytest| image:: https://github.com/ladisk/pyFRF/actions/workflows/python-package.yml/badge.svg
    :target: https://github.com/ladisk/pyFRF/actions
chainos 0.1.0
ChainOS-python is a python client for the ChainOS engine
Requires Python: >=3.10,<4.0

# ChainOS

An extremely fast, language-agnostic, graph workflow engine for building, testing, and deploying complex workflows.

[![versions](https://img.shields.io/badge/python-3.9|3.10)](https://github.com/chainos-io/chainos-python)

![Static Badge](https://img.shields.io/badge/python-3.9%7C3.10)


___
## Story

***Chainos : the Forger of Sequential Bonds***

Chainos focuses on the power of chained processes, from AI to algorithmic sequences where each step is linked to the next. As the forger of sequences, Chainos ensures that every link in the chain holds, promoting security, efficiency, and integrity in systems that rely on unbroken processes.

[Website: chainos.io](https://chainos.io/)

## Help

[Documentation](https://chainos.io/docs/)

[Examples](https://chainos.io/examples/)

## Installing

#### Setup environment
```bash
# Choose a python version
pyenv install 3.10
pyenv install 3.11

# Create a virtualenv
# Can replace 3.11 with your version
pyenv virtualenv 3.11 chainos

# See all installed python versions and available virtualenvs
pyenv versions

# activate virtualenv
pyenv activate chainos

# leave virtualenv
pyenv deactivate

pip install poetry
```

### Setup project

```bash
git clone git@github.com:chainos-io/chainos-python.git

cd chainos-python

poetry install --with test,dev --no-root
```

## Running ChainOS

Example chainos project

```python
from chainos import ChainOS as cos

container = cos.Container()

chain = cos.Chain(container=container)

@cos.task
def step1() -> int:
    print("Hello, World!")
    return 1

@cos.task
def step2(input1: int):
    print(f"step2: {input1}")
    return input1 * 2

chain.add(step1)
chain.add(step2)

container.add(chain)

chain.run()
```

## Contributing

For guidance on setting up a development environment and how to make a
contribution to Chainos, see
[Contributing to Pydantic](https://docs.chainos.io/contributing/).

Or see [Contribution guidelines for this project](docs/CONTRIBUTING.md)

## Reporting a Security Vulnerability

See our [security policy](https://github.com/chainos-io/chainos-python/security/policy).