circuits package

Subpackages

• circuits.app package
  • Submodules
    • circuits.app.daemon module
      • daemonize
      • daemonized
      • deletepid
      • writepid
      • Daemon
        • Daemon.channel
        • Daemon.init()
        • Daemon.deletepid()
        • Daemon.writepid()
        • Daemon.daemonize()
        • Daemon.registered()
        • Daemon.on_started()
  • Module contents
    • Daemon
      • Daemon.channel
      • Daemon.init()
      • Daemon.deletepid()
      • Daemon.writepid()
      • Daemon.daemonize()
      • Daemon.registered()
      • Daemon.on_started()
    • DropPrivileges
      • DropPrivileges.init()
      • DropPrivileges.drop_privileges()
      • DropPrivileges.on_ready()
• circuits.core package
  • Submodules
    • circuits.core.bridge module
      • ipc
      • Bridge
        • Bridge.channel
        • Bridge.init()
    • circuits.core.components module
      • prepare_unregister
        • prepare_unregister.complete
        • prepare_unregister.in_subtree()
      • BaseComponent
        • BaseComponent.channel
        • BaseComponent.register()
        • BaseComponent.unregister()
        • BaseComponent.unregister_pending
        • BaseComponent.handlers()
        • BaseComponent.events()
        • BaseComponent.handles()
      • Component
    • circuits.core.debugger module
      • Debugger
        • Debugger.IgnoreEvents
        • Debugger.IgnoreChannels
    • circuits.core.events module
      • Event
        • Event.channels
        • Event.parent
        • Event.notify
        • Event.success
        • Event.failure
        • Event.complete
        • Event.alert_done
        • Event.waitingHandlers
        • Event.create()
        • Event.child()
        • Event.cancel()
        • Event.stop()
      • exception
        • exception.format_traceback()
      • started
      • stopped
      • signal
      • registered
      • unregistered
      • generate_events
        • generate_events.time_left
        • generate_events.reduce_time_left()
        • generate_events.lock
    • circuits.core.handlers module
      • handler()
      • Unknown
      • reprhandler()
      • HandlerMetaClass
    • circuits.core.helpers module
      • FallBackGenerator
        • FallBackGenerator.resume()
      • FallBackExceptionHandler
      • FallBackSignalHandler
    • circuits.core.loader module
      • Loader
        • Loader.channel
        • Loader.load()
    • circuits.core.manager module
      • UnregistrableError
      • TimeoutError
      • CallValue
      • ExceptionWrapper
        • ExceptionWrapper.extract()
      • Sleep
        • Sleep.expired
        • Sleep.task
      • sleep()
      • Manager
        • Manager.name
        • Manager.running
        • Manager.pid
        • Manager.getHandlers()
        • Manager.addHandler()
        • Manager.removeHandler()
        • Manager.registerChild()
        • Manager.unregisterChild()
        • Manager.fireEvent()
        • Manager.fire()
        • Manager.registerTask()
        • Manager.unregisterTask()
        • Manager.waitEvent()
        • Manager.wait()
        • Manager.callEvent()
        • Manager.call()
        • Manager.flushEvents()
        • Manager.flush()
        • Manager.start()
        • Manager.join()
        • Manager.stop()
        • Manager.processTask()
        • Manager.tick()
        • Manager.run()
    • circuits.core.pollers module
      • BasePoller
        • BasePoller.channel
        • BasePoller.resume()
        • BasePoller.addReader()
        • BasePoller.addWriter()
        • BasePoller.removeReader()
        • BasePoller.removeWriter()
        • BasePoller.isReading()
        • BasePoller.isWriting()
        • BasePoller.discard()
        • BasePoller.getTarget()
      • EPoll
        • EPoll.channel
        • EPoll.addReader()
        • EPoll.addWriter()
        • EPoll.removeReader()
        • EPoll.removeWriter()
        • EPoll.discard()
      • KQueue
        • KQueue.channel
        • KQueue.addReader()
        • KQueue.addWriter()
        • KQueue.removeReader()
        • KQueue.removeWriter()
        • KQueue.discard()
      • Poll
        • Poll.channel
        • Poll.addReader()
        • Poll.addWriter()
        • Poll.removeReader()
        • Poll.removeWriter()
        • Poll.discard()
      • Poller
      • Select
        • Select.channel
    • circuits.core.timers module
      • Timer
        • Timer.reset()
        • Timer.expiry
    • circuits.core.utils module
      • flatten()
      • findchannel()
      • findtype()
      • findcmp()
      • findroot()
      • safeimport()
    • circuits.core.values module
      • Value
        • Value.inform()
        • Value.getValue()
        • Value.setValue()
        • Value.value
    • circuits.core.workers module
      • task
        • task.success
        • task.failure
      • Worker
        • Worker.channel
        • Worker.init()
  • Module contents
    • handler()
    • BaseComponent
      • BaseComponent.channel
      • BaseComponent.register()
      • BaseComponent.unregister()
      • BaseComponent.unregister_pending
      • BaseComponent.handlers()
      • BaseComponent.events()
      • BaseComponent.handles()
    • Component
    • Event
      • Event.channels
      • Event.parent
      • Event.notify
      • Event.success
      • Event.failure
      • Event.complete
      • Event.alert_done
      • Event.waitingHandlers
      • Event.create()
      • Event.child()
      • Event.cancel()
      • Event.stop()
    • task
      • task.success
      • task.failure
    • Worker
      • Worker.channel
      • Worker.init()
    • ipc
    • Bridge
      • Bridge.channel
      • Bridge.init()
    • Debugger
      • Debugger.IgnoreEvents
      • Debugger.IgnoreChannels
    • Timer
      • Timer.reset()
      • Timer.expiry
    • Manager
      • Manager.name
      • Manager.running
      • Manager.pid
      • Manager.getHandlers()
      • Manager.addHandler()
      • Manager.removeHandler()
      • Manager.registerChild()
      • Manager.unregisterChild()
      • Manager.fireEvent()
      • Manager.fire()
      • Manager.registerTask()
      • Manager.unregisterTask()
      • Manager.waitEvent()
      • Manager.wait()
      • Manager.callEvent()
      • Manager.call()
      • Manager.flushEvents()
      • Manager.flush()
      • Manager.start()
      • Manager.join()
      • Manager.stop()
      • Manager.processTask()
      • Manager.tick()
      • Manager.run()
    • TimeoutError
