def __init__(self, tender_id, worker_defaults={}, auction_data={}):
self.tender_id = tender_id
self.auction_doc_id = tender_id
self._end_auction_event = Event()
self.tender_url = urljoin(
worker_defaults["resource_api_server"],
'/api/{0}/auctions/{1}'.format(
worker_defaults["resource_api_version"], tender_id))
if auction_data:
self.debug = True
LOGGER.setLevel(logging.DEBUG)
self._auction_data = auction_data
else:
self.debug = False
self.bids_actions = BoundedSemaphore()
self.session = RequestsSession()
self.features = {} # bw
self.worker_defaults = worker_defaults
if self.worker_defaults.get('with_document_service', False):
self.session_ds = RequestsSession()
self._bids_data = {}
self.db = Database(str(self.worker_defaults["COUCH_DATABASE"]),
session=Session(retry_delays=range(10)))
self.audit = {}
self.retries = 10
self.mapping = {}
self._bids_data = defaultdict(list)
self.has_critical_error = False
if REQUEST_QUEUE_SIZE == -1:
self.bids_queue = Queue()
else:
self.bids_queue = Queue(REQUEST_QUEUE_SIZE)
self.bidders_data = []
def __init__(self, config):
# Checking API availability
health_url = urljoin(config['resource_api_server'],
"/api/{resource_api_version}/health")
response = make_request(url=health_url.format(**config),
method="get",
retry_count=5)
if not response:
raise Exception("API can't be reached")
self.api_url = urljoin(
config['resource_api_server'],
'/api/{0}/{1}/{2}'.format(config['resource_api_version'],
config['resource_name'],
config['auction_id']))
self.api_token = config["resource_api_token"]
self.source_id = config['auction_id']
self.auction_url = config["AUCTIONS_URL"].format(
auction_id=self.source_id)
self.hash_secret = config["HASH_SECRET"]
self.with_document_service = config.get('with_document_service', False)
self.session = RequestsSession()
if config.get('with_document_service', False):
self.ds_credential['username'] = config['DOCUMENT_SERVICE'][
'username']
self.ds_credential['password'] = config['DOCUMENT_SERVICE'][
'password']
self.document_service_url = config['DOCUMENT_SERVICE']['url']
# Checking DS availability and setting session_ds attribute
request("GET", self.document_service_url, timeout=5)
self.session_ds = RequestsSession()
def session(self, base_url="http://testserver"):
"""Cached Testing HTTP client based on Requests by Kenneth Reitz."""
if self._session is None:
session = RequestsSession()
session.mount(base_url, RequestsWSGIAdapter(self))
self._session = session
return self._session
def __init__(self, client=None, timeout=None):
self.timeout = timeout
self.store = {}
if client is None:
self.client = RequestsSession()
else:
self.client = client
def send_message(chat_id: int, text: str, session: RequestsSession = RequestsSession()):
with session.get(
f'https://api.telegram.org/bot{settings.MEME}/sendMessage',
params={'chat_id': chat_id, 'text': text}
) as response:
if response.status_code != 429:
return
raise TooManyRequests(response.json()['parameters']['retry_after'])
def __init__(self, tender_id,
worker_defaults,
auction_data={},
lot_id=None):
super(Auction, self).__init__()
self.generate_request_id()
self.tender_id = tender_id
self.lot_id = lot_id
if lot_id:
self.auction_doc_id = tender_id + "_" + lot_id
else:
self.auction_doc_id = tender_id
self.tender_url = urljoin(
worker_defaults["resource_api_server"],
'/api/{0}/{1}/{2}'.format(
worker_defaults["resource_api_version"],
worker_defaults["resource_name"],
tender_id
)
)
if auction_data:
self.debug = True
LOGGER.setLevel(logging.DEBUG)
self._auction_data = auction_data
else:
self.debug = False
self._end_auction_event = Event()
self.bids_actions = BoundedSemaphore()
self.session = RequestsSession()
self.worker_defaults = worker_defaults
if self.worker_defaults.get('with_document_service', False):
self.session_ds = RequestsSession()
self._bids_data = {}
self.db = Database(str(self.worker_defaults["COUCH_DATABASE"]),
session=Session(retry_delays=range(10)))
self.audit = {}
self.retries = 10
self.bidders_count = 0
self.bidders_data = []
self.bidders_features = {}
self.bidders_coeficient = {}
self.features = None
self.mapping = {}
self.rounds_stages = []
def get_mailman_lists(
owner: Owner, sess: RequestsSession = RequestsSession()) -> List[MailList]:
"""
Query mailing lists owned by the given member or society.
"""
prefix = owner_name(owner)
resp = sess.get("https://lists.srcf.net/getlists.cgi",
params={"prefix": prefix})
return [MailList(name) for name in resp.text.splitlines()]
def test_session(self, base_url="http://testserver"):
"""
Creates a test client associated with the given a url.
The test session will be a requests session to be able to
emulate a client in the browser.
"""
session = RequestsSession()
session.mount(prefix=base_url, adapter=RequestsWSGIAdapter(self))
return session
def session(self, base_url="http://baseserver"):
"""
mount it to session object
any request will start using URL given
by prefix base_url
"""
session = RequestsSession()
session.mount(prefix=base_url, adapter=RequestWSGIAdapter(self))
return session
def main():
new_ads = []
bot = Bot(token=settings.TELEGRAM_BOT_KEY)
with RequestsSession() as session:
ads = fetch_ads(session)
if ads:
new_ads = filter_new_ads(session, ads)
if new_ads:
send_message_into_telegram(bot, new_ads)
def session(self, base_url="http://;"):
"""Testing HTTP client. Returns a Requests session object, able to send HTTP requests to the WSGI application.
:param base_url: The URL to mount the connection adaptor to.
"""
if self._session is None:
session = RequestsSession()
session.mount(base_url, RequestsWSGIAdapter(self))
self._session = session
return self._session
def test_session(self, base_url="http://localserver"):
"""
Creates a session so we can use requests whilst testing.
Any URL that starts with base_url will be passed to the adapter
:param base_url: url to use as a local test server
:return: session with a mounted WSGI adapter
:rtype: RequestsSession
"""
session = RequestsSession()
session.mount(prefix=base_url, adapter=RequestsWSGIAdapter(self))
return session
def __init__(self, config):
self.api_url = urljoin(
config['resource_api_server'],
'/api/{0}/{1}/{2}'.format(config['resource_api_version'],
config['resource_name'],
config['auction_id']))
self.api_token = config["resource_api_token"]
self.source_id = config['auction_id']
self.auction_url = config["AUCTIONS_URL"].format(
auction_id=self.source_id)
self.hash_secret = config["HASH_SECRET"]
self.with_document_service = config.get('with_document_service', False)
self.session = RequestsSession()
if config.get('with_document_service', False):
self.ds_credential['username'] = config['DOCUMENT_SERVICE'][
'username']
self.ds_credential['password'] = config['DOCUMENT_SERVICE'][
'password']
self.document_service_url = config['DOCUMENT_SERVICE']['url']
self.session_ds = RequestsSession()
def __init__(self, ansible_module):
if not HAS_REQUESTS:
ansible_module.fail_json(
msg='The "requests"'
' python library is required to use the aoscx connection type.'
)
s = RequestsSession()
connection = Connection(ansible_module._socket_path)
session_data = connection.get_session()
if session_data['success'] is False:
ansible_module.fail_json(msg="Connection Failed")
add_dict_to_cookiejar(s.cookies, session_data["cookies"])
if session_data["use_proxy"] is False:
s.proxies = {"http": None, "https": None}
self._session = dict(s=s,
url=session_data["url"],
credentials=session_data["credentials"])
def __init__(self,
tender_id,
worker_defaults={},
auction_data={},
lot_id=None,
activate=False):
super(Auction, self).__init__()
self.generate_request_id()
self.tender_id = tender_id
self.lot_id = lot_id
if lot_id:
self.auction_doc_id = tender_id + "_" + lot_id
else:
self.auction_doc_id = tender_id
self.tender_url = urljoin(
worker_defaults["TENDERS_API_URL"], '/api/{0}/tenders/{1}'.format(
worker_defaults["TENDERS_API_VERSION"], tender_id))
self.activate = activate
if auction_data:
self.debug = True
logger.setLevel(logging.DEBUG)
self._auction_data = auction_data
else:
self.debug = False
self.session = RequestsSession()
self._end_auction_event = Event()
self.bids_actions = BoundedSemaphore()
self.worker_defaults = worker_defaults
self._bids_data = {}
self.db = Database(str(self.worker_defaults["COUCH_DATABASE"]),
session=Session(retry_delays=range(10)))
self.audit = {}
self.retries = 10
self.bidders_count = 0
self.bidders_data = []
self.bidders_features = {}
self.bidders_coeficient = {}
self.features = None
self.mapping = {}
self.rounds_stages = []
def test_upload_audit_file_with_document_service(auction, db, logger, mocker):
from requests import Session as RequestsSession
auction.session_ds = RequestsSession()
auction.prepare_auction_document()
auction.get_auction_info()
res = auction.upload_audit_file_with_document_service()
assert res is None # method does not return anything
mock_session_request = mocker.patch.object(Session, 'request', autospec=True)
mock_session_request.return_value.json.return_value = {
'data': {
'id': 'UA-11111'
}
}
res = auction.upload_audit_file_with_document_service('UA-11111')
assert res == 'UA-11111'
log_strings = logger.log_capture_string.getvalue().split('\n')
assert log_strings[3] == 'Audit log not approved.'
def from_dict(config):
# type: (dict) -> Client
client = Client()
client.username = config['username']
client.password = config['password']
client.cache_name = config['cache_name']
if config['address'].startswith('http'):
address = config['address']
else:
address = 'http{}://{}'.format('s' if config['is_https'] else '',
config['address'])
client.address = address
session = RequestsSession()
if client.password:
session.auth = (client.username, client.password)
client.session = session
return client
def edit_message_reply_markup(
chat_id: int,
new_reply_markup: dict,
message_id: int = None,
inline_message_id: int = None,
session: RequestsSession = RequestsSession()
):
assert message_id is not None or inline_message_id is not None,\
'You must at least provide message_id or inline_message_id !'
params = {'chat_id': chat_id, 'reply_markup': json.dumps(new_reply_markup)}
if message_id:
params['message_id'] = message_id
else:
params['inline_message_id'] = inline_message_id
with session.get(
f'https://api.telegram.org/bot{settings.MEME}/editMessageReplyMarkup',
timeout=(settings.REQUESTS_TIMEOUT * 20),
params=params
) as response:
if response.status_code != 429:
return
raise TooManyRequests(response.json()['parameters']['retry_after'])
def session(self, base_url="http://app"):
if self._session is None:
session = RequestsSession()
session.mount(base_url, RequestsWSGIAdapter(self))
self._session = session
return self._session
def test_session(self, base_url="http://testserver") -> RequestsSession:
"""Used for Testing"""
session = RequestsSession()
session.mount(prefix=base_url, adapter=RequestsWSGIAdapter(self))
return session
def startJanus(self):
with self._janusStartStopCondition:
#Start janus command here
if self._JanusProcess and self._JanusProcess.returncode is None:
self._logger.debug('Janus was already running')
return True #already running
args = ['/opt/janus/bin/janus']
nm = networkManager()
if not nm.isOnline():
args.append('--config=/opt/janus/etc/janus/janus.cfg.local')
try:
self._JanusProcess = subprocess.Popen(args,
stdout=subprocess.PIPE)
except Exception, error:
self._logger.error("Error initiating janus process: %s" %
str(error))
self._JanusProcess = None
self.sendEventToPeers('stopConnection')
if self._JanusProcess:
self._logger.debug('Janus Starting...')
from requests import Session as RequestsSession
session = RequestsSession()
response = None
tryingCounter = 0
while response is None:
time.sleep(0.3)
try:
response = session.post(url='http://127.0.0.1:8088',
data={
"message": {
"request": 'info',
"transaction": 'ready'
}
})
except Exception, error:
self._logger.debug('Waiting for Janus initialization')
tryingCounter += 1
if tryingCounter >= 100:
self._logger.error(error)
return False
self._logger.debug('Janus Started.')
#Connect the signal for fatal errors when they happen
ready = signal('manage_fatal_error_webrtc')
ready.connect(self.closeAllSessions)
#START TIMER FOR LOST PEERS
self.peersDeadDetacher = interval(30.0, self.pingPongRounder,
None)
self.peersDeadDetacher.start()
return True
def test_session(self, base_url="http://testserver"):
session = RequestsSession()
session.mount(prefix=base_url, adapter=RequestsWSGIAdapter(self))
return session
def test_session(self, base_url=BASE_URL):
session = RequestsSession()
session.mount(prefix=base_url, adapter=RequestsWSGIAdapter(self))
return session
def session(self, base_url="http://testserver"):
if self._session is None:
session = RequestsSession()
session.mount(prefix=base_url, adapter=RequestsWSGIAdapter(self))
self._session = session
return self._session
def client(app):
session = RequestsSession()
session.mount(prefix=BASE_URL, adapter=RequestsWSGIAdapter(app))
return session
def Session():
# TODO, consider using CacheControl, or write a new
# cache tool.
# TODO, restore method signatures somehow?
return RequestsSession()
