semvec/pypi-packages huggingface dataset:
bwutils 0.0.1
A set of scripts for LCA related calculations using Brightway framework v 2.4.*
Requires Python: <4.0,>=3.8

# bwutils

[![Release](https://img.shields.io/github/v/release/rahulrameshnair/bwutils)](https://img.shields.io/github/v/release/rahulrameshnair/bwutils)
[![Build status](https://img.shields.io/github/actions/workflow/status/rahulrameshnair/bwutils/main.yml?branch=main)](https://github.com/rahulrameshnair/bwutils/actions/workflows/main.yml?query=branch%3Amain)
[![codecov](https://codecov.io/gh/rahulrameshnair/bwutils/branch/main/graph/badge.svg)](https://codecov.io/gh/rahulrameshnair/bwutils)
[![Commit activity](https://img.shields.io/github/commit-activity/m/rahulrameshnair/bwutils)](https://img.shields.io/github/commit-activity/m/rahulrameshnair/bwutils)
[![License](https://img.shields.io/github/license/rahulrameshnair/bwutils)](https://img.shields.io/github/license/rahulrameshnair/bwutils)

A set of scripts for LCA related calculations using Brightway framework v 2.4.*

- **Github repository**: <https://github.com/rahulrameshnair/bwutils/>
- **Documentation** <https://rahulrameshnair.github.io/bwutils/>

## About 

This is a set of helpful scripts, packages and jupyternotebooks for performing lca-related calculations using brightway framework versions less than 2.5. The idea is to share repetitive and complex calculations/plots through scripts, and others as jupyternotebooks that can work once this package is installed via pypi or Github.
bbp-atlas-pipeline-validator 0.4.0
A pipeline validator for Blue Brain Project

# Pipeline Validator


## Install

You can install the file by using `pip install bbp-atlas-pipeline-validator`


## Examples

You can use the validator in the following way:

```python
from pipeline_validator.pipeline_validator import pipeline_validator

path_to_file = "./my_config.json"
token = "THIS_IS_MY_NEXUS_TOKEN"
whitelisted_vars = ["var1", "var2"]

pipeline_validator(path_to_file, token, whitelisted_vars)
```

where:

- `path_to_file` is the relative path to the configuration
- `token` is a valid nexus token
- `whitelisted_vars` is an array of accepted variables


## Configuration Format

The JSON configuration file should be in the following format:

```json
{
  "rules":[
    {
      "rule": "<NAME_OF_RULE_1>",
      "execute":
        [
          {
            "brainRegion": "http://api.brain-map.org/api/v2/data/Structure/<BRAIN_REGION_ID_1>",
            "container": "docker://<PATH_TO_DOCKER_IMAGE>",
            "command": "<THE COMMAND TO BE EXECUTED>"
          },
          {
            "brainRegion": "http://api.brain-map.org/api/v2/data/Structure/<BRAIN_REGION_ID_2>",
            "container": "docker://<PATH_TO_DOCKER_IMAGE>",
            "command": "<THE COMMAND TO BE EXECUTED>"
          }
        ]
    },
    {
      "rule": "<NAME_OF_RULE_2>",
      "execute":
        [
          {
            "brainRegion": "http://api.brain-map.org/api/v2/data/Structure/<BRAIN_REGION_ID_1>",
            "container": "docker://<PATH_TO_DOCKER_IMAGE>",
            "command": "<THE COMMAND TO BE EXECUTED>"
          },
          {
            "brainRegion": "http://api.brain-map.org/api/v2/data/Structure/<BRAIN_REGION_ID_2>",
            "container": "docker://<PATH_TO_DOCKER_IMAGE>",
            "command": "<THE COMMAND TO BE EXECUTED>"
          }
        ]
    }
  ]
}
```


## Validation Criteria

The following criteria need to be met in order for the configuration to be validated:

- The configuration need to follow the above JSON schema
- Brain region ID should be valid (exist in brain region ontology)
- Within each rule, each brain region need to be followed by brain region that are not related or that they are descendants in the ontology
- For each command, the variables passed need to be part of the whitelisted variables


## Funding & Acknowledgment

The development of this software was supported by funding to the Blue Brain Project, a 
research center of the École polytechnique fédérale de Lausanne (EPFL), from the Swiss 
government’s ETH Board of the Swiss Federal Institutes of Technology.

Copyright © 2023-2024 Blue Brain Project/EPFL
basic-gear 0.0.0.16
Basic Template Gear
Requires Python: >=3.11

# basic-gear

gcc -shared -o basic_gear/shared_library/libmath_operations.dylib -fPIC basic_gear/src/math_operations.c
test : file basic_gear/shared_library/libmath_operations.dylib
out : basic_gear/shared_library/libmath_operations.dylib: Mach-O 64-bit dynamically linked shared library arm64

test: file basic_gear/shared_library/libmath_operations.dll
out: basic_gear/shared_library/libmath_operations.dll: PE32+ executable (DLL) (console) x86-64, for MS Windows

test: file basic_gear/shared_library/libmath_operations_arm.dylib
out: basic_gear/shared_library/libmath_operations_arm.dylib: Mach-O 64-bit dynamically linked shared library arm64
sales-prediction 0.0.1
Sales forecasting model based on date features
Requires Python: ~=3.10

# sales_forecasting

<a target="_blank" href="https://cookiecutter-data-science.drivendata.org/">
    <img src="https://img.shields.io/badge/CCDS-Project%20template-328F97?logo=cookiecutter" />
</a>

Sales forecasting model based on date features

## Project Organization

```
├── LICENSE            <- Open-source license if one is chosen
├── Makefile           <- Makefile with convenience commands like `make data` or `make train`
├── README.md          <- The top-level README for developers using this project.
├── data
│   ├── external       <- Data from third party sources.
│   ├── interim        <- Intermediate data that has been transformed.
│   ├── processed      <- The final, canonical data sets for modeling.
│   └── raw            <- The original, immutable data dump.
│
├── docs               <- A default mkdocs project; see www.mkdocs.org for details
│
├── models             <- Trained and serialized models, model predictions, or model summaries
│
├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
│                         the creator's initials, and a short `-` delimited description, e.g.
│                         `1.0-jqp-initial-data-exploration`.
│
├── pyproject.toml     <- Project configuration file with package metadata for 
│                         sales_prediction and configuration for tools like black
│
├── references         <- Data dictionaries, manuals, and all other explanatory materials.
│
├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
│   └── figures        <- Generated graphics and figures to be used in reporting
│
├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
│                         generated with `pip freeze > requirements.txt`
│
├── setup.cfg          <- Configuration file for flake8
│
└── sales_prediction   <- Source code for use in this project.
    │
    ├── __init__.py             <- Makes sales_prediction a Python module
    │
    ├── config.py               <- Store useful variables and configuration
    │
    ├── dataset.py              <- Scripts to download or generate data
    │
    ├── features.py             <- Code to create features for modeling
    │
    ├── modeling                
    │   ├── __init__.py 
    │   ├── predict.py          <- Code to run model inference with trained models          
    │   └── train.py            <- Code to train models
    │
    └── plots.py                <- Code to create visualizations
```

--------
Flask-Viewsets 0.2.6
Adds Django REST Framework inspired viewsets to Flask.
Requires Python: <4.0,>=3.12

# Flask-Viewsets

`Flask-Viewsets` is a Python package that provides a `ViewSet` class, inheriting from Flask's `View`, inspired by [Django REST Framework](https://github.com/encode/django-rest-framework)'s `ViewSet`. This package aims to streamline the development of RESTful APIs in Flask by offering a simple and flexible class-based view structure for mapping HTTP methods to defined actions on a per route basis.

## Features

- Provides an easy-to-use class-based view to manage HTTP methods.
- Supports all HTTP methods (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`, ...).
- Extensible and customizable for various use cases.

## Installation

You can install `Flask-Viewsets` using pip:

```bash
pip install Flask-Viewsets
```

## Usage

To use the ViewSet class, import it in your Flask application, define a viewset class by inheriting ViewSet, and implement the desired HTTP methods. Here’s a simple example:

```python
# views.py
from flask_viewsets import ViewSet

class ExampleViewSet(ViewSet):
    def hello(self):
        return "Hello, world!"

    def echo(self, message: str):
        return message
```

```python
# app.py
from flask import Flask

from . import views

app = Flask(__name__)
app.add_url_rule('/hello', view_func=views.ExampleViewSet.as_view({
    "get": "hello"
}))
app.add_url_rule('/echo/<string:message>', view_func=views.ExampleViewSet.as_view({
    "get": "echo"
}))

if __name__ == "__main__":
    app.run(debug=True)
```

## Requirements

- Python ^3.12
- Flask ^3.0.3

## Contributing

Contributions are welcome! Please feel free to submit a pull request, file an issue, or suggest improvements.

## License

This project is licensed under the GNU Affero General Public License. See the LICENSE.md file for details.

Enjoy using Flask-Viewsets? Give it a star and help make Flask development easier!
python-bol-api-latest 1.4.0
Wrapper for the bol.com API
Keywords: bol bol.com api wrapper

==============
python-bol-api
==============

.. image:: https://app.travis-ci.com/dreambits/python-bol-api.svg?branch=master
    :target: https://app.travis-ci.com/dreambits/python-bol-api

.. image:: https://badge.fury.io/py/python-bol-api-latest.svg
    :target: https://badge.fury.io/py/python-bol-api-latest

.. image:: https://static.pepy.tech/personalized-badge/python-bol-api-latest?period=total&units=international_system&left_color=brightgreen&right_color=black&left_text=Downloads
 :target: https://pepy.tech/project/python-bol-api-latest

A Python wrapper for the bol.com API forked from https://github.com/pennersr/python-bol-api
This is currently under development but stable to be used.
We are adding more and more features as the api has changed a lot from the time this version was created in original project

A Python wrapper for the bol.com API. Currently rather incomplete, as
it offers only those methods required for my own projects so far.


Open API
========

Instantiate the API::

    >>> from bol.openapi.api import OpenAPI
    >>> api = OpenAPI('api_key')

Invoke a method::

    >>> data = api.catalog.products((['1004004011187773', '1004004011231766'])

JSON data is returned "as is":

    >>> data['products'][0]['ean']
    u'0093155141650'

Retailer API
============

Supports the BOL Api v10, documented here: https://api.bol.com/retailer/public/Retailer-API/selling-on-bolcom-processflow.html

Instantiate the API::

    >>> from bol.retailer.api import RetailerAPI
    >>> api = RetailerAPI()

Authenticate::

    >>> api.login('client_id', 'client_secret')

Invoke a method::

    >>> orders = api.orders.list()
    >>> order = api.orders.get(orders[0].orderId))

Fields are derived 1:1 from the bol.com API, including lower-CamelCase
conventions::

    >>> order.customerDetails.shipmentDetails.streetName
    'Billingstraat'

Fields are properly typed::

    >>> repr(order.orderPlacedDateTime)
    datetime.datetime(2020, 2, 12, 16, 6, 17, tzinfo=tzoffset(None, 3600))
    >>> repr(order.orderItems[0].offerPrice)
    Decimal('106.52')

Access the underlying raw (unparsed) data at any time::

    >>> order.raw_data
    >>> order.raw_content


Running the tests
=================

First, make sure that you have ``tox`` installed on your system::

    pip install tox

Then, just run the tox::

    tox
Flastel 0.0.14.5.post1
Flastel – Telegram Bot API.
Requires Python: >=3.6
Keywords: Telegram Bot API


## Installation

```bash
  pip install flastel
```
    

# Flastel
Flastel is a new module for creating a Telegram bot.    
    You will be able to create several bots on your site by setting them up on your hosting.    
    The "polling" mode is also supported.   
    With the "webhook" method, you don't need multi-mode support.
    You no longer need to create a background specifically for the bot.     
    This module supports weak hosting, which allows you to save money. 



## Usage/Examples

```
from Flastel import TelegramPollingBot
import asyncio
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

bot_token = "bot_token"
bot = TelegramPollingBot(bot_token)

@bot.command(commands=["/start"], caps_ignore=False)
async def start_command(message):
    chat_id = message.chat_id
    from_user_name = message.from_user.all_name
    await bot.send_message(chat_id, f"РџСЂРёРІС–С‚, {from_user_name}! Р¦Рµ СЃС‚Р°СЂС‚РѕРІР° РєРѕРјР°РЅРґР°.", parse_mode="HTML")
    
@bot.command_with_params(commands=["/start"], params=["play", "say", "pay"])
async def start_command_with_params(message, params):
    chat_id = message.chat_id
    from_user_name = message.from_user.all_name
    await bot.send_message(chat_id, f"РџСЂРёРІС–С‚, {from_user_name}! Р¦Рµ СЃС‚Р°СЂС‚РѕРІР° РєРѕРјР°РЅРґР° Р· РїР°СЂР°РјРµС‚СЂР°РјРё {params}.")

@bot.messages_text(messages_txt=["Hello"],  caps_ignore=True)
async def message_handler(message):
    chat_id = message.chat_id
    from_user_name = message.from_user.all_name
    await bot.send_message(chat_id, f"РџСЂРёРІС–С‚, {from_user_name}! Р”СЏРєСѓСЋ Р·Р° С‚Р°РєСѓ РїСЂРёРІС–С‚РЅС–СЃС‚СЊ.")

@bot.command(commands=["/donate"], caps_ignore=False)
async def donate_command(message):
    user_id = message.chat_id
    title = 'РќР° СЂРѕР·РІРёС‚РѕРє РјРѕРґСѓР»СЏ'
    description = 'РќСЏ, РЅР°СЃРїСЂР°РІРґС– С†С– РєРѕС€С‚Рё РїС–РґСѓС‚СЊ РЅР° РєР°РІСѓ СЂРѕР·СЂРѕР±РЅРёРєСѓ К•вЂўМЃбґҐвЂўМЂК”гЃЈ'
    payload = 'new_donate'
    currency = 'XTR'
    prices = ['Donates', 10]
    await bot.send_pay(user_id, title, description, payload, currency, prices, in_support=False)

@bot.pay_pre(currency="XTR", prices=[10, 20])
async def handle_xtr_payment(query_data):
    await bot.ok_pay(query_data)

@bot.successful_payment(currency="XTR", prices=[10, 20])
async def handle_successful_xtr_payment(payment_data):
    chat_id = payment_data.chat_id
    await bot.send_message(chat_id,
                f"""Р”СЏРєСѓСЋ Р·Р° РєСЂСѓР¶РµС‡РєСѓ РєР°РІРё, С‚РµРїРµСЂ РЅР° Сѓ РјРµРЅРµ РЅР° РѕРґРЅСѓ РєСЂСѓР¶РєСѓ Р±С–Р»СЊС€Рµ!
              пј€гЃЈпјѕв–їпјѕпј‰\nб•™(^в–ї^-б•™) {payment_data.total_amount}{payment_data.currency}""")

if __name__ == "__main__":
    asyncio.run(bot.run_polling())
```


## Links
[Telegram Chat](https://t.me/Flastele)     
[PyPI](https://pypi.org/project/Flastel/)   
[Wiki](https://github.com/DepyXa/Flastel/wiki)


## Support

For support, email gosdepyxa@gmail.com.