• circuits.io package
  • Submodules
    • circuits.io.events module
      • eof
      • seek
      • read
      • close
      • write
      • error
      • open
      • opened
      • closed
      • ready
      • started
      • stopped
      • moved
      • created
      • deleted
      • accessed
      • modified
      • unmounted
    • circuits.io.file module
      • File
        • File.channel
        • File.init()
        • File.closed
        • File.filename
        • File.mode
        • File.close()
        • File.seek()
        • File.write()
    • circuits.io.notify module
      • Notify
        • Notify.channel
        • Notify.add_path()
        • Notify.remove_path()
    • circuits.io.process module
      • terminated
      • Process
        • Process.channel
        • Process.init()
        • Process.start()
        • Process.stop()
        • Process.kill()
        • Process.signal()
        • Process.wait()
        • Process.write()
        • Process.status
    • circuits.io.serial module
      • Serial
        • Serial.channel
        • Serial.close()
        • Serial.write()
  • Module contents
• circuits.net package
  • Submodules
    • circuits.net.events module
      • connect
      • disconnect
      • connected
      • disconnected
      • read
      • error
      • unreachable
      • broadcast
      • write
      • close
      • ready
      • closed
      • starttls
    • circuits.net.sockets module
      • wrap_socket()
      • do_handshake()
      • Client
        • Client.channel
        • Client.socket_family
        • Client.socket_type
        • Client.socket_protocol
        • Client.socket_options
        • Client.parse_bind_parameter()
        • Client.connected
        • Client.close()
        • Client.write()
      • TCPClient
        • TCPClient.socket_family
        • TCPClient.socket_type
        • TCPClient.socket_protocol
        • TCPClient.socket_options
        • TCPClient.init()
        • TCPClient.connect()
      • TCP6Client
        • TCP6Client.socket_family
        • TCP6Client.parse_bind_parameter()
      • UNIXClient
        • UNIXClient.socket_family
        • UNIXClient.socket_type
        • UNIXClient.socket_options
        • UNIXClient.ready()
        • UNIXClient.connect()
      • Server
        • Server.channel
        • Server.socket_protocol
        • Server.parse_bind_parameter()
        • Server.connected
        • Server.host
        • Server.port
        • Server.close()
        • Server.write()
        • Server.starttls()
      • TCPServer
        • TCPServer.socket_family
        • TCPServer.socket_type
        • TCPServer.socket_options
        • TCPServer.parse_bind_parameter()
      • parse_ipv4_parameter()
      • parse_ipv6_parameter()
      • TCP6Server
        • TCP6Server.socket_family
        • TCP6Server.parse_bind_parameter()
      • UNIXServer
        • UNIXServer.socket_family
        • UNIXServer.socket_type
        • UNIXServer.socket_options
      • UDPServer
        • UDPServer.socket_family
        • UDPServer.socket_type
        • UDPServer.socket_options
        • UDPServer.close()
        • UDPServer.write()
        • UDPServer.broadcast()
      • UDPClient
      • UDP6Server
        • UDP6Server.socket_family
        • UDP6Server.parse_bind_parameter()
      • UDP6Client
      • Pipe()
  • Module contents
