semvec/pypi-packages huggingface dataset:
eclipse-pay 1.0.2
Manage payments on scratch automatically.
Keywords: python, scratch, scratch.mit.edu, Blockbit, LRCOIN, BB, LRC, eclipseai


# eclipse-pay

Python library for interacting with scratch currencies.

# Documentation

### Running a server

#### Run a server with password on scratch
```python
from eclipse_pay import Auth,Server

auth = Auth({
    "type": "password",
    "username": "LIZARD_OFFICIAL",
    "password": "nuh uh"
})

server = Server(
    auth=auth,
    project_id="<project id>",
)

server.run()
```

#### Run a server with session id on scratch
```python
from eclipse_pay import Auth,Server

auth = Auth({
    "type": "sessionid",
    "username": "LIZARD_OFFICIAL",
    "sessionid": "nuh uh"
})

server = Server(
    auth=auth,
    project_id="<project id>",
)

server.run()
```

#### Run a server with username on turbowarp
```python
from eclipse_pay import Auth,Server

auth = Auth({
    "type": "tw",
    "username": "LIZARD_OFFICIAL"
})

server = Server(
    auth=auth,
    project_id="<project id>",
    on_turbowarp=True
)

server.run()
```

### Adding new currencies
Create a new file in eclipse_pay/currencies (e.g. coolcoin.py):
```python

from eclipse_pay import BaseCurrency

class CoolCoin(BaseCurrency):
    @property
    def name():
        return "coolcoin" # in lowercase
    def check_transaction(sender,recipient,amount):
        """Make this function check, if *sender* sent *recipient* *amount* CoolCoins. (Usually with an API.)"""
        return True
```

And then, add your currency in eclipse_pay/\_\_init\_\_.py

```python
from currencies.lrcoin import LRCOIN
from currencies.coolcoin import CoolCoin
_CURRENCY = [
    LRCOIN,
    CoolCoin
]
```
dtintegrations 0.6.1
Disruptive Technologies Python Integrations.
Requires Python: >=3.8
Keywords: disruptive, technologies, dt, integration, api

# Disruptive Technologies Python Integrations

