def __init__(self, host: str = 'localhost', port: int = 8080, path: str = '/', realm: str = 'default', *, reconnect_delay: int = 5, max_reconnection_attempts: int = None, registry: Union[WAMPRegistry, str] = None, ssl: Union[bool, str, SSLContext] = False, serializer: Union[Serializer, str] = None, auth_method: str = 'anonymous', auth_id: str = None, auth_secret: str = None): """ The following parameters are also available as instance attributes: :param host: host address of the WAMP router :param port: port to connect to :param path: HTTP path on the router :param realm: the WAMP realm to join the application session to (defaults to the resource name if not specified) :param reconnect_delay: delay between connection attempts (in seconds) :param max_reconnection_attempts: maximum number of connection attempts before giving up :param registry: a WAMP registry or a string reference to one (defaults to creating a new instance if omitted) :param ssl: one of the following: * ``False`` to disable SSL * ``True`` to enable SSL using the default context * an :class:`ssl.SSLContext` instance * a ``module:varname`` reference to an :class:`~ssl.SSLContext` instance * name of an :class:`ssl.SSLContext` resource :param serializer: a serializer instance or the name of a :class:`asphalt.serialization.api.Serializer` resource (defaults to creating a new :class:`~asphalt.serialization.json.JSONSerializer` if omitted) :param auth_method: authentication method to use (valid values are currently ``anonymous``, ``wampcra`` and ``ticket``) :param auth_id: authentication ID (username) :param auth_secret: secret to use for authentication (ticket or password) """ assert check_argument_types() self.host = host self.port = port self.path = path self.reconnect_delay = reconnect_delay self.max_reconnection_attempts = max_reconnection_attempts self.realm = realm self.registry = resolve_reference(registry) or WAMPRegistry() self.ssl = resolve_reference(ssl) self.serializer = resolve_reference(serializer) or JSONSerializer() self.auth_method = auth_method self.auth_id = auth_id self.auth_secret = auth_secret self._context = None self._session = None # type: AsphaltSession self._session_details = None # type: SessionDetails self._connect_task = None # type: Task
def __init__( self, *, url: str | URL | dict[str, Any] | None = None, bind: Connection | Engine | AsyncConnection | AsyncEngine | None = None, engine_args: dict[str, Any] | None = None, session_args: dict[str, Any] | None = None, commit_executor_workers: int = 5, ready_callback: Callable[[Engine, sessionmaker], Any] | str | None = None, poolclass: str | type[Pool] | None = None, resource_name: str = "default", ): self.resource_name = resource_name self.commit_executor_workers = commit_executor_workers self.ready_callback = resolve_reference(ready_callback) engine_args = engine_args or {} session_args = session_args or {} session_args["expire_on_commit"] = False session_args["future"] = True if bind: self.bind = bind self.engine = cast("Engine | AsyncEngine", bind.engine) else: if isinstance(url, dict): url = URL.create(**url) elif isinstance(url, str): url = make_url(url) elif url is None: raise TypeError('both "url" and "bind" cannot be None') # This is a hack to get SQLite to play nice with asphalt-sqlalchemy's # juggling of connections between multiple threads. The same connection # should, however, never be used in multiple threads at once. if url.get_dialect().name == "sqlite": connect_args = engine_args.setdefault("connect_args", {}) connect_args.setdefault("check_same_thread", False) if isinstance(poolclass, str): poolclass = resolve_reference(poolclass) pool_class = cast("type[Pool]", poolclass) try: self.engine = self.bind = create_async_engine( url, poolclass=pool_class, **engine_args) except InvalidRequestError: self.engine = self.bind = create_engine(url, poolclass=pool_class, **engine_args) if url.get_dialect().name == "sqlite": apply_sqlite_hacks(self.engine) if isinstance(self.engine, AsyncEngine): session_args.setdefault("class_", AsyncSession) self.sessionmaker = sessionmaker(bind=self.bind, **session_args)
def __init__(self, app, ip: str = "127.0.0.1", port: int = 4444, **cfg): from kyoukai.app import Kyoukai if not isinstance(app, Kyoukai): app = resolve_reference(app) #: The application object for a this component. self.app = app #: The IP address to boot the server on. self.ip = ip #: The port to boot the server on. self.port = port #: The config file to use. self.cfg = cfg #: The :class:`asyncio.Server` instance that is serving us today. self.server = None #: The base context for this server. self.base_context = None # type: Context #: The backend to use for the HTTP server. self.backend = self.cfg.get("backend", "kyoukai.backends.httptools_") self.logger = logging.getLogger("Kyoukai") self._server_name = app.server_name or socket.getfqdn()
def __init__(self, encoder_options: Dict[str, Any] = None, decoder_options: Dict[str, Any] = None, custom_type_codec: Union[CBORTypeCodec, str] = None) -> None: assert check_argument_types() super().__init__(resolve_reference(custom_type_codec) or CBORTypeCodec()) self.encoder_options = encoder_options or {} self.decoder_options = decoder_options or {}
def __init__(self, encoder_options: Dict[str, Any] = None, decoder_options: Dict[str, Any] = None, custom_type_codec: Union[CBORTypeCodec, str] = None): assert check_argument_types() super().__init__(resolve_reference(custom_type_codec) or CBORTypeCodec()) self.encoder_options = encoder_options or {} self.decoder_options = decoder_options or {}
def __init__(self, encoder_options: Dict[str, Any] = None, decoder_options: Dict[str, Any] = None, encoding: str = 'utf-8', custom_type_codec: Union[JSONTypeCodec, str] = None): assert check_argument_types() super().__init__(resolve_reference(custom_type_codec) or JSONTypeCodec()) self.encoding = encoding self.encoder_options = encoder_options or {} self.encoder_options['default'] = resolve_reference(self.encoder_options.get('default')) self._encoder = JSONEncoder(**self.encoder_options) self.decoder_options = decoder_options or {} self.decoder_options['object_hook'] = resolve_reference( self.decoder_options.get('object_hook')) self.decoder_options['object_pairs_hook'] = resolve_reference( self.decoder_options.get('object_pairs_hook')) self._decoder = JSONDecoder(**self.decoder_options)
def __init__(self, encoder_options: Dict[str, Any] = None, decoder_options: Dict[str, Any] = None, encoding: str = 'utf-8', custom_type_codec: Union[JSONTypeCodec, str] = None) -> None: assert check_argument_types() super().__init__(resolve_reference(custom_type_codec) or JSONTypeCodec()) self.encoding = encoding self.encoder_options = encoder_options or {} self.encoder_options['default'] = resolve_reference(self.encoder_options.get('default')) self._encoder = JSONEncoder(**self.encoder_options) self.decoder_options = decoder_options or {} self.decoder_options['object_hook'] = resolve_reference( self.decoder_options.get('object_hook')) self.decoder_options['object_pairs_hook'] = resolve_reference( self.decoder_options.get('object_pairs_hook')) self._decoder = JSONDecoder(**self.decoder_options)
def configure_engine(cls, url: Union[str, URL, Dict[str, Any]] = None, bind: Union[Connection, Engine] = None, session: Dict[str, Any] = None, ready_callback: Union[Callable[[Engine, sessionmaker], Any], str] = None, poolclass: Union[str, Pool] = None, **engine_args): """ Create an engine and selectively apply certain hacks to make it Asphalt friendly. :param url: the connection url passed to :func:`~sqlalchemy.create_engine` (can also be a dictionary of :class:`~sqlalchemy.engine.url.URL` keyword arguments) :param bind: a connection or engine to use instead of creating a new engine :param session: keyword arguments to :class:`~sqlalchemy.orm.session.sessionmaker` :param ready_callback: callable (or a ``module:varname`` reference to one) called with two arguments: the Engine and the sessionmaker when the component is started but before the resources are added to the context :param poolclass: the SQLAlchemy Pool class to use; passed to :func:`~sqlalchemy.create_engine` :param engine_args: keyword arguments passed to :func:`~sqlalchemy.create_engine` """ assert check_argument_types() if bind is None: if isinstance(url, dict): url = URL(**url) elif isinstance(url, str): url = make_url(url) elif url is None: raise TypeError('both "url" and "bind" cannot be None') if isinstance(poolclass, str): poolclass = resolve_reference(poolclass) # This is a hack to get SQLite to play nice with asphalt-sqlalchemy's juggling of # connections between multiple threads. The same connection should, however, never be # used in multiple threads at once. if url.get_dialect().name == 'sqlite': connect_args = engine_args.setdefault('connect_args', {}) connect_args.setdefault('check_same_thread', False) bind = create_engine(url, poolclass=poolclass, **engine_args) session = session or {} session.setdefault('expire_on_commit', False) ready_callback = resolve_reference(ready_callback) return bind, sessionmaker(bind, **session), ready_callback
def __init__(self, packer_options: Dict[str, Any] = None, unpacker_options: Dict[str, Any] = None, custom_type_codec: Union[MsgpackTypeCodec, str] = None): assert check_argument_types() super().__init__( resolve_reference(custom_type_codec) or MsgpackTypeCodec()) self.packer_options = packer_options or {} self.packer_options.setdefault('use_bin_type', True) self.unpacker_options = unpacker_options or {} self.unpacker_options.setdefault('encoding', 'utf-8')
def __init__(self, environment: Union[Environment, Dict[str, Any]] = None, loader_class: Union[type, str] = PackageLoader, **loader_args): assert check_argument_types() if environment is None: environment = {} if isinstance(environment, dict): environment = Environment(**environment) self.environment = environment if self.environment.loader is None: loader_class = resolve_reference(loader_class) self.environment.loader = loader_class(**loader_args)
def __init__(self, app: Union[str, Kyoukai], ip: str = '0.0.0.0', port: int = 4444, **cfg): assert check_argument_types() if not isinstance(app, Kyoukai): self.app = resolve_reference(app) else: self.app = app self.ip = ip self.port = port self._extra_cfg = cfg # Reconfigure the app with the extra config. self.app.reconfigure(**self._extra_cfg) self.server = None
def __init__( self, environment: Environment | dict[str, Any] = None, loader_class: type | str = PackageLoader, **loader_args, ) -> None: if environment is None: environment = {} if isinstance(environment, dict): environment = Environment(**environment) self.environment = environment if self.environment.loader is None: resolved_loader_class = resolve_reference(loader_class) self.environment.loader = resolved_loader_class(**loader_args)
def __init__(self, router: Union[Router, str], host: Union[str, Sequence[str]] = None, port: int = 8888, socket_path: Union[str, Path] = None, backlog: int = 100, external_host: str = None, external_port: int = None, external_prefix: str = None): assert check_argument_types() self.router = resolve_reference(router) # type: Router self.host = host if isinstance(host, str) else tuple(host) self.port = port self.socket_path = str(socket_path) if socket_path else None self.backlog = backlog self.external_host = external_host self.external_port = external_port or port self.external_prefix = external_prefix self.parent_ctx = None # type: Context self.clients = set() self.logger = logging.getLogger(self.__class__.__module__)
def configure_engine(cls, context_attr: str = None, metadata: Union[str, MetaData] = None, url: Union[str, URL, Dict[str, Any]] = None, bind: Connectable = None, **engine_args): """ Create an engine and optionally bind it to a :class:`~sqlalchemy.schema.MetaData`. If both ``url`` and ``bind`` are provided, the ``bind`` parameter takes priority. :param context_attr: context attribute for the engine :param metadata: a metadata object to bind to :param url: the connection url passed to :func:`~sqlalchemy.create_engine` (can also be a dictionary of :class:`~sqlalchemy.engine.url.URL` keyword arguments) :param bind: a connection or engine instance to use instead of creating a new engine :param engine_args: keyword arguments passed to :func:`~sqlalchemy.create_engine` """ assert check_argument_types() if url and not bind: if isinstance(url, dict): url = URL(**url) elif isinstance(url, str): url = make_url(url) # This is a hack to get SQLite to play nice with asphalt-sqlalchemy's juggling of # connections between multiple threads. The same connection should, however, never be # used in multiple threads at once. if url.drivername.split('+')[0] == 'sqlite': connect_args = engine_args.setdefault('connect_args', {}) connect_args.setdefault('check_same_thread', False) bind = create_engine(url, **engine_args) elif not bind: raise ValueError('specify either url or bind') if metadata: metadata = resolve_reference(metadata) assert isinstance(metadata, MetaData) metadata.bind = bind return context_attr, bind
def configure_client( cls, context_attr: str, address: Union[str, Path] = "localhost", port: int = 6379, db: int = 0, password: str = None, ssl: Union[bool, str, SSLContext] = False, **client_args ): """ Configure a Redis client. :param context_attr: context attribute of the serializer (if omitted, the resource name will be used instead) :param address: IP address, host name or path to a UNIX socket :param port: port number to connect to (ignored for UNIX sockets) :param db: database number to connect to :param password: password used if the server requires authentication :param ssl: one of the following: * ``False`` to disable SSL * ``True`` to enable SSL using the default context * an :class:`ssl.SSLContext` instance * a ``module:varname`` reference to an :class:`~ssl.SSLContext` instance * name of an :class:`ssl.SSLContext` resource :param client_args: extra keyword arguments passed to :func:`~aioredis.create_reconnecting_redis` """ assert check_argument_types() if isinstance(address, str) and not address.startswith("/"): address = (address, port) client_args.update({"address": address, "db": db, "password": password, "ssl": resolve_reference(ssl)}) return context_attr, client_args
def __init__(self, host: str = 'localhost', port: int = 8080, path: str = '/ws', realm: str = 'realm1', *, protocol_options: Dict[str, Any] = None, connection_timeout: float = 10, reconnect_delay: float = 5, max_reconnection_attempts: Optional[int] = 15, shutdown_timeout: Optional[float] = 15, registry: Union[WAMPRegistry, str] = None, tls: bool = False, tls_context: Union[str, SSLContext] = None, serializer: Union[Serializer, str] = None, auth_method: str = 'anonymous', auth_id: str = None, auth_secret: str = None) -> None: """ :param host: host address of the WAMP router :param port: port to connect to :param path: HTTP path on the router :param realm: the WAMP realm to join the application session to (defaults to the resource name if not specified) :param protocol_options: dictionary of Autobahn's `websocket protocol options`_ :param connection_timeout: maximum time to wait for the client to connect to the router and join a realm :param reconnect_delay: delay between connection attempts (in seconds) :param max_reconnection_attempts: maximum number of connection attempts before giving up :param shutdown_timeout: maximum number of seconds to wait for the client to complete its shutdown sequence (unregister procedures/subscriptions, wait for running handlers to finish, leave the realm) :param registry: a :class:`~asphalt.wamp.registry.WAMPRegistry` instance, a ``module:varname`` reference or resource name of one :param tls: ``True`` to use TLS when connecting to the router :param tls_context: an :class:`~ssl.SSLContext` instance or the resource name of one :param serializer: a :class:`asphalt.serialization.api.Serializer` instance or the resource name of one :param auth_method: authentication method to use (valid values are currently ``anonymous``, ``wampcra`` and ``ticket``) :param auth_id: authentication ID (username) :param auth_secret: secret to use for authentication (ticket or password) .. _websocket protocol options: http://autobahn.readthedocs.io/en/latest/websocket/programming.html#websocket-options """ assert check_argument_types() self.host = host self.port = port self.path = path self.reconnect_delay = reconnect_delay self.connection_timeout = connection_timeout self.shutdown_timeout = shutdown_timeout self.max_reconnection_attempts = max_reconnection_attempts self.realm = realm self.protocol_options = protocol_options or {} self.tls = tls self.tls_context = tls_context self.serializer = serializer or JSONSerializer() self.auth_method = auth_method self.auth_id = auth_id self.auth_secret = auth_secret self._parent_context = None # type: Context self._loop = None # type: AbstractEventLoop self._registry = resolve_reference(registry) or WAMPRegistry() self._session = None # type: AsphaltSession self._session_details = None # type: SessionDetails self._connect_task = None # type: Task self._request_tasks = set() # type: Set[Task] self._registrations = [] # type: List[IRegistration] self._subscriptions = [] # type: List[ISubscription]