• circuits.node package
  • Submodules
    • circuits.node.client module
      • Client
        • Client.channel
        • Client.close()
        • Client.connect()
        • Client.send()
    • circuits.node.events module
      • connected_to
      • disconnected_from
      • remote
    • circuits.node.node module
      • Node
        • Node.channel
        • Node.add()
        • Node.get_connection_names()
        • Node.get_peer()
    • circuits.node.server module
      • Server
        • Server.channel
        • Server.send()
        • Server.send_to()
        • Server.send_all()
        • Server.host
        • Server.port
        • Server.get_socks()
    • circuits.node.utils module
      • load_event()
      • dump_event()
      • dump_value()
      • load_value()
  • Module contents
• circuits.protocols package
  • Submodules
    • circuits.protocols.http module
      • request
      • response
      • ResponseObject
        • ResponseObject.read()
      • HTTP
        • HTTP.channel
    • circuits.protocols.irc module
    • circuits.protocols.line module
      • splitLines()
      • line
      • Line
    • circuits.protocols.websocket module
      • WebSocketCodec
        • WebSocketCodec.channel
  • Module contents
• circuits.tools package
  • Module contents
    • tryimport()
    • getargspec()
    • walk()
    • edges()
    • findroot()
    • kill()
    • graph_ascii()
    • graph_dot()
    • graph_png()
    • graph()
    • inspect()
    • deprecated()