![build](https://github.com/disruptive-technologies/python-integrations/actions/workflows/build.yml/badge.svg)
[![codecov](https://codecov.io/gh/disruptive-technologies/python-integrations/branch/main/graph/badge.svg?token=KX0W7H6ALS)](https://codecov.io/gh/disruptive-technologies/python-integrations)

## Documentation

- [Python API Reference](https://developer.disruptive-technologies.com/api/libraries/python/)
- [Developer Documentation](https://developer.disruptive-technologies.com/docs/)

## Installation

The package can be installed through pip:

```sh
pip install --upgrade dtintegrations
```

or from source:

```sh
pip install .
```

### Requirements

- Python 3.8, 3.9, 3.10, 3.11

## Usage
Currently, the main functionality of this package is validating requests forwarded by a [Data Connector](https://developer.disruptive-technologies.com/docs/data-connectors/introduction-to-data-connector).  

The following example shows this for a [Google Cloud Function](https://cloud.google.com/functions).
```python
from dtintegrations import data_connector, provider


def endpoint(request):
    # Validate and decode the incoming request.
    payload = data_connector.HttpPush.from_provider(
        request=request,
        provider=provider.GCLOUD,
        secret='<SIGNATURE_SECRET>',
    )

    # Print the payload data.
    print(payload)

    # If all is well, return 200 response.
    return ('OK', 200)
```

## Examples
A few examples has been provided, but must be run either on a serverless platform or locally with a combination or [ngrok](https://developer.disruptive-technologies.com/docs/data-connectors/development-guides/local-development-with-ngrok) and the appropriate development framework.

## Exceptions
If a method is unsuccessful or has been provided with invalid parameters, an exception is raised. A list of available exceptions are available in the [API Reference](https://developer.disruptive-technologies.com/api/libraries/python/client/errors.html).

## Development
Set up the development virtualenv environment:
```
make
```

Run unit-tests against the currently active python version:
```
make test
```

Lint the package code using MyPy and flake8:
```
make lint
```

Build the package distribution:
```
make build
```
pyCoreWLAN 1.0.1
A Python package that provides stubs for the PyObjC CoreWLAN Wrapper.
Requires Python: >=3.6

# `pyCoreWLAN`

Provides Python stubs for the Apple [CoreWLAN](https://developer.apple.com/documentation/corewlan) framework and should be used alongside the CoreWLAN wrappers provided by [PyObjC](https://github.com/ronaldoussoren/pyobjc).
Provides code completion and docstring hints equivalent to the CoreWLAN
documentation. Intended to work with VS Code Intellisense with Pylance installed.

## Installation & Usage

Install `pyCoreWLAN` as follows:

```
pip install pyCoreWLAN
```

For use with VSCode, update the settings to include the path to the package if using a virtual environment.

```json
{
  "python.analysis.stubPath": "./.venv/lib/python3.10/site-packages/pyCoreWLAN"
}
```
fast-sqlite-python 0.0.5
Fast_sqlite is a library to use sqlite database faster and easier.
Requires Python: >=3.9

# Fast_sqlite

<b>Fast SQL</b> is a Python library to make and use a sqlite3 database. For use this library you can copy the file in your code directory and use below codes or read <b>src/example/write_and_read_data.py</b> file

# Create values to use library
```python

from fast_sql import fast_sqlite

fsql = fast_sqlite(db_name="database.db", table_name="users", attributes=["username", "email", "password"])

```

# Connect to a database

```python

fsql.connect()
# Congratulation! You have been connected :)

```

# Close connection

```python

fsql.close()
# Oh... You have been disconnected :( 
# We will work together for next time

```

# Insert data in database

```python

fsql.Insert_in(values=["admin", "admin.root@admin.com", "admin"]) # output: True/False

# This is how it save:
# --> users:
#      ________________________________________________________________
#     |                |                         |                     |
#     |    username    |          email          |       password      |
#     |________________|_________________________|_____________________|
#     |                |                         |                     |
#     |     admin      |     admin.root@ad...    |        admin        |
#     |                |                         |                     |
#     |     user1      |     user.1234@use...    |        12345        |
#     |                |                         |                     |
#     |________________|_________________________|_____________________|

```

# Select data from database

```python

#                    select "password", where username='username'
password = fsql.Select_from("password", "username", username) # output: password

```

# Use a custome command

```python

output = fsql.Custome_command("command") # output: output of your command :)
print(output)

```

# Contributes
<h3> 1.<a target="_blank" href="https://www.github.com/Unknow-per/">Unknow-per</a></h3>
consoil 0.0.1
Consolidation and Sedimentation software in Python
Requires Python: >=3.11

consoil
==========

|PyPI| |Documentation Status| |PyPI - License|

A Python package to calculate consolidation of sediment particles in soil suspensions. The code is being developed by `Ismail Myouri` 
for the MUDNET group at Delft Technical University and DELTARES, The Netherlands. 
The **consoil** package can be used under the conditions of the GPLv3 license.

Features
--------

* Basic classes for sedimentation.


Installation
------------

To use the package `consoil`, install it in a Python environment:

.. code-block:: console

    (env) pip install consoil

or

.. code-block:: console

    (env) conda install consoil

This should
automatically install the dependency packages ``matplotlib`` , ``scipy``
and ``pandas``, if they haven't been installed already. If you are
installing by hand, ensure that these packages are installed as well.

Example use
-----------

.. code:: python

   import numpy as np

   from consoil.constants import *
   from consoil import *

   import matplotlib
   import matplotlib.pyplot as plt
   from pathlib import Path

   matplotlib.use("Qt5Agg")
   DATADIR = Path(__file__).parent


consoil pages
----------------

-  `PyPi <https://pypi.org/project/consoil/>`__: consoil Python package
-  `BitBucket <https://bitbucket.org/deltares/consoil/>`__: consoil source code
-  `ReadTheDocs <https://consoil.readthedocs.io/>`__: consoil documentation

Author and license
------------------

-  Author: Ismail Myouri
-  Contact: i.myouri@tudelft.nl
-  License: `GPLv3 <https://www.gnu.org/licenses/gpl.html>`__

References
----------

-  ...

.. |PyPi| image:: https://img.shields.io/pypi/v/consoil
   :alt: PyPI

.. |PyPI - Downloads| image:: https://img.shields.io/pypi/dm/consoil
   :alt: PyPI - Downloads

.. |PyPi Status| image:: https://img.shields.io/pypi/status/consoil
   :alt: PyPI - Status

.. |Documentation Status| image:: https://readthedocs.org/projects/dielectric/badge/?version=latest
   :target: https://edumud.readthedocs.io/en/latest/?badge=latest

.. |PyPI - License| image:: https://img.shields.io/pypi/l/consoil
   :alt: PyPI - License
git-time-tracking 0.0.2
This is a small frontend, which is supposed to help with time tracking using git.
Requires Python: >=3.8

# Git Time Tracking

This is a tool, allowing you to view the commits you have made in a set of repositories. This is useful if you need to write down your times for work.

## Installation

You can install the program by using pip:

```bash
pip install git-time-tracking
```

> Make sure nano is installed on your system, as it is used for editing the config file.

## Usage

You can see all the cli options by running:

```bash
git_time_tracking --help
```

The first time running the program, you will be thrown into `nano` (has to be installed). Here you can specify the repositories you want to track, and some other settings.
elephant-parsel 1.2.1
wrapper for PostgreSQL queries with transaction and connection pooling support
Requires Python: >=3.7

# elephant_parsel
 wrapper for PostgreSQL queries with transaction and connection pooling support 

This project is about making [psycopg2](https://www.psycopg.org/) easier to use.

## supported versions
Debian >=10, psycopg2 >=2.7, python >=3.7

## installation

install using [pipenv](https://pipenv.pypa.io/en/latest/):
```bash
pipenv install elephant_parsel
```

## basic usage

```python3
from elephant_parsel.postgres_db import PostgresDB, PostgresDBException
import logging
db = PostgresDB(connection_config=dict(
    host='db.example.com',
    port=5432,
    dbname='the_database_name',
    user='the_username',
    password='****',
    minconn=1,
    maxconn=4
  ), logger=logging.getLogger(), connect=True, register_hstore=False)

server_version_string = db.query_one('select version()', None, column='version')
```
The `connection_config` is used as kwargs for the `psycopg2.ThreadedConnectionPool`, so it should support all libpq connection variables: https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PARAMKEYWORDS

API docs: https://elephant-parsel.readthedocs.io/en/latest/