async def foo():
  print(1)
  await one()
  print(2)
  await two()
  print(3)

await asyncio.wait([foo(), foo(), foo()])

1
2
3
1
2
3
1
2
3

m["ReceivedTimestamp"] = time.Now().UTC()

from pymongo import MongoClient
import datetime

r = next(collection.find(...).sort(...).limit(1))
dt: datetime.datetime = r['ReceivedTimestamp']
print(dt, dt.timestamp())

2018-01-19 07:06:43.453000 1516334803.453

>>> needed    sym /lib32/libm.so.6
>>> needed    obj /lib32/libpthread-2.26.so
>>> needed    sym /lib32/libpthread.so.0
>>> needed    obj /lib32/librt-2.26.so
>>> needed    sym /lib32/librt.so.1
>>> Safely unmerging already-installed instance...
[Errno 80] Accessing a corrupted shared library: b'/bin/bash':
   /bin/bash -c /usr/lib/portage/python3.6/ebuild.sh clean
Traceback (most recent call last):
  File "/usr/lib64/python3.6/site-packages/portage/dbapi/vartree.py", line 2127, in unmerge
    preserve_paths=preserve_paths)
  File "/usr/lib64/python3.6/site-packages/portage/dbapi/vartree.py", line 1935, in _prune_plib_registry
    include_file=needed, preserve_paths=preserve_paths)
  File "/usr/lib64/python3.6/site-packages/portage/dbapi/vartree.py", line 3074, in _linkmap_rebuild
    self.vartree.dbapi._linkmap.rebuild(**kwargs)
  File "/usr/lib64/python3.6/site-packages/portage/util/_dyn_libs/LinkageMapELF.py", line 275, in rebuild
    proc = subprocess.Popen(args, stdout=subprocess.PIPE)
  File "/usr/lib64/python3.6/subprocess.py", line 709, in __init__
    restore_signals, start_new_session)
  File "/usr/lib64/python3.6/subprocess.py", line 1344, in _execute_child
    raise child_exception_type(errno_num, err_msg, err_filename)
OSError: [Errno 80] Accessing a corrupted shared library: '/usr/bin/scanelf'

During handling of the above exception, another exception occurred:

└─[127] <> uname
zsh: accessing a corrupted shared library: uname

/usr/bin/eix-sync: line 22: ReadFunctions: command not found
/usr/bin/eix-sync: line 24: ReadVar: command not found
/usr/bin/eix-sync: line 25: ReadVar: command not found
/usr/bin/eix-sync: line 26: ReadVar: command not found
/usr/bin/eix-sync: line 27: ReadVar: command not found
/usr/bin/eix-sync: line 28: local_portage_configroot: unbound variable

def eventFilter(self, obj: QObject, event: QEvent):
    if event.type() == QEvent.Drop:
         event: QDropEvent = event
         print(event.pos())

running register
running check
Registering dfclean to https://upload.pypi.org/legacy/
Server response (500): <urlopen error [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:720)>

from distutils.core import setup

with open('README.md') as file:
    long_description = file.read()

setup(
    name='dfclean',
    version='0.0.0.1',
    packages=['dfclean'],
    url='https://gitlab.com/panter_dsd/distfilescleaner',
    license='GPLv3',
    author='PanteR',
    author_email='panter.dsd@gmail.com',
    description='Clean up old distfiles in Gentoo',
    long_description=long_description,
    classifiers=[
        'Development Status :: 3 - Alpha',
        'Programming Language :: Python :: 4.6',
    ]
)

cat ~/.pypirc
[distutils]
index-servers = pypi

[pypi]
repository=https://pypi.python.org/pypi
username=panter_dsd
password=*********

[server-login]
username:panter_dsd
password:*********

sudo pip install twine
ERROR: (Gentoo) Please run pip with the --user option to avoid breaking python-exec

class Request(object):
    def __init__(self, url: str, host: str, port: int, session: ClientSession, data: bytes,
                 ids_to_remove: list, callback):
        super().__init__()

        self.__url = url
        self.__host = host
        self.__port = port
        self.__session = session
        self.__data = data
        self.__ids_to_remove = ids_to_remove
        self.__callback = callback

    async def send(self):
        try:
            async with self.__session.post('http://{}:{}{}'.format(self.__host, self.__port, self.__url),
                                           data=self.__data) as r:

                if r.status == int(HTTPStatus.OK):
                    await self.__callback(self.__ids_to_remove)
        except Exception as e:
            print(e)

    def ids_to_remove(self):
        return self.__ids_to_remove


class ConnectionsPool(object):
    def __init__(self, host: str, port: int, max_connections: int, remove_ids_callback):
        super().__init__()

        self.__max_connections = max_connections

        self.__host = host
        self.__port = port
        self.__remove_ids_callback = remove_ids_callback

        self.__sending_futures = []
        self.__session = ClientSession(connector=TCPConnector(verify_ssl=False, limit=max_connections))

    async def send(self, url: str, data: bytes, ids_to_remove: List):
        if len(self.__sending_futures) > self.__max_connections:
            await asyncio.wait(self.__sending_futures, return_when=asyncio.FIRST_COMPLETED)

        request = Request(url, self.__host, self.__port, self.__session, data, ids_to_remove,
                          self.__remove_ids_callback)
        future = asyncio.ensure_future(request.send())
        future.request = request
        future.add_done_callback(self.future_done)
        self.__sending_futures.append(future)

    def future_done(self, future):
        self.__sending_futures.remove(future)

    def ids_to_remove(self):
        result = []
        for f in self.__sending_futures:
            result += f.request.ids_to_remove()
        return result

root: 'Task' object has no attribute 'ids_to_remove' (abstract_retranslator.py:31)
Traceback (most recent call last):
  File "/srv/backend/common/retranslation/abstract_retranslator.py", line 29, in retranslate
    await self._retranslate()
  File "/srv/backend/common/retranslation/http_retranslator.py", line 135, in _retranslate
    async for event in self.events(connections_pool.ids_to_remove()):
  File "/srv/backend/common/retranslation/http_retranslator.py", line 70, in ids_to_remove
    result += f.request.ids_to_remove()
AttributeError: 'Task' object has no attribute 'ids_to_remove'

from aiohttp import ClientSession

async def post(semaphore: asyncio.Semaphore, session: ClientSession, url: str, data: str):
    async with semaphore:
        try:
            async with session.post(url, data=data) as r:
                response_data = await r.read()

                class Response(object):
                    def __init__(self, status_code, text):
                        self.status_code = status_code
                        self.text = text

                return Response(r.status, response_data.decode('utf-8'))
        except Exception as e:
            print(e)
            return None


...................................
async with ClientSession() as session:
    semaphore = asyncio.Semaphore(256)
    coros = [post(semaphore, session, r[0], r[1]) for r in requests]
    requests = await asyncio.gather(*coros)