• circuits.web package
  • Subpackages
    • circuits.web.dispatchers package
      • Submodules
        • circuits.web.dispatchers.dispatcher module
          • resolve_path()
          • resolve_methods()
          • find_handlers()
          • Dispatcher
            • Dispatcher.channel
        • circuits.web.dispatchers.jsonrpc module
          • rpc
          • JSONRPC
            • JSONRPC.channel
        • circuits.web.dispatchers.static module
          • Static
            • Static.channel
        • circuits.web.dispatchers.virtualhosts module
          • VirtualHosts
            • VirtualHosts.channel
        • circuits.web.dispatchers.xmlrpc module
          • rpc
          • XMLRPC
            • XMLRPC.channel
      • Module contents
    • circuits.web.parsers package
      • Submodules
        • circuits.web.parsers.http module
          • InvalidRequestLine
          • InvalidHeader
          • InvalidChunkSize
          • HttpParser
            • HttpParser.get_version()
            • HttpParser.get_method()
            • HttpParser.get_status_code()
            • HttpParser.get_url()
            • HttpParser.get_scheme()
            • HttpParser.get_path()
            • HttpParser.get_query_string()
            • HttpParser.get_headers()
            • HttpParser.recv_body()
            • HttpParser.recv_body_into()
            • HttpParser.is_upgrade()
            • HttpParser.is_headers_complete()
            • HttpParser.is_partial_body()
            • HttpParser.is_message_begin()
            • HttpParser.is_message_complete()
            • HttpParser.is_chunked()
            • HttpParser.should_keep_alive()
            • HttpParser.execute()
        • circuits.web.parsers.multipart module
          • Parser for multipart/form-data
            • Licence (MIT)
          • MultiDict
            • MultiDict.keys()
            • MultiDict.append()
            • MultiDict.replace()
            • MultiDict.getall()
            • MultiDict.get()
            • MultiDict.iterallitems()
          • tob()
          • copy_file()
          • header_quote()
          • header_unquote()
          • parse_options_header()
          • MultipartError
          • MultipartParser
            • MultipartParser.parts()
            • MultipartParser.get()
            • MultipartParser.get_all()
          • MultipartPart
            • MultipartPart.feed()
            • MultipartPart.write_header()
            • MultipartPart.write_body()
            • MultipartPart.finish_header()
            • MultipartPart.is_buffered()
            • MultipartPart.value
            • MultipartPart.save_as()
          • parse_form_data()
        • circuits.web.parsers.querystring module
          • QueryStringToken
            • QueryStringToken.ARRAY
            • QueryStringToken.OBJECT
            • QueryStringToken.KEY
          • QueryStringParser
            • QueryStringParser.process()
            • QueryStringParser.parse()
            • QueryStringParser.tokens()
      • Module contents
    • circuits.web.websockets package
      • Submodules
        • circuits.web.websockets.client module
          • WebSocketClient
            • WebSocketClient.channel
            • WebSocketClient.close()
            • WebSocketClient.connected
        • circuits.web.websockets.dispatcher module
          • WebSocketsDispatcher
            • WebSocketsDispatcher.channel
            • WebSocketsDispatcher.select_subprotocol()
      • Module contents
  • Submodules
    • circuits.web.client module
      • parse_url()
      • HTTPException
      • NotConnected
      • request
      • Client
        • Client.channel
        • Client.write()
        • Client.close()
        • Client.connect()
        • Client.request()
        • Client.connected
        • Client.response
    • circuits.web.constants module
    • circuits.web.controllers module
      • expose()
      • ExposeMetaClass
      • BaseController
        • BaseController.channel
        • BaseController.uri
        • BaseController.forbidden()
        • BaseController.notfound()
        • BaseController.redirect()
        • BaseController.serve_file()
        • BaseController.serve_download()
        • BaseController.expires()
      • Controller
      • exposeJSON()
      • ExposeJSONMetaClass
      • JSONController
    • circuits.web.errors module
      • httperror
        • httperror.code
        • httperror.description
        • httperror.sanitize()
      • forbidden
        • forbidden.code
      • unauthorized
        • unauthorized.code
      • notfound
        • notfound.code
      • redirect
    • circuits.web.events module
      • request
        • request.success
        • request.failure
        • request.complete
      • response
        • response.success
        • response.failure
        • response.complete
      • stream
        • stream.success
        • stream.failure
        • stream.complete
      • terminate
    • circuits.web.exceptions module
      • BadGateway
        • BadGateway.code
        • BadGateway.description
      • BadRequest
        • BadRequest.code
        • BadRequest.description
      • Forbidden
        • Forbidden.code
        • Forbidden.description
      • Gone
        • Gone.code
        • Gone.description
      • HTTPException
        • HTTPException.code
        • HTTPException.description
        • HTTPException.traceback
        • HTTPException.name
      • InternalServerError
        • InternalServerError.code
        • InternalServerError.description
      • LengthRequired
        • LengthRequired.code
        • LengthRequired.description
      • MethodNotAllowed
        • MethodNotAllowed.code
      • NotAcceptable
        • NotAcceptable.code
        • NotAcceptable.description
      • NotFound
        • NotFound.code
        • NotFound.description
      • NotImplemented
        • NotImplemented.code
        • NotImplemented.description
      • PreconditionFailed
        • PreconditionFailed.code
        • PreconditionFailed.description
      • RangeUnsatisfiable
        • RangeUnsatisfiable.code
        • RangeUnsatisfiable.description
      • Redirect
        • Redirect.code
      • RequestEntityTooLarge
        • RequestEntityTooLarge.code
        • RequestEntityTooLarge.description
      • RequestTimeout
        • RequestTimeout.code
        • RequestTimeout.description
      • RequestURITooLarge
        • RequestURITooLarge.code
        • RequestURITooLarge.description
      • ServiceUnavailable
        • ServiceUnavailable.code
        • ServiceUnavailable.description
      • Unauthorized
        • Unauthorized.code
        • Unauthorized.description
      • UnicodeError
      • UnsupportedMediaType
        • UnsupportedMediaType.code
        • UnsupportedMediaType.description
    • circuits.web.headers module
      • header_elements()
      • HeaderElement
        • HeaderElement.parse()
        • HeaderElement.from_str()
      • AcceptElement
        • AcceptElement.from_str()
        • AcceptElement.qvalue
      • CaseInsensitiveDict
        • CaseInsensitiveDict.get()
        • CaseInsensitiveDict.update()
        • CaseInsensitiveDict.fromkeys()
        • CaseInsensitiveDict.setdefault()
        • CaseInsensitiveDict.pop()
      • Headers
        • Headers.elements()
        • Headers.get_all()
        • Headers.items()
        • Headers.append()
        • Headers.add_header()
    • circuits.web.http module
      • HTTP
        • HTTP.channel
        • HTTP.version
        • HTTP.protocol
        • HTTP.scheme
        • HTTP.base
        • HTTP.uri
    • circuits.web.loggers module
      • formattime()
      • Logger
        • Logger.channel
        • Logger.format
        • Logger.log_response()
        • Logger.log()
    • circuits.web.main module
      • parse_options()
      • Authentication
        • Authentication.channel
        • Authentication.realm
        • Authentication.users
        • Authentication.request()
      • HelloWorld
        • HelloWorld.channel
        • HelloWorld.request()
      • Root
        • Root.hello()
      • select_poller()
      • parse_bind()
      • main()
    • circuits.web.processors module
      • process_multipart()
      • process_urlencoded()
      • process()
    • circuits.web.servers module
      • BaseServer
        • BaseServer.channel
        • BaseServer.host
        • BaseServer.port
        • BaseServer.display_banner
        • BaseServer.secure
      • Server
      • FakeSock
        • FakeSock.getpeername()
      • StdinServer
        • StdinServer.channel
        • StdinServer.host
        • StdinServer.port
        • StdinServer.secure
        • StdinServer.read()
        • StdinServer.write()
    • circuits.web.sessions module
      • who()
      • create_session()
      • verify_session()
      • Session
        • Session.sid
        • Session.store
        • Session.expire()
      • Store
        • Store.delete()
        • Store.load()
        • Store.save()
      • MemoryStore
        • MemoryStore.data
        • MemoryStore.delete()
        • MemoryStore.load()
        • MemoryStore.save()
      • Sessions
        • Sessions.channel
        • Sessions.name
        • Sessions.store
        • Sessions.request()
    • circuits.web.tools module
      • expires()
      • serve_file()
      • serve_download()
      • validate_etags()
      • validate_since()
      • check_auth()
      • basic_auth()
      • digest_auth()
      • gzip()
      • ReverseProxy
        • ReverseProxy.headers
        • ReverseProxy.init()
    • circuits.web.url module
      • parse_url()
      • URL
        • URL.parse()
        • URL.equiv()
        • URL.canonical()
        • URL.defrag()
        • URL.deparam()
        • URL.abspath()
        • URL.lower()
        • URL.sanitize()
        • URL.escape()
        • URL.unescape()
        • URL.encode()
        • URL.relative()
        • URL.punycode()
        • URL.unpunycode()
        • URL.absolute()
        • URL.unicode()
        • URL.utf8()
    • circuits.web.utils module
      • is_unix_socket()
      • average()
      • variance()
      • stddev()
      • parse_qs()
      • compress()
      • get_ranges()
    • circuits.web.wrappers module
      • file_generator()
      • Host
        • Host.ip
        • Host.port
        • Host.name
      • HTTPStatus
        • HTTPStatus.status
        • HTTPStatus.reason
      • Request
        • Request.index
        • Request.script_name
        • Request.login
        • Request.handled
        • Request.scheme
        • Request.protocol
        • Request.server
        • Request.remote
        • Request.local
        • Request.host
      • Body
        • Body.encode_errors
      • Status
      • Response
        • Response.body
        • Response.status
        • Response.done
        • Response.close
        • Response.stream
        • Response.chunked
        • Response.prepare()
    • circuits.web.wsgi module
      • create_environ()
      • Application
        • Application.channel
        • Application.headerNames
        • Application.init()
        • Application.translateHeaders()
        • Application.getRequestResponse()
        • Application.on_response()
        • Application.host
        • Application.port
        • Application.secure
      • Gateway
        • Gateway.channel
        • Gateway.init()
  • Module contents

Submodules

• circuits.version module

Module contents

Lightweight Event driven and Asynchronous Application Framework

circuits is a Lightweight Event driven and Asynchronous Application Framework for the Python Programming Language with a strong Component Architecture.

copyright:

CopyRight (C) 2004-2016 by James Mills

license:

MIT (See: LICENSE)