def __init__(self, atac_api_key):
self.atac_api_key = atac_api_key
atac_api = "http://muovi.roma.it/ws/xml/"
self.servers = {
"auth": Server(urljoin(atac_api, "autenticazione/" + "1")),
"paline": Server(urljoin(atac_api, "paline/" + "7")),
"percorso": Server(urljoin(atac_api, "percorso/" + "2"))
}
self.server_resp_codes = {"expired_session": 824, "unknown_percorso": 807,
"unknown_palina": 803, "linea_inesistente": 804}
self.__update_token()
self.generic_error = BotResponse(False,
"Ho incontrato un errore :pensive: forse atac "
"non è online al momento :worried:. Riprova fra poco!")
def _connect(self):
if not self.conn:
self.conn = Server(self.cobbler_host, allow_none=True)
self.token = None
if self.cobbler_username is not None:
self.token = self.conn.login(self.cobbler_username,
self.cobbler_password)
def gnuradio_stop_graph(gr_host="localhost", gr_port=8080):
try:
from xmlrpc.client import Server
from xmlrpc.client import Fault
except ImportError:
print("xmlrpc is needed to call 'gnuradio_stop_graph'")
else:
s = Server(f"http://{gr_host}:{gr_port}")
s.stop()
s.wait()
def make_pypi_client(url):
http_proxy_url = urllib.getproxies().get("http", "")
if http_proxy_url:
http_proxy_spec = urllib.splithost(
urllib.splittype(http_proxy_url)[1])[0]
transport = ProxiedTransport()
transport.set_proxy(http_proxy_spec)
else:
transport = None
return Server(url, transport=transport)
def __init__(self, host):
"""
Args:
host (str): URL to your archiver's ArchiveDataServer.cgi. Will
look something like: http://cr01arc01/cgi-bin/ArchiveDataServer.cgi
"""
super(Archiver, self).__init__()
self.server = Server(host)
self.archiver = self.server.archiver
self.archives_for_channel = defaultdict(list)
def gnuradio_start_graph(gr_host="localhost", gr_port=8080):
try:
from xmlrpc.client import Server
from xmlrpc.client import Fault
except ImportError:
print("xmlrpclib is needed to call 'gnuradio_start_graph'")
else:
s = Server(f"http://{gr_host}:{gr_port}")
try:
s.start()
except Fault as e:
print(f"ERROR: {e.faultString}")
def find_updates(pkgset, stable_only=True):
no_releases = set()
def write(s):
sys.stdout.write(s)
sys.stdout.flush()
pypi = Server("http://pypi.python.org/pypi/")
pkgname2latest = {}
pkgfiles = [pkgfile(x) for x in pkgset.find_packages()]
for x in pkgfiles:
if x.pkgname not in pkgname2latest:
pkgname2latest[x.pkgname] = x
elif x.version_info > pkgname2latest[x.pkgname].version_info:
pkgname2latest[x.pkgname] = x
need_update = []
sys.stdout.write("checking %s packages for newer version\n" % len(pkgname2latest),)
for count, (pkgname, file) in enumerate(pkgname2latest.items()):
if count % 40 == 0:
write("\n")
releases = pypi.package_releases(pkgname)
releases = [(parse_version(x), x) for x in releases]
if stable_only:
releases = filter_stable_releases(releases)
status = "."
if releases:
m = max(releases)
if m[0] > file.version_info:
file.latest_version = m[1]
status = "u"
# print "%s needs update from %s to %s" % (pkgname, file.version, m[1])
need_update.append(file)
else:
no_releases.add(pkgname)
status = "e"
write(status)
write("\n\n")
no_releases = list(no_releases)
if no_releases:
no_releases.sort()
sys.stdout.write("no releases found on pypi for %s\n\n" % (", ".join(no_releases),))
return need_update
def gnuradio_set_vars(gr_host=IP_TX_MACHINE, gr_port=PORT_TX_MACHINE_VAR, **kwargs):
try:
from xmlrpc.client import Server
from xmlrpc.client import Fault
except ImportError:
print("xmlrpc is needed to call 'gnuradio_set_vars'")
else:
s = Server("http://{}:{}".format(gr_host, gr_port))
for k, v in kwargs.items():
try:
getattr(s, "set_{}".format(k))(v)
except Fault:
print("Unknown variable '{}'".format(k))
s = None
def gnuradio_set_vars(gr_host="localhost", gr_port=8080, **kwargs):
if not kwargs:
return
try:
from xmlrpc.client import Server
from xmlrpc.client import Fault
except ImportError:
print("xmlrpc is needed to call 'gnuradio_set_vars'")
else:
s = Server(f"http://{gr_host}:{gr_port}")
for k, v in kwargs.items():
try:
getattr(s, f"set_{k}")(v)
except Fault:
print(f"Unknown variable '{k}'")
s = None
def latest_release(package):
"""Retrieve latest released data."""
url = 'http://pypi.python.org/pypi'
LOGGER.info("Connecting to '{0:s}'.".format(url))
if _PY3K:
from xmlrpc.client import Server
else:
from xmlrpclib import Server
pypi = Server(url)
show_hidden = False
releases = pypi.package_releases(package, show_hidden)
for release in releases:
urls = pypi.release_urls(package, release)
return urls
def create_jdbc_driver_with_all_jars(server_proxy: str,
path_to_the_jars_folder: str,
jdbc_name: str, jdbc_main_class: str,
jdbc_prefix: str):
srv = Server(server_proxy, context=ssl._create_unverified_context())
jdbc_name = srv.addJDBCDriver({
'comment': '',
'jdbc_main': jdbc_main_class,
'jdbc_name': jdbc_name,
'jdbc_prefix': jdbc_prefix
})
jdbc = getattr(srv, jdbc_name)
for filename in glob.glob(os.path.join(path_to_the_jars_folder, '*.jar')):
jar = open(filename, "rb")
read = jar.read()
jdbc.uploadFile(Binary(read), os.path.basename(filename))
print("Uploaded successfully.")
def load_stock_price_from_rpc_server(server_port, trade_date, stock_ticker):
server = Server('http://localhost:{}'.format(server_port))
while True:
try:
stock_data = server.load_stock_price(trade_date.strftime('%Y%m%d'),
stock_ticker)
except ConnectionResetError:
time.sleep(0.1)
else:
break
data_df = pd.read_json(stock_data, orient='records', date_unit='s')
if data_df.empty:
return {}
else:
return data_df.loc[0].to_dict()
def gnuradio_get_vars(*args, **kwargs):
if "gr_host" not in kwargs:
kwargs["gr_host"] = "127.0.0.1"
if "gr_port" not in kwargs:
kwargs["gr_port"] = 8080
rv = {}
try:
from xmlrpc.client import Server
from xmlrpc.client import Fault
except ImportError:
print("xmlrpc is needed to call 'gnuradio_get_vars'")
else:
s = Server(f"http://{kwargs['gr_host']}:{kwargs['gr_port']}")
for v in args:
try:
res = getattr(s, f"get_{v}")()
rv[v] = res
except Fault:
print(f"Unknown variable '{v}'")
s = None
if len(args) == 1:
return rv[args[0]]
return rv
def gnuradio_get_vars(*args, **kwargs):
if "gr_host" not in kwargs:
kwargs["gr_host"] = IP_TX_MACHINE
if "gr_port" not in kwargs:
kwargs["gr_port"] = PORT_TX_MACHINE_VAR
rv = {}
try:
from xmlrpc.client import Server
from xmlrpc.client import Fault
except ImportError:
print("xmlrpc is needed to call 'gnuradio_get_vars'")
else:
s = Server("http://{}:{}".format(kwargs["gr_host"], kwargs["gr_port"]))
for v in args:
try:
res = getattr(s, "get_{}".format(v))()
rv[v] = res
except Fault:
print("Unknown variable '{}'".format(v))
s = None
if len(args) == 1:
return rv[args[0]]
return rv
def lambda_handler(event, context):
"""
Input:
event: {
'body': {
'id_palina': id_palina,
'token': authentication_token
}
}
"""
body = event['body']
print('Request for palina {}'.format(body['id_palina']))
server = Server(os.environ['PALINA_URL'], use_builtin_types=True)
ts = datetime.datetime.utcnow()
try:
res = server.paline.Previsioni(body['token'], body['id_palina'], 'it')
except Fault as err:
if err.faultCode == 803:
return invalid_palina(err)
else:
raise
arrival.process(res, ts)
return {'statusCode': 200, 'body': 'DONE'}
def lambda_handler(event, context):
id_palina_list = get_id_palina_list()
s1 = Server(os.environ['ATAC_AUTH_URL'], use_builtin_types=True)
token = s1.autenticazione.Accedi(os.environ['ATAC_DEV_KEY'], os.environ['ATAC_ID_UTENTE'])
client = boto3.client('lambda')
for id_palina in id_palina_list:
client.invoke(
FunctionName="palinaRequest",
InvocationType='Event',
Payload=json.dumps(
{
'body': {
'id_palina': id_palina,
'token': token
}
}
)
)
return {
'statusCode': 200,
'body': json.dumps('DONE')
}
def check_for_updates():
"""
Check and return available updates.
Honour the frequency of update checking unless force is True.
Return list of pair (version, description),
where description is an html-formatted text.
Raise an exception if anything goes wrong.
"""
if (force or preferences.updateLastCheck is None
or datetime.datetime.now() > preferences.updateLastCheck +
datetime.timedelta(days=preferences.updateFrequency)):
tr = RequestsTransport()
s = Server(preferences.updateUrl, transport=tr)
# method returns a dictionary with those keys:
# 'new_url': if defined, new url of the webservice
# 'updates': list of 3-tuples (version, description, downloadUrl)
u = s.checkForUpdates(
glb.VERSION,
preferences.updateFrequency,
platform.system(),
platform.architecture(),
platform.platform(),
platform.python_version(),
wx.version(),
i18n.getLang(),
)
u2 = [
x for x in u['updates']
if x[0] not in preferences.ignoredUpdates
]
preferences.updateLastCheck = datetime.datetime.now()
if 'new_url' in u:
preferences.updateUrl = u['new_url']
return u2
return []
import os
import sys
from os import path
from xmlrpc.client import Server
from virtualenv import create_bootstrap_script
from application import create_bootstrap_script
from flask_script import Manager, Server
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),'..')))
app = create_app()
manager = Manager(app)
manager.add_command("runserver", Server(
use_debugger = True,
use_reloader = True,
host = os.getenv('IP', '0.0.0.0'),
port = int(os.getenv('PORT', 5000)))
)
if __name__ == "__main"
import os
import sys
from os import path
from xmlrpc.client import Server
from virtualenv import create_bootstrap_script
from application import create_bootstrap_script
from flask_script import Manager, Server
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),'..')))
app = create_app()
manager = Manager(app)
manager.add_command("runserver", Server()
use_debugger = True,
use_reloader = True,
host = os.getenv('IP', '0.0.0.0'),
port = int(os.getenv('PORT', 5000)))
)
import os
import sys
from os import path
from xmlrpc.client import Server
from virtualenv import create_bootstrap_script
from application import create_bootstrap_script
from flask_script import Manager, Server
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),'..')))
app = create_app()
manager = Manager(app)
manager.add_command("runserver", Server(
use_debugger = True,
use_reloader = True,
host = os.getenv('IP', '0.0.0.0'),DS
port = int(os.getenv('PORT', 5000)))
)
import os
import sys
from os import path
from xmlrpc.client import Server
from virtualenv import create_bootstrap_script
from application import create_bootstrap_script
from flask_script import Manager, Server
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
app = create_app()
manager = Manager(app)
manager.add_command(
"runserver",
Server(use_debugger=True,
use_reloader=True,
host=os.getenv('IP', '0.0.0.0'),
port=int(os.getenv('PORT', 5000))))
if __name__ == "__main__":
manager.run()
# testing xmlrpc finger
try:
# Python 3
from xmlrpc.client import Server
except ImportError:
# Python 2
from xmlrpclib import Server
server = Server("http://127.0.0.1:8000/RPC2")
print(server.getUser("moshez"))
def setUp(self):
s1 = Server(os.environ['ATAC_AUTH_URL'], use_builtin_types=True)
self.token = s1.autenticazione.Accedi(os.environ['ATAC_DEV_KEY'],
os.environ['ATAC_ID_UTENTE'])
self.event = {'body': {'token': self.token, 'id_palina': '10037'}}
self.context = None
def __init__(self):
self.rpc = Server(config.get('api.url'), allow_none=True)
self.key = config.get('api.key')
def login(self, user, password):
self.server = Server(self.generic.url + '/rpc/xmlrpc')
self.token = self.server.confluence1.login(user, password)
assert self.token is not None, 'Login failed'
return self.token
def make_pypi_client(url):
return Server(url)
# testing xmlrpc finger
try:
# Python 3
from xmlrpc.client import Server
except ImportError:
# Python 2
from xmlrpclib import Server
server = Server('http://127.0.0.1:8000/RPC2')
print(server.getUser('moshez'))