semvec/pypi-packages huggingface dataset:
sqlalchemy-mutablesoup 0.0.9
Mutable BeautifulSoup database type
Requires Python: >=3.6

SQLAlchemy-MutableSoup defines a mutable [BeautifulSoup](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) [SQLAlchemy](https://www.sqlalchemy.org/) database type.

## Installation

```
$ pip install sqlalchemy-mutablesoup
```

## Quickstart

```python
from sqlalchemy_mutablesoup import MutableSoupType

from sqlalchemy import Column, Integer, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, scoped_session

# standard session creation
engine = create_engine('sqlite:///:memory:')
session_factory = sessionmaker(bind=engine)
Session = scoped_session(session_factory)
session = Session()
Base = declarative_base()

# define and instantiate a model with a MutableSoupType column.
class Model(Base):
    __tablename__ = 'model'
    id = Column(Integer, primary_key=True)
    soup = Column(MutableSoupType)

Base.metadata.create_all(engine)

model = Model()
session.add(model)
```

You can now treat `model.soup` as a `bs4.BeautifulSoup` object.

## Citation

```
@software{bowen2020sqlalchemy-mutablesoup,
  author = {Dillon Bowen},
  title = {SQLAlchemy-MutableSoup},
  url = {https://dsbowen.github.io/sqlalchemy-mutablesoup/},
  date = {2020-06-04},
}
```

## License

Users must cite this package in any publications which use it.

It is licensed with the MIT [License](https://github.com/dsbowen/sqlalchemy-mutablesoup/blob/master/LICENSE).
dependency-fixer 1.0.2
A simple inscript multi-package installer
Requires Python: >=3.5
Keywords: dependencyfixer,dependencyhandler,dependency-fixer

# dependencyfixer

A python dependency fixer and importable script function

This python script can work as a standalone python module installer and can be used to install modules in program runtime by importing the **fix** function from dependencyfixer into program.

>uses `pip._internal.cli.main.main()` function to install

## #pros of using this package
* Standalone installing script
* Can install many modules at once
* gives report of how many script left to be installed(unsuccessful attempts)

### #install

`pip install dependency-fixer`

### #usage

> **❖Direct:** *(If are using source clone)
>> 	 run **dependencyfixer.py** and follow instruction

> **❖Importing to other python scripts**
>> * ***Import it like*** :
>> `from dependencyfixer import fix`
>>>* Function and Arguements:
>>> >* Function: `fix(dep,auto=True,instantkill=False)`
>>> >* Arguements: 
>>>> >* Mandatory: `dep` ( List of all packages to be installed or checked )
>>>> >* Optional: 
➤`instantkill` ( If set `True` then stops any futher execution of script in which function is used ) ***( False by default )***
➤`auto` ( If set `False` then asks for user's consent to install packages, if user refuses, then return result=0 )  ***( True by default )***
➤`verbose` ( If set `True` then prints details in console during installation and after installation ) ***( False by default )***
>>* ***Example***:
`dep=['pillow','jupyter']`
`result,leftdep=fix(dep)`
>>>>* This function returns 2 values :
>>>> > * leftdependencies : (list of packages that couldn't be installed)
>>>> > * result {1,0,-1} 
>>>>> | 1   | :   All modules installed
>>>>> | 0   | :   No modules installed
>>>>> | -1 | :   Some modules can not be installed
aiotime 0.1.0
Test helper for controlling the asyncio event loop's internal clock
Requires Python: >=3.6
Keywords: asyncio async time sleep

# aiotime

An `asyncio` test helper that allows you to deterministically control the event loop's internal clock in your tests, affecting the behavior of the following functions:

1. `asyncio.sleep`
2. `loop.call_at`
3. `loop.call_later`

## Note about behavior

If you enter the `aiotime.FastForward` context manager (as in the `with` block in the examples below), then the `loop` supplied to its constructor will STOP triggering scheduled events, tasks or callbacks. Once you `__enter__` the context manager, you MUST call the returned object or the event loop will be stuck in time. Only when you `__exit__` the context manager will the loop return to normal behavior.

(Using the same event loop with and without `aiotime` control is not supported; there may be unexpected effects with scheduling at the margins.)

## Getting started

```python
# TODO Add to pypi
```

### Controlling `asyncio.sleep`

```python
loop = asyncio.get_event_loop()

# Try sleeping with normal loop behavior
start = dt.datetime.now()
sleep_task = asyncio.create_task(asyncio.sleep(0.25))
await sleep_task
assert dt.datetime.now() - start > dt.timedelta(seconds=0.25)

with aiotime.FastForward(loop) as ff:
    # Try fast-forwarding through the sleep
    start = dt.datetime.now()
    sleep_task = asyncio.create_task(asyncio.sleep(0.25))
    await ff(1.5)  # ff more than necessary
    await sleep_task
    assert dt.datetime.now() - start < dt.timedelta(seconds=0.05)
```

### Controlling `loop.call_later`

```python
loop = asyncio.get_event_loop()

with aiotime.FastForward(loop) as ff:
    # Try call_later() with fast-forwarding
    start = dt.datetime.now()
    event = asyncio.Event()
    def test():
        event.set()
    loop.call_later(0.25, test)
    await ff(1.5)  # ff more than necessary
    await asyncio.wait_for(event.wait(), 2)  # timeout just in case
    assert dt.datetime.now() - start < dt.timedelta(seconds=0.05)

# call_later() with normal loop behavior now, after context manager exits
start = dt.datetime.now()
event = asyncio.Event()
def test():
    event.set()
loop.call_later(0.25, test)
await asyncio.wait_for(event.wait(), 1)  # timeout just in case
assert dt.datetime.now() - start > dt.timedelta(seconds=0.25)
```