repo_name
stringlengths 5
100
| ref
stringlengths 12
67
| path
stringlengths 4
244
| copies
stringlengths 1
8
| content
stringlengths 0
1.05M
⌀ |
|---|---|---|---|---|
GitHublong/hue | refs/heads/master | desktop/core/ext-py/MySQL-python-1.2.5/tests/test_MySQLdb_nonstandard.py | 41 | import unittest
import _mysql
import MySQLdb
from MySQLdb.constants import FIELD_TYPE
from configdb import connection_factory
import warnings
warnings.simplefilter("ignore")
class TestDBAPISet(unittest.TestCase):
def test_set_equality(self):
self.assertTrue(MySQLdb.STRING == MySQLdb.STRING)
def test_set_inequality(self):
self.assertTrue(MySQLdb.STRING != MySQLdb.NUMBER)
def test_set_equality_membership(self):
self.assertTrue(FIELD_TYPE.VAR_STRING == MySQLdb.STRING)
def test_set_inequality_membership(self):
self.assertTrue(FIELD_TYPE.DATE != MySQLdb.STRING)
class CoreModule(unittest.TestCase):
"""Core _mysql module features."""
def test_NULL(self):
"""Should have a NULL constant."""
self.assertEqual(_mysql.NULL, 'NULL')
def test_version(self):
"""Version information sanity."""
self.assertTrue(isinstance(_mysql.__version__, str))
self.assertTrue(isinstance(_mysql.version_info, tuple))
self.assertEqual(len(_mysql.version_info), 5)
def test_client_info(self):
self.assertTrue(isinstance(_mysql.get_client_info(), str))
def test_thread_safe(self):
self.assertTrue(isinstance(_mysql.thread_safe(), int))
class CoreAPI(unittest.TestCase):
"""Test _mysql interaction internals."""
def setUp(self):
self.conn = connection_factory(use_unicode=True)
def tearDown(self):
self.conn.close()
def test_thread_id(self):
tid = self.conn.thread_id()
self.assertTrue(isinstance(tid, int),
"thread_id didn't return an int.")
self.assertRaises(TypeError, self.conn.thread_id, ('evil',),
"thread_id shouldn't accept arguments.")
def test_affected_rows(self):
self.assertEquals(self.conn.affected_rows(), 0,
"Should return 0 before we do anything.")
#def test_debug(self):
## FIXME Only actually tests if you lack SUPER
#self.assertRaises(MySQLdb.OperationalError,
#self.conn.dump_debug_info)
def test_charset_name(self):
self.assertTrue(isinstance(self.conn.character_set_name(), str),
"Should return a string.")
def test_host_info(self):
self.assertTrue(isinstance(self.conn.get_host_info(), str),
"Should return a string.")
def test_proto_info(self):
self.assertTrue(isinstance(self.conn.get_proto_info(), int),
"Should return an int.")
def test_server_info(self):
self.assertTrue(isinstance(self.conn.get_server_info(), str),
"Should return an str.")
|
kxxoling/fabric | refs/heads/chs | tests/Python26SocketServer.py | 21 | """Generic socket server classes.
This module tries to capture the various aspects of defining a server:
For socket-based servers:
- address family:
- AF_INET{,6}: IP (Internet Protocol) sockets (default)
- AF_UNIX: Unix domain sockets
- others, e.g. AF_DECNET are conceivable (see <socket.h>
- socket type:
- SOCK_STREAM (reliable stream, e.g. TCP)
- SOCK_DGRAM (datagrams, e.g. UDP)
For request-based servers (including socket-based):
- client address verification before further looking at the request
(This is actually a hook for any processing that needs to look
at the request before anything else, e.g. logging)
- how to handle multiple requests:
- synchronous (one request is handled at a time)
- forking (each request is handled by a new process)
- threading (each request is handled by a new thread)
The classes in this module favor the server type that is simplest to
write: a synchronous TCP/IP server. This is bad class design, but
save some typing. (There's also the issue that a deep class hierarchy
slows down method lookups.)
There are five classes in an inheritance diagram, four of which represent
synchronous servers of four types:
+------------+
| BaseServer |
+------------+
|
v
+-----------+ +------------------+
| TCPServer |------->| UnixStreamServer |
+-----------+ +------------------+
|
v
+-----------+ +--------------------+
| UDPServer |------->| UnixDatagramServer |
+-----------+ +--------------------+
Note that UnixDatagramServer derives from UDPServer, not from
UnixStreamServer -- the only difference between an IP and a Unix
stream server is the address family, which is simply repeated in both
unix server classes.
Forking and threading versions of each type of server can be created
using the ForkingMixIn and ThreadingMixIn mix-in classes. For
instance, a threading UDP server class is created as follows:
class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
The Mix-in class must come first, since it overrides a method defined
in UDPServer! Setting the various member variables also changes
the behavior of the underlying server mechanism.
To implement a service, you must derive a class from
BaseRequestHandler and redefine its handle() method. You can then run
various versions of the service by combining one of the server classes
with your request handler class.
The request handler class must be different for datagram or stream
services. This can be hidden by using the request handler
subclasses StreamRequestHandler or DatagramRequestHandler.
Of course, you still have to use your head!
For instance, it makes no sense to use a forking server if the service
contains state in memory that can be modified by requests (since the
modifications in the child process would never reach the initial state
kept in the parent process and passed to each child). In this case,
you can use a threading server, but you will probably have to use
locks to avoid two requests that come in nearly simultaneous to apply
conflicting changes to the server state.
On the other hand, if you are building e.g. an HTTP server, where all
data is stored externally (e.g. in the file system), a synchronous
class will essentially render the service "deaf" while one request is
being handled -- which may be for a very long time if a client is slow
to reqd all the data it has requested. Here a threading or forking
server is appropriate.
In some cases, it may be appropriate to process part of a request
synchronously, but to finish processing in a forked child depending on
the request data. This can be implemented by using a synchronous
server and doing an explicit fork in the request handler class
handle() method.
Another approach to handling multiple simultaneous requests in an
environment that supports neither threads nor fork (or where these are
too expensive or inappropriate for the service) is to maintain an
explicit table of partially finished requests and to use select() to
decide which request to work on next (or whether to handle a new
incoming request). This is particularly important for stream services
where each client can potentially be connected for a long time (if
threads or subprocesses cannot be used).
Future work:
- Standard classes for Sun RPC (which uses either UDP or TCP)
- Standard mix-in classes to implement various authentication
and encryption schemes
- Standard framework for select-based multiplexing
XXX Open problems:
- What to do with out-of-band data?
BaseServer:
- split generic "request" functionality out into BaseServer class.
Copyright (C) 2000 Luke Kenneth Casson Leighton <[email protected]>
example: read entries from a SQL database (requires overriding
get_request() to return a table entry from the database).
entry is processed by a RequestHandlerClass.
"""
# This file copyright (c) 2001-2015 Python Software Foundation; All Rights Reserved
# Author of the BaseServer patch: Luke Kenneth Casson Leighton
# XXX Warning!
# There is a test suite for this module, but it cannot be run by the
# standard regression test.
# To run it manually, run Lib/test/test_socketserver.py.
__version__ = "0.4"
import socket
import select
import sys
import os
try:
import threading
except ImportError:
import dummy_threading as threading
__all__ = ["TCPServer", "UDPServer", "ForkingUDPServer", "ForkingTCPServer",
"ThreadingUDPServer", "ThreadingTCPServer", "BaseRequestHandler",
"StreamRequestHandler", "DatagramRequestHandler",
"ThreadingMixIn", "ForkingMixIn"]
if hasattr(socket, "AF_UNIX"):
__all__.extend(["UnixStreamServer", "UnixDatagramServer",
"ThreadingUnixStreamServer",
"ThreadingUnixDatagramServer"])
class BaseServer:
"""Base class for server classes.
Methods for the caller:
- __init__(server_address, RequestHandlerClass)
- serve_forever(poll_interval=0.5)
- shutdown()
- handle_request() # if you do not use serve_forever()
- fileno() -> int # for select()
Methods that may be overridden:
- server_bind()
- server_activate()
- get_request() -> request, client_address
- handle_timeout()
- verify_request(request, client_address)
- server_close()
- process_request(request, client_address)
- close_request(request)
- handle_error()
Methods for derived classes:
- finish_request(request, client_address)
Class variables that may be overridden by derived classes or
instances:
- timeout
- address_family
- socket_type
- allow_reuse_address
Instance variables:
- RequestHandlerClass
- socket
"""
timeout = None
def __init__(self, server_address, RequestHandlerClass):
"""Constructor. May be extended, do not override."""
self.server_address = server_address
self.RequestHandlerClass = RequestHandlerClass
self.__is_shut_down = threading.Event()
self.__serving = False
def server_activate(self):
"""Called by constructor to activate the server.
May be overridden.
"""
pass
def serve_forever(self, poll_interval=0.5):
"""Handle one request at a time until shutdown.
Polls for shutdown every poll_interval seconds. Ignores
self.timeout. If you need to do periodic tasks, do them in
another thread.
"""
self.__serving = True
self.__is_shut_down.clear()
while self.__serving:
# XXX: Consider using another file descriptor or
# connecting to the socket to wake this up instead of
# polling. Polling reduces our responsiveness to a
# shutdown request and wastes cpu at all other times.
r, w, e = select.select([self], [], [], poll_interval)
if r:
self._handle_request_noblock()
self.__is_shut_down.set()
def shutdown(self):
"""Stops the serve_forever loop.
Blocks until the loop has finished. This must be called while
serve_forever() is running in another thread, or it will
deadlock.
"""
self.__serving = False
self.__is_shut_down.wait()
# The distinction between handling, getting, processing and
# finishing a request is fairly arbitrary. Remember:
#
# - handle_request() is the top-level call. It calls
# select, get_request(), verify_request() and process_request()
# - get_request() is different for stream or datagram sockets
# - process_request() is the place that may fork a new process
# or create a new thread to finish the request
# - finish_request() instantiates the request handler class;
# this constructor will handle the request all by itself
def handle_request(self):
"""Handle one request, possibly blocking.
Respects self.timeout.
"""
# Support people who used socket.settimeout() to escape
# handle_request before self.timeout was available.
timeout = self.socket.gettimeout()
if timeout is None:
timeout = self.timeout
elif self.timeout is not None:
timeout = min(timeout, self.timeout)
fd_sets = select.select([self], [], [], timeout)
if not fd_sets[0]:
self.handle_timeout()
return
self._handle_request_noblock()
def _handle_request_noblock(self):
"""Handle one request, without blocking.
I assume that select.select has returned that the socket is
readable before this function was called, so there should be
no risk of blocking in get_request().
"""
try:
request, client_address = self.get_request()
except socket.error:
return
if self.verify_request(request, client_address):
try:
self.process_request(request, client_address)
except:
self.handle_error(request, client_address)
self.close_request(request)
def handle_timeout(self):
"""Called if no new request arrives within self.timeout.
Overridden by ForkingMixIn.
"""
pass
def verify_request(self, request, client_address):
"""Verify the request. May be overridden.
Return True if we should proceed with this request.
"""
return True
def process_request(self, request, client_address):
"""Call finish_request.
Overridden by ForkingMixIn and ThreadingMixIn.
"""
self.finish_request(request, client_address)
self.close_request(request)
def server_close(self):
"""Called to clean-up the server.
May be overridden.
"""
pass
def finish_request(self, request, client_address):
"""Finish one request by instantiating RequestHandlerClass."""
self.RequestHandlerClass(request, client_address, self)
def close_request(self, request):
"""Called to clean up an individual request."""
pass
def handle_error(self, request, client_address):
"""Handle an error gracefully. May be overridden.
The default is to print a traceback and continue.
"""
print('-' * 40)
print('Exception happened during processing of request from %s' % (client_address,))
import traceback
traceback.print_exc() # XXX But this goes to stderr!
print('-' * 40)
class TCPServer(BaseServer):
"""Base class for various socket-based server classes.
Defaults to synchronous IP stream (i.e., TCP).
Methods for the caller:
- __init__(server_address, RequestHandlerClass, bind_and_activate=True)
- serve_forever(poll_interval=0.5)
- shutdown()
- handle_request() # if you don't use serve_forever()
- fileno() -> int # for select()
Methods that may be overridden:
- server_bind()
- server_activate()
- get_request() -> request, client_address
- handle_timeout()
- verify_request(request, client_address)
- process_request(request, client_address)
- close_request(request)
- handle_error()
Methods for derived classes:
- finish_request(request, client_address)
Class variables that may be overridden by derived classes or
instances:
- timeout
- address_family
- socket_type
- request_queue_size (only for stream sockets)
- allow_reuse_address
Instance variables:
- server_address
- RequestHandlerClass
- socket
"""
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
request_queue_size = 5
allow_reuse_address = False
def __init__(self, server_address, RequestHandlerClass,
bind_and_activate=True):
"""Constructor. May be extended, do not override."""
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = socket.socket(self.address_family,
self.socket_type)
if bind_and_activate:
self.server_bind()
self.server_activate()
def server_bind(self):
"""Called by constructor to bind the socket.
May be overridden.
"""
if self.allow_reuse_address:
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(self.server_address)
self.server_address = self.socket.getsockname()
def server_activate(self):
"""Called by constructor to activate the server.
May be overridden.
"""
self.socket.listen(self.request_queue_size)
def server_close(self):
"""Called to clean-up the server.
May be overridden.
"""
self.socket.close()
def fileno(self):
"""Return socket file number.
Interface required by select().
"""
return self.socket.fileno()
def get_request(self):
"""Get the request and client address from the socket.
May be overridden.
"""
return self.socket.accept()
def close_request(self, request):
"""Called to clean up an individual request."""
request.close()
class UDPServer(TCPServer):
"""UDP server class."""
allow_reuse_address = False
socket_type = socket.SOCK_DGRAM
max_packet_size = 8192
def get_request(self):
data, client_addr = self.socket.recvfrom(self.max_packet_size)
return (data, self.socket), client_addr
def server_activate(self):
# No need to call listen() for UDP.
pass
def close_request(self, request):
# No need to close anything.
pass
class ForkingMixIn:
"""Mix-in class to handle each request in a new process."""
timeout = 300
active_children = None
max_children = 40
def collect_children(self):
"""Internal routine to wait for children that have exited."""
if self.active_children is None:
return
while len(self.active_children) >= self.max_children:
# XXX: This will wait for any child process, not just ones
# spawned by this library. This could confuse other
# libraries that expect to be able to wait for their own
# children.
try:
pid, status = os.waitpid(0, 0)
except os.error:
pid = None
if pid not in self.active_children:
continue
self.active_children.remove(pid)
# XXX: This loop runs more system calls than it ought
# to. There should be a way to put the active_children into a
# process group and then use os.waitpid(-pgid) to wait for any
# of that set, but I couldn't find a way to allocate pgids
# that couldn't collide.
for child in self.active_children:
try:
pid, status = os.waitpid(child, os.WNOHANG)
except os.error:
pid = None
if not pid:
continue
try:
self.active_children.remove(pid)
except ValueError, e:
raise ValueError('%s. x=%d and list=%r' % \
(e.message, pid, self.active_children))
def handle_timeout(self):
"""Wait for zombies after self.timeout seconds of inactivity.
May be extended, do not override.
"""
self.collect_children()
def process_request(self, request, client_address):
"""Fork a new subprocess to process the request."""
self.collect_children()
pid = os.fork()
if pid:
# Parent process
if self.active_children is None:
self.active_children = []
self.active_children.append(pid)
self.close_request(request)
return
else:
# Child process.
# This must never return, hence os._exit()!
try:
self.finish_request(request, client_address)
os._exit(0)
except:
try:
self.handle_error(request, client_address)
finally:
os._exit(1)
class ThreadingMixIn:
"""Mix-in class to handle each request in a new thread."""
# Decides how threads will act upon termination of the
# main process
daemon_threads = False
def process_request_thread(self, request, client_address):
"""Same as in BaseServer but as a thread.
In addition, exception handling is done here.
"""
try:
self.finish_request(request, client_address)
self.close_request(request)
except:
self.handle_error(request, client_address)
self.close_request(request)
def process_request(self, request, client_address):
"""Start a new thread to process the request."""
t = threading.Thread(target=self.process_request_thread,
args=(request, client_address))
if self.daemon_threads:
t.setDaemon(1)
t.start()
class ForkingUDPServer(ForkingMixIn, UDPServer):
pass
class ForkingTCPServer(ForkingMixIn, TCPServer):
pass
class ThreadingUDPServer(ThreadingMixIn, UDPServer):
pass
class ThreadingTCPServer(ThreadingMixIn, TCPServer):
pass
if hasattr(socket, 'AF_UNIX'):
class UnixStreamServer(TCPServer):
address_family = socket.AF_UNIX
class UnixDatagramServer(UDPServer):
address_family = socket.AF_UNIX
class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer):
pass
class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer):
pass
class BaseRequestHandler:
"""Base class for request handler classes.
This class is instantiated for each request to be handled. The
constructor sets the instance variables request, client_address
and server, and then calls the handle() method. To implement a
specific service, all you need to do is to derive a class which
defines a handle() method.
The handle() method can find the request as self.request, the
client address as self.client_address, and the server (in case it
needs access to per-server information) as self.server. Since a
separate instance is created for each request, the handle() method
can define arbitrary other instance variariables.
"""
def __init__(self, request, client_address, server):
self.request = request
self.client_address = client_address
self.server = server
try:
self.setup()
self.handle()
self.finish()
finally:
sys.exc_traceback = None # Help garbage collection
def setup(self):
pass
def handle(self):
pass
def finish(self):
pass
# The following two classes make it possible to use the same service
# class for stream or datagram servers.
# Each class sets up these instance variables:
# - rfile: a file object from which receives the request is read
# - wfile: a file object to which the reply is written
# When the handle() method returns, wfile is flushed properly
class StreamRequestHandler(BaseRequestHandler):
"""Define self.rfile and self.wfile for stream sockets."""
# Default buffer sizes for rfile, wfile.
# We default rfile to buffered because otherwise it could be
# really slow for large data (a getc() call per byte); we make
# wfile unbuffered because (a) often after a write() we want to
# read and we need to flush the line; (b) big writes to unbuffered
# files are typically optimized by stdio even when big reads
# aren't.
rbufsize = -1
wbufsize = 0
def setup(self):
self.connection = self.request
self.rfile = self.connection.makefile('rb', self.rbufsize)
self.wfile = self.connection.makefile('wb', self.wbufsize)
def finish(self):
if not self.wfile.closed:
self.wfile.flush()
self.wfile.close()
self.rfile.close()
class DatagramRequestHandler(BaseRequestHandler):
# XXX Regrettably, I cannot get this working on Linux;
# s.recvfrom() doesn't return a meaningful client address.
"""Define self.rfile and self.wfile for datagram sockets."""
def setup(self):
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
self.packet, self.socket = self.request
self.rfile = StringIO(self.packet)
self.wfile = StringIO()
def finish(self):
self.socket.sendto(self.wfile.getvalue(), self.client_address)
|
tinkhaven-organization/odoo | refs/heads/8.0 | addons/hw_posbox_homepage/controllers/main.py | 112 | # -*- coding: utf-8 -*-
import logging
import os
import time
from os import listdir
import openerp
from openerp import http
from openerp.http import request
from openerp.tools.translate import _
_logger = logging.getLogger(__name__)
index_template = """
<!DOCTYPE HTML>
<html>
<head>
<title>Odoo's PosBox</title>
<style>
body {
width: 480px;
margin: 60px auto;
font-family: sans-serif;
text-align: justify;
color: #6B6B6B;
}
</style>
</head>
<body>
<h1>Your PosBox is up and running</h1>
<p>
The PosBox is an hardware adapter that allows you to use
receipt printers and barcode scanners with Odoo's Point of
Sale, <b>version 8.0 or later</b>. You can start an <a href='https://www.odoo.com/start'>online free trial</a>,
or <a href='https://www.odoo.com/start?download'>download and install</a> it yourself.
</p>
<p>
For more information on how to setup the Point of Sale with
the PosBox, please refer to <a href='/hw_proxy/static/doc/manual.pdf'>the manual</a>.
</p>
<p>
To see the status of the connected hardware, please refer
to the <a href='/hw_proxy/status'>hardware status page</a>.
</p>
<p>
The PosBox software installed on this posbox is <b>version 13</b>,
the posbox version number is independent from Odoo. You can upgrade
the software on the <a href='/hw_proxy/upgrade/'>upgrade page</a>.
</p>
<p>For any other question, please contact the Odoo support at <a href='mailto:[email protected]'>[email protected]</a>
</p>
</body>
</html>
"""
class PosboxHomepage(openerp.addons.web.controllers.main.Home):
@http.route('/', type='http', auth='none', website=True)
def index(self):
#return request.render('hw_posbox_homepage.index',mimetype='text/html')
return index_template
|
imtapps/django-class-registry | refs/heads/master | class_registry/tests/demo/__init__.py | 1 | from . import actions
from class_registry.auto_import import AutoImport
AutoImport(actions).setup()
|
ZerpaTechnology/AsenZor | refs/heads/master | static/js/brython/Lib/encodings/mac_croatian.py | 37 | """ Python Character Mapping Codec mac_croatian generated from 'MAPPINGS/VENDORS/APPLE/CROATIAN.TXT' with gencodec.py.
"""#"
import codecs
### Codec APIs
class Codec(codecs.Codec):
def encode(self,input,errors='strict'):
return codecs.charmap_encode(input,errors,encoding_table)
def decode(self,input,errors='strict'):
return codecs.charmap_decode(input,errors,decoding_table)
class IncrementalEncoder(codecs.IncrementalEncoder):
def encode(self, input, final=False):
return codecs.charmap_encode(input,self.errors,encoding_table)[0]
class IncrementalDecoder(codecs.IncrementalDecoder):
def decode(self, input, final=False):
return codecs.charmap_decode(input,self.errors,decoding_table)[0]
class StreamWriter(Codec,codecs.StreamWriter):
pass
class StreamReader(Codec,codecs.StreamReader):
pass
### encodings module API
def getregentry():
return codecs.CodecInfo(
name='mac-croatian',
encode=Codec().encode,
decode=Codec().decode,
incrementalencoder=IncrementalEncoder,
incrementaldecoder=IncrementalDecoder,
streamreader=StreamReader,
streamwriter=StreamWriter,
)
### Decoding Table
decoding_table = (
'\x00' # 0x00 -> CONTROL CHARACTER
'\x01' # 0x01 -> CONTROL CHARACTER
'\x02' # 0x02 -> CONTROL CHARACTER
'\x03' # 0x03 -> CONTROL CHARACTER
'\x04' # 0x04 -> CONTROL CHARACTER
'\x05' # 0x05 -> CONTROL CHARACTER
'\x06' # 0x06 -> CONTROL CHARACTER
'\x07' # 0x07 -> CONTROL CHARACTER
'\x08' # 0x08 -> CONTROL CHARACTER
'\t' # 0x09 -> CONTROL CHARACTER
'\n' # 0x0A -> CONTROL CHARACTER
'\x0b' # 0x0B -> CONTROL CHARACTER
'\x0c' # 0x0C -> CONTROL CHARACTER
'\r' # 0x0D -> CONTROL CHARACTER
'\x0e' # 0x0E -> CONTROL CHARACTER
'\x0f' # 0x0F -> CONTROL CHARACTER
'\x10' # 0x10 -> CONTROL CHARACTER
'\x11' # 0x11 -> CONTROL CHARACTER
'\x12' # 0x12 -> CONTROL CHARACTER
'\x13' # 0x13 -> CONTROL CHARACTER
'\x14' # 0x14 -> CONTROL CHARACTER
'\x15' # 0x15 -> CONTROL CHARACTER
'\x16' # 0x16 -> CONTROL CHARACTER
'\x17' # 0x17 -> CONTROL CHARACTER
'\x18' # 0x18 -> CONTROL CHARACTER
'\x19' # 0x19 -> CONTROL CHARACTER
'\x1a' # 0x1A -> CONTROL CHARACTER
'\x1b' # 0x1B -> CONTROL CHARACTER
'\x1c' # 0x1C -> CONTROL CHARACTER
'\x1d' # 0x1D -> CONTROL CHARACTER
'\x1e' # 0x1E -> CONTROL CHARACTER
'\x1f' # 0x1F -> CONTROL CHARACTER
' ' # 0x20 -> SPACE
'!' # 0x21 -> EXCLAMATION MARK
'"' # 0x22 -> QUOTATION MARK
'#' # 0x23 -> NUMBER SIGN
'$' # 0x24 -> DOLLAR SIGN
'%' # 0x25 -> PERCENT SIGN
'&' # 0x26 -> AMPERSAND
"'" # 0x27 -> APOSTROPHE
'(' # 0x28 -> LEFT PARENTHESIS
')' # 0x29 -> RIGHT PARENTHESIS
'*' # 0x2A -> ASTERISK
'+' # 0x2B -> PLUS SIGN
',' # 0x2C -> COMMA
'-' # 0x2D -> HYPHEN-MINUS
'.' # 0x2E -> FULL STOP
'/' # 0x2F -> SOLIDUS
'0' # 0x30 -> DIGIT ZERO
'1' # 0x31 -> DIGIT ONE
'2' # 0x32 -> DIGIT TWO
'3' # 0x33 -> DIGIT THREE
'4' # 0x34 -> DIGIT FOUR
'5' # 0x35 -> DIGIT FIVE
'6' # 0x36 -> DIGIT SIX
'7' # 0x37 -> DIGIT SEVEN
'8' # 0x38 -> DIGIT EIGHT
'9' # 0x39 -> DIGIT NINE
':' # 0x3A -> COLON
';' # 0x3B -> SEMICOLON
'<' # 0x3C -> LESS-THAN SIGN
'=' # 0x3D -> EQUALS SIGN
'>' # 0x3E -> GREATER-THAN SIGN
'?' # 0x3F -> QUESTION MARK
'@' # 0x40 -> COMMERCIAL AT
'A' # 0x41 -> LATIN CAPITAL LETTER A
'B' # 0x42 -> LATIN CAPITAL LETTER B
'C' # 0x43 -> LATIN CAPITAL LETTER C
'D' # 0x44 -> LATIN CAPITAL LETTER D
'E' # 0x45 -> LATIN CAPITAL LETTER E
'F' # 0x46 -> LATIN CAPITAL LETTER F
'G' # 0x47 -> LATIN CAPITAL LETTER G
'H' # 0x48 -> LATIN CAPITAL LETTER H
'I' # 0x49 -> LATIN CAPITAL LETTER I
'J' # 0x4A -> LATIN CAPITAL LETTER J
'K' # 0x4B -> LATIN CAPITAL LETTER K
'L' # 0x4C -> LATIN CAPITAL LETTER L
'M' # 0x4D -> LATIN CAPITAL LETTER M
'N' # 0x4E -> LATIN CAPITAL LETTER N
'O' # 0x4F -> LATIN CAPITAL LETTER O
'P' # 0x50 -> LATIN CAPITAL LETTER P
'Q' # 0x51 -> LATIN CAPITAL LETTER Q
'R' # 0x52 -> LATIN CAPITAL LETTER R
'S' # 0x53 -> LATIN CAPITAL LETTER S
'T' # 0x54 -> LATIN CAPITAL LETTER T
'U' # 0x55 -> LATIN CAPITAL LETTER U
'V' # 0x56 -> LATIN CAPITAL LETTER V
'W' # 0x57 -> LATIN CAPITAL LETTER W
'X' # 0x58 -> LATIN CAPITAL LETTER X
'Y' # 0x59 -> LATIN CAPITAL LETTER Y
'Z' # 0x5A -> LATIN CAPITAL LETTER Z
'[' # 0x5B -> LEFT SQUARE BRACKET
'\\' # 0x5C -> REVERSE SOLIDUS
']' # 0x5D -> RIGHT SQUARE BRACKET
'^' # 0x5E -> CIRCUMFLEX ACCENT
'_' # 0x5F -> LOW LINE
'`' # 0x60 -> GRAVE ACCENT
'a' # 0x61 -> LATIN SMALL LETTER A
'b' # 0x62 -> LATIN SMALL LETTER B
'c' # 0x63 -> LATIN SMALL LETTER C
'd' # 0x64 -> LATIN SMALL LETTER D
'e' # 0x65 -> LATIN SMALL LETTER E
'f' # 0x66 -> LATIN SMALL LETTER F
'g' # 0x67 -> LATIN SMALL LETTER G
'h' # 0x68 -> LATIN SMALL LETTER H
'i' # 0x69 -> LATIN SMALL LETTER I
'j' # 0x6A -> LATIN SMALL LETTER J
'k' # 0x6B -> LATIN SMALL LETTER K
'l' # 0x6C -> LATIN SMALL LETTER L
'm' # 0x6D -> LATIN SMALL LETTER M
'n' # 0x6E -> LATIN SMALL LETTER N
'o' # 0x6F -> LATIN SMALL LETTER O
'p' # 0x70 -> LATIN SMALL LETTER P
'q' # 0x71 -> LATIN SMALL LETTER Q
'r' # 0x72 -> LATIN SMALL LETTER R
's' # 0x73 -> LATIN SMALL LETTER S
't' # 0x74 -> LATIN SMALL LETTER T
'u' # 0x75 -> LATIN SMALL LETTER U
'v' # 0x76 -> LATIN SMALL LETTER V
'w' # 0x77 -> LATIN SMALL LETTER W
'x' # 0x78 -> LATIN SMALL LETTER X
'y' # 0x79 -> LATIN SMALL LETTER Y
'z' # 0x7A -> LATIN SMALL LETTER Z
'{' # 0x7B -> LEFT CURLY BRACKET
'|' # 0x7C -> VERTICAL LINE
'}' # 0x7D -> RIGHT CURLY BRACKET
'~' # 0x7E -> TILDE
'\x7f' # 0x7F -> CONTROL CHARACTER
'\xc4' # 0x80 -> LATIN CAPITAL LETTER A WITH DIAERESIS
'\xc5' # 0x81 -> LATIN CAPITAL LETTER A WITH RING ABOVE
'\xc7' # 0x82 -> LATIN CAPITAL LETTER C WITH CEDILLA
'\xc9' # 0x83 -> LATIN CAPITAL LETTER E WITH ACUTE
'\xd1' # 0x84 -> LATIN CAPITAL LETTER N WITH TILDE
'\xd6' # 0x85 -> LATIN CAPITAL LETTER O WITH DIAERESIS
'\xdc' # 0x86 -> LATIN CAPITAL LETTER U WITH DIAERESIS
'\xe1' # 0x87 -> LATIN SMALL LETTER A WITH ACUTE
'\xe0' # 0x88 -> LATIN SMALL LETTER A WITH GRAVE
'\xe2' # 0x89 -> LATIN SMALL LETTER A WITH CIRCUMFLEX
'\xe4' # 0x8A -> LATIN SMALL LETTER A WITH DIAERESIS
'\xe3' # 0x8B -> LATIN SMALL LETTER A WITH TILDE
'\xe5' # 0x8C -> LATIN SMALL LETTER A WITH RING ABOVE
'\xe7' # 0x8D -> LATIN SMALL LETTER C WITH CEDILLA
'\xe9' # 0x8E -> LATIN SMALL LETTER E WITH ACUTE
'\xe8' # 0x8F -> LATIN SMALL LETTER E WITH GRAVE
'\xea' # 0x90 -> LATIN SMALL LETTER E WITH CIRCUMFLEX
'\xeb' # 0x91 -> LATIN SMALL LETTER E WITH DIAERESIS
'\xed' # 0x92 -> LATIN SMALL LETTER I WITH ACUTE
'\xec' # 0x93 -> LATIN SMALL LETTER I WITH GRAVE
'\xee' # 0x94 -> LATIN SMALL LETTER I WITH CIRCUMFLEX
'\xef' # 0x95 -> LATIN SMALL LETTER I WITH DIAERESIS
'\xf1' # 0x96 -> LATIN SMALL LETTER N WITH TILDE
'\xf3' # 0x97 -> LATIN SMALL LETTER O WITH ACUTE
'\xf2' # 0x98 -> LATIN SMALL LETTER O WITH GRAVE
'\xf4' # 0x99 -> LATIN SMALL LETTER O WITH CIRCUMFLEX
'\xf6' # 0x9A -> LATIN SMALL LETTER O WITH DIAERESIS
'\xf5' # 0x9B -> LATIN SMALL LETTER O WITH TILDE
'\xfa' # 0x9C -> LATIN SMALL LETTER U WITH ACUTE
'\xf9' # 0x9D -> LATIN SMALL LETTER U WITH GRAVE
'\xfb' # 0x9E -> LATIN SMALL LETTER U WITH CIRCUMFLEX
'\xfc' # 0x9F -> LATIN SMALL LETTER U WITH DIAERESIS
'\u2020' # 0xA0 -> DAGGER
'\xb0' # 0xA1 -> DEGREE SIGN
'\xa2' # 0xA2 -> CENT SIGN
'\xa3' # 0xA3 -> POUND SIGN
'\xa7' # 0xA4 -> SECTION SIGN
'\u2022' # 0xA5 -> BULLET
'\xb6' # 0xA6 -> PILCROW SIGN
'\xdf' # 0xA7 -> LATIN SMALL LETTER SHARP S
'\xae' # 0xA8 -> REGISTERED SIGN
'\u0160' # 0xA9 -> LATIN CAPITAL LETTER S WITH CARON
'\u2122' # 0xAA -> TRADE MARK SIGN
'\xb4' # 0xAB -> ACUTE ACCENT
'\xa8' # 0xAC -> DIAERESIS
'\u2260' # 0xAD -> NOT EQUAL TO
'\u017d' # 0xAE -> LATIN CAPITAL LETTER Z WITH CARON
'\xd8' # 0xAF -> LATIN CAPITAL LETTER O WITH STROKE
'\u221e' # 0xB0 -> INFINITY
'\xb1' # 0xB1 -> PLUS-MINUS SIGN
'\u2264' # 0xB2 -> LESS-THAN OR EQUAL TO
'\u2265' # 0xB3 -> GREATER-THAN OR EQUAL TO
'\u2206' # 0xB4 -> INCREMENT
'\xb5' # 0xB5 -> MICRO SIGN
'\u2202' # 0xB6 -> PARTIAL DIFFERENTIAL
'\u2211' # 0xB7 -> N-ARY SUMMATION
'\u220f' # 0xB8 -> N-ARY PRODUCT
'\u0161' # 0xB9 -> LATIN SMALL LETTER S WITH CARON
'\u222b' # 0xBA -> INTEGRAL
'\xaa' # 0xBB -> FEMININE ORDINAL INDICATOR
'\xba' # 0xBC -> MASCULINE ORDINAL INDICATOR
'\u03a9' # 0xBD -> GREEK CAPITAL LETTER OMEGA
'\u017e' # 0xBE -> LATIN SMALL LETTER Z WITH CARON
'\xf8' # 0xBF -> LATIN SMALL LETTER O WITH STROKE
'\xbf' # 0xC0 -> INVERTED QUESTION MARK
'\xa1' # 0xC1 -> INVERTED EXCLAMATION MARK
'\xac' # 0xC2 -> NOT SIGN
'\u221a' # 0xC3 -> SQUARE ROOT
'\u0192' # 0xC4 -> LATIN SMALL LETTER F WITH HOOK
'\u2248' # 0xC5 -> ALMOST EQUAL TO
'\u0106' # 0xC6 -> LATIN CAPITAL LETTER C WITH ACUTE
'\xab' # 0xC7 -> LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
'\u010c' # 0xC8 -> LATIN CAPITAL LETTER C WITH CARON
'\u2026' # 0xC9 -> HORIZONTAL ELLIPSIS
'\xa0' # 0xCA -> NO-BREAK SPACE
'\xc0' # 0xCB -> LATIN CAPITAL LETTER A WITH GRAVE
'\xc3' # 0xCC -> LATIN CAPITAL LETTER A WITH TILDE
'\xd5' # 0xCD -> LATIN CAPITAL LETTER O WITH TILDE
'\u0152' # 0xCE -> LATIN CAPITAL LIGATURE OE
'\u0153' # 0xCF -> LATIN SMALL LIGATURE OE
'\u0110' # 0xD0 -> LATIN CAPITAL LETTER D WITH STROKE
'\u2014' # 0xD1 -> EM DASH
'\u201c' # 0xD2 -> LEFT DOUBLE QUOTATION MARK
'\u201d' # 0xD3 -> RIGHT DOUBLE QUOTATION MARK
'\u2018' # 0xD4 -> LEFT SINGLE QUOTATION MARK
'\u2019' # 0xD5 -> RIGHT SINGLE QUOTATION MARK
'\xf7' # 0xD6 -> DIVISION SIGN
'\u25ca' # 0xD7 -> LOZENGE
'\uf8ff' # 0xD8 -> Apple logo
'\xa9' # 0xD9 -> COPYRIGHT SIGN
'\u2044' # 0xDA -> FRACTION SLASH
'\u20ac' # 0xDB -> EURO SIGN
'\u2039' # 0xDC -> SINGLE LEFT-POINTING ANGLE QUOTATION MARK
'\u203a' # 0xDD -> SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
'\xc6' # 0xDE -> LATIN CAPITAL LETTER AE
'\xbb' # 0xDF -> RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
'\u2013' # 0xE0 -> EN DASH
'\xb7' # 0xE1 -> MIDDLE DOT
'\u201a' # 0xE2 -> SINGLE LOW-9 QUOTATION MARK
'\u201e' # 0xE3 -> DOUBLE LOW-9 QUOTATION MARK
'\u2030' # 0xE4 -> PER MILLE SIGN
'\xc2' # 0xE5 -> LATIN CAPITAL LETTER A WITH CIRCUMFLEX
'\u0107' # 0xE6 -> LATIN SMALL LETTER C WITH ACUTE
'\xc1' # 0xE7 -> LATIN CAPITAL LETTER A WITH ACUTE
'\u010d' # 0xE8 -> LATIN SMALL LETTER C WITH CARON
'\xc8' # 0xE9 -> LATIN CAPITAL LETTER E WITH GRAVE
'\xcd' # 0xEA -> LATIN CAPITAL LETTER I WITH ACUTE
'\xce' # 0xEB -> LATIN CAPITAL LETTER I WITH CIRCUMFLEX
'\xcf' # 0xEC -> LATIN CAPITAL LETTER I WITH DIAERESIS
'\xcc' # 0xED -> LATIN CAPITAL LETTER I WITH GRAVE
'\xd3' # 0xEE -> LATIN CAPITAL LETTER O WITH ACUTE
'\xd4' # 0xEF -> LATIN CAPITAL LETTER O WITH CIRCUMFLEX
'\u0111' # 0xF0 -> LATIN SMALL LETTER D WITH STROKE
'\xd2' # 0xF1 -> LATIN CAPITAL LETTER O WITH GRAVE
'\xda' # 0xF2 -> LATIN CAPITAL LETTER U WITH ACUTE
'\xdb' # 0xF3 -> LATIN CAPITAL LETTER U WITH CIRCUMFLEX
'\xd9' # 0xF4 -> LATIN CAPITAL LETTER U WITH GRAVE
'\u0131' # 0xF5 -> LATIN SMALL LETTER DOTLESS I
'\u02c6' # 0xF6 -> MODIFIER LETTER CIRCUMFLEX ACCENT
'\u02dc' # 0xF7 -> SMALL TILDE
'\xaf' # 0xF8 -> MACRON
'\u03c0' # 0xF9 -> GREEK SMALL LETTER PI
'\xcb' # 0xFA -> LATIN CAPITAL LETTER E WITH DIAERESIS
'\u02da' # 0xFB -> RING ABOVE
'\xb8' # 0xFC -> CEDILLA
'\xca' # 0xFD -> LATIN CAPITAL LETTER E WITH CIRCUMFLEX
'\xe6' # 0xFE -> LATIN SMALL LETTER AE
'\u02c7' # 0xFF -> CARON
)
### Encoding table
encoding_table=codecs.charmap_build(decoding_table)
|
napalm-automation/napalm-yang | refs/heads/develop | napalm_yang/models/openconfig/network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/__init__.py | 1 | # -*- coding: utf-8 -*-
from operator import attrgetter
from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
from pyangbind.lib.yangtypes import RestrictedClassType
from pyangbind.lib.yangtypes import TypedListType
from pyangbind.lib.yangtypes import YANGBool
from pyangbind.lib.yangtypes import YANGListType
from pyangbind.lib.yangtypes import YANGDynClass
from pyangbind.lib.yangtypes import ReferenceType
from pyangbind.lib.base import PybindBase
from collections import OrderedDict
from decimal import Decimal
from bitarray import bitarray
import six
# PY3 support of some PY2 keywords (needs improved)
if six.PY3:
import builtins as __builtin__
long = int
elif six.PY2:
import __builtin__
class state(PybindBase):
"""
This class was auto-generated by the PythonClass plugin for PYANG
from YANG module openconfig-network-instance - based on the path /network-instances/network-instance/protocols/protocol/isis/interfaces/interface/levels/level/packet-counters/iih/state. Each member element of
the container is represented as a class variable - with a specific
YANG type.
YANG Description: Operational counters relating to IIH PDUs
"""
__slots__ = (
"_path_helper",
"_extmethods",
"__received",
"__processed",
"__dropped",
"__sent",
"__retransmit",
)
_yang_name = "state"
_pybind_generated_by = "container"
def __init__(self, *args, **kwargs):
self._path_helper = False
self._extmethods = False
self.__received = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="received",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
self.__processed = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="processed",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
self.__dropped = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="dropped",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
self.__sent = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="sent",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
self.__retransmit = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="retransmit",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
load = kwargs.pop("load", None)
if args:
if len(args) > 1:
raise TypeError("cannot create a YANG container with >1 argument")
all_attr = True
for e in self._pyangbind_elements:
if not hasattr(args[0], e):
all_attr = False
break
if not all_attr:
raise ValueError("Supplied object did not have the correct attributes")
for e in self._pyangbind_elements:
nobj = getattr(args[0], e)
if nobj._changed() is False:
continue
setmethod = getattr(self, "_set_%s" % e)
if load is None:
setmethod(getattr(args[0], e))
else:
setmethod(getattr(args[0], e), load=load)
def _path(self):
if hasattr(self, "_parent"):
return self._parent._path() + [self._yang_name]
else:
return [
"network-instances",
"network-instance",
"protocols",
"protocol",
"isis",
"interfaces",
"interface",
"levels",
"level",
"packet-counters",
"iih",
"state",
]
def _get_received(self):
"""
Getter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/received (yang:counter32)
YANG Description: The number of the specified type of PDU received on the interface.
"""
return self.__received
def _set_received(self, v, load=False):
"""
Setter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/received (yang:counter32)
If this variable is read-only (config: false) in the
source YANG file, then _set_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_received() directly.
YANG Description: The number of the specified type of PDU received on the interface.
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(
v,
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="received",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
except (TypeError, ValueError):
raise ValueError(
{
"error-string": """received must be of a type compatible with yang:counter32""",
"defined-type": "yang:counter32",
"generated-type": """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="received", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='yang:counter32', is_config=False)""",
}
)
self.__received = t
if hasattr(self, "_set"):
self._set()
def _unset_received(self):
self.__received = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="received",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
def _get_processed(self):
"""
Getter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/processed (yang:counter32)
YANG Description: The number of the specified type of PDU received on the interface
that have been processed by the local system.
"""
return self.__processed
def _set_processed(self, v, load=False):
"""
Setter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/processed (yang:counter32)
If this variable is read-only (config: false) in the
source YANG file, then _set_processed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_processed() directly.
YANG Description: The number of the specified type of PDU received on the interface
that have been processed by the local system.
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(
v,
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="processed",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
except (TypeError, ValueError):
raise ValueError(
{
"error-string": """processed must be of a type compatible with yang:counter32""",
"defined-type": "yang:counter32",
"generated-type": """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="processed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='yang:counter32', is_config=False)""",
}
)
self.__processed = t
if hasattr(self, "_set"):
self._set()
def _unset_processed(self):
self.__processed = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="processed",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
def _get_dropped(self):
"""
Getter method for dropped, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/dropped (yang:counter32)
YANG Description: The number of the specified type of PDU received on the interface
that have been dropped.
"""
return self.__dropped
def _set_dropped(self, v, load=False):
"""
Setter method for dropped, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/dropped (yang:counter32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dropped is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dropped() directly.
YANG Description: The number of the specified type of PDU received on the interface
that have been dropped.
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(
v,
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="dropped",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
except (TypeError, ValueError):
raise ValueError(
{
"error-string": """dropped must be of a type compatible with yang:counter32""",
"defined-type": "yang:counter32",
"generated-type": """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="dropped", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='yang:counter32', is_config=False)""",
}
)
self.__dropped = t
if hasattr(self, "_set"):
self._set()
def _unset_dropped(self):
self.__dropped = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="dropped",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
def _get_sent(self):
"""
Getter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/sent (yang:counter32)
YANG Description: The number of the specified type of PDU that have been sent by the
local system on the interface.
"""
return self.__sent
def _set_sent(self, v, load=False):
"""
Setter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/sent (yang:counter32)
If this variable is read-only (config: false) in the
source YANG file, then _set_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sent() directly.
YANG Description: The number of the specified type of PDU that have been sent by the
local system on the interface.
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(
v,
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="sent",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
except (TypeError, ValueError):
raise ValueError(
{
"error-string": """sent must be of a type compatible with yang:counter32""",
"defined-type": "yang:counter32",
"generated-type": """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="sent", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='yang:counter32', is_config=False)""",
}
)
self.__sent = t
if hasattr(self, "_set"):
self._set()
def _unset_sent(self):
self.__sent = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="sent",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
def _get_retransmit(self):
"""
Getter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/retransmit (yang:counter32)
YANG Description: The number of the specified type of PDU that that have been
retransmitted by the local system on the interface.
"""
return self.__retransmit
def _set_retransmit(self, v, load=False):
"""
Setter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/retransmit (yang:counter32)
If this variable is read-only (config: false) in the
source YANG file, then _set_retransmit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_retransmit() directly.
YANG Description: The number of the specified type of PDU that that have been
retransmitted by the local system on the interface.
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(
v,
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="retransmit",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
except (TypeError, ValueError):
raise ValueError(
{
"error-string": """retransmit must be of a type compatible with yang:counter32""",
"defined-type": "yang:counter32",
"generated-type": """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="retransmit", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='yang:counter32', is_config=False)""",
}
)
self.__retransmit = t
if hasattr(self, "_set"):
self._set()
def _unset_retransmit(self):
self.__retransmit = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="retransmit",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
received = __builtin__.property(_get_received)
processed = __builtin__.property(_get_processed)
dropped = __builtin__.property(_get_dropped)
sent = __builtin__.property(_get_sent)
retransmit = __builtin__.property(_get_retransmit)
_pyangbind_elements = OrderedDict(
[
("received", received),
("processed", processed),
("dropped", dropped),
("sent", sent),
("retransmit", retransmit),
]
)
class state(PybindBase):
"""
This class was auto-generated by the PythonClass plugin for PYANG
from YANG module openconfig-network-instance-l2 - based on the path /network-instances/network-instance/protocols/protocol/isis/interfaces/interface/levels/level/packet-counters/iih/state. Each member element of
the container is represented as a class variable - with a specific
YANG type.
YANG Description: Operational counters relating to IIH PDUs
"""
__slots__ = (
"_path_helper",
"_extmethods",
"__received",
"__processed",
"__dropped",
"__sent",
"__retransmit",
)
_yang_name = "state"
_pybind_generated_by = "container"
def __init__(self, *args, **kwargs):
self._path_helper = False
self._extmethods = False
self.__received = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="received",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
self.__processed = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="processed",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
self.__dropped = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="dropped",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
self.__sent = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="sent",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
self.__retransmit = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="retransmit",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
load = kwargs.pop("load", None)
if args:
if len(args) > 1:
raise TypeError("cannot create a YANG container with >1 argument")
all_attr = True
for e in self._pyangbind_elements:
if not hasattr(args[0], e):
all_attr = False
break
if not all_attr:
raise ValueError("Supplied object did not have the correct attributes")
for e in self._pyangbind_elements:
nobj = getattr(args[0], e)
if nobj._changed() is False:
continue
setmethod = getattr(self, "_set_%s" % e)
if load is None:
setmethod(getattr(args[0], e))
else:
setmethod(getattr(args[0], e), load=load)
def _path(self):
if hasattr(self, "_parent"):
return self._parent._path() + [self._yang_name]
else:
return [
"network-instances",
"network-instance",
"protocols",
"protocol",
"isis",
"interfaces",
"interface",
"levels",
"level",
"packet-counters",
"iih",
"state",
]
def _get_received(self):
"""
Getter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/received (yang:counter32)
YANG Description: The number of the specified type of PDU received on the interface.
"""
return self.__received
def _set_received(self, v, load=False):
"""
Setter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/received (yang:counter32)
If this variable is read-only (config: false) in the
source YANG file, then _set_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_received() directly.
YANG Description: The number of the specified type of PDU received on the interface.
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(
v,
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="received",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
except (TypeError, ValueError):
raise ValueError(
{
"error-string": """received must be of a type compatible with yang:counter32""",
"defined-type": "yang:counter32",
"generated-type": """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="received", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='yang:counter32', is_config=False)""",
}
)
self.__received = t
if hasattr(self, "_set"):
self._set()
def _unset_received(self):
self.__received = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="received",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
def _get_processed(self):
"""
Getter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/processed (yang:counter32)
YANG Description: The number of the specified type of PDU received on the interface
that have been processed by the local system.
"""
return self.__processed
def _set_processed(self, v, load=False):
"""
Setter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/processed (yang:counter32)
If this variable is read-only (config: false) in the
source YANG file, then _set_processed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_processed() directly.
YANG Description: The number of the specified type of PDU received on the interface
that have been processed by the local system.
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(
v,
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="processed",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
except (TypeError, ValueError):
raise ValueError(
{
"error-string": """processed must be of a type compatible with yang:counter32""",
"defined-type": "yang:counter32",
"generated-type": """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="processed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='yang:counter32', is_config=False)""",
}
)
self.__processed = t
if hasattr(self, "_set"):
self._set()
def _unset_processed(self):
self.__processed = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="processed",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
def _get_dropped(self):
"""
Getter method for dropped, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/dropped (yang:counter32)
YANG Description: The number of the specified type of PDU received on the interface
that have been dropped.
"""
return self.__dropped
def _set_dropped(self, v, load=False):
"""
Setter method for dropped, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/dropped (yang:counter32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dropped is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dropped() directly.
YANG Description: The number of the specified type of PDU received on the interface
that have been dropped.
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(
v,
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="dropped",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
except (TypeError, ValueError):
raise ValueError(
{
"error-string": """dropped must be of a type compatible with yang:counter32""",
"defined-type": "yang:counter32",
"generated-type": """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="dropped", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='yang:counter32', is_config=False)""",
}
)
self.__dropped = t
if hasattr(self, "_set"):
self._set()
def _unset_dropped(self):
self.__dropped = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="dropped",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
def _get_sent(self):
"""
Getter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/sent (yang:counter32)
YANG Description: The number of the specified type of PDU that have been sent by the
local system on the interface.
"""
return self.__sent
def _set_sent(self, v, load=False):
"""
Setter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/sent (yang:counter32)
If this variable is read-only (config: false) in the
source YANG file, then _set_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sent() directly.
YANG Description: The number of the specified type of PDU that have been sent by the
local system on the interface.
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(
v,
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="sent",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
except (TypeError, ValueError):
raise ValueError(
{
"error-string": """sent must be of a type compatible with yang:counter32""",
"defined-type": "yang:counter32",
"generated-type": """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="sent", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='yang:counter32', is_config=False)""",
}
)
self.__sent = t
if hasattr(self, "_set"):
self._set()
def _unset_sent(self):
self.__sent = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="sent",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
def _get_retransmit(self):
"""
Getter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/retransmit (yang:counter32)
YANG Description: The number of the specified type of PDU that that have been
retransmitted by the local system on the interface.
"""
return self.__retransmit
def _set_retransmit(self, v, load=False):
"""
Setter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/retransmit (yang:counter32)
If this variable is read-only (config: false) in the
source YANG file, then _set_retransmit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_retransmit() directly.
YANG Description: The number of the specified type of PDU that that have been
retransmitted by the local system on the interface.
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(
v,
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="retransmit",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
except (TypeError, ValueError):
raise ValueError(
{
"error-string": """retransmit must be of a type compatible with yang:counter32""",
"defined-type": "yang:counter32",
"generated-type": """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="retransmit", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='yang:counter32', is_config=False)""",
}
)
self.__retransmit = t
if hasattr(self, "_set"):
self._set()
def _unset_retransmit(self):
self.__retransmit = YANGDynClass(
base=RestrictedClassType(
base_type=long,
restriction_dict={"range": ["0..4294967295"]},
int_size=32,
),
is_leaf=True,
yang_name="retransmit",
parent=self,
path_helper=self._path_helper,
extmethods=self._extmethods,
register_paths=True,
namespace="http://openconfig.net/yang/network-instance",
defining_module="openconfig-network-instance",
yang_type="yang:counter32",
is_config=False,
)
received = __builtin__.property(_get_received)
processed = __builtin__.property(_get_processed)
dropped = __builtin__.property(_get_dropped)
sent = __builtin__.property(_get_sent)
retransmit = __builtin__.property(_get_retransmit)
_pyangbind_elements = OrderedDict(
[
("received", received),
("processed", processed),
("dropped", dropped),
("sent", sent),
("retransmit", retransmit),
]
)
|
dOpensource/dsiprouter | refs/heads/master | gui/globals.py | 1 | #
# TODO: this module shadows globals() builtin, which is a bad practice
# and may have unintended consequences elsewhere, we need to find a better implementation
#
# Also, we lose the state of global required if dsiprouter restarts
# which means kamailio may not have reloaded memory at all
# We should track the state of reloads in a file or database (the latter preferably)
#
def initialize():
global reload_required
global licensed
globals()['licensed'] = False
globals()['reload_required'] = False
# allow references in code before initialize is called
reload_required = globals()['reload_required'] if 'reload_required' in globals() else False
licensed = globals()['licensed'] if 'licensed' in globals() else False
|
Tejal011089/paypal_erpnext | refs/heads/develop | erpnext/stock/doctype/stock_settings/stock_settings.py | 63 | # Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
# For license information, please see license.txt
from __future__ import unicode_literals
import frappe
from frappe import _
from frappe.utils import cint
from frappe.model.document import Document
class StockSettings(Document):
def validate(self):
for key in ["item_naming_by", "item_group", "stock_uom", "allow_negative_stock"]:
frappe.db.set_default(key, self.get(key, ""))
from erpnext.setup.doctype.naming_series.naming_series import set_by_naming_series
set_by_naming_series("Item", "item_code",
self.get("item_naming_by")=="Naming Series", hide_name_field=True)
stock_frozen_limit = 356
submitted_stock_frozen = self.stock_frozen_upto_days
if submitted_stock_frozen > stock_frozen_limit:
self.stock_frozen_upto_days = stock_frozen_limit
frappe.msgprint (_("`Freeze Stocks Older Than` should be smaller than %d days.") %stock_frozen_limit)
|
dimasad/numpy | refs/heads/master | numpy/tests/test_ctypeslib.py | 69 | from __future__ import division, absolute_import, print_function
import sys
import numpy as np
from numpy.ctypeslib import ndpointer, load_library
from numpy.distutils.misc_util import get_shared_lib_extension
from numpy.testing import *
try:
cdll = load_library('multiarray', np.core.multiarray.__file__)
_HAS_CTYPE = True
except ImportError:
_HAS_CTYPE = False
class TestLoadLibrary(TestCase):
@dec.skipif(not _HAS_CTYPE, "ctypes not available on this python installation")
@dec.knownfailureif(sys.platform=='cygwin', "This test is known to fail on cygwin")
def test_basic(self):
try:
cdll = load_library('multiarray',
np.core.multiarray.__file__)
except ImportError as e:
msg = "ctypes is not available on this python: skipping the test" \
" (import error was: %s)" % str(e)
print(msg)
@dec.skipif(not _HAS_CTYPE, "ctypes not available on this python installation")
@dec.knownfailureif(sys.platform=='cygwin', "This test is known to fail on cygwin")
def test_basic2(self):
"""Regression for #801: load_library with a full library name
(including extension) does not work."""
try:
try:
so = get_shared_lib_extension(is_python_ext=True)
cdll = load_library('multiarray%s' % so,
np.core.multiarray.__file__)
except ImportError:
print("No distutils available, skipping test.")
except ImportError as e:
msg = "ctypes is not available on this python: skipping the test" \
" (import error was: %s)" % str(e)
print(msg)
class TestNdpointer(TestCase):
def test_dtype(self):
dt = np.intc
p = ndpointer(dtype=dt)
self.assertTrue(p.from_param(np.array([1], dt)))
dt = '<i4'
p = ndpointer(dtype=dt)
self.assertTrue(p.from_param(np.array([1], dt)))
dt = np.dtype('>i4')
p = ndpointer(dtype=dt)
p.from_param(np.array([1], dt))
self.assertRaises(TypeError, p.from_param,
np.array([1], dt.newbyteorder('swap')))
dtnames = ['x', 'y']
dtformats = [np.intc, np.float64]
dtdescr = {'names' : dtnames, 'formats' : dtformats}
dt = np.dtype(dtdescr)
p = ndpointer(dtype=dt)
self.assertTrue(p.from_param(np.zeros((10,), dt)))
samedt = np.dtype(dtdescr)
p = ndpointer(dtype=samedt)
self.assertTrue(p.from_param(np.zeros((10,), dt)))
dt2 = np.dtype(dtdescr, align=True)
if dt.itemsize != dt2.itemsize:
self.assertRaises(TypeError, p.from_param, np.zeros((10,), dt2))
else:
self.assertTrue(p.from_param(np.zeros((10,), dt2)))
def test_ndim(self):
p = ndpointer(ndim=0)
self.assertTrue(p.from_param(np.array(1)))
self.assertRaises(TypeError, p.from_param, np.array([1]))
p = ndpointer(ndim=1)
self.assertRaises(TypeError, p.from_param, np.array(1))
self.assertTrue(p.from_param(np.array([1])))
p = ndpointer(ndim=2)
self.assertTrue(p.from_param(np.array([[1]])))
def test_shape(self):
p = ndpointer(shape=(1, 2))
self.assertTrue(p.from_param(np.array([[1, 2]])))
self.assertRaises(TypeError, p.from_param, np.array([[1], [2]]))
p = ndpointer(shape=())
self.assertTrue(p.from_param(np.array(1)))
def test_flags(self):
x = np.array([[1, 2], [3, 4]], order='F')
p = ndpointer(flags='FORTRAN')
self.assertTrue(p.from_param(x))
p = ndpointer(flags='CONTIGUOUS')
self.assertRaises(TypeError, p.from_param, x)
p = ndpointer(flags=x.flags.num)
self.assertTrue(p.from_param(x))
self.assertRaises(TypeError, p.from_param, np.array([[1, 2], [3, 4]]))
if __name__ == "__main__":
run_module_suite()
|
Jgarcia-IAS/localizacion | refs/heads/master | openerp/addons-extra/odoo-pruebas/odoo-server/addons-extra/multi_store/__openerp__.py | 9 | # -*- coding: utf-8 -*-
{
'name': 'Multi Store',
'version': '1.0',
'category': 'Accounting',
'sequence': 14,
'summary': '',
'description': """
Multi Store
===========
The main purpose of this module is to restrict journals access for users on different stores.
This module add a new concept "stores" in some point similar to multicompany.
Similar to multicompany:
* User can have multiple stores available (store_ids)
* User can be active only in one store (store_id) which can be set up in his own preferences
* There is a group "multi store" that gives users the availability to see multi store fields
This module also adds a store_id field on journal:
* If store_id = False then journal can be seen by everyone
* If store_id is set, then journal can be seen by users on that store and parent stores
It also restrict edition, creation and unlink on: account.move, account.invoice and account.voucher.
It is done with the same logic to journal. We do not limitate the "read" of this models because user should need to access those documents, for example, to see partner due.
""",
'author': 'Ingenieria ADHOC',
'website': 'www.ingadhoc.com',
'images': [
],
'depends': [
'account',
'account_voucher',
'stock',
'sale',
'purchase',
'product',
],
'data': [
'views/res_store_view.xml',
'views/res_users_view.xml',
'views/account_view.xml',
'views/stock_view.xml',
'views/sale_view.xml',
'views/purchase_view.xml',
'views/product_view.xml',
'views/res_partner_view.xml',
'security/multi_store_security.xml',
'security/ir.model.access.csv',
],
'demo': [
],
'test': [
],
'installable': True,
'auto_install': False,
'application': False,
}
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
|
willbittner/datto-php-test-polymer | refs/heads/master | node_modules/node-sass/node_modules/pangyp/gyp/pylib/gyp/MSVSNew.py | 601 | # Copyright (c) 2012 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""New implementation of Visual Studio project generation."""
import os
import random
import gyp.common
# hashlib is supplied as of Python 2.5 as the replacement interface for md5
# and other secure hashes. In 2.6, md5 is deprecated. Import hashlib if
# available, avoiding a deprecation warning under 2.6. Import md5 otherwise,
# preserving 2.4 compatibility.
try:
import hashlib
_new_md5 = hashlib.md5
except ImportError:
import md5
_new_md5 = md5.new
# Initialize random number generator
random.seed()
# GUIDs for project types
ENTRY_TYPE_GUIDS = {
'project': '{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}',
'folder': '{2150E333-8FDC-42A3-9474-1A3956D46DE8}',
}
#------------------------------------------------------------------------------
# Helper functions
def MakeGuid(name, seed='msvs_new'):
"""Returns a GUID for the specified target name.
Args:
name: Target name.
seed: Seed for MD5 hash.
Returns:
A GUID-line string calculated from the name and seed.
This generates something which looks like a GUID, but depends only on the
name and seed. This means the same name/seed will always generate the same
GUID, so that projects and solutions which refer to each other can explicitly
determine the GUID to refer to explicitly. It also means that the GUID will
not change when the project for a target is rebuilt.
"""
# Calculate a MD5 signature for the seed and name.
d = _new_md5(str(seed) + str(name)).hexdigest().upper()
# Convert most of the signature to GUID form (discard the rest)
guid = ('{' + d[:8] + '-' + d[8:12] + '-' + d[12:16] + '-' + d[16:20]
+ '-' + d[20:32] + '}')
return guid
#------------------------------------------------------------------------------
class MSVSSolutionEntry(object):
def __cmp__(self, other):
# Sort by name then guid (so things are in order on vs2008).
return cmp((self.name, self.get_guid()), (other.name, other.get_guid()))
class MSVSFolder(MSVSSolutionEntry):
"""Folder in a Visual Studio project or solution."""
def __init__(self, path, name = None, entries = None,
guid = None, items = None):
"""Initializes the folder.
Args:
path: Full path to the folder.
name: Name of the folder.
entries: List of folder entries to nest inside this folder. May contain
Folder or Project objects. May be None, if the folder is empty.
guid: GUID to use for folder, if not None.
items: List of solution items to include in the folder project. May be
None, if the folder does not directly contain items.
"""
if name:
self.name = name
else:
# Use last layer.
self.name = os.path.basename(path)
self.path = path
self.guid = guid
# Copy passed lists (or set to empty lists)
self.entries = sorted(list(entries or []))
self.items = list(items or [])
self.entry_type_guid = ENTRY_TYPE_GUIDS['folder']
def get_guid(self):
if self.guid is None:
# Use consistent guids for folders (so things don't regenerate).
self.guid = MakeGuid(self.path, seed='msvs_folder')
return self.guid
#------------------------------------------------------------------------------
class MSVSProject(MSVSSolutionEntry):
"""Visual Studio project."""
def __init__(self, path, name = None, dependencies = None, guid = None,
spec = None, build_file = None, config_platform_overrides = None,
fixpath_prefix = None):
"""Initializes the project.
Args:
path: Absolute path to the project file.
name: Name of project. If None, the name will be the same as the base
name of the project file.
dependencies: List of other Project objects this project is dependent
upon, if not None.
guid: GUID to use for project, if not None.
spec: Dictionary specifying how to build this project.
build_file: Filename of the .gyp file that the vcproj file comes from.
config_platform_overrides: optional dict of configuration platforms to
used in place of the default for this target.
fixpath_prefix: the path used to adjust the behavior of _fixpath
"""
self.path = path
self.guid = guid
self.spec = spec
self.build_file = build_file
# Use project filename if name not specified
self.name = name or os.path.splitext(os.path.basename(path))[0]
# Copy passed lists (or set to empty lists)
self.dependencies = list(dependencies or [])
self.entry_type_guid = ENTRY_TYPE_GUIDS['project']
if config_platform_overrides:
self.config_platform_overrides = config_platform_overrides
else:
self.config_platform_overrides = {}
self.fixpath_prefix = fixpath_prefix
self.msbuild_toolset = None
def set_dependencies(self, dependencies):
self.dependencies = list(dependencies or [])
def get_guid(self):
if self.guid is None:
# Set GUID from path
# TODO(rspangler): This is fragile.
# 1. We can't just use the project filename sans path, since there could
# be multiple projects with the same base name (for example,
# foo/unittest.vcproj and bar/unittest.vcproj).
# 2. The path needs to be relative to $SOURCE_ROOT, so that the project
# GUID is the same whether it's included from base/base.sln or
# foo/bar/baz/baz.sln.
# 3. The GUID needs to be the same each time this builder is invoked, so
# that we don't need to rebuild the solution when the project changes.
# 4. We should be able to handle pre-built project files by reading the
# GUID from the files.
self.guid = MakeGuid(self.name)
return self.guid
def set_msbuild_toolset(self, msbuild_toolset):
self.msbuild_toolset = msbuild_toolset
#------------------------------------------------------------------------------
class MSVSSolution:
"""Visual Studio solution."""
def __init__(self, path, version, entries=None, variants=None,
websiteProperties=True):
"""Initializes the solution.
Args:
path: Path to solution file.
version: Format version to emit.
entries: List of entries in solution. May contain Folder or Project
objects. May be None, if the folder is empty.
variants: List of build variant strings. If none, a default list will
be used.
websiteProperties: Flag to decide if the website properties section
is generated.
"""
self.path = path
self.websiteProperties = websiteProperties
self.version = version
# Copy passed lists (or set to empty lists)
self.entries = list(entries or [])
if variants:
# Copy passed list
self.variants = variants[:]
else:
# Use default
self.variants = ['Debug|Win32', 'Release|Win32']
# TODO(rspangler): Need to be able to handle a mapping of solution config
# to project config. Should we be able to handle variants being a dict,
# or add a separate variant_map variable? If it's a dict, we can't
# guarantee the order of variants since dict keys aren't ordered.
# TODO(rspangler): Automatically write to disk for now; should delay until
# node-evaluation time.
self.Write()
def Write(self, writer=gyp.common.WriteOnDiff):
"""Writes the solution file to disk.
Raises:
IndexError: An entry appears multiple times.
"""
# Walk the entry tree and collect all the folders and projects.
all_entries = set()
entries_to_check = self.entries[:]
while entries_to_check:
e = entries_to_check.pop(0)
# If this entry has been visited, nothing to do.
if e in all_entries:
continue
all_entries.add(e)
# If this is a folder, check its entries too.
if isinstance(e, MSVSFolder):
entries_to_check += e.entries
all_entries = sorted(all_entries)
# Open file and print header
f = writer(self.path)
f.write('Microsoft Visual Studio Solution File, '
'Format Version %s\r\n' % self.version.SolutionVersion())
f.write('# %s\r\n' % self.version.Description())
# Project entries
sln_root = os.path.split(self.path)[0]
for e in all_entries:
relative_path = gyp.common.RelativePath(e.path, sln_root)
# msbuild does not accept an empty folder_name.
# use '.' in case relative_path is empty.
folder_name = relative_path.replace('/', '\\') or '.'
f.write('Project("%s") = "%s", "%s", "%s"\r\n' % (
e.entry_type_guid, # Entry type GUID
e.name, # Folder name
folder_name, # Folder name (again)
e.get_guid(), # Entry GUID
))
# TODO(rspangler): Need a way to configure this stuff
if self.websiteProperties:
f.write('\tProjectSection(WebsiteProperties) = preProject\r\n'
'\t\tDebug.AspNetCompiler.Debug = "True"\r\n'
'\t\tRelease.AspNetCompiler.Debug = "False"\r\n'
'\tEndProjectSection\r\n')
if isinstance(e, MSVSFolder):
if e.items:
f.write('\tProjectSection(SolutionItems) = preProject\r\n')
for i in e.items:
f.write('\t\t%s = %s\r\n' % (i, i))
f.write('\tEndProjectSection\r\n')
if isinstance(e, MSVSProject):
if e.dependencies:
f.write('\tProjectSection(ProjectDependencies) = postProject\r\n')
for d in e.dependencies:
f.write('\t\t%s = %s\r\n' % (d.get_guid(), d.get_guid()))
f.write('\tEndProjectSection\r\n')
f.write('EndProject\r\n')
# Global section
f.write('Global\r\n')
# Configurations (variants)
f.write('\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\r\n')
for v in self.variants:
f.write('\t\t%s = %s\r\n' % (v, v))
f.write('\tEndGlobalSection\r\n')
# Sort config guids for easier diffing of solution changes.
config_guids = []
config_guids_overrides = {}
for e in all_entries:
if isinstance(e, MSVSProject):
config_guids.append(e.get_guid())
config_guids_overrides[e.get_guid()] = e.config_platform_overrides
config_guids.sort()
f.write('\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\r\n')
for g in config_guids:
for v in self.variants:
nv = config_guids_overrides[g].get(v, v)
# Pick which project configuration to build for this solution
# configuration.
f.write('\t\t%s.%s.ActiveCfg = %s\r\n' % (
g, # Project GUID
v, # Solution build configuration
nv, # Project build config for that solution config
))
# Enable project in this solution configuration.
f.write('\t\t%s.%s.Build.0 = %s\r\n' % (
g, # Project GUID
v, # Solution build configuration
nv, # Project build config for that solution config
))
f.write('\tEndGlobalSection\r\n')
# TODO(rspangler): Should be able to configure this stuff too (though I've
# never seen this be any different)
f.write('\tGlobalSection(SolutionProperties) = preSolution\r\n')
f.write('\t\tHideSolutionNode = FALSE\r\n')
f.write('\tEndGlobalSection\r\n')
# Folder mappings
# Omit this section if there are no folders
if any([e.entries for e in all_entries if isinstance(e, MSVSFolder)]):
f.write('\tGlobalSection(NestedProjects) = preSolution\r\n')
for e in all_entries:
if not isinstance(e, MSVSFolder):
continue # Does not apply to projects, only folders
for subentry in e.entries:
f.write('\t\t%s = %s\r\n' % (subentry.get_guid(), e.get_guid()))
f.write('\tEndGlobalSection\r\n')
f.write('EndGlobal\r\n')
f.close()
|
SahilTikale/switchHaaS | refs/heads/haas-as-a-switch | tests/unit/config.py | 3 | from haas.test_common import config_set
from haas import config
import sys
def test_load_extension():
"""Check that putting modules in [extensions] results in importing them."""
config_set({
'extensions': {
# These modules are chosen because:
#
# 1. They are in the standard library, and cross-platform
# 2. If you ever think you need to import these for use in
# HaaS, I will judge you.
'sndhdr': '',
'colorsys': '',
'email.mime.audio': '',
},
})
config.load_extensions()
for module in 'sndhdr', 'colorsys', 'email.mime.audio':
assert module in sys.modules
|
jeffery-do/Vizdoombot | refs/heads/master | doom/lib/python3.5/site-packages/numpy/core/tests/test_scalarmath.py | 21 | from __future__ import division, absolute_import, print_function
import sys
import itertools
import warnings
import operator
import numpy as np
from numpy.testing.utils import _gen_alignment_data
from numpy.testing import (
TestCase, run_module_suite, assert_, assert_equal, assert_raises,
assert_almost_equal, assert_allclose
)
types = [np.bool_, np.byte, np.ubyte, np.short, np.ushort, np.intc, np.uintc,
np.int_, np.uint, np.longlong, np.ulonglong,
np.single, np.double, np.longdouble, np.csingle,
np.cdouble, np.clongdouble]
floating_types = np.floating.__subclasses__()
# This compares scalarmath against ufuncs.
class TestTypes(TestCase):
def test_types(self, level=1):
for atype in types:
a = atype(1)
assert_(a == 1, "error with %r: got %r" % (atype, a))
def test_type_add(self, level=1):
# list of types
for k, atype in enumerate(types):
a_scalar = atype(3)
a_array = np.array([3], dtype=atype)
for l, btype in enumerate(types):
b_scalar = btype(1)
b_array = np.array([1], dtype=btype)
c_scalar = a_scalar + b_scalar
c_array = a_array + b_array
# It was comparing the type numbers, but the new ufunc
# function-finding mechanism finds the lowest function
# to which both inputs can be cast - which produces 'l'
# when you do 'q' + 'b'. The old function finding mechanism
# skipped ahead based on the first argument, but that
# does not produce properly symmetric results...
assert_equal(c_scalar.dtype, c_array.dtype,
"error with types (%d/'%c' + %d/'%c')" %
(k, np.dtype(atype).char, l, np.dtype(btype).char))
def test_type_create(self, level=1):
for k, atype in enumerate(types):
a = np.array([1, 2, 3], atype)
b = atype([1, 2, 3])
assert_equal(a, b)
def test_leak(self):
# test leak of scalar objects
# a leak would show up in valgrind as still-reachable of ~2.6MB
for i in range(200000):
np.add(1, 1)
class TestBaseMath(TestCase):
def test_blocked(self):
# test alignments offsets for simd instructions
# alignments for vz + 2 * (vs - 1) + 1
for dt, sz in [(np.float32, 11), (np.float64, 7)]:
for out, inp1, inp2, msg in _gen_alignment_data(dtype=dt,
type='binary',
max_size=sz):
exp1 = np.ones_like(inp1)
inp1[...] = np.ones_like(inp1)
inp2[...] = np.zeros_like(inp2)
assert_almost_equal(np.add(inp1, inp2), exp1, err_msg=msg)
assert_almost_equal(np.add(inp1, 1), exp1 + 1, err_msg=msg)
assert_almost_equal(np.add(1, inp2), exp1, err_msg=msg)
np.add(inp1, inp2, out=out)
assert_almost_equal(out, exp1, err_msg=msg)
inp2[...] += np.arange(inp2.size, dtype=dt) + 1
assert_almost_equal(np.square(inp2),
np.multiply(inp2, inp2), err_msg=msg)
assert_almost_equal(np.reciprocal(inp2),
np.divide(1, inp2), err_msg=msg)
inp1[...] = np.ones_like(inp1)
inp2[...] = np.zeros_like(inp2)
np.add(inp1, 1, out=out)
assert_almost_equal(out, exp1 + 1, err_msg=msg)
np.add(1, inp2, out=out)
assert_almost_equal(out, exp1, err_msg=msg)
def test_lower_align(self):
# check data that is not aligned to element size
# i.e doubles are aligned to 4 bytes on i386
d = np.zeros(23 * 8, dtype=np.int8)[4:-4].view(np.float64)
o = np.zeros(23 * 8, dtype=np.int8)[4:-4].view(np.float64)
assert_almost_equal(d + d, d * 2)
np.add(d, d, out=o)
np.add(np.ones_like(d), d, out=o)
np.add(d, np.ones_like(d), out=o)
np.add(np.ones_like(d), d)
np.add(d, np.ones_like(d))
class TestPower(TestCase):
def test_small_types(self):
for t in [np.int8, np.int16, np.float16]:
a = t(3)
b = a ** 4
assert_(b == 81, "error with %r: got %r" % (t, b))
def test_large_types(self):
for t in [np.int32, np.int64, np.float32, np.float64, np.longdouble]:
a = t(51)
b = a ** 4
msg = "error with %r: got %r" % (t, b)
if np.issubdtype(t, np.integer):
assert_(b == 6765201, msg)
else:
assert_almost_equal(b, 6765201, err_msg=msg)
def test_mixed_types(self):
typelist = [np.int8, np.int16, np.float16,
np.float32, np.float64, np.int8,
np.int16, np.int32, np.int64]
for t1 in typelist:
for t2 in typelist:
a = t1(3)
b = t2(2)
result = a**b
msg = ("error with %r and %r:"
"got %r, expected %r") % (t1, t2, result, 9)
if np.issubdtype(np.dtype(result), np.integer):
assert_(result == 9, msg)
else:
assert_almost_equal(result, 9, err_msg=msg)
class TestModulus(TestCase):
floordiv = operator.floordiv
mod = operator.mod
def test_modulus_basic(self):
dt = np.typecodes['AllInteger'] + np.typecodes['Float']
for dt1, dt2 in itertools.product(dt, dt):
for sg1, sg2 in itertools.product((+1, -1), (+1, -1)):
if sg1 == -1 and dt1 in np.typecodes['UnsignedInteger']:
continue
if sg2 == -1 and dt2 in np.typecodes['UnsignedInteger']:
continue
fmt = 'dt1: %s, dt2: %s, sg1: %s, sg2: %s'
msg = fmt % (dt1, dt2, sg1, sg2)
a = np.array(sg1*71, dtype=dt1)[()]
b = np.array(sg2*19, dtype=dt2)[()]
div = self.floordiv(a, b)
rem = self.mod(a, b)
assert_equal(div*b + rem, a, err_msg=msg)
if sg2 == -1:
assert_(b < rem <= 0, msg)
else:
assert_(b > rem >= 0, msg)
def test_float_modulus_exact(self):
# test that float results are exact for small integers. This also
# holds for the same integers scaled by powers of two.
nlst = list(range(-127, 0))
plst = list(range(1, 128))
dividend = nlst + [0] + plst
divisor = nlst + plst
arg = list(itertools.product(dividend, divisor))
tgt = list(divmod(*t) for t in arg)
a, b = np.array(arg, dtype=int).T
# convert exact integer results from Python to float so that
# signed zero can be used, it is checked.
tgtdiv, tgtrem = np.array(tgt, dtype=float).T
tgtdiv = np.where((tgtdiv == 0.0) & ((b < 0) ^ (a < 0)), -0.0, tgtdiv)
tgtrem = np.where((tgtrem == 0.0) & (b < 0), -0.0, tgtrem)
for dt in np.typecodes['Float']:
msg = 'dtype: %s' % (dt,)
fa = a.astype(dt)
fb = b.astype(dt)
# use list comprehension so a_ and b_ are scalars
div = [self.floordiv(a_, b_) for a_, b_ in zip(fa, fb)]
rem = [self.mod(a_, b_) for a_, b_ in zip(fa, fb)]
assert_equal(div, tgtdiv, err_msg=msg)
assert_equal(rem, tgtrem, err_msg=msg)
def test_float_modulus_roundoff(self):
# gh-6127
dt = np.typecodes['Float']
for dt1, dt2 in itertools.product(dt, dt):
for sg1, sg2 in itertools.product((+1, -1), (+1, -1)):
fmt = 'dt1: %s, dt2: %s, sg1: %s, sg2: %s'
msg = fmt % (dt1, dt2, sg1, sg2)
a = np.array(sg1*78*6e-8, dtype=dt1)[()]
b = np.array(sg2*6e-8, dtype=dt2)[()]
div = self.floordiv(a, b)
rem = self.mod(a, b)
# Equal assertion should hold when fmod is used
assert_equal(div*b + rem, a, err_msg=msg)
if sg2 == -1:
assert_(b < rem <= 0, msg)
else:
assert_(b > rem >= 0, msg)
def test_float_modulus_corner_cases(self):
# Check remainder magnitude.
for dt in np.typecodes['Float']:
b = np.array(1.0, dtype=dt)
a = np.nextafter(np.array(0.0, dtype=dt), -b)
rem = self.mod(a, b)
assert_(rem <= b, 'dt: %s' % dt)
rem = self.mod(-a, -b)
assert_(rem >= -b, 'dt: %s' % dt)
# Check nans, inf
with warnings.catch_warnings():
warnings.simplefilter('always')
warnings.simplefilter('ignore', RuntimeWarning)
for dt in np.typecodes['Float']:
fone = np.array(1.0, dtype=dt)
fzer = np.array(0.0, dtype=dt)
finf = np.array(np.inf, dtype=dt)
fnan = np.array(np.nan, dtype=dt)
rem = self.mod(fone, fzer)
assert_(np.isnan(rem), 'dt: %s' % dt)
# MSVC 2008 returns NaN here, so disable the check.
#rem = self.mod(fone, finf)
#assert_(rem == fone, 'dt: %s' % dt)
rem = self.mod(fone, fnan)
assert_(np.isnan(rem), 'dt: %s' % dt)
rem = self.mod(finf, fone)
assert_(np.isnan(rem), 'dt: %s' % dt)
class TestComplexDivision(TestCase):
def test_zero_division(self):
with np.errstate(all="ignore"):
for t in [np.complex64, np.complex128]:
a = t(0.0)
b = t(1.0)
assert_(np.isinf(b/a))
b = t(complex(np.inf, np.inf))
assert_(np.isinf(b/a))
b = t(complex(np.inf, np.nan))
assert_(np.isinf(b/a))
b = t(complex(np.nan, np.inf))
assert_(np.isinf(b/a))
b = t(complex(np.nan, np.nan))
assert_(np.isnan(b/a))
b = t(0.)
assert_(np.isnan(b/a))
def test_signed_zeros(self):
with np.errstate(all="ignore"):
for t in [np.complex64, np.complex128]:
# tupled (numerator, denominator, expected)
# for testing as expected == numerator/denominator
data = (
(( 0.0,-1.0), ( 0.0, 1.0), (-1.0,-0.0)),
(( 0.0,-1.0), ( 0.0,-1.0), ( 1.0,-0.0)),
(( 0.0,-1.0), (-0.0,-1.0), ( 1.0, 0.0)),
(( 0.0,-1.0), (-0.0, 1.0), (-1.0, 0.0)),
(( 0.0, 1.0), ( 0.0,-1.0), (-1.0, 0.0)),
(( 0.0,-1.0), ( 0.0,-1.0), ( 1.0,-0.0)),
((-0.0,-1.0), ( 0.0,-1.0), ( 1.0,-0.0)),
((-0.0, 1.0), ( 0.0,-1.0), (-1.0,-0.0))
)
for cases in data:
n = cases[0]
d = cases[1]
ex = cases[2]
result = t(complex(n[0], n[1])) / t(complex(d[0], d[1]))
# check real and imag parts separately to avoid comparison
# in array context, which does not account for signed zeros
assert_equal(result.real, ex[0])
assert_equal(result.imag, ex[1])
def test_branches(self):
with np.errstate(all="ignore"):
for t in [np.complex64, np.complex128]:
# tupled (numerator, denominator, expected)
# for testing as expected == numerator/denominator
data = list()
# trigger branch: real(fabs(denom)) > imag(fabs(denom))
# followed by else condition as neither are == 0
data.append((( 2.0, 1.0), ( 2.0, 1.0), (1.0, 0.0)))
# trigger branch: real(fabs(denom)) > imag(fabs(denom))
# followed by if condition as both are == 0
# is performed in test_zero_division(), so this is skipped
# trigger else if branch: real(fabs(denom)) < imag(fabs(denom))
data.append((( 1.0, 2.0), ( 1.0, 2.0), (1.0, 0.0)))
for cases in data:
n = cases[0]
d = cases[1]
ex = cases[2]
result = t(complex(n[0], n[1])) / t(complex(d[0], d[1]))
# check real and imag parts separately to avoid comparison
# in array context, which does not account for signed zeros
assert_equal(result.real, ex[0])
assert_equal(result.imag, ex[1])
class TestConversion(TestCase):
def test_int_from_long(self):
l = [1e6, 1e12, 1e18, -1e6, -1e12, -1e18]
li = [10**6, 10**12, 10**18, -10**6, -10**12, -10**18]
for T in [None, np.float64, np.int64]:
a = np.array(l, dtype=T)
assert_equal([int(_m) for _m in a], li)
a = np.array(l[:3], dtype=np.uint64)
assert_equal([int(_m) for _m in a], li[:3])
def test_iinfo_long_values(self):
for code in 'bBhH':
res = np.array(np.iinfo(code).max + 1, dtype=code)
tgt = np.iinfo(code).min
assert_(res == tgt)
for code in np.typecodes['AllInteger']:
res = np.array(np.iinfo(code).max, dtype=code)
tgt = np.iinfo(code).max
assert_(res == tgt)
for code in np.typecodes['AllInteger']:
res = np.typeDict[code](np.iinfo(code).max)
tgt = np.iinfo(code).max
assert_(res == tgt)
def test_int_raise_behaviour(self):
def overflow_error_func(dtype):
np.typeDict[dtype](np.iinfo(dtype).max + 1)
for code in 'lLqQ':
assert_raises(OverflowError, overflow_error_func, code)
def test_longdouble_int(self):
# gh-627
x = np.longdouble(np.inf)
assert_raises(OverflowError, x.__int__)
x = np.clongdouble(np.inf)
assert_raises(OverflowError, x.__int__)
def test_numpy_scalar_relational_operators(self):
# All integer
for dt1 in np.typecodes['AllInteger']:
assert_(1 > np.array(0, dtype=dt1)[()], "type %s failed" % (dt1,))
assert_(not 1 < np.array(0, dtype=dt1)[()], "type %s failed" % (dt1,))
for dt2 in np.typecodes['AllInteger']:
assert_(np.array(1, dtype=dt1)[()] > np.array(0, dtype=dt2)[()],
"type %s and %s failed" % (dt1, dt2))
assert_(not np.array(1, dtype=dt1)[()] < np.array(0, dtype=dt2)[()],
"type %s and %s failed" % (dt1, dt2))
#Unsigned integers
for dt1 in 'BHILQP':
assert_(-1 < np.array(1, dtype=dt1)[()], "type %s failed" % (dt1,))
assert_(not -1 > np.array(1, dtype=dt1)[()], "type %s failed" % (dt1,))
assert_(-1 != np.array(1, dtype=dt1)[()], "type %s failed" % (dt1,))
#unsigned vs signed
for dt2 in 'bhilqp':
assert_(np.array(1, dtype=dt1)[()] > np.array(-1, dtype=dt2)[()],
"type %s and %s failed" % (dt1, dt2))
assert_(not np.array(1, dtype=dt1)[()] < np.array(-1, dtype=dt2)[()],
"type %s and %s failed" % (dt1, dt2))
assert_(np.array(1, dtype=dt1)[()] != np.array(-1, dtype=dt2)[()],
"type %s and %s failed" % (dt1, dt2))
#Signed integers and floats
for dt1 in 'bhlqp' + np.typecodes['Float']:
assert_(1 > np.array(-1, dtype=dt1)[()], "type %s failed" % (dt1,))
assert_(not 1 < np.array(-1, dtype=dt1)[()], "type %s failed" % (dt1,))
assert_(-1 == np.array(-1, dtype=dt1)[()], "type %s failed" % (dt1,))
for dt2 in 'bhlqp' + np.typecodes['Float']:
assert_(np.array(1, dtype=dt1)[()] > np.array(-1, dtype=dt2)[()],
"type %s and %s failed" % (dt1, dt2))
assert_(not np.array(1, dtype=dt1)[()] < np.array(-1, dtype=dt2)[()],
"type %s and %s failed" % (dt1, dt2))
assert_(np.array(-1, dtype=dt1)[()] == np.array(-1, dtype=dt2)[()],
"type %s and %s failed" % (dt1, dt2))
#class TestRepr(TestCase):
# def test_repr(self):
# for t in types:
# val = t(1197346475.0137341)
# val_repr = repr(val)
# val2 = eval(val_repr)
# assert_equal( val, val2 )
class TestRepr(object):
def _test_type_repr(self, t):
finfo = np.finfo(t)
last_fraction_bit_idx = finfo.nexp + finfo.nmant
last_exponent_bit_idx = finfo.nexp
storage_bytes = np.dtype(t).itemsize*8
# could add some more types to the list below
for which in ['small denorm', 'small norm']:
# Values from http://en.wikipedia.org/wiki/IEEE_754
constr = np.array([0x00]*storage_bytes, dtype=np.uint8)
if which == 'small denorm':
byte = last_fraction_bit_idx // 8
bytebit = 7-(last_fraction_bit_idx % 8)
constr[byte] = 1 << bytebit
elif which == 'small norm':
byte = last_exponent_bit_idx // 8
bytebit = 7-(last_exponent_bit_idx % 8)
constr[byte] = 1 << bytebit
else:
raise ValueError('hmm')
val = constr.view(t)[0]
val_repr = repr(val)
val2 = t(eval(val_repr))
if not (val2 == 0 and val < 1e-100):
assert_equal(val, val2)
def test_float_repr(self):
# long double test cannot work, because eval goes through a python
# float
for t in [np.float32, np.float64]:
yield self._test_type_repr, t
class TestSizeOf(TestCase):
def test_equal_nbytes(self):
for type in types:
x = type(0)
assert_(sys.getsizeof(x) > x.nbytes)
def test_error(self):
d = np.float32()
assert_raises(TypeError, d.__sizeof__, "a")
class TestAbs(TestCase):
def _test_abs_func(self, absfunc):
for tp in floating_types:
x = tp(-1.5)
assert_equal(absfunc(x), 1.5)
x = tp(0.0)
res = absfunc(x)
# assert_equal() checks zero signedness
assert_equal(res, 0.0)
x = tp(-0.0)
res = absfunc(x)
assert_equal(res, 0.0)
def test_builtin_abs(self):
self._test_abs_func(abs)
def test_numpy_abs(self):
self._test_abs_func(np.abs)
if __name__ == "__main__":
run_module_suite()
|
unho/pootle | refs/heads/master | pootle/core/views/base.py | 5 | # -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from collections import OrderedDict
from django.urls import reverse
from django.utils.decorators import method_decorator
from django.utils.functional import cached_property
from django.utils.translation import get_language
from django.views.decorators.cache import never_cache
from django.views.generic import DetailView
from pootle.core.delegate import site_languages
from pootle.core.url_helpers import get_path_parts
from pootle.i18n.gettext import ugettext as _
from pootle_app.models.permissions import check_permission
from pootle_misc.util import ajax_required
from .decorators import requires_permission, set_permissions
from .mixins import GatherContextMixin, PootleJSONMixin
class PootleDetailView(GatherContextMixin, DetailView):
translate_url_path = ""
browse_url_path = ""
resource_path = ""
view_name = ""
sw_version = 0
ns = "pootle.core"
@property
def browse_url(self):
return reverse(
self.browse_url_path,
kwargs=self.url_kwargs)
@property
def cache_key(self):
return (
"%s.%s.%s.%s"
% (self.page_name,
self.view_name,
self.object.data_tool.cache_key,
self.request_lang))
@property
def request_lang(self):
return get_language()
@cached_property
def has_admin_access(self):
return check_permission('administrate', self.request)
@property
def language(self):
if self.tp:
return self.tp.language
@property
def permission_context(self):
return self.get_object()
@property
def pootle_path(self):
return self.object.pootle_path
@property
def project(self):
if self.tp:
return self.tp.project
@property
def tp(self):
return None
@property
def translate_url(self):
return reverse(
self.translate_url_path,
kwargs=self.url_kwargs)
@set_permissions
@requires_permission("view")
def dispatch(self, request, *args, **kwargs):
# get funky with the request 8/
return super(PootleDetailView, self).dispatch(request, *args, **kwargs)
@property
def languages(self):
languages = site_languages.get()
languages = (
languages.all_languages
if self.has_admin_access
else languages.languages)
lang_map = {
v: k
for k, v
in languages.items()}
return OrderedDict(
(lang_map[v], v)
for v
in sorted(languages.values()))
def get_context_data(self, *args, **kwargs):
return {
'object': self.object,
'pootle_path': self.pootle_path,
'project': self.project,
'language': self.language,
"all_languages": self.languages,
'translation_project': self.tp,
'has_admin_access': self.has_admin_access,
'resource_path': self.resource_path,
'resource_path_parts': get_path_parts(self.resource_path),
'translate_url': self.translate_url,
'browse_url': self.browse_url,
'paths_placeholder': _("Entire Project"),
'unit_api_root': "/xhr/units/"}
class PootleJSON(PootleJSONMixin, PootleDetailView):
@never_cache
@method_decorator(ajax_required)
@set_permissions
@requires_permission("view")
def dispatch(self, request, *args, **kwargs):
return super(PootleJSON, self).dispatch(request, *args, **kwargs)
class PootleAdminView(DetailView):
@set_permissions
@requires_permission("administrate")
def dispatch(self, request, *args, **kwargs):
return super(PootleAdminView, self).dispatch(request, *args, **kwargs)
@property
def permission_context(self):
return self.get_object().directory
def post(self, *args, **kwargs):
return self.get(*args, **kwargs)
|
bowang/tensorflow | refs/heads/master | tensorflow/python/kernel_tests/distributions/exponential_test.py | 76 | # Copyright 2016 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.
# ==============================================================================
"""Tests for initializers."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import importlib
import numpy as np
from tensorflow.python.client import session
from tensorflow.python.framework import constant_op
from tensorflow.python.ops import nn_ops
from tensorflow.python.ops.distributions import exponential as exponential_lib
from tensorflow.python.platform import test
from tensorflow.python.platform import tf_logging
def try_import(name): # pylint: disable=invalid-name
module = None
try:
module = importlib.import_module(name)
except ImportError as e:
tf_logging.warning("Could not import %s: %s" % (name, str(e)))
return module
stats = try_import("scipy.stats")
class ExponentialTest(test.TestCase):
def testExponentialLogPDF(self):
with session.Session():
batch_size = 6
lam = constant_op.constant([2.0] * batch_size)
lam_v = 2.0
x = np.array([2.5, 2.5, 4.0, 0.1, 1.0, 2.0], dtype=np.float32)
exponential = exponential_lib.Exponential(rate=lam)
log_pdf = exponential.log_prob(x)
self.assertEqual(log_pdf.get_shape(), (6,))
pdf = exponential.prob(x)
self.assertEqual(pdf.get_shape(), (6,))
if not stats:
return
expected_log_pdf = stats.expon.logpdf(x, scale=1 / lam_v)
self.assertAllClose(log_pdf.eval(), expected_log_pdf)
self.assertAllClose(pdf.eval(), np.exp(expected_log_pdf))
def testExponentialCDF(self):
with session.Session():
batch_size = 6
lam = constant_op.constant([2.0] * batch_size)
lam_v = 2.0
x = np.array([2.5, 2.5, 4.0, 0.1, 1.0, 2.0], dtype=np.float32)
exponential = exponential_lib.Exponential(rate=lam)
cdf = exponential.cdf(x)
self.assertEqual(cdf.get_shape(), (6,))
if not stats:
return
expected_cdf = stats.expon.cdf(x, scale=1 / lam_v)
self.assertAllClose(cdf.eval(), expected_cdf)
def testExponentialMean(self):
with session.Session():
lam_v = np.array([1.0, 4.0, 2.5])
exponential = exponential_lib.Exponential(rate=lam_v)
self.assertEqual(exponential.mean().get_shape(), (3,))
if not stats:
return
expected_mean = stats.expon.mean(scale=1 / lam_v)
self.assertAllClose(exponential.mean().eval(), expected_mean)
def testExponentialVariance(self):
with session.Session():
lam_v = np.array([1.0, 4.0, 2.5])
exponential = exponential_lib.Exponential(rate=lam_v)
self.assertEqual(exponential.variance().get_shape(), (3,))
if not stats:
return
expected_variance = stats.expon.var(scale=1 / lam_v)
self.assertAllClose(exponential.variance().eval(), expected_variance)
def testExponentialEntropy(self):
with session.Session():
lam_v = np.array([1.0, 4.0, 2.5])
exponential = exponential_lib.Exponential(rate=lam_v)
self.assertEqual(exponential.entropy().get_shape(), (3,))
if not stats:
return
expected_entropy = stats.expon.entropy(scale=1 / lam_v)
self.assertAllClose(exponential.entropy().eval(), expected_entropy)
def testExponentialSample(self):
with self.test_session():
lam = constant_op.constant([3.0, 4.0])
lam_v = [3.0, 4.0]
n = constant_op.constant(100000)
exponential = exponential_lib.Exponential(rate=lam)
samples = exponential.sample(n, seed=137)
sample_values = samples.eval()
self.assertEqual(sample_values.shape, (100000, 2))
self.assertFalse(np.any(sample_values < 0.0))
if not stats:
return
for i in range(2):
self.assertLess(
stats.kstest(
sample_values[:, i], stats.expon(scale=1.0 / lam_v[i]).cdf)[0],
0.01)
def testExponentialSampleMultiDimensional(self):
with self.test_session():
batch_size = 2
lam_v = [3.0, 22.0]
lam = constant_op.constant([lam_v] * batch_size)
exponential = exponential_lib.Exponential(rate=lam)
n = 100000
samples = exponential.sample(n, seed=138)
self.assertEqual(samples.get_shape(), (n, batch_size, 2))
sample_values = samples.eval()
self.assertFalse(np.any(sample_values < 0.0))
if not stats:
return
for i in range(2):
self.assertLess(
stats.kstest(
sample_values[:, 0, i],
stats.expon(scale=1.0 / lam_v[i]).cdf)[0],
0.01)
self.assertLess(
stats.kstest(
sample_values[:, 1, i],
stats.expon(scale=1.0 / lam_v[i]).cdf)[0],
0.01)
def testExponentialWithSoftplusRate(self):
with self.test_session():
lam = [-2.2, -3.4]
exponential = exponential_lib.ExponentialWithSoftplusRate(rate=lam)
self.assertAllClose(nn_ops.softplus(lam).eval(),
exponential.rate.eval())
if __name__ == "__main__":
test.main()
|
snehasi/servo | refs/heads/master | tests/wpt/web-platform-tests/tools/wptserve/tests/functional/docroot/test_tuple_3.py | 467 | def main(request, response):
return (202, "Giraffe"), [("Content-Type", "text/html"), ("X-Test", "PASS")], "PASS"
|
sunjerry019/photonLauncher | refs/heads/master | micron/project_guimicro/guimicro.py | 1 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
# final level Graphical User Interface for stagecontrol.py
# Swapped to PyQt5 from Tkinter, because the former is more powerful/intuitive to implement features
# microgui will pair functions with commands imported from stagecontrol.py which uses raster in turn
# I'm sorry to whoever has to maintain this GUI code. I tried my best to make it as clear and precise as
# possible but it like trying to make a HTML page using pure JavaScript and it's well...messy
# The helper codes used in this are meant to be extensible for any weird scale coding projects that you might want
# Made 2019, Sun Yudong, Wu Mingsong
# sunyudong [at] outlook [dot] sg, mingsongwu [at] outlook [dot] sg
import sys, os
# import pathlib
from PyQt5 import QtCore, QtGui, QtWidgets
import time, datetime
from PIL import Image as PILImage
import argparse
# AUDIO
from contextlib import redirect_stdout
import io, threading
# threading for interrupt
# multiprocessing so we can terminate the processes on abort
import traceback
import math
from functools import reduce
# To catch Ctrl+C
import signal
import platform, ctypes # For Windows Icon
base_dir = os.path.dirname(os.path.realpath(__file__))
root_dir = os.path.abspath(os.path.join(base_dir, ".."))
sys.path.insert(0, root_dir)
import stagecontrol, picConv
import servos
from micron import Stage as mstage # for default x and y lims
from extraFunctions import moveToCentre, ThreadWithExc, DoneObject
if platform.system() == "Windows":
from pycaw.pycaw import AudioUtilities, ISimpleAudioVolume
class MicroGui(QtWidgets.QMainWindow):
def __init__(self, devMode = False, noHome = False):
super().__init__()
self.micronInitialized = False
self.currentStatus = ""
self.devMode = devMode
self.noHome = noHome
self.customicon = os.path.join(base_dir, 'icons', 'guimicro.svg')
self._DP_optionsChangedFlag = False
# symboldefs
self.MICROSYMBOL = u"\u00B5"
self.KEYSTROKE_TIMEOUT = 10 # ms
# Default based on 100ums / 10um
# need to change on speed and interval change
self.initUI()
def initUI(self):
self.setGeometry(50, 50, 800, 700) # x, y, w, h
# moveToCentre(self)
self.setWindowTitle('Micos Stage Controller MARK II 0.15b')
self.setWindowIcon(QtGui.QIcon(self.customicon))
# Essentially the steps for the gui works like this
# Create a widget -> Create a layout -> Add widgets to layout -> Assign layout to widget -> Assign widget to window
# FONTS AND STYLES
# TODO INSERT SOME HERE
# WINDOW_WIDGET
self.window_widget = QtWidgets.QWidget()
self.window_layout = QtWidgets.QVBoxLayout()
# MENU
self.createMenu()
# / MENU
# MODE WIDGET
self.mode_widget = self.createModes()
self.window_layout.addWidget(self.mode_widget)
# / MODE WIDGET
# MAIN WIDGET
self.main_widget = QtWidgets.QStackedWidget() # We use stacked widget to avoid using a stackedlayout
# Add widgets in order of the top menu
# DrawPic, Single Raster, Array Raster, Stage Movement
self.drawpic_widget = self.create_drawpic()
self.single_raster_widget = self.create_single_raster()
self.array_raster_widget = self.create_array_raster()
self.stage_widget = self.create_stage()
self.main_widget.addWidget(self.drawpic_widget)
self.main_widget.addWidget(self.array_raster_widget)
self.main_widget.addWidget(self.single_raster_widget)
self.main_widget.addWidget(self.stage_widget)
# / MAIN WIDGET
self.window_layout.addWidget(self.main_widget)
# SHUTTER WIDGET
self.shutter_widget = self.create_shutter_control()
self.window_layout.addWidget(self.shutter_widget)
# / SHUTTER WIDGET
# STATUS BAR WIDGET
self.statusBarWidget = QtWidgets.QStatusBar()
self._statusbar_label = QtWidgets.QLabel("status")
self.setStyleSheet("QStatusBar::item { border: 0px solid black };"); # Remove border around the status
self.statusBarWidget.addWidget(self._statusbar_label, stretch = 1)
self.setStatusBar(self.statusBarWidget)
# / STATUS BAR WIDGET
# / WINDOW_WIDGET
self.window_widget.setLayout(self.window_layout)
# WRAP UP
self.setCentralWidget(self.window_widget)
self.initSettings()
self.initEventListeners()
self.initializeDevice()
self.winAudioSetMuted(False)
self.recalculateARValues()
# Set to the last menu item
self.showPage(self.main_widget.count() - 1)
if platform.system() == "Windows":
self.resize(self.minimumSizeHint())
moveToCentre(self)
# Show actual window
self.show()
def initSettings(self):
# Here we make a QSettings Object and read data from it to populate default variables
QtCore.QCoreApplication.setOrganizationName("NUS Nanomaterials Lab")
QtCore.QCoreApplication.setOrganizationDomain("physics.nus.edu.sg")
QtCore.QCoreApplication.setApplicationName("Micos Stage Controller and Shutter")
# These settings are to be shared between this and shutterbtn
self.qsettings = QtCore.QSettings()
self.set_shutterAbsoluteMode = self.qsettings.value("shutter/absoluteMode", True, type = bool)
self.set_shutterChannel = self.qsettings.value("shutter/channel", servos.Servo.RIGHTCH, type = int)
self.set_powerAbsoluteMode = self.qsettings.value("power/absoluteMode", False, type = bool)
self.set_invertx = self.qsettings.value("stage/invertx", False, type = bool)
self.set_inverty = self.qsettings.value("stage/inverty", False, type = bool)
self.set_stageConfig = self.qsettings.value("stage/config", None, type = dict) # Should be a dictionary
self.explicitNoHomeSet = self.noHome
self.noHome = self.qsettings.value("stage/noHome", False, type = bool) if not self.noHome else self.noHome
# Load nohome from settings only if not explicitly specified ^
self.set_noFinishTone = self.qsettings.value("audio/noFinishTone", True, type = bool)
self.logconsole("Settings Loaded:\n\tShutterAbsolute = {}\n\tShutterChannel = {}\n\tPowerAbsolute = {}\n\tInvert-X = {}\n\tInvert-Y = {}\n\tStageConfig = {}\n\tnoHome = {}\n\tnoFinishTone = {}".format(
self.set_shutterAbsoluteMode ,
self.set_shutterChannel ,
self.set_powerAbsoluteMode ,
self.set_invertx ,
self.set_inverty ,
self.set_stageConfig ,
self.noHome ,
self.set_noFinishTone ,
))
# Update GUI Checkboxes
self._SL_invertx_checkbox.setChecked(self.set_invertx)
self._SL_inverty_checkbox.setChecked(self.set_inverty)
# Settings will be reloaded whenever the settings window is called
# self.qsettings.sync()
def startInterruptHandler(self):
# Usually not started because signal doesn't work with PyQt anyway
# https://stackoverflow.com/a/4205386/3211506
signal.signal(signal.SIGINT, self.KeyboardInterruptHandler)
def KeyboardInterruptHandler(self, signal = None, frame = None, abortTrigger = False):
# 2 args above for use with signal.signal
# ALt + B also aborts
# Disable the abort button
self._abortBtn.setEnabled(False)
self._abortBtn.setStyleSheet("background-color: #ccc;")
# Close shutter
self.stageControl.controller.shutter.quietLog = True
if not abortTrigger:
self.setOperationStatus("^C Detected: Aborting the FIFO stack. Shutter will be closed as part of the aborting process.")
else:
self.setOperationStatus("Aborting the FIFO stack. Shutter will be closed as part of the aborting process.")
self.stageControl.controller.shutter.close()
self.stageControl.controller.shutter.quietLog = False
# / Close shutter
# End all running threads
main_thread = threading.main_thread()
for p in threading.enumerate():
if p is main_thread:
continue
if isinstance(p, ThreadWithExc):
p.terminate()
# / End all running threads
if not self.devMode:
self.stageControl.controller.abort()
self._SR_start.setEnabled(True)
self._AR_start.setEnabled(True)
# Enable the abort button
self._abortBtn.setStyleSheet("background-color: #DF2928;")
self._abortBtn.setEnabled(True)
# self.dev.close()
# print("Exiting")
# sys.exit(1)
# use os._exit(1) to avoid raising any SystemExit exception
def initializeDevice(self):
# We create a blocked window which the user cannot close
initWindow = QtWidgets.QDialog()
initWindow.setWindowTitle("Initializing...")
self.setOperationStatus("Initializing StageControl()")
initWindow.setGeometry(50, 50, 300, 200)
initWindow.setWindowFlags(QtCore.Qt.WindowTitleHint | QtCore.Qt.Dialog | QtCore.Qt.WindowMaximizeButtonHint | QtCore.Qt.CustomizeWindowHint)
initWindow.setWindowIcon(QtGui.QIcon(self.customicon))
moveToCentre(initWindow)
initWindow_layout = QtWidgets.QVBoxLayout()
initWindow_wrapper_widget = QtWidgets.QWidget()
initWindow_wrapper_layout = QtWidgets.QVBoxLayout()
statusLabel = QtWidgets.QLabel("Initializing...")
statusLabel.setWordWrap(True)
statusLabel.setMaximumWidth(250)
topLabel = QtWidgets.QLabel("--- INITIALIZING STAGECONTROL---")
topLabel.setAlignment(QtCore.Qt.AlignCenter)
bottomLabel = QtWidgets.QLabel("-- PLEASE WAIT AND DO NOT CLOSE --")
bottomLabel.setAlignment(QtCore.Qt.AlignCenter)
lineC = QtWidgets.QFrame()
lineC.setFrameShape(QtWidgets.QFrame.HLine);
lineD = QtWidgets.QFrame()
lineD.setFrameShape(QtWidgets.QFrame.HLine);
initWindow_wrapper_layout.addWidget(topLabel)
initWindow_wrapper_layout.addWidget(lineC)
initWindow_wrapper_layout.addStretch(1)
initWindow_wrapper_layout.addWidget(statusLabel)
initWindow_wrapper_layout.addStretch(1)
initWindow_wrapper_layout.addWidget(lineD)
initWindow_wrapper_layout.addWidget(bottomLabel)
initWindow_wrapper_widget.setLayout(initWindow_wrapper_layout)
initWindow_layout.addWidget(initWindow_wrapper_widget)
initWindow.setLayout(initWindow_layout)
# We create a file-like object to capture the micron-messages
f = io.StringIO()
l = []
def initMicron():
self.stageControl = None
with redirect_stdout(f):
if self.devMode:
# Following code is for testing and emulation of homing commands
# for i in range(2):
# print("Message number:", i)
# time.sleep(1)
self.stageControl = stagecontrol.StageControl(noCtrlCHandler = True, devMode = True, GUI_Object = self, shutter_channel = self.set_shutterChannel, shutterAbsolute = self.set_shutterAbsoluteMode, powerAbsolute = self.set_powerAbsoluteMode, noFinishTone = self.set_noFinishTone)
else:
try:
self.stageControl = stagecontrol.StageControl(
noCtrlCHandler = True,
GUI_Object = self,
noHome = self.noHome,
noinvertx = -1 if self.set_invertx else 1,
noinverty = -1 if self.set_inverty else 1,
stageConfig = self.set_stageConfig,
shutter_channel = self.set_shutterChannel,
shutterAbsolute = self.set_shutterAbsoluteMode,
powerAbsolute = self.set_powerAbsoluteMode,
noFinishTone = self.set_noFinishTone,
)
except RuntimeError as e:
initWindow.close()
# mb.setTextFormat(Qt.RichText)
# mb.setDetailedText(message)
# msgBox.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse)
self.EL_self_criticalDialog.emit("System has encountered a RuntimeError and will now exit.", "Oh no!", "Error: {}".format(e), True)
# Clean up unneeded settings
del self.set_shutterChannel
del self.set_shutterAbsoluteMode
del self.set_powerAbsoluteMode
del self.set_invertx
del self.set_inverty
del self.set_stageConfig
del self.set_noFinishTone
self.micronInitialized = True
self.setOperationStatus("StageControl Initialized")
def printStuff():
prevValue = ""
while True:
q = f.getvalue()
if q != prevValue:
prevValue = q
status = q.split("\n")[-2].strip()
# l.append(status)
# initWindow.setWindowTitle(q.split()[-1].strip())
self.setOperationStatus(status, printToTerm = False)
statusLabel.setText(status)
if threading.activeCount() == baselineThreads:
# The initialization is done and we quit the initWindow
self.updatePositionDisplay()
initWindow.close()
break
time.sleep(0.5) # We have to sleep to release the lock on f
thread1 = threading.Thread(target = initMicron, args = ())
thread2 = threading.Thread(target = printStuff, args = ())
thread1.start()
baselineThreads = threading.activeCount()
thread2.start()
# We need exec so that the event loop is started to show the widgets
initWindow.exec_()
# We end the initWindow from the thread itself since code below .exec() doesn't actually get run
# This is because .exec() starts a loop that blocks the process
# exec() and exec_() is equivalent for Py3
# thread1.join()
# thread2.join()
# initWindow.close()
# We declare a decorator to initialize a widget and assign the layout
def make_widget_from_layout(function):
def wrapper(self):
# We create a widget
widget = QtWidgets.QWidget()
# Get the layout
layout = function(self, widget)
# Assign the layout to the widget
widget.setLayout(layout)
return widget
return wrapper
# Menu
def createMenu(self):
menu_bar = self.menuBar()
# File Menu
file_menu = menu_bar.addMenu("File")
settings = QtWidgets.QAction("Settings", self)
settings.setShortcut("Ctrl+,")
settings.setStatusTip('Configure the application')
settings.triggered.connect(self.showSettings)
file_menu.addAction(settings)
quit = QtWidgets.QAction("Quit", self)
quit.setShortcut("Ctrl+Q")
quit.setStatusTip('Exit application')
quit.triggered.connect(self.close)
file_menu.addAction(quit)
# Help Menu
help_menu = menu_bar.addMenu("Help")
about = QtWidgets.QAction("About", self)
about.setStatusTip('About this application')
about.triggered.connect(self.showAbout)
help_menu.addAction(about)
def showAbout(self):
self.exPopup = aboutPopUp(parent = self)
self.exPopup.exec_() # show()
# buttonReply = QtWidgets.QMessageBox.about(self, 'About', "Made 2019, Sun Yudong, Wu Mingsong\n\nsunyudong [at] outlook [dot] sg\n\nmingsongwu [at] outlook [dot] sg")
def showSettings(self):
self.settingsScreen = SettingsScreen(parent = self)
self.settingsScreen.exec_()
# Top row buttons
@make_widget_from_layout
def createModes(self, widget):
_mode_layout = QtWidgets.QHBoxLayout()
self._modes = [
QtWidgets.QPushButton("Draw &Picture") ,
QtWidgets.QPushButton("&Array Raster") ,
QtWidgets.QPushButton("Single &Raster") ,
QtWidgets.QPushButton("&Stage Movement")
]
# for i, btn in enumerate(_modes):
# _modes[i].clicked.connect(lambda: self.showPage(i))
# Somehow I cannot dynamic the showpage index
self._modes[0].clicked.connect(lambda: self.showPage(0))
self._modes[1].clicked.connect(lambda: self.showPage(1))
self._modes[2].clicked.connect(lambda: self.showPage(2))
self._modes[3].clicked.connect(lambda: self.showPage(3))
for btn in self._modes:
_mode_layout.addWidget(btn)
return _mode_layout
def showPage(self, page):
# Page 0 = Draw Picture
# Page 1 = Array Raster
# Page 2 = Single Raster
# Page 3 = Stage Movement
# Change colour of the current tab
self._modes[self.main_widget.currentIndex()].setStyleSheet("")
self._modes[page].setStyleSheet("border : 0px; border-bottom : 4px solid #09c; padding-bottom: 3px; padding-top: -3px")
self.main_widget.setCurrentIndex(page)
if page == 3:
self.updatePositionDisplay()
# Shutter Control layout
@make_widget_from_layout
def create_shutter_control(self, widget):
_shutter_layout = QtWidgets.QGridLayout()
# Shutter controls
self._shutter_label = QtWidgets.QLabel("Shutter Controls")
self._shutter_state = QtWidgets.QLabel() # Change color
self._open_shutter = QtWidgets.QPushButton("&Open")
self._close_shutter = QtWidgets.QPushButton("&Close")
self._abortBtn = QtWidgets.QPushButton("A&bort")
self._shutter_state.setStyleSheet("QLabel { background-color: #DF2928; }")
self._shutter_state.setAlignment(QtCore.Qt.AlignCenter)
self._abortBtn.setMinimumHeight(50)
self._abortBtn.setStyleSheet("background-color: #DF2928;")
_shutter_layout.addWidget(self._shutter_label, 0, 0)
_shutter_layout.addWidget(self._shutter_state, 0, 1)
_shutter_layout.addWidget(self._open_shutter, 0, 2)
_shutter_layout.addWidget(self._close_shutter, 0, 3)
_shutter_layout.addWidget(self._abortBtn, 1, 0, 1, 4)
return _shutter_layout
# first layout
@make_widget_from_layout
def create_stage(self, widget):
# Create all child elements
# need to link to stagecontrol to read position of controllers
# LCDS
_lcdx_label = QtWidgets.QLabel("Current X")
_lcdy_label = QtWidgets.QLabel("Current Y")
_lcdx_label.setAlignment(QtCore.Qt.AlignCenter)
_lcdy_label.setAlignment(QtCore.Qt.AlignCenter)
_lcdx_label.setMaximumHeight(20)
_lcdy_label.setMaximumHeight(20)
self._lcdx = QtWidgets.QLCDNumber()
self._lcdx.setDigitCount(8)
self._lcdx.setSmallDecimalPoint(True)
self._lcdx.setMaximumHeight(200)
self._lcdx.setMinimumHeight(150)
self._lcdy = QtWidgets.QLCDNumber()
self._lcdy.setDigitCount(8)
self._lcdy.setSmallDecimalPoint(True)
self._lcdy.setMaximumHeight(200)
self._lcdy.setMinimumHeight(150)
# TODO: Some styling here for the QLCD number
# BUTTONS
self._upArrow = QtWidgets.QPushButton(u'\u21E7')
self._downArrow = QtWidgets.QPushButton(u'\u21E9')
self._leftArrow = QtWidgets.QPushButton(u'\u21E6')
self._rightArrow = QtWidgets.QPushButton(u'\u21E8')
self._homeBtn = QtWidgets.QPushButton("Home\nStage")
self._stage_buttons = [
self._upArrow ,
self._downArrow ,
self._leftArrow ,
self._rightArrow ,
self._homeBtn ,
]
for btn in self._stage_buttons:
btn.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
btn.setMaximumHeight(150)
self.arrowFont = QtGui.QFont("Arial", 30)
self.arrowFont.setBold(True)
self._upArrow.setFont(self.arrowFont); self._downArrow.setFont(self.arrowFont); self._leftArrow.setFont(self.arrowFont); self._rightArrow.setFont(self.arrowFont);
# SETTINGS AND PARAMS
_velocity_label = QtWidgets.QLabel("Velocity ({}m/s)".format(self.MICROSYMBOL))
_velocity_label.setAlignment(QtCore.Qt.AlignRight)
_step_size_label = QtWidgets.QLabel("Step size ({}m)".format(self.MICROSYMBOL))
self._SL_velocity = QtWidgets.QLineEdit()
self._SL_velocity.setText('100')
self._SL_velocity.setValidator(QtGui.QDoubleValidator(0,10000, 12))
# _velocity.setFont(QtGui.QFont("Arial",20))
self._SL_step_size = QtWidgets.QLineEdit()
self._SL_step_size.setText('10')
self._SL_step_size.setValidator(QtGui.QDoubleValidator(0.5,10000, 12))
# _step_size.setFont(QtGui.QFont("Arial",20))
_SL_settings = QtWidgets.QWidget()
_SL_settings_layout = QtWidgets.QVBoxLayout()
self._SL_invertx_checkbox = QtWidgets.QCheckBox("Invert Horizontal")
self._SL_inverty_checkbox = QtWidgets.QCheckBox("Invert Vertical")
_SL_settings_layout.addWidget(self._SL_invertx_checkbox)
_SL_settings_layout.addWidget(self._SL_inverty_checkbox)
_SL_settings.setLayout(_SL_settings_layout)
# Create the layout with the child elements
_stage_layout = QtWidgets.QGridLayout()
# void QGridLayout::addWidget(QWidget *widget, int row, int column, Qt::Alignment alignment = Qt::Alignment())
# void QGridLayout::addWidget(QWidget *widget, int fromRow, int fromColumn, int rowSpan, int columnSpan, Qt::Alignment alignment = Qt::Alignment())
# currx, y label
_stage_layout.addWidget(_lcdx_label, 0, 1, 1, 2)
_stage_layout.addWidget(_lcdy_label, 0, 3, 1, 2)
_stage_layout.addWidget(self._lcdx, 1, 1, 1, 2)
_stage_layout.addWidget(self._lcdy, 1, 3, 1, 2)
_stage_layout.addWidget(_lcdx_label, 0, 1, 1, 2)
_stage_layout.addWidget(_lcdy_label, 0, 3, 1, 2)
_stage_layout.addWidget(_velocity_label, 2, 0)
_stage_layout.addWidget(self._SL_velocity, 2, 1, 1, 2)
_stage_layout.addWidget(self._SL_step_size, 2, 3, 1, 2)
_stage_layout.addWidget(_step_size_label, 2, 5)
_stage_layout.addWidget(self._upArrow, 4, 2, 1, 2)
_stage_layout.addWidget(self._downArrow, 5, 2, 1, 2)
_stage_layout.addWidget(self._leftArrow, 5, 0, 1, 2)
_stage_layout.addWidget(self._rightArrow, 5, 4, 1, 2)
_stage_layout.addWidget(_SL_settings, 4, 4, 1, 2)
_stage_layout.addWidget(self._homeBtn, 4, 0, 1, 2)
return _stage_layout
# second layout
@make_widget_from_layout
def create_single_raster(self, widget):
_single_raster_layout = QtWidgets.QGridLayout()
# Velocity and power adjustments
_SR_params = QtWidgets.QGroupBox("Parameters")
_SR_params_layout = QtWidgets.QGridLayout()
_SR_vel_label = QtWidgets.QLabel("Velocity ({}m/s)".format(self.MICROSYMBOL))
_SR_vel_label.setAlignment(QtCore.Qt.AlignHCenter| QtCore.Qt.AlignVCenter)
_SR_pow_label = QtWidgets.QLabel("Power (steps)")
_SR_pow_label.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
self._SR_pow_up = QtWidgets.QPushButton("++")
self._SR_pow_up.setToolTip("Increase Power")
self._SR_pow_dn = QtWidgets.QPushButton("--")
self._SR_pow_dn.setToolTip("Decrease Power")
self._SR_pow_step = QtWidgets.QLineEdit()
self._SR_pow_step.setText('1')
self._SR_pow_step.setValidator(QtGui.QIntValidator(0,10000))
self._SR_pow_step.setAlignment(QtCore.Qt.AlignHCenter)
self._SR_velocity = QtWidgets.QLineEdit()
self._SR_velocity.setText('100')
self._SR_velocity.setValidator(QtGui.QDoubleValidator(0,10000, 12))
self._SR_velocity.setAlignment(QtCore.Qt.AlignHCenter)
_SR_params_layout.addWidget(_SR_vel_label, 0, 0, 1, 1)
_SR_params_layout.addWidget(self._SR_velocity, 1, 0, 1, 1)
_SR_params_layout.addWidget(_SR_pow_label, 0, 1, 1, 1)
_SR_params_layout.addWidget(self._SR_pow_step, 1, 1, 1, 1)
_SR_params_layout.addWidget(self._SR_pow_up, 0, 2, 1, 1)
_SR_params_layout.addWidget(self._SR_pow_dn, 1, 2, 1, 1)
_SR_params_layout.setColumnStretch(0, 1)
_SR_params_layout.setColumnStretch(1, 1)
_SR_params_layout.setColumnStretch(2, 1)
_SR_params.setLayout(_SR_params_layout)
# / Velocity and power adjustments
# Box Settings
_SR_settings = QtWidgets.QGroupBox("Settings")
_SR_settings_layout = QtWidgets.QGridLayout()
_SR_size_y_label = QtWidgets.QLabel("Height ({}m)".format(self.MICROSYMBOL))
_SR_size_y_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
_SR_size_x_label = QtWidgets.QLabel("Width ({}m)".format(self.MICROSYMBOL))
_SR_size_x_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
_SR_step_size_label = QtWidgets.QLabel("Step Size ({}m)".format(self.MICROSYMBOL))
_SR_step_size_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._SR_size_x = QtWidgets.QLineEdit()
self._SR_size_x.setText("10")
self._SR_size_x.setValidator(QtGui.QDoubleValidator(1,10000,12))
self._SR_size_y = QtWidgets.QLineEdit()
self._SR_size_y.setText("10")
self._SR_size_y.setValidator(QtGui.QDoubleValidator(1,10000,12))
self._SR_step_size = QtWidgets.QLineEdit()
self._SR_step_size.setText("1")
self._SR_step_size.setValidator(QtGui.QDoubleValidator(0.1,10000,12))
self._SR_raster_x = QtWidgets.QCheckBox()
self._SR_raster_y = QtWidgets.QCheckBox()
self._SR_raster_y.setChecked(True)
_SR_raster_step_along_label = QtWidgets.QLabel("Steps?")
_SR_raster_step_along_label.setAlignment(QtCore.Qt.AlignBottom | QtCore.Qt.AlignLeft)
self._SR_raster_style = QtWidgets.QLabel("Filled square\nContinuous along y-axis")
self._SR_raster_style.setAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignRight)
_SR_settings_layout.addWidget(_SR_step_size_label, 0, 0)
_SR_settings_layout.addWidget(self._SR_step_size, 0, 1)
_SR_settings_layout.addWidget(_SR_raster_step_along_label, 0, 2)
_SR_settings_layout.addWidget(self._SR_raster_y, 1, 2)
_SR_settings_layout.addWidget(self._SR_raster_x, 2, 2)
_SR_settings_layout.addWidget(_SR_size_y_label, 1, 0)
_SR_settings_layout.addWidget(_SR_size_x_label, 2, 0)
_SR_settings_layout.addWidget(self._SR_size_y, 1, 1)
_SR_settings_layout.addWidget(self._SR_size_x, 2, 1)
_SR_settings_layout.addWidget(self._SR_raster_style, 3, 0, 1, 3)
_SR_settings.setLayout(_SR_settings_layout)
# / Box Settings
# Action Buttons
_SR_action_btns = QtWidgets.QWidget()
_SR_action_btns_layout = QtWidgets.QGridLayout()
# https://stackoverflow.com/a/33793752/3211506
_SR_action_btns_spacer = QtWidgets.QSpacerItem(0, 0, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self._SR_retToOri = QtWidgets.QCheckBox("Return to Origin")
self._SR_retToOri.setChecked(True)
self._SR_start = QtWidgets.QPushButton("START")
_SR_action_btns_layout.setColumnStretch(0, 0)
_SR_action_btns_layout.addItem(_SR_action_btns_spacer, 0, 0)
_SR_action_btns_layout.addWidget(self._SR_retToOri, 1, 0)
_SR_action_btns_layout.addWidget(self._SR_start, 2, 0)
_SR_action_btns.setLayout(_SR_action_btns_layout)
# / Action Buttons
_single_raster_layout.addWidget(_SR_settings, 0, 1, 1, 1)
_single_raster_layout.addWidget(_SR_params, 1, 1, 1, 1)
_single_raster_layout.addWidget(_SR_action_btns, 2, 1, 1, 1)
_single_raster_layout.setColumnStretch(0, 1)
_single_raster_layout.setColumnStretch(1, 2)
_single_raster_layout.setColumnStretch(2, 1)
return _single_raster_layout
# third layout
@make_widget_from_layout
def create_array_raster(self, widget):
# https://doc.qt.io/archives/qtjambi-4.5.2_01/com/trolltech/qt/core/Qt.AlignmentFlag.html
# Widget Defs
# AR_initial_settings
_AR_initial_settings = QtWidgets.QGroupBox("Initial Values")
_AR_initial_settings_layout = QtWidgets.QGridLayout()
_AR_init_vel_label = QtWidgets.QLabel("Velocity ({}m/s)".format(self.MICROSYMBOL))
_AR_init_vel_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
_AR_init_pow_label = QtWidgets.QLabel("Power (steps)")
_AR_init_pow_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._AR_init_velocity = QtWidgets.QLineEdit()
self._AR_init_velocity.setText('100')
self._AR_init_velocity.setValidator(QtGui.QDoubleValidator(0,10000, 12))
self._AR_init_power = QtWidgets.QLineEdit()
self._AR_init_power.setText('0')
self._AR_init_power.setValidator(QtGui.QIntValidator(0,10000))
_AR_initial_settings_layout.addWidget(_AR_init_vel_label, 0, 0)
_AR_initial_settings_layout.addWidget(_AR_init_pow_label, 1, 0)
_AR_initial_settings_layout.addWidget(self._AR_init_velocity, 0, 1)
_AR_initial_settings_layout.addWidget(self._AR_init_power, 1, 1)
_AR_initial_settings.setLayout(_AR_initial_settings_layout)
# / AR_initial_settings
# AR_X_final_settings
self._AR_X_final_settings = QtWidgets.QGroupBox("Calculated Final Values")
_AR_X_final_settings_layout = QtWidgets.QGridLayout()
_AR_X_final_vel_label = QtWidgets.QLabel("Velocity ({}m/s)".format(self.MICROSYMBOL))
_AR_X_final_vel_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
_AR_X_final_pow_label = QtWidgets.QLabel("Power (steps)")
_AR_X_final_pow_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._AR_X_final_velocity = QtWidgets.QLabel("0")
self._AR_X_final_power = QtWidgets.QLabel("0")
self._AR_X_final_velocity.setAlignment(QtCore.Qt.AlignVCenter)
self._AR_X_final_power.setAlignment(QtCore.Qt.AlignVCenter)
_AR_X_final_settings_layout.addWidget(_AR_X_final_vel_label, 0, 0)
_AR_X_final_settings_layout.addWidget(_AR_X_final_pow_label, 1, 0)
_AR_X_final_settings_layout.addWidget(self._AR_X_final_velocity, 0, 1)
_AR_X_final_settings_layout.addWidget(self._AR_X_final_power, 1, 1)
self._AR_X_final_settings.setLayout(_AR_X_final_settings_layout)
# / AR_X_final_settings
# AR_Y_final_settings
self._AR_Y_final_settings = QtWidgets.QGroupBox("Calculated Final Values")
_AR_Y_final_settings_layout = QtWidgets.QGridLayout()
_AR_Y_final_vel_label = QtWidgets.QLabel("Velocity ({}m/s)".format(self.MICROSYMBOL))
_AR_Y_final_vel_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
_AR_Y_final_pow_label = QtWidgets.QLabel("Power (steps)")
_AR_Y_final_pow_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._AR_Y_final_velocity = QtWidgets.QLabel("0")
self._AR_Y_final_power = QtWidgets.QLabel("0")
self._AR_Y_final_velocity.setAlignment(QtCore.Qt.AlignVCenter)
self._AR_Y_final_power.setAlignment(QtCore.Qt.AlignVCenter)
_AR_Y_final_settings_layout.addWidget(_AR_Y_final_vel_label, 0, 0)
_AR_Y_final_settings_layout.addWidget(_AR_Y_final_pow_label, 1, 0)
_AR_Y_final_settings_layout.addWidget(self._AR_Y_final_velocity, 0, 1)
_AR_Y_final_settings_layout.addWidget(self._AR_Y_final_power, 1, 1)
self._AR_Y_final_settings.setLayout(_AR_Y_final_settings_layout)
# / AR_Y_final_settings
# X Interval
_AR_X_interval_settings = QtWidgets.QGroupBox("Horizontal Settings")
_AR_X_interval_settings_layout = QtWidgets.QGridLayout()
self._AR_X_mode = QtWidgets.QComboBox()
self._AR_X_mode.addItem("Velocity")
self._AR_X_mode.addItem("Power")
_AR_cols_label = QtWidgets.QLabel("NCols")
_AR_cols_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._AR_cols = QtWidgets.QLineEdit()
self._AR_cols.setText("1")
self._AR_cols.setValidator(QtGui.QIntValidator(1,10000))
_AR_X_intervals_label = QtWidgets.QLabel("Increment")
_AR_X_intervals_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._AR_X_intervals = QtWidgets.QLineEdit()
self._AR_X_intervals.setText("10")
self._AR_X_intervals.setValidator(QtGui.QDoubleValidator(-10000,10000,12))
# self._AR_X_intervals.setMinimumWidth(50)
_AR_X_spacing_label = QtWidgets.QLabel("Spacing")
_AR_X_spacing_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._AR_X_spacing = QtWidgets.QLineEdit()
self._AR_X_spacing.setText("10")
self._AR_X_spacing.setValidator(QtGui.QDoubleValidator(1,10000,12))
_AR_X_interval_settings_layout.addWidget(self._AR_X_mode, 0, 0, 1, 2)
_AR_X_interval_settings_layout.addWidget(_AR_X_intervals_label, 0, 2)
_AR_X_interval_settings_layout.addWidget(self._AR_X_intervals, 0, 3)
_AR_X_interval_settings_layout.addWidget(_AR_cols_label, 1, 0)
_AR_X_interval_settings_layout.addWidget(self._AR_cols, 1, 1)
_AR_X_interval_settings_layout.addWidget(_AR_X_spacing_label, 1, 2)
_AR_X_interval_settings_layout.addWidget(self._AR_X_spacing, 1, 3)
_AR_X_interval_settings.setLayout(_AR_X_interval_settings_layout)
_AR_X_interval_settings.setStyleSheet("QGroupBox { background-color: rgba(0,0,0,0.1); }")
# / X Interval
# Y Interval
_AR_Y_interval_settings = QtWidgets.QGroupBox("Vertical Settings")
_AR_Y_interval_settings_layout = QtWidgets.QGridLayout()
self._AR_Y_mode = QtWidgets.QComboBox()
self._AR_Y_mode.addItem("Velocity")
self._AR_Y_mode.addItem("Power")
_AR_rows_label = QtWidgets.QLabel("NRows")
_AR_rows_label.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignBottom)
self._AR_rows = QtWidgets.QLineEdit()
self._AR_rows.setText("1")
self._AR_rows.setValidator(QtGui.QIntValidator(1,10000))
_AR_Y_intervals_label = QtWidgets.QLabel("Increment")
_AR_Y_intervals_label.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignBottom)
self._AR_Y_intervals = QtWidgets.QLineEdit()
self._AR_Y_intervals.setText("10")
self._AR_Y_intervals.setValidator(QtGui.QDoubleValidator(-10000,10000,12))
_AR_Y_spacing_label = QtWidgets.QLabel("Spacing")
_AR_Y_spacing_label.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignBottom)
self._AR_Y_spacing = QtWidgets.QLineEdit()
self._AR_Y_spacing.setText("10")
self._AR_Y_spacing.setValidator(QtGui.QDoubleValidator(1,10000,12))
_AR_Y_interval_settings_layout.addWidget(self._AR_Y_mode, 0, 0, 2, 1)
_AR_Y_interval_settings_layout.addWidget(_AR_Y_intervals_label, 0, 1)
_AR_Y_interval_settings_layout.addWidget(self._AR_Y_intervals, 1, 1)
_AR_Y_interval_settings_layout.addWidget(_AR_rows_label, 2, 0)
_AR_Y_interval_settings_layout.addWidget(self._AR_rows, 3, 0)
_AR_Y_interval_settings_layout.addWidget(_AR_Y_spacing_label, 2, 1)
_AR_Y_interval_settings_layout.addWidget(self._AR_Y_spacing, 3, 1)
_AR_Y_interval_settings.setLayout(_AR_Y_interval_settings_layout)
_AR_Y_interval_settings.setStyleSheet("QGroupBox { background-color: rgba(0,0,0,0.1); }")
# / Y Interval
# AR_XY_final_settings
self._AR_XY_final_settings = QtWidgets.QGroupBox("Calculated Final Values")
_AR_XY_final_settings_layout = QtWidgets.QGridLayout()
_AR_XY_final_vel_label = QtWidgets.QLabel("Velocity ({}m/s)".format(self.MICROSYMBOL))
_AR_XY_final_vel_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
_AR_XY_final_pow_label = QtWidgets.QLabel("Power (steps)")
_AR_XY_final_pow_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._AR_XY_final_velocity = QtWidgets.QLabel("0")
self._AR_XY_final_power = QtWidgets.QLabel("0")
self._AR_XY_final_velocity.setAlignment(QtCore.Qt.AlignVCenter)
self._AR_XY_final_power.setAlignment(QtCore.Qt.AlignVCenter)
_AR_XY_final_settings_layout.addWidget(_AR_XY_final_vel_label, 0, 0)
_AR_XY_final_settings_layout.addWidget(_AR_XY_final_pow_label, 1, 0)
_AR_XY_final_settings_layout.addWidget(self._AR_XY_final_velocity, 0, 1)
_AR_XY_final_settings_layout.addWidget(self._AR_XY_final_power, 1, 1)
self._AR_XY_final_settings.setLayout(_AR_XY_final_settings_layout)
# / AR_XY_final_settings
# Arrows
# https://www.compart.com/en/unicode/U+1F82F
_right_dash = QtWidgets.QLabel(u"\u25B6")
_down_dash = QtWidgets.QLabel(u"\u25BC")
_right_arrow = QtWidgets.QLabel(u"\u25B6")
_down_arrow = QtWidgets.QLabel(u"\u25BC")
_arrows = [_right_dash, _down_dash, _right_arrow, _down_arrow]
for arr in _arrows:
arr.setAlignment(QtCore.Qt.AlignCenter)
# arr.setStyleSheet("line-height: 25px; font-size: 25px;")
# / Arrows
# Each Box Size
_AR_size = QtWidgets.QGroupBox("Individual Raster Setting")
_AR_size_layout = QtWidgets.QGridLayout()
_AR_size_y_label = QtWidgets.QLabel("Height ({}m)".format(self.MICROSYMBOL))
_AR_size_y_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
_AR_size_x_label = QtWidgets.QLabel("Width ({}m)".format(self.MICROSYMBOL))
_AR_size_x_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
_AR_step_size_label = QtWidgets.QLabel("Step Size ({}m)".format(self.MICROSYMBOL))
_AR_step_size_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._AR_size_x = QtWidgets.QLineEdit()
self._AR_size_x.setText("10")
self._AR_size_x.setValidator(QtGui.QDoubleValidator(1,10000,12))
self._AR_size_y = QtWidgets.QLineEdit()
self._AR_size_y.setText("10")
self._AR_size_y.setValidator(QtGui.QDoubleValidator(1,10000,12))
self._AR_step_size = QtWidgets.QLineEdit()
self._AR_step_size.setText("1")
self._AR_step_size.setValidator(QtGui.QDoubleValidator(0.1,10000,12))
self._AR_raster_x = QtWidgets.QCheckBox()
self._AR_raster_y = QtWidgets.QCheckBox()
self._AR_raster_y.setChecked(True)
_AR_raster_step_along_label = QtWidgets.QLabel("Steps?")
_AR_raster_step_along_label.setAlignment(QtCore.Qt.AlignBottom | QtCore.Qt.AlignLeft)
self._AR_raster_style = QtWidgets.QLabel("Filled square\nContinuous along y-axis")
self._AR_raster_style.setAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignRight)
_AR_size_layout.addWidget(_AR_step_size_label, 0, 0)
_AR_size_layout.addWidget(self._AR_step_size, 0, 1)
_AR_size_layout.addWidget(_AR_raster_step_along_label, 0, 2)
_AR_size_layout.addWidget(self._AR_raster_y, 1, 2)
_AR_size_layout.addWidget(self._AR_raster_x, 2, 2)
_AR_size_layout.addWidget(_AR_size_y_label, 1, 0)
_AR_size_layout.addWidget(_AR_size_x_label, 2, 0)
_AR_size_layout.addWidget(self._AR_size_y, 1, 1)
_AR_size_layout.addWidget(self._AR_size_x, 2, 1)
_AR_size_layout.addWidget(self._AR_raster_style, 3, 0, 1, 3)
_AR_size.setLayout(_AR_size_layout)
# / Each Box Size
# Summary
_AR_summary = QtWidgets.QGroupBox("Array Raster Summary")
_AR_summary_layout = QtWidgets.QGridLayout()
self._AR_summary_text = QtWidgets.QLabel("-")
self._AR_summary_text.setAlignment(QtCore.Qt.AlignVCenter)
_AR_summary_layout.addWidget(self._AR_summary_text, 0, 0)
_AR_summary.setLayout(_AR_summary_layout)
_AR_summary.setStyleSheet("QGroupBox { background-color: rgba(255, 165, 0, 0.4); }")
# / Summary
# Action Buttons
_AR_action_btns = QtWidgets.QWidget()
_AR_action_btns_layout = QtWidgets.QGridLayout()
# https://stackoverflow.com/a/33793752/3211506
_AR_action_btns_spacer = QtWidgets.QSpacerItem(0, 0, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self._AR_retToOri = QtWidgets.QCheckBox("Return to Origin")
self._AR_retToOri.setChecked(True)
self._AR_start = QtWidgets.QPushButton("START")
_AR_action_btns_layout.setColumnStretch(0, 0)
_AR_action_btns_layout.addItem(_AR_action_btns_spacer, 0, 0)
_AR_action_btns_layout.addWidget(self._AR_retToOri, 1, 0)
_AR_action_btns_layout.addWidget(self._AR_start, 2, 0)
_AR_action_btns.setLayout(_AR_action_btns_layout)
# / Action Buttons
# void QGridLayout::addWidget(QWidget *widget, int row, int column, Qt::Alignment alignment = Qt::Alignment())
# void QGridLayout::addWidget(QWidget *widget, int fromRow, int fromColumn, int rowSpan, int columnSpan, Qt::Alignment alignment = Qt::Alignment())
# Create Layout to add widgets
_AR_numrows = 5
_AR_numcols = 6
_array_raster_layout = QtWidgets.QGridLayout()
# Add widgets at position
_array_raster_layout.addWidget(_AR_initial_settings, 0, 0)
_array_raster_layout.addWidget(_right_dash, 0, 1)
_array_raster_layout.addWidget(_AR_X_interval_settings, 0, 2, 1, 2)
_array_raster_layout.addWidget(_right_arrow, 0, 4)
_array_raster_layout.addWidget(self._AR_X_final_settings, 0, 5)
_array_raster_layout.addWidget(_down_dash, 1, 0)
_array_raster_layout.addWidget(_AR_Y_interval_settings, 2, 0)
_array_raster_layout.addWidget(_down_arrow, 3, 0)
_array_raster_layout.addWidget(_AR_size, 1, 2, 2, 2)
_array_raster_layout.addWidget(_AR_summary, 4, 1, 1, 4)
_array_raster_layout.addWidget(self._AR_Y_final_settings, 4, 0)
_array_raster_layout.addWidget(self._AR_XY_final_settings, 4, 5)
_array_raster_layout.addWidget(_AR_action_btns, 2, 5)
# To ensure each row and column is the same width
# https://stackoverflow.com/a/40154349/3211506
for i in range(_AR_numrows):
_array_raster_layout.setRowStretch(i, 1)
for j in range(_AR_numcols):
_array_raster_layout.setColumnStretch(j, 1)
_array_raster_layout.setColumnStretch(1, 0.5)
_array_raster_layout.setColumnStretch(4, 0.5)
_array_raster_layout.setRowStretch(1, 0.5)
_array_raster_layout.setRowStretch(3, 0.5)
# Velocities, comma separated
# Size
# Power, comma separated
return _array_raster_layout
# fourth layout
@make_widget_from_layout
def create_drawpic(self, widget):
_drawpic_layout = QtWidgets.QGridLayout()
# INSTRUCTION
# _DP_instructions = QtWidgets.QGroupBox("Instructions")
# _DP_instructions_layout = QtWidgets.QVBoxLayout()
_DP_instructions_scrollArea = QtWidgets.QScrollArea() # QTextBrowser
_DP_instructions_label = QtWidgets.QLabel()
_DP_instructions_string = [
"<b style='color: #22F;'>Instructions</b>",
"'Draw Picture' takes in a 1-bit BMP image and prints it out using the stage.",
"Each option has some hints on mouseover.",
"Go through each step <span style='font-family: Menlo, Consolas, monospace;'>[i]</span> sequentially to print the image. Each pixel represents 1 {}m.".format(self.MICROSYMBOL),
"Scale:<br>If x-scale = 2, this means that for every 1-pixel move along the x-direction the code sees, it moves 2{0}m along the x-direction. Generally, scale = beamspot-size in {0}m if x-scale = y-scale. Test and iterate to ensure.".format(self.MICROSYMBOL),
"Print a non-symmetrical image (e.g. <a href='{}'>fliptest.bmp</a>) to test whether the horizontal and vertical needs to be flipped. <span style='color: red;'>NOTE:</span> Flipping flips the image first before parsing its lines! To flip after, use a negative number as the scale.".format(os.path.join(root_dir, '1_runs', 'fliptest', 'fliptest.bmp')),
"The code will greedily search for the next pixel to the right of the current pixel to determine continuous lines. To prioritize searching the left pixel first, check 'Search left before right'."
]
_DP_instructions_label.setText("<br/><br/>".join(_DP_instructions_string))
_DP_instructions_label.setWordWrap(True)
_DP_instructions_label.setTextFormat(QtCore.Qt.RichText)
_DP_instructions_label.setTextInteractionFlags(QtCore.Qt.TextBrowserInteraction)
_DP_instructions_label.setOpenExternalLinks(True)
_DP_instructions_scrollArea.setBackgroundRole(QtGui.QPalette.Light)
_DP_instructions_scrollArea.setWidget(_DP_instructions_label)
_DP_instructions_scrollArea.setWidgetResizable(True)
# https://www.oipapio.com/question-3065786
# _DP_instructions_layout.addWidget(_DP_instructions_scrollArea)
# _DP_instructions.setLayout(_DP_instructions_layout)
# / INSTRUCTIONS
# DRAW PIC INTERFACE
_DP_main = QtWidgets.QGroupBox("Parameters")
_DP_main_layout = QtWidgets.QGridLayout()
# _DP_picture_fn_label = QtWidgets.QLabel("BMP File")
# _DP_picture_fn_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._DP_picture_fn = QtWidgets.QLineEdit()
self._DP_picture_fn.setPlaceholderText("File name")
self._DP_picture_btn = QtWidgets.QPushButton("Browse...")
self._DP_picture_load = QtWidgets.QPushButton("Load")
self._DP_picture_preview = QtWidgets.QLabel("<i>Preview Here</i>")
self._DP_picture_preview.setStyleSheet("color: #777;")
self._DP_picture_preview.setAlignment(QtCore.Qt.AlignCenter)
# Options
# def __init__(self, filename, xscale = 1, yscale = 1, cut = 0, allowDiagonals = False, prioritizeLeft = False, flipHorizontally = False, flipVertically = False ,frames = False, simulate = False, simulateDrawing = False, micronInstance = None, shutterTime = 800)
_DP_options = QtWidgets.QWidget() # QGroupBox("Options")
_DP_options_layout = QtWidgets.QGridLayout()
_DP_xscale_label = QtWidgets.QLabel("X-Scale")
_DP_xscale_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._DP_xscale = QtWidgets.QLineEdit("1")
# self._DP_xscale.setValidator(QtGui.QDoubleValidator(0,10000, 12))
self._DP_xscale.setValidator(QtGui.QDoubleValidator())
self._DP_xscale.setToolTip("This is usually your beam spot size.")
_DP_yscale_label = QtWidgets.QLabel("Y-Scale")
_DP_yscale_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._DP_yscale = QtWidgets.QLineEdit("1")
# self._DP_yscale.setValidator(QtGui.QDoubleValidator(0,10000, 12))
self._DP_yscale.setValidator(QtGui.QDoubleValidator())
self._DP_yscale.setToolTip("This is usually your beam spot size.")
_DP_cutMode_label = QtWidgets.QLabel("Cut")
_DP_cutMode_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._DP_cutMode = QtWidgets.QComboBox()
self._DP_cutMode.addItem("Black")
self._DP_cutMode.addItem("White")
self._DP_allowDiagonals = QtWidgets.QCheckBox("Allow Diagonals")
self._DP_flipVertically = QtWidgets.QCheckBox("Flip Vertically")
self._DP_flipHorizontally = QtWidgets.QCheckBox("Flip Horizontally")
self._DP_allowDiagonals.setChecked(True)
self._DP_allowDiagonals.setToolTip("Diagonal pixels will also be considered adjacent\npixels when parsing the picture into lines.")
self._DP_flipVertically.setToolTip("Use a simple image to test whether flipping is necessary.\nImage is flipped BEFORE parsing it.")
self._DP_flipHorizontally.setToolTip("Use a simple image to test whether flipping is necessary.\nImage is flipped BEFORE parsing it.")
self._DP_prioritizeLeft = QtWidgets.QCheckBox("Search left before right")
self._DP_prioritizeLeft.setToolTip("Algorithm moves from right to left and searches for\na left pixel first before of the right pixel.")
_DP_options_layout.addWidget(_DP_xscale_label , 0, 0, 1, 1)
_DP_options_layout.addWidget(self._DP_xscale , 0, 1, 1, 1)
_DP_options_layout.addWidget(_DP_yscale_label , 1, 0, 1, 1)
_DP_options_layout.addWidget(self._DP_yscale , 1, 1, 1, 1)
_DP_options_layout.addWidget(_DP_cutMode_label , 2, 0, 1, 1)
_DP_options_layout.addWidget(self._DP_cutMode , 2, 1, 1, 1)
_DP_options_layout.addWidget(self._DP_allowDiagonals , 2, 2, 1, 1)
_DP_options_layout.addWidget(self._DP_flipVertically , 1, 2, 1, 1)
_DP_options_layout.addWidget(self._DP_flipHorizontally , 0, 2, 1, 1)
_DP_options_layout.addWidget(self._DP_prioritizeLeft , 3, 0, 1, 3)
_DP_options_layout.setColumnStretch(0, 1)
_DP_options_layout.setColumnStretch(1, 2)
_DP_options_layout.setColumnStretch(2, 1)
_DP_options.setLayout(_DP_options_layout)
# / Options
self._DP_picture_parse = QtWidgets.QPushButton("Parse Picture")
_DP_moveToZero = QtWidgets.QLabel('Move to (0, 0), usually top-left, of the image using "Stage Movement"')
_DP_moveToZero.setWordWrap(True)
_DP_velocity_label = QtWidgets.QLabel("Velocity ({}m/s)".format(self.MICROSYMBOL))
_DP_velocity_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self._DP_velocity = QtWidgets.QLineEdit("100")
self._DP_velocity.setValidator(QtGui.QDoubleValidator(0,10000, 12))
self._DP_picture_estimateTime = QtWidgets.QPushButton("Estimate Time")
self._DP_picture_draw = QtWidgets.QPushButton("Draw")
_DP_steps_labels = []
for i in range(6):
_temp_label = QtWidgets.QLabel("[{}]".format(i + 1))
_temp_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
_temp_label.setStyleSheet("font-family: Menlo, Consolas, monospace;")
_DP_steps_labels.append(_temp_label)
_DP_main_layout.addWidget(_DP_steps_labels[0], 0, 0, 1, 1)
# _DP_main_layout.addWidget(_DP_picture_fn_label, 1, 1, 1, 1)
_DP_main_layout.addWidget(self._DP_picture_fn, 0, 1, 1, 3)
_DP_main_layout.addWidget(self._DP_picture_btn, 0, 4, 1, 1)
_DP_main_layout.addWidget(_DP_steps_labels[1], 1, 0, 1, 1)
_DP_main_layout.addWidget(self._DP_picture_load, 1, 1, 1, 4)
_DP_main_layout.addWidget(_DP_steps_labels[2], 2, 0, 1, 1)
_DP_main_layout.addWidget(_DP_options, 2, 1, 1, 4)
_DP_main_layout.addWidget(_DP_steps_labels[3], 3, 0, 1, 1)
_DP_main_layout.addWidget(self._DP_picture_parse, 3, 1, 1, 4)
_DP_main_layout.addWidget(_DP_steps_labels[4], 4, 0, 1, 1)
_DP_main_layout.addWidget(_DP_moveToZero, 4, 1, 1, 4)
_DP_main_layout.addWidget(_DP_steps_labels[5], 5, 0, 1, 1)
_DP_main_layout.addWidget(_DP_velocity_label, 5, 1, 1, 1)
_DP_main_layout.addWidget(self._DP_velocity, 5, 2, 1, 3)
_DP_main_layout.addWidget(self._DP_picture_estimateTime, 6, 0, 1, 2)
_DP_main_layout.addWidget(self._DP_picture_draw, 6, 2, 1, 3)
_DP_main_layout.setColumnStretch(0, 1)
for i in range(1, 4):
_DP_main_layout.setColumnStretch(i, 2)
_DP_main.setLayout(_DP_main_layout)
# / DRAW PIC INTERFACE
# _drawpic_layout.addWidget(_DP_instructions, 0, 0)
_drawpic_layout.addWidget(self._DP_picture_preview, 0, 0, 1, 1)
_drawpic_layout.addWidget(_DP_instructions_scrollArea, 1, 0, 1, 1)
_drawpic_layout.addWidget(_DP_main, 0, 1, 2, 1)
_drawpic_layout.setColumnStretch(0, 1)
_drawpic_layout.setColumnStretch(1, 1)
_drawpic_layout.setRowStretch(0, 1)
_drawpic_layout.setRowStretch(1, 1)
return _drawpic_layout
# INTERACTION FUNCTONS
def initEventListeners(self):
# STAGE
self.UP, self.RIGHT, self.DOWN, self.LEFT = (0, 1), (1, 0), (0, -1), (-1, 0)
self.cardinalStageMoving = False
self.lastCardinalStageMove = datetime.datetime.now()
self._upArrow.clicked.connect(lambda: self.cardinalMoveStage(self.UP))
self._downArrow.clicked.connect(lambda: self.cardinalMoveStage(self.DOWN))
self._leftArrow.clicked.connect(lambda: self.cardinalMoveStage(self.LEFT))
self._rightArrow.clicked.connect(lambda: self.cardinalMoveStage(self.RIGHT))
self._homeBtn.clicked.connect(lambda: self.homeStage())
self._SL_invertx_checkbox.stateChanged.connect(lambda: self.invertCheck())
self._SL_inverty_checkbox.stateChanged.connect(lambda: self.invertCheck())
self._SL_velocity.textChanged.connect(lambda: self.recalculateKeystrokeTimeout())
self._SL_step_size.textChanged.connect(lambda: self.recalculateKeystrokeTimeout())
self.keyMapping = {
QtCore.Qt.Key_Up : "Up",
QtCore.Qt.Key_Down : "Down",
QtCore.Qt.Key_Left : "Left",
QtCore.Qt.Key_Right: "Right"
}
# self.keysPressed = {}
# Not implementing due to not being able to obtain keyPress events reliably
self.stage_widget.installEventFilter(self)
self.installEventFilter(self)
# note that the following you cannot connect(self.checkSRValues) because the value will be passed in as an argument to self.checkSRValues
# COMMON
self.operationDone.connect(self.on_operationDone)
self.EL_self_criticalDialog.connect(self.on_EL_self_criticalDialog)
# SINGLE RASTER
self._SR_velocity.textChanged.connect(lambda: self.checkSRValues())
self._SR_size_x.textChanged.connect(lambda: self.checkSRValues())
self._SR_size_y.textChanged.connect(lambda: self.checkSRValues())
self._SR_step_size.textChanged.connect(lambda: self.checkSRValues())
self._SR_raster_x.stateChanged.connect(lambda: self.checkSRValues())
self._SR_raster_y.stateChanged.connect(lambda: self.checkSRValues())
self._SR_retToOri.stateChanged.connect(lambda: self.checkSRValues())
self._SR_start.clicked.connect(lambda: self.checkSRValues(startRaster = True))
self._SR_pow_up.clicked.connect(lambda: self.adjustPower(direction = "+"))
self._SR_pow_dn.clicked.connect(lambda: self.adjustPower(direction = "-"))
self._SR_pow_step.textChanged.connect(lambda: self._SR_pow_step.setStyleSheet("background-color: none; color: #000;"))
# ARRAY RASTER
self._AR_init_velocity.textChanged.connect(lambda: self.recalculateARValues())
self._AR_init_power.textChanged.connect(lambda: self.recalculateARValues())
self._AR_X_mode.currentIndexChanged.connect(lambda: self.recalculateARValues())
self._AR_cols.textChanged.connect(lambda: self.recalculateARValues())
self._AR_X_intervals.textChanged.connect(lambda: self.recalculateARValues())
self._AR_X_spacing.textChanged.connect(lambda: self.recalculateARValues())
self._AR_Y_mode.currentIndexChanged.connect(lambda: self.recalculateARValues())
self._AR_rows.textChanged.connect(lambda: self.recalculateARValues())
self._AR_Y_intervals.textChanged.connect(lambda: self.recalculateARValues())
self._AR_Y_spacing.textChanged.connect(lambda: self.recalculateARValues())
self._AR_size_x.textChanged.connect(lambda: self.recalculateARValues())
self._AR_size_y.textChanged.connect(lambda: self.recalculateARValues())
self._AR_step_size.textChanged.connect(lambda: self.recalculateARValues())
self._AR_raster_x.stateChanged.connect(lambda: self.recalculateARValues())
self._AR_raster_y.stateChanged.connect(lambda: self.recalculateARValues())
self._AR_retToOri.stateChanged.connect(lambda: self.recalculateARValues())
self._AR_start.clicked.connect(lambda: self.recalculateARValues(startRaster = True))
# DRAW PIC
self._DP_picture_btn.clicked.connect(lambda: self._DP_getFile())
self._DP_picture_load.clicked.connect(lambda: self._DP_loadPicture())
self._DP_picture_parse.clicked.connect(lambda: self._DP_parsePicture())
self._DP_picture_estimateTime.clicked.connect(lambda: self._DP_drawPicture(estimateOnly = True))
self._DP_picture_draw.clicked.connect(lambda: self._DP_drawPicture())
self._DP_xscale.textChanged.connect(lambda: self._DP_optionsChanged())
self._DP_yscale.textChanged.connect(lambda: self._DP_optionsChanged())
self._DP_cutMode.currentIndexChanged.connect(lambda: self._DP_optionsChanged())
self._DP_allowDiagonals.stateChanged.connect(lambda: self._DP_optionsChanged())
self._DP_flipVertically.stateChanged.connect(lambda: self._DP_optionsChanged())
self._DP_flipHorizontally.stateChanged.connect(lambda: self._DP_optionsChanged())
self._DP_prioritizeLeft.stateChanged.connect(lambda: self._DP_optionsChanged())
self._DP_picture_fn.textChanged.connect(lambda: self._DP_filenameLineEditChanged())
self.picConvWarn.connect(self.on_picConvWarn)
# SHUTTER
self._close_shutter.clicked.connect(lambda: self.stageControl.controller.shutter.close())
self._open_shutter.clicked.connect(lambda: self.stageControl.controller.shutter.open())
self._abortBtn.clicked.connect(lambda: threading.Thread(target = self.KeyboardInterruptHandler, kwargs = dict(abortTrigger = True)).start())
# keyPressEvent(self, evt)
def eventFilter(self, source, evt):
# https://www.riverbankcomputing.com/static/Docs/PyQt4/qt.html#Key-enum
# print(evt)
if isinstance(evt, QtGui.QKeyEvent): #.type() ==
# Check source here
evtkey = evt.key()
# if (evt.type() == QtCore.QEvent.KeyPress):
# print("KeyPress : {}".format(key))
# if key not in self.keysPressed:
# self.keysPressed[key] = 1
# if key in self.keysPressed:
# del self.keysPressed[key]
# print("\033[K", str(self.keysPressed), end="\r")
if (evt.type() == QtCore.QEvent.KeyRelease):
# print("KeyRelease : {}".format(evtkey))
# All KeyRelease events go here
if evtkey == QtCore.Qt.Key_C and (evt.modifiers() & QtCore.Qt.ControlModifier):
# Will work everywhere
self.KeyboardInterruptHandler()
return True # Prevents further handling
if evtkey == QtCore.Qt.Key_Space:
self.stageControl.controller.shutter.close() if self.stageControl.controller.shutter.isOpen else self.stageControl.controller.shutter.open()
return True # Prevents further handling
# self.logconsole(self.lastCardinalStageMove)
# now = datetime.datetime.now()
# try:
# if now >= self.lastEvent + datetime.timedelta(seconds = 1):
# print(self.numEvents)
# self.numSeconds += 1
# self.lastEvent = now
# self.numEvents = 0
# except Exception as e:
# self.lastEvent = now
# self.numSeconds = 0
# self.numEvents = 0
#
# self.numEvents += 1
# ==> we deduce about 66 events / second
# we try to block it as early and possible
# WARNING: This still doesn't work as expected like in the previous VBA iteration of this
if source == self.stage_widget and not self.cardinalStageMoving and datetime.datetime.now() > self.lastCardinalStageMove + datetime.timedelta(milliseconds = self.KEYSTROKE_TIMEOUT):
if evtkey == QtCore.Qt.Key_Up:
self.cardinalMoveStage(self.UP)
if evtkey == QtCore.Qt.Key_Down:
self.cardinalMoveStage(self.DOWN)
if evtkey == QtCore.Qt.Key_Left:
self.cardinalMoveStage(self.LEFT)
if evtkey == QtCore.Qt.Key_Right:
self.cardinalMoveStage(self.RIGHT)
# TODO: Catching alert sound
# if isintance(evt, QtGui.QAccessibleEvent)
# return QtWidgets.QWidget.eventFilter(self, source, evt)
return super(QtWidgets.QWidget, self).eventFilter(source, evt)
# Custom functions
# Stage Movement
def homeStage(self):
if not self.devMode:
self.setOperationStatus("Homing stage...If any error arises, abort immediately with Ctrl + C")
self.stageControl.controller.homeStage()
self.setOperationStatus("Home stage finished")
else:
self.setOperationStatus("devMode, not homing...")
def cardinalMoveStage(self, direction):
# Get the distance
dist = float(self._SL_step_size.text())
vel = float(self._SL_velocity.text())
# Move the stage
if not self.devMode:
self.moveStage(direction, distance = dist, velocity = vel)
def moveStage(self, direction, distance, velocity):
# direction is a (dx, dy) tuple/vector that defines the direction that gets multiplied by distance
if sum(map(abs, direction)) > 1:
_mag = math.sqrt(direction[0]**2 + direction[1]**2)
direction = (direction[0] / _mag , direction[1] / _mag)
if not self.cardinalStageMoving:
self.cardinalStageMoving = True
if self.stageControl.controller.velocity != velocity:
# We reset the velocity if it is different
self.stageControl.controller.setvel(velocity)
self.stageControl.controller.rmove(x = direction[0] * distance * self.stageControl.noinvertx, y = direction[1] * distance * self.stageControl.noinverty)
self.updatePositionDisplay()
self.lastCardinalStageMove = datetime.datetime.now()
self.cardinalStageMoving = False
def updatePositionDisplay(self):
if self.stageControl is not None:
# self.logconsole(self.stageControl.controller.stage.position)
self._lcdx.display(self.stageControl.controller.stage.x)
self._lcdy.display(self.stageControl.controller.stage.y)
def invertCheck(self):
self.stageControl.noinvertx = -1 if self._SL_invertx_checkbox.checkState() else 1
self.stageControl.noinverty = -1 if self._SL_inverty_checkbox.checkState() else 1
self.qsettings.setValue("stage/invertx", True) if self.stageControl.noinvertx == -1 else self.qsettings.setValue("stage/invertx", False)
self.qsettings.setValue("stage/inverty", True) if self.stageControl.noinverty == -1 else self.qsettings.setValue("stage/inverty", False)
self.qsettings.sync()
def recalculateKeystrokeTimeout(self):
try:
vel = float(self._SL_velocity.text())
dist = float(self._SL_step_size.text())
estTime = self.stageControl.controller.getDeltaTime(x = dist, y = 0, velocity = vel)
self.KEYSTROKE_TIMEOUT = estTime * 66 * 0.002 * 1000 # 66 events per second, 0.002 to process each event
# i.e. to say how long to burn all the events
# Issue is events gets queued, not the connected function
except Exception as e:
self.logconsole(e)
self.KEYSTROKE_TIMEOUT = 10
# Common
def setStartButtonsEnabled(self, state):
self._SR_start.setEnabled(state)
self._AR_start.setEnabled(state)
self._DP_picture_draw.setEnabled(state)
def winAudioSetMuted(self, state):
if not hasattr(self, "pycaw_sess"):
if platform.system() == "Windows":
sessions = AudioUtilities.GetAllSessions()
for session in sessions:
if session.Process and session.Process.name() == "python.exe":
self.pycaw_sess = session
self.pycaw_vol = self.pycaw_sess._ctl.QueryInterface(ISimpleAudioVolume)
else:
self.pycaw_sess = None
if self.pycaw_sess is None:
return
return self.pycaw_vol.SetMasterVolume(0, None) if state else self.pycaw_vol.SetMasterVolume(1, None)
# Single Raster
def adjustPower(self, direction):
try:
assert direction == "+" or direction == "-", "Invalid Direction"
_step = int(self._SR_pow_step.text())
except ValueError as e:
self._SR_pow_step.setStyleSheet("background-color: #DF2928; color: #fff;")
return
except AssertionError as e:
self.logconsole("Invalid call to MicroGUI.adjustPower(direction = {})".format(direction))
return
self._SR_pow_step.setStyleSheet("background-color: none; color: #000;")
self.setOperationStatus("Adjusting power...")
self._SR_pow_up.setEnabled(False)
self._SR_pow_dn.setEnabled(False)
powerThread = ThreadWithExc(target = self._adjustPower, kwargs = dict(_step = _step, direction = direction))
powerThread.start()
# self._adjustPower()
def _adjustPower(self, _step, direction):
self.stageControl.controller.powerServo.powerstep(number = (-1 * _step) if direction == "-" else (_step))
self._SR_pow_up.setEnabled(True)
self._SR_pow_dn.setEnabled(True)
self.setOperationStatus("Ready.")
def checkSRValues(self, startRaster = False):
_got_error = False
try:
# Recalculate the values for Array Raster
_vel = float(self._SR_velocity.text())
# we convert 2 to 1 since .checkState gives 0 = unchecked, 2 = checked
step_along_x = not not self._SR_raster_x.checkState()
step_along_y = not not self._SR_raster_y.checkState()
step_size = float(self._SR_step_size.text())
returnToOrigin = not not self._SR_retToOri.checkState()
# sizes
# y, x
size = [float(self._SR_size_y.text()), float(self._SR_size_x.text())]
# Recalculate size based on flooring calculations
_lines = math.floor(abs(size[step_along_x] / step_size))
size[step_along_x] = _lines * step_size
# Indivdual Raster Type
indiv_type = "square" if size[0] == size[1] else "rectangle"
# catch all errors:
_got_error = (size[1] <= 0 or size[0] <= 0 or _vel <= 0)
self._SR_size_x.setStyleSheet("background-color: #DF2928; color: #fff;") if size[1] <= 0 else self._SR_size_x.setStyleSheet("background-color: none; color: #000;")
self._SR_size_y.setStyleSheet("background-color: #DF2928; color: #fff;") if size[0] <= 0 else self._SR_size_y.setStyleSheet("background-color: none; color: #000;")
# If power, ensure changes are integer
# RASTER SETTINGS
self._SR_raster_style.setStyleSheet("background-color: none; color: #000;")
if step_along_x and step_along_y:
self._SR_raster_style.setText("Unfilled {}\nDrawing an outline".format(indiv_type))
self._SR_step_size.setReadOnly(True)
self._SR_step_size.setStyleSheet("background-color: #ccc; color: #555;")
elif step_along_x:
self._SR_raster_style.setText("Filled {}\nContinuous along x-axis".format(indiv_type))
self._SR_step_size.setReadOnly(False)
self._SR_step_size.setStyleSheet("background-color: none; color: #000;")
elif step_along_y:
self._SR_raster_style.setText("Filled {}\nContinuous along y-axis".format(indiv_type))
self._SR_step_size.setReadOnly(False)
self._SR_step_size.setStyleSheet("background-color: none; color: #000;")
else:
_got_error = True
self._SR_raster_style.setText("No axis selected\nChoose at least one axis")
self._SR_raster_style.setStyleSheet("background-color: #DF2928; color: #fff;")
self._SR_step_size.setReadOnly(False)
self._SR_step_size.setStyleSheet("background-color: none; color: #000;")
except Exception as e:
# We assume the user is not done entering the data
self.logconsole("{}: {}".format(type(e).__name__, e))
self._SR_size_x.setStyleSheet("background-color: none; color: #000;")
self._SR_size_y.setStyleSheet("background-color: none; color: #000;")
self._SR_raster_style.setText("-\n")
self._SR_raster_style.setStyleSheet("background-color: none; color: #000;")
# Check if the values are even valid
# Change background if necessary
else:
# There are no errors, and we check if startRaster
if startRaster and not _got_error:
# JUMP TO DEF
# def singleraster(self, velocity, xDist, yDist, rasterSettings, returnToOrigin = False, estimateTime = True, onlyEstimate = False):
# Raster in a rectangle
# rasterSettings = {
# "direction": "x" || "y" || "xy", # Order matters here xy vs yx
# "step": 1 # If set to xy, step is not necessary
# }
if not step_along_x and not step_along_y:
self.setOperationStatus("Step-axis not selected!")
return
rsSettingsDir = ""
rsSettingsDir += "x" if step_along_x else ""
rsSettingsDir += "y" if step_along_y else ""
if step_along_x and step_along_y:
rsSettings = { "direction" : rsSettingsDir }
else:
rsSettings = { "direction" : rsSettingsDir, "step": step_size }
self.setOperationStatus("Starting Single Raster...")
self.setStartButtonsEnabled(False)
self.setOperationStatus("Starting Single Raster...")
sr_thread = ThreadWithExc(target = self._singleRaster, kwargs = dict(
velocity = _vel,
xDist = size[1],
yDist = size[0],
rasterSettings = rsSettings,
returnToOrigin = returnToOrigin
))
sr_thread.start()
elif startRaster:
# Alert got error
self.criticalDialog(message = "Error in single raster settings.\nPlease check again!", host = self)
def _singleRaster(self, **kwargs):
try:
self.stageControl.singleraster(**kwargs)
except Exception as e:
self.setOperationStatus("Error Occurred. {}".format(e))
if self.devMode:
raise
else:
# If no error
self.setOperationStatus("Ready.")
finally:
# Always run
self.setStartButtonsEnabled(True)
# Array Raster
def recalculateARValues(self, startRaster = False):
_got_error = False
try:
# Recalculate the values for Array Raster
vel_0 = float(self._AR_init_velocity.text())
pow_0 = int(self._AR_init_power.text())
# we convert 2 to 1 since .checkState gives 0 = unchecked, 2 = checked
step_along_x = not not self._AR_raster_x.checkState()
step_along_y = not not self._AR_raster_y.checkState()
step_size = float(self._AR_step_size.text())
# 0 = Velocity, 1 = Power
x_isPow = self._AR_X_mode.currentIndex()
x_incr = float(self._AR_X_intervals.text())
x_cols = int(self._AR_cols.text())
x_spac = float(self._AR_X_spacing.text())
y_isPow = self._AR_Y_mode.currentIndex()
y_incr = float(self._AR_Y_intervals.text())
y_rows = int(self._AR_rows.text())
y_spac = float(self._AR_Y_spacing.text())
returnToOrigin = not not self._AR_retToOri.checkState()
# sizes
# y, x
size = [float(self._AR_size_y.text()), float(self._AR_size_x.text())]
# Recalculate size based on flooring calculations
_lines = math.floor(abs(size[step_along_x] / step_size))
size[step_along_x] = _lines * step_size
# Horizontal
vel_x_f = vel_0 + (x_cols - 1) * x_incr if not x_isPow else vel_0
pow_x_f = pow_0 + (x_cols - 1) * x_incr if x_isPow else pow_0
# Vertical
vel_y_f = vel_0 + (y_rows - 1) * y_incr if not y_isPow else vel_0
pow_y_f = pow_0 + (y_rows - 1) * y_incr if y_isPow else pow_0
# Final
vel_xy_f = vel_x_f + vel_y_f - vel_0
pow_xy_f = pow_x_f + pow_y_f - pow_0
# Total Raster Area
tt_x = x_cols * size[1] + (x_cols - 1) * x_spac
tt_y = y_rows * size[0] + (y_rows - 1) * y_spac
# Indivdual Raster Type
indiv_type = "square" if size[0] == size[1] else "rectangle"
# catch all errors:
_got_error = (x_cols <= 0 or y_rows <= 0 or size[1] <= 0 or size[0] <= 0 or vel_x_f < 0 or vel_y_f < 0 or vel_xy_f < 0)
self._AR_cols.setStyleSheet("background-color: #DF2928; color: #fff;") if x_cols <= 0 else self._AR_cols.setStyleSheet("background-color: none; color: #000;")
self._AR_rows.setStyleSheet("background-color: #DF2928; color: #fff;") if y_rows <= 0 else self._AR_rows.setStyleSheet("background-color: none; color: #000;")
self._AR_size_x.setStyleSheet("background-color: #DF2928; color: #fff;") if size[1] <= 0 else self._AR_size_x.setStyleSheet("background-color: none; color: #000;")
self._AR_size_y.setStyleSheet("background-color: #DF2928; color: #fff;") if size[0] <= 0 else self._AR_size_y.setStyleSheet("background-color: none; color: #000;")
self._AR_X_final_settings.setStyleSheet("background-color: #DF2928; color: #fff;") if vel_x_f < 0 else self._AR_X_final_settings.setStyleSheet("background-color: none; color: #000;")
self._AR_Y_final_settings.setStyleSheet("background-color: #DF2928; color: #fff;") if vel_y_f < 0 else self._AR_Y_final_settings.setStyleSheet("background-color: none; color: #000;")
self._AR_XY_final_settings.setStyleSheet("background-color: #DF2928; color: #fff;") if vel_xy_f < 0 else self._AR_XY_final_settings.setStyleSheet("background-color: none; color: #000;")
self._AR_summary_text.setText("Rastering a {} x {} array\nEach {} {} x {} {}m\nRaster Area = {} x {} {}m".format(y_rows, x_cols, indiv_type, *size, self.MICROSYMBOL, tt_y, tt_x, self.MICROSYMBOL))
self._AR_X_final_velocity.setText(str(vel_x_f))
self._AR_Y_final_velocity.setText(str(vel_y_f))
self._AR_XY_final_velocity.setText(str(vel_xy_f))
self._AR_X_final_power.setText(str(pow_x_f))
self._AR_Y_final_power.setText(str(pow_y_f))
self._AR_XY_final_power.setText(str(pow_xy_f))
# If power, ensure changes are integer
if x_isPow and not (x_incr.is_integer()):
# x_power error
_got_error = True
self._AR_X_intervals.setStyleSheet("background-color: #DF2928; color: #fff;")
self._AR_X_final_power.setText("<b style='color: red'>INT!<b>")
self._AR_XY_final_power.setText("<b style='color: red'>INT!<b>")
else:
self._AR_X_intervals.setStyleSheet("background-color: none; color: #000;")
if y_isPow and not (y_incr.is_integer()):
# y_power error
_got_error = True
self._AR_Y_intervals.setStyleSheet("background-color: #DF2928; color: #fff;")
self._AR_Y_final_power.setText("<b style='color: red'>INT!<b>")
self._AR_XY_final_power.setText("<b style='color: red'>INT!<b>")
else:
self._AR_Y_intervals.setStyleSheet("background-color: none; color: #000;")
# RASTER SETTINGS
self._AR_raster_style.setStyleSheet("background-color: none; color: #000;")
if step_along_x and step_along_y:
self._AR_raster_style.setText("Unfilled {}\nDrawing an outline".format(indiv_type))
self._AR_step_size.setReadOnly(True)
self._AR_step_size.setStyleSheet("background-color: #ccc; color: #555;")
elif step_along_x:
self._AR_raster_style.setText("Filled {}\nContinuous along x-axis".format(indiv_type))
self._AR_step_size.setReadOnly(False)
self._AR_step_size.setStyleSheet("background-color: none; color: #000;")
elif step_along_y:
self._AR_raster_style.setText("Filled {}\nContinuous along y-axis".format(indiv_type))
self._AR_step_size.setReadOnly(False)
self._AR_step_size.setStyleSheet("background-color: none; color: #000;")
else:
_got_error = True
self._AR_raster_style.setText("No axis selected\nChoose at least one axis")
self._AR_raster_style.setStyleSheet("background-color: #DF2928; color: #fff;")
self._AR_step_size.setReadOnly(False)
self._AR_step_size.setStyleSheet("background-color: none; color: #000;")
except Exception as e:
# We assume the user is not done entering the data
self.logconsole("{}: {}".format(type(e).__name__, e))
self._AR_Y_final_settings.setStyleSheet("background-color: none; color: #000;")
self._AR_Y_final_settings.setStyleSheet("background-color: none; color: #000;")
self._AR_XY_final_settings.setStyleSheet("background-color: none; color: #000;")
self._AR_rows.setStyleSheet("background-color: none; color: #000;")
self._AR_rows.setStyleSheet("background-color: none; color: #000;")
self._AR_size_x.setStyleSheet("background-color: none; color: #000;")
self._AR_size_y.setStyleSheet("background-color: none; color: #000;")
self._AR_summary_text.setText("-")
self._AR_raster_style.setText("-\n")
self._AR_raster_style.setStyleSheet("background-color: none; color: #000;")
self._AR_X_final_velocity.setText("-")
self._AR_Y_final_velocity.setText("-")
self._AR_XY_final_velocity.setText("-")
self._AR_X_final_power.setText("-")
self._AR_Y_final_power.setText("-")
self._AR_XY_final_power.setText("-")
# Check if the values are even valid
# Change background if necessary
else:
# There are no errors, and we check if startRaster
if startRaster and not _got_error:
# JUMP TO DEF
# def arrayraster(self, inivel, inipower, x_isVel, ncols, xincrement, xGap, y_isVel, nrows, yincrement, ygap, xDist, yDist, rasterSettings, returnToOrigin = True):
# Raster in a rectangle
# rasterSettings = {
# "direction": "x" || "y" || "xy", # Order matters here xy vs yx
# "step": 1 # If set to xy, step is not necessary
# }
if not step_along_x and not step_along_y:
self.setOperationStatus("Step-axis not selected!")
return
rsSettingsDir = ""
rsSettingsDir += "x" if step_along_x else ""
rsSettingsDir += "y" if step_along_y else ""
if step_along_x and step_along_y:
rsSettings = { "direction" : rsSettingsDir }
else:
rsSettings = { "direction" : rsSettingsDir, "step": step_size }
self.setStartButtonsEnabled(False)
self.setOperationStatus("Starting Array Raster...")
ar_thread = ThreadWithExc(target = self._arrayraster, kwargs = dict(
xDist = size[1], yDist = size[0],
xGap = x_spac, yGap = y_spac,
nrows = y_rows, ncols = x_cols,
inivel = vel_0, inipower = pow_0,
x_isVel = x_isPow ^ 1, y_isVel = y_isPow ^ 1,
xincrement = x_incr, yincrement = y_incr,
rasterSettings = rsSettings,
returnToOrigin = returnToOrigin
))
ar_thread.start()
elif startRaster:
# Alert got error
self.criticalDialog(message = "Error in array raster settings.\nPlease check again!", host = self)
def _arrayraster(self, **kwargs):
try:
self.stageControl.arrayraster(**kwargs)
except Exception as e:
self.setOperationStatus("Error Occurred. {}".format(e))
if self.devMode:
raise
else:
self.setOperationStatus("Ready.")
finally:
self.setStartButtonsEnabled(True)
# Draw Picture
def _DP_getFile(self):
# THIS IS PURELY FOR GUI CHOOSE FILE
# Attempt to get filename from QLineEdit
filename = self._DP_picture_fn.text()
if os.path.isfile(filename):
filename = os.path.abspath(os.path.realpath(os.path.expanduser(filename)))
dirname = os.path.dirname(filename)
else:
dirname = base_dir # base_dir of this file
self._DP_FileDialog = QtWidgets.QFileDialog(self, "Open Image", dirname, "1-Bit Bitmap Files (*.bmp)")
self._DP_FileDialog.setFileMode(QtWidgets.QFileDialog.ExistingFile)
self._DP_FileDialog.setViewMode(QtWidgets.QFileDialog.Detail)
firstRun = True
isValid = False
error = None
while not os.path.isfile(filename) or not isValid:
if not firstRun:
self.criticalDialog(message = "You have selected an invalid file", informativeText = "E: {}".format(error), title = "Invalid File", host = self)
firstRun = False
if (self._DP_FileDialog.exec_()):
filename = self._DP_FileDialog.selectedFiles()[0]
filename = os.path.abspath(os.path.realpath(os.path.expanduser(filename)))
# Running this before loadPicture is so that windows gives the same file path url
else:
return
# else (i.e. the user cancelled) we just ignore and act as though nothing happened
# We run some checks here
try:
isValid = self._DP_runChecks(filename)
except picConv.ImageError as e:
isValid = False
error = e
if isValid:
self._DP_picture_fn.setText(filename)
def _DP_runChecks(self, filename):
# Checks if the file exists and is valid
# Raises picConv.ImageError if there are any errors
if not os.path.isfile(filename):
raise picConv.ImageError("Path is not file!")
try:
image = PILImage.open(filename)
except Exception as e:
raise picConv.ImageError("({}): {}".format(type(e).__name__, e))
if image.format != "BMP":
raise picConv.ImageError("The selected image is not a valid .bmp file!")
if image.mode != '1':
raise picConv.ImageError("Your image has mode {}. Please use a 1-bit indexed (mode 1) image, see <a href='https://pillow.readthedocs.io/en/stable/handbook/concepts.html#bands'>https://pillow.readthedocs.io/en/stable/handbook/concepts.html#bands</a>. If using GIMP to convert picture to 1-bit index, ensure 'remove colour from palette' is unchecked. ".format(image.mode))
# Check size purely based on image and stage size
# Does not take into account the scaling factor yet
xlim = self.stageControl.controller.stage.xlim
ylim = self.stageControl.controller.stage.ylim
if image.size[0] > abs(xlim[1] - xlim[0]) or image.size[1] > abs(ylim[1] - ylim[0]):
raise picConv.ImageError("Image way too big ._., exceeds stage limits")
return True
def _DP_loadPictureIntoPreviewer(self, filename):
self._DP_picture_preview_pic = QtGui.QPixmap()
if self._DP_picture_preview_pic.load(filename):
self._DP_picture_preview_pic = self._DP_picture_preview_pic.scaled(self._DP_picture_preview.size(), QtCore.Qt.KeepAspectRatio)
self._DP_picture_preview.setPixmap(self._DP_picture_preview_pic)
return DoneObject()
else:
return self.criticalDialog(message = "Unable to load the selected file into preview", title = "Unable to load file", host = self)
def _DP_loadPicture(self):
# run tests again
filename = self._DP_picture_fn.text()
try:
filename = os.path.abspath(os.path.realpath(os.path.expanduser(filename)))
isValid = self._DP_runChecks(filename)
except picConv.ImageError as e:
return self.criticalDialog(message = "You have selected an invalid file", informativeText = "E: {}".format(e), title = "Invalid File", host = self)
# Load picture into previewer
x = self._DP_loadPictureIntoPreviewer(filename)
if isinstance(x, DoneObject):
# save the filename if everything passes
self._DP_filename_string = filename
self._DP_optionsChanged()
def _DP_filenameLineEditChanged(self):
self._DP_picture_load.setStyleSheet("background-color: #FF8800;")
def _DP_optionsChanged(self):
if hasattr(self, "_DP_filename_string"):
self._DP_optionsChangedFlag = True
self._DP_picture_load.setStyleSheet("")
self._DP_picture_parse.setStyleSheet("background-color: #FF8800;")
def _DP_parsePicture(self):
# _DP_loadPicture has to be run first to do sanity checks
if not hasattr(self, "_DP_filename_string") or self._DP_filename_string is None or not len(self._DP_filename_string):
return self.criticalDialog(message = "Image not loaded!", informativeText = "Please load the image first before parsing. Filename not captured", title = "Image not loaded!", host = self)
# Differs from Line edit, prompt to let user know
lefn = self._DP_picture_fn.text()
if self._DP_filename_string != lefn:
ret = self.unsavedQuestionDialog(message = "Load new filenames?", title = "Differing filenames",informativeText = "Registered filename differs from the input filename:\n\nREG:{}\nENT:{}\n\nSave to proceed.\nDiscard/Cancel to go back".format(self._DP_filename_string, lefn), host = self)
if ret == QtWidgets.QMessageBox.Save:
self._DP_loadPicture()
else:
return
# Change colour of the Parse button
self._DP_picture_parse.setStyleSheet("")
# Get Options
try:
xscale = float(self._DP_xscale.text())
yscale = float(self._DP_yscale.text())
cutMode = self._DP_cutMode.currentIndex()
allowDiagonals = not not self._DP_allowDiagonals.checkState()
flipVertically = not not self._DP_flipVertically.checkState()
flipHorizontally = not not self._DP_flipHorizontally.checkState()
prioritizeLeft = not not self._DP_prioritizeLeft.checkState()
except Exception as e:
return self.criticalDialog(message = "Invalid values", informativeText = "Please double check your parameters.", host = self)
# TODO: create the picConv object
# def __init__(self, filename, xscale = 1, yscale = 1, cut = 0, allowDiagonals = False, prioritizeLeft = False, flipHorizontally = False, flipVertically = False ,frames = False, simulate = False, simulateDrawing = False, micronInstance = None, shutterTime = 800):
self.picConv = picConv.PicConv(
filename = self._DP_filename_string,
xscale = xscale,
yscale = yscale,
cut = cutMode,
allowDiagonals = allowDiagonals,
prioritizeLeft = prioritizeLeft,
flipHorizontally = flipHorizontally,
flipVertically = flipVertically,
shutterTime = self.stageControl.controller.shutter.duration * 2,
micronInstance = self.stageControl.controller,
GUI_Object = self
)
# def progressDialog(self, host = None, title = "Progress", labelText = None, cancelButtonText = "Cancel", range = (0, 100)):
# Should be regenerated every time
if hasattr(self, "pDialog"):
del self.pDialog
self.pDialog = self.progressDialog(
host = self,
title = "PicConv",
labelText = "Converting Picture",
)
self.picConv_conversion_thread = ThreadWithExc(target = self._DP_ConvertParseLines)
self.picConv_conversion_thread.start()
self.pDialog.exec_()
if hasattr(self, "pDialog"):
del self.pDialog
def _DP_ConvertParseLines(self):
def cancelOperation(self):
return self.pDialog.close() if hasattr(self, "pDialog") else None
self.pDialog.canceled.connect(lambda: cancelOperation(self))
self.pDialog.setValue(0)
# Redirect output through pDialog.setLabelText()
try:
self.picConv.convert()
except Exception as e:
# The error should have been emitted already
self.logconsole("{}: {}".format(type(e).__name__, e))
return cancelOperation(self)
# Show test.png
try:
self._DP_loadPictureIntoPreviewer("picconv_test.png")
except Exception as e:
self.logconsole("{}: {}".format(type(e).__name__, e))
while datetime.datetime.now() < self.lastPDialogUpdate + datetime.timedelta(seconds = self.PDIALOG_TIMEOUT):
time.sleep(self.PDIALOG_TIMEOUT)
self.pDialog.setWindowTitle("Parsing Lines")
self.pDialog_setLabelText("Parsing Lines")
try:
self.picConv.parseLines()
except Exception as e:
# The error should have been emitted already
self.logconsole("{}: {}".format(type(e).__name__, e))
return cancelOperation(self)
# Change Colour of Draw
self._DP_picture_draw.setStyleSheet("background-color: #FF8800;")
self._DP_optionsChangedFlag = False
return self.pDialog.close() if hasattr(self, "pDialog") else None
def _DP_drawPicture(self, estimateOnly = False):
# Check if loaded
if not hasattr(self, "_DP_filename_string") or self._DP_filename_string is None or not len(self._DP_filename_string):
return self.criticalDialog(message = "Image not loaded!", informativeText = "Please load the image first before parsing and drawing. Filename not captured", title = "Image not loaded!", host = self)
# Check if parseded
if not hasattr(self, "picConv") or not isinstance(self.picConv, picConv.PicConv):
return self.criticalDialog(message = "Image not parsed!", informativeText = "Please parse the image first before drawing. Image and options not captured.", title = "Image not parsed!", host = self)
# Check if options changed
if self._DP_optionsChangedFlag:
ret = self.unsavedQuestionDialog(message = "Reparse with changed options?", title = "Options Changed",informativeText = "The parsing options have been changed since the last parse.\n\nSave to reparse with new options\nDiscard/Cancel to go back", host = self)
if ret == QtWidgets.QMessageBox.Save:
self._DP_parsePicture()
else:
return
# Check if enough space
if not estimateOnly:
size = self.picConv.image.size # (width, height)
fx = self.stageControl.controller.stage.x + self.picConv.scale["x"] * size[0]
fy = self.stageControl.controller.stage.y + self.picConv.scale["y"] * size[1]
xlim = sorted(self.stageControl.controller.stage.xlim)
ylim = sorted(self.stageControl.controller.stage.ylim)
xcond = xlim[0] <= fx <= xlim[1]
ycond = ylim[0] <= fy <= ylim[1]
if not xcond and not ycond:
return self.criticalDialog(message = "Image too large!", informativeText = "At the current position, printing the picture will exceed stage limits in both the x and y direction\n\nStage Limits = x[{}, {}], y[{}, {}]\nImage Size = ({}, {})\nCurrent Stage Position = ({}, {})".format(*xlim, *ylim, *size, *self.stageControl.controller.stage.position), title = "Image too large!", host = self)
elif not xcond:
return self.criticalDialog(message = "Image too large!", informativeText = "At the current position, printing the picture will exceed stage limits in the x direction\n\nStage Limits = x[{}, {}]\nImage Size = ({}, {})\nCurrent Stage Position = ({}, {})".format(*xlim, *size, *self.stageControl.controller.stage.position), title = "Image too large!", host = self)
elif not ycond:
return self.criticalDialog(message = "Image too large!", informativeText = "At the current position, printing the picture will exceed stage limits in the y direction\n\nStage Limits = y[{}, {}]\nImage Size = ({}, {})\nCurrent Stage Position = ({}, {})".format(*ylim, *size, *self.stageControl.controller.stage.position), title = "Image too large!", host = self)
# / Check space
# Check the velocity
vel = self._DP_velocity.text()
try:
vel = float(vel)
except Exception as e:
return self.criticalDialog(message = "Input Error", informativeText = "Unable to parse velocity into float. (Got {})".format(vel), title = "Input Error", host = self)
if not estimateOnly:
# alert confirm user has moved to (0,0)
# We don't bother if the user changed the filename without loading, we just let them know what image will be drawn.
ret = self.unsavedQuestionDialog(message = "Start drawing?", title = "Draw Picture",informativeText = "Using {}\n\nThis point has been taken as the (0, 0) of the image. This usually the top left.\n\nDraw to proceed.\nCancel to go back and change stage position.".format(self._DP_filename_string), host = self, buttons = {
QtWidgets.QMessageBox.Save : "Draw"
}, noDiscard = True)
if ret != QtWidgets.QMessageBox.Save:
return
# Here we start to draw
self.setStartButtonsEnabled(False)
self._DP_picture_draw.setStyleSheet("")
self.setOperationStatus("Starting Draw Picture...")
q = ThreadWithExc(target = self._picConv_draw, args=(vel,))
q.start()
else:
td = datetime.timedelta(seconds = self.picConv.estimateTime(velocity = vel))
return self.informationDialog(message = "The picture will take approximately {}.".format(td), title = "Estimated Time", host = self)
def _picConv_draw(self, velocity):
try:
# Errors are supposed to be emitted directly
self.stageControl.controller.shutter.quietLog = True
self.picConv.draw(velocity = velocity)
self.stageControl.controller.shutter.quietLog = False
self.stageControl.finishTone()
except Exception as e:
self.setOperationStatus("Error Occurred. {}".format(e))
if self.devMode:
raise
else:
# If no error
self.setOperationStatus("Ready.")
finally:
# Always run
self.setStartButtonsEnabled(True)
PDIALOG_TIMEOUT = 1 # in seconds
def pDialog_setValue(self, val):
# print("SETTING VALUE: ", val)
if val == 100 or val == 50 or val == 0 or datetime.datetime.now() > self.lastPDialogUpdate + datetime.timedelta(seconds = self.PDIALOG_TIMEOUT):
self.lastPDialogUpdate = datetime.datetime.now()
self.pDialog.setValue(val)
elif val == 100:
time.sleep(PDIALOG_TIMEOUT)
self.pDialog_setValue(val)
def pDialog_setLabelText(self, text):
if datetime.datetime.now() > self.lastPDialogUpdate + datetime.timedelta(seconds = self.PDIALOG_TIMEOUT):
self.lastPDialogUpdate = datetime.datetime.now()
self.pDialog.setLabelText(text)
# Helper functions
def setOperationStatus(self, status, printToTerm = True, **printArgs):
self.currentStatus = status
if printToTerm:
print("[{}]".format(datetime.datetime.now().time()), status, **printArgs)
# Do some updating of the status bar
self._statusbar_label.setText(status)
def logconsole(self, status):
print("[{}]".format(datetime.datetime.now().time()), status)
EL_self_criticalDialog = QtCore.pyqtSignal('QString', 'QString', 'QString', 'bool')
def on_EL_self_criticalDialog(self, message, title = "Oh no!", informativeText = None, exitAfter = False):
ret = self.criticalDialog(message = message, title = title, informativeText = informativeText, host = self)
if exitAfter:
return os._exit(1) # For the exit to propagate upwards
else:
return ret
def criticalDialog(self, message, title = "Oh no!", informativeText = None, host = None):
_msgBox = QtWidgets.QMessageBox(host)
_msgBox.setIcon(QtWidgets.QMessageBox.Critical)
_msgBox.setWindowTitle(title)
_msgBox.setText(message)
if informativeText is not None:
_msgBox.setInformativeText(informativeText)
# Get height and width
_h = _msgBox.height()
_w = _msgBox.width()
_msgBox.setGeometry(0, 0, _w, _h)
moveToCentre(_msgBox)
# mb.setTextFormat(Qt.RichText)
# mb.setDetailedText(message)
_msgBox.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse)
self.winAudioSetMuted(True)
ret = _msgBox.exec_()
self.winAudioSetMuted(False)
return ret
def informationDialog(self, message, title = "Information", informativeText = None, host = None):
_msgBox = QtWidgets.QMessageBox(host)
_msgBox.setIcon(QtWidgets.QMessageBox.Information)
_msgBox.setWindowTitle(title)
_msgBox.setText(message)
if informativeText is not None:
_msgBox.setInformativeText(informativeText)
# Get height and width
_h = _msgBox.height()
_w = _msgBox.width()
_msgBox.setGeometry(0, 0, _w, _h)
moveToCentre(_msgBox)
# mb.setTextFormat(Qt.RichText)
# mb.setDetailedText(message)
# _msgBox.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse)
self.winAudioSetMuted(True)
ret = _msgBox.exec_()
self.winAudioSetMuted(False)
return ret
def unsavedQuestionDialog(self, message, title = "Unsaved", informativeText = None, host = None, buttons = {}, noDiscard = False):
_msgBox = QtWidgets.QMessageBox(host)
_msgBox.setIcon(QtWidgets.QMessageBox.Question)
_msgBox.setWindowTitle(title)
_msgBox.setText(message)
if informativeText is not None:
_msgBox.setInformativeText(informativeText)
if not noDiscard:
_msgBox.setStandardButtons(QtWidgets.QMessageBox.Save | QtWidgets.QMessageBox.Discard | QtWidgets.QMessageBox.Cancel)
else:
_msgBox.setStandardButtons(QtWidgets.QMessageBox.Save | QtWidgets.QMessageBox.Cancel)
_msgBox.setDefaultButton(QtWidgets.QMessageBox.Cancel)
if buttons and isinstance(buttons, dict):
for key, val in buttons.items():
_msgBox.button(key).setText(val)
# Get height and width
_h = _msgBox.height()
_w = _msgBox.width()
_msgBox.setGeometry(0, 0, _w, _h)
moveToCentre(_msgBox)
# mb.setTextFormat(Qt.RichText)
# mb.setDetailedText(message)
# _msgBox.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse)
self.winAudioSetMuted(True)
ret = _msgBox.exec_()
self.winAudioSetMuted(False)
return ret
# https://doc.qt.io/qt-5/qprogressdialog.html
def progressDialog(self, host = None, title = "Progress", labelText = None, cancelButtonText = "Cancel", range = (0, 100)):
# QProgressDialog::QProgressDialog(const QString &labelText, const QString &cancelButtonText, int minimum, int maximum, QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags())
# NOTE: DOES NOT EXEC
pDialog = QtWidgets.QProgressDialog(labelText, cancelButtonText, range[0], range[1], host)
pDialog.setWindowFlags(QtCore.Qt.WindowTitleHint | QtCore.Qt.Dialog | QtCore.Qt.WindowMaximizeButtonHint | QtCore.Qt.CustomizeWindowHint)
pDialog.setWindowTitle(title)
pDialog.setWindowModality(QtCore.Qt.WindowModal)
# Get height and width
_h = pDialog.height()
_w = pDialog.width()
pDialog.setGeometry(0, 0, _w, _h)
moveToCentre(pDialog)
self.lastPDialogUpdate = datetime.datetime.now()
return pDialog
operationDone = QtCore.pyqtSignal()
def on_operationDone(self):
self.informationDialog(message = "Operation Completed!", title = "Done!", host = self)
if self.stageControl.musicProcess and self.stageControl.musicProcess.isAlive():
try:
self.stageControl.musicProcess.terminate()
except Exception as e:
self.logconsole("{}: {}".format(type(e).__name__, e))
picConvWarn = QtCore.pyqtSignal('QString', 'QString')
# [str, str]
def on_picConvWarn(self, message, error):
return self.criticalDialog(message = message, title = "PicConv Error!", informativeText = error, host = self)
# Status Bar
class aboutPopUp(QtWidgets.QDialog):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.initUI()
def initUI(self):
# x, y, w, h
self.setGeometry(0, 0, 250, 200)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose) # WidgetAttribute.
self.setWindowTitle("About")
moveToCentre(self)
self._main_layout = QtWidgets.QVBoxLayout()
# setContentsMargins(left, top, right, bottom)
self._main_layout.setContentsMargins(10, 10, 10, 10)
one = QtWidgets.QLabel("Made by")
one.setAlignment(QtCore.Qt.AlignCenter)
two = QtWidgets.QLabel("Sun Yudong, Wu Mingsong\n2019")
two.setAlignment(QtCore.Qt.AlignCenter)
ema = QtWidgets.QLabel()
dianyous = [
["sunyudong", "outlook.sg"],
["mingsongwu", "outlook.sg"]
]
ema.setText("<a href=\"mailto:{}\" title=\"Please don't spam us thanks\">sunyudong [at] outlook [dot] sg</a><br/><a href=\"mailto:{}\" title=\"Please don't spam us thanks\">mingsongwu [at] outlook [dot] sg</a>".format(*map("@".join, dianyous)))
ema.setTextFormat(QtCore.Qt.RichText)
ema.setTextInteractionFlags(QtCore.Qt.TextBrowserInteraction)
ema.setOpenExternalLinks(True)
ema.setAlignment(QtCore.Qt.AlignCenter)
thr = QtWidgets.QLabel("NUS Nanomaterials Lab")
thr.setAlignment(QtCore.Qt.AlignCenter)
self._main_layout.addWidget(one)
self._main_layout.addWidget(two)
self._main_layout.addWidget(ema)
self._main_layout.addWidget(thr)
self.setLayout(self._main_layout)
class SettingsScreen(QtWidgets.QDialog):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.microGUIParent = self.parentWidget()
self.initUI()
def initUI(self):
self.setWindowTitle("Settings")
# x, y ,w, h
self.setGeometry(0, 0, 500, 300)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
moveToCentre(self)
self.makeUI()
self.loadSettings()
self.initEventListeners()
def makeUI(self):
self._main_layout = QtWidgets.QGridLayout()
# Optomechanical
_servos = QtWidgets.QGroupBox("Optomechanical")
_servos_layout = QtWidgets.QGridLayout()
self._shutterAbsoluteMode = QtWidgets.QCheckBox("Use Absolute Mode for Shutter")
self._powerAbsoluteMode = QtWidgets.QCheckBox("Use Absolute Mode for Power")
_shutterChannel_label_main = QtWidgets.QLabel("Shutter Channel")
_shutterChannel_label_left = QtWidgets.QLabel("Left")
_shutterChannel_label_righ = QtWidgets.QLabel("Right")
_shutterChannel_label_main.setAlignment(QtCore.Qt.AlignTop)
_shutterChannel_label_left.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignTop)
_shutterChannel_label_righ.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignTop)
self._shutterChannel = QtWidgets.QSlider(QtCore.Qt.Horizontal)
self._shutterChannel.setTickPosition(QtWidgets.QSlider.TicksBothSides)
self._shutterChannel.setRange(0, 1)
self._shutterChannel.setSingleStep(1)
self._shutterChannel.setPageStep(1)
self._shutterChannel.setTickInterval(1)
# WE USE THIS WORKAROUND OF SETTING 0 TO 1 BECAUSE MOUSEEVENTS ARE NOT AFFECTED BY ABOVE SETTINGS
# addWidget(QWidget * widget, int fromRow, int fromColumn, int rowSpan, int columnSpan, Qt::Alignment alignment = 0)
_servos_layout.addWidget(self._shutterAbsoluteMode, 0, 0, 1, 3)
_servos_layout.addWidget(self._powerAbsoluteMode, 1, 0, 1, 3)
_servos_layout.addWidget(_shutterChannel_label_main, 2, 0, 2, 1)
_servos_layout.addWidget(self._shutterChannel, 2, 1, 1, 2)
_servos_layout.addWidget(_shutterChannel_label_left, 3, 1, 1, 1)
_servos_layout.addWidget(_shutterChannel_label_righ, 3, 2, 1, 1)
_servos_layout.setColumnStretch(0, 2)
_servos_layout.setColumnStretch(1, 1)
_servos_layout.setColumnStretch(2, 1)
_servos.setLayout(_servos_layout)
# / Optomechanical
# Stage Configuration
# These are the initialization settings and does not affect the current session!
_stage = QtWidgets.QGroupBox("Stage Settings")
_stage_layout = QtWidgets.QGridLayout()
_stage_xlim_label = QtWidgets.QLabel("X-Limits")
self._stage_xlim_lower = QtWidgets.QLineEdit()
self._stage_xlim_lower.setValidator(QtGui.QDoubleValidator()) # Accept any Double
self._stage_xlim_upper = QtWidgets.QLineEdit()
self._stage_xlim_upper.setValidator(QtGui.QDoubleValidator()) # Accept any Double
_stage_ylim_label = QtWidgets.QLabel("Y-Limits")
self._stage_ylim_lower = QtWidgets.QLineEdit()
self._stage_ylim_lower.setValidator(QtGui.QDoubleValidator()) # Accept any Double
self._stage_ylim_upper = QtWidgets.QLineEdit()
self._stage_ylim_upper.setValidator(QtGui.QDoubleValidator()) # Accept any Double
self._noHome = QtWidgets.QCheckBox("Do not home stage on start")
_note = QtWidgets.QLabel("Limits and Homing Settings take effect only after app restart!\nStage will be initialised in the center of the limits")
_note.setStyleSheet("color: red;")
self._invertx = QtWidgets.QCheckBox("Invert Horizontal")
self._inverty = QtWidgets.QCheckBox("Invert Vertical")
_stage_layout.addWidget(_stage_xlim_label, 0, 0)
_stage_layout.addWidget(self._stage_xlim_lower, 0, 1)
_stage_layout.addWidget(QtWidgets.QLabel("to"), 0, 2)
_stage_layout.addWidget(self._stage_xlim_upper, 0, 3)
_stage_layout.addWidget(_stage_ylim_label, 1, 0)
_stage_layout.addWidget(self._stage_ylim_lower, 1, 1)
_stage_layout.addWidget(QtWidgets.QLabel("to"), 1, 2)
_stage_layout.addWidget(self._stage_ylim_upper, 1, 3)
_stage_layout.addWidget(self._noHome, 2, 0, 1, 4)
_stage_layout.addWidget(_note, 3, 0, 1, 4)
_stage_layout.addWidget(self._invertx, 4, 0, 1, 2)
_stage_layout.addWidget(self._inverty, 4, 2, 1, 2)
# TODO: Add some way of moving dx and dy
_stage.setLayout(_stage_layout)
# / Stage Configuration
# Audio
_audio = QtWidgets.QGroupBox("Audio")
_audio_layout = QtWidgets.QVBoxLayout()
self._disableFinishTone = QtWidgets.QCheckBox("Disable Finish Tone")
# WE USE THIS WORKAROUND OF SETTING 0 TO 1 BECAUSE MOUSEEVENTS ARE NOT AFFECTED BY ABOVE SETTINGS
# addWidget(QWidget * widget, int fromRow, int fromColumn, int rowSpan, int columnSpan, Qt::Alignment alignment = 0)
_audio_layout.addWidget(self._disableFinishTone)
_audio.setLayout(_audio_layout)
# / Audio
# Labels and warnings
_persistent = QtWidgets.QLabel("These settings persists across launches! Refer to documentation for more information.")
# / Labels and warnings
# Buttons
self._buttonBox = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.Apply | QtWidgets.QDialogButtonBox.RestoreDefaults | QtWidgets.QDialogButtonBox.Close)
# / Buttons
self._main_layout.addWidget(_servos, 0, 0, 1, 1)
self._main_layout.addWidget(_audio, 1, 0, 1, 1)
self._main_layout.addWidget(_stage, 0, 1, 2, 1)
self._main_layout.addWidget(_persistent, 2, 0, 1, 2)
self._main_layout.addWidget(self._buttonBox, 3, 0, 1, 2)
self._main_layout.setColumnStretch(0, 1)
self._main_layout.setColumnStretch(1, 1)
self.setLayout(self._main_layout)
def initEventListeners(self):
self._buttonBox.rejected.connect(self.closeCheck)
self._buttonBox.button(QtWidgets.QDialogButtonBox.RestoreDefaults).clicked.connect(self.reset)
self._buttonBox.button(QtWidgets.QDialogButtonBox.Apply).clicked.connect(self.apply)
@property
def set_shutterChannel(self):
# THIS is gonna be abit confusing argh
return servos.Servo.LEFTCH if self._set_shutterChannel == 0 else servos.Servo.RIGHTCH
@set_shutterChannel.setter
def set_shutterChannel(self, x):
self._set_shutterChannel = 0 if x == servos.Servo.LEFTCH else 1
def loadSettings(self):
self.microGUIParent.qsettings.sync()
self.set_shutterAbsoluteMode = self.microGUIParent.qsettings.value("shutter/absoluteMode", True, type = bool)
self.set_shutterChannel = self.microGUIParent.qsettings.value("shutter/channel", servos.Servo.RIGHTCH, type = int)
self.set_powerAbsoluteMode = self.microGUIParent.qsettings.value("power/absoluteMode", False, type = bool)
self.set_invertx = self.microGUIParent.qsettings.value("stage/invertx", False, type = bool)
self.set_inverty = self.microGUIParent.qsettings.value("stage/inverty", False, type = bool)
self.set_stageConfig = self.microGUIParent.qsettings.value("stage/config", None, type = dict) # Should be a dictionary
self.set_noHome = self.microGUIParent.qsettings.value("stage/noHome", False, type = bool)
self.set_noFinishTone = self.microGUIParent.qsettings.value("audio/noFinishTone", True, type = bool)
# Update the GUI with the settings
self._shutterAbsoluteMode.setChecked(self.set_shutterAbsoluteMode)
self._powerAbsoluteMode.setChecked(self.set_powerAbsoluteMode)
self._shutterChannel.setValue(self._set_shutterChannel) # we use the _ value to get 0 and 1
self._invertx.setChecked(self.set_invertx)
self._inverty.setChecked(self.set_inverty)
self._disableFinishTone.setChecked(self.set_noFinishTone)
if not self.set_stageConfig:
self.set_stageConfig = {
"xlim" : mstage.DEFAULT_XLIM ,
"ylim" : mstage.DEFAULT_YLIM
}
self._stage_xlim_lower.setText(str(self.set_stageConfig["xlim"][0]))
self._stage_xlim_upper.setText(str(self.set_stageConfig["xlim"][1]))
self._stage_ylim_lower.setText(str(self.set_stageConfig["ylim"][0]))
self._stage_ylim_upper.setText(str(self.set_stageConfig["ylim"][1]))
def getStageConfigFromGUI(self):
try:
return {
"xlim" : [float(self._stage_xlim_lower.text()), float(self._stage_xlim_upper.text())] ,
"ylim" : [float(self._stage_ylim_lower.text()), float(self._stage_ylim_upper.text())]
}
except ValueError as e:
return None
def settingsEdited(self):
return not (self.set_shutterAbsoluteMode == (not not self._shutterAbsoluteMode.checkState()) and \
self._set_shutterChannel == self._shutterChannel.value() and \
self.set_powerAbsoluteMode == (not not self._powerAbsoluteMode.checkState()) and \
self.set_invertx == (not not self._invertx.checkState()) and \
self.set_inverty == (not not self._inverty.checkState()) and \
self.set_stageConfig == self.getStageConfigFromGUI() and \
self.set_noHome == (not not self._noHome.checkState()) and \
self.set_noFinishTone == (not not self._disableFinishTone.checkState())
)
def closeCheck(self):
if self.settingsEdited():
# Alert saying changes not saved
ret = self.microGUIParent.unsavedQuestionDialog(message = "Settings Changed", informativeText = "Save or Discard?\nClick Cancel to go back.", title = "Unsaved settings", host = self)
if ret == QtWidgets.QMessageBox.Save:
self.apply(noDialog = False)
return self.close()
elif ret == QtWidgets.QMessageBox.Discard:
self.microGUIParent.setOperationStatus("Changed settings discarded! Ready.")
return self.close()
else:
self.microGUIParent.setOperationStatus("Ready.")
return self.close()
def reset(self):
self._shutterAbsoluteMode.setChecked(True)
self._powerAbsoluteMode.setChecked(False)
self._shutterChannel.setValue(servos.Servo.RIGHTCH) # This is fine since its = 1
self._stage_xlim_lower.setText(str(mstage.DEFAULT_XLIM[0]))
self._stage_xlim_upper.setText(str(mstage.DEFAULT_XLIM[1]))
self._stage_ylim_lower.setText(str(mstage.DEFAULT_YLIM[0]))
self._stage_ylim_upper.setText(str(mstage.DEFAULT_YLIM[1]))
self._invertx.setChecked(False)
self._inverty.setChecked(False)
self._disableFinishTone.setChecked(True)
def apply(self, noDialog = False):
# TODO: Check for sane stage config values
newStageConfig = self.getStageConfigFromGUI()
if newStageConfig is None:
return self.microGUIParent.criticalDialog(message = "Error parsing Stage limits!", host = self)
elif newStageConfig["xlim"][0] >= newStageConfig["xlim"][1] or newStageConfig["ylim"][0] >= newStageConfig["ylim"][1]:
return self.microGUIParent.criticalDialog(message = "Stage lower limit must be strictly lower than higher limit!", host = self)
self._set_shutterChannel = self._shutterChannel.value() # Convert to PAN values
self.microGUIParent.qsettings.setValue("shutter/channel", self.set_shutterChannel)
self.microGUIParent.qsettings.setValue("shutter/absoluteMode", not not self._shutterAbsoluteMode.checkState())
self.microGUIParent.qsettings.setValue("power/absoluteMode", not not self._powerAbsoluteMode.checkState())
self.microGUIParent.qsettings.setValue("stage/invertx", not not self._invertx.checkState())
self.microGUIParent.qsettings.setValue("stage/inverty", not not self._inverty.checkState())
self.microGUIParent.qsettings.setValue("stage/noHome", not not self._noHome.checkState())
self.microGUIParent.qsettings.setValue("stage/config", newStageConfig) # Should be a dictionary
self.microGUIParent.qsettings.setValue("audio/noFinishTone", not not self._disableFinishTone.checkState())
self.microGUIParent.qsettings.sync()
# Set the settings in the main GUI also
# We do this after sync because invertCheck() calls sync as well
self.microGUIParent._SL_invertx_checkbox.setChecked(not not self._invertx.checkState())
self.microGUIParent._SL_inverty_checkbox.setChecked(not not self._inverty.checkState())
self.microGUIParent.invertCheck() # This will auto update the necessary variables
# Update the servos absoluteMode
self.microGUIParent.stageControl.controller.shutter.absoluteMode = (not not self._shutterAbsoluteMode.checkState())
self.microGUIParent.stageControl.controller.powerServo.absoluteMode = (not not self._powerAbsoluteMode.checkState())
self.microGUIParent.stageControl.controller.shutter.channel = self.set_shutterChannel
self.microGUIParent.stageControl.controller.powerServo.channel = self.set_shutterChannel * -1
# Update the finish tone
self.microGUIParent.stageControl.noFinishTone = (not not self._disableFinishTone.checkState())
# Reload from memory
self.loadSettings()
self.microGUIParent.setOperationStatus("Settings saved. Ready.")
if not noDialog:
self.microGUIParent.informationDialog(message = "Settings saved successfully.", title="Yay!", host = self)
def main(**kwargs):
# https://stackoverflow.com/a/1857/3211506
# Windows = Windows, Linux = Linux, Mac = Darwin
# For setting icon on Windows
if platform.system() == "Windows":
# https://stackoverflow.com/a/1552105/3211506
myappid = u'NUS.Nanomaterials.MicroGUI.0.10a' # arbitrary string
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
app = QtWidgets.QApplication(sys.argv)
window = MicroGui(**kwargs)
# Start the signal handler
# window.startInterruptHandler()
window.show()
window.raise_()
sys.exit(app.exec_())
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('-d', '--devMode', help="Use DevMode so that StageControl is not initialized", action='store_true')
parser.add_argument('-H', '--noHome', help="Stage will not be homed", action='store_true')
args = parser.parse_args()
main(devMode = args.devMode, noHome = args.noHome)
# ARCHIVE CODE
# def moveToCentre(QtObj):
# # Get center of the window and move the window to the centre
# # Remember to setGeometry of the object first
# # https://pythonprogramminglanguage.com/pyqt5-center-window/
# _qtRectangle = QtObj.frameGeometry()
# _centerPoint = QtWidgets.QDesktopWidget().availableGeometry().center()
# _qtRectangle.moveCenter(_centerPoint)
# QtObj.move(_qtRectangle.topLeft())
|
srluge/SickRage | refs/heads/master | lib/sqlalchemy/orm/properties.py | 79 | # orm/properties.py
# Copyright (C) 2005-2014 the SQLAlchemy authors and contributors <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
"""MapperProperty implementations.
This is a private module which defines the behavior of invidual ORM-
mapped attributes.
"""
from __future__ import absolute_import
from .. import util, log
from ..sql import expression
from . import attributes
from .util import _orm_full_deannotate
from .interfaces import PropComparator, StrategizedProperty
__all__ = ['ColumnProperty', 'CompositeProperty', 'SynonymProperty',
'ComparableProperty', 'RelationshipProperty']
@log.class_logger
class ColumnProperty(StrategizedProperty):
"""Describes an object attribute that corresponds to a table column.
Public constructor is the :func:`.orm.column_property` function.
"""
strategy_wildcard_key = 'column'
def __init__(self, *columns, **kwargs):
"""Provide a column-level property for use with a Mapper.
Column-based properties can normally be applied to the mapper's
``properties`` dictionary using the :class:`.Column` element directly.
Use this function when the given column is not directly present within the
mapper's selectable; examples include SQL expressions, functions, and
scalar SELECT queries.
Columns that aren't present in the mapper's selectable won't be persisted
by the mapper and are effectively "read-only" attributes.
:param \*cols:
list of Column objects to be mapped.
:param active_history=False:
When ``True``, indicates that the "previous" value for a
scalar attribute should be loaded when replaced, if not
already loaded. Normally, history tracking logic for
simple non-primary-key scalar values only needs to be
aware of the "new" value in order to perform a flush. This
flag is available for applications that make use of
:func:`.attributes.get_history` or :meth:`.Session.is_modified`
which also need to know
the "previous" value of the attribute.
.. versionadded:: 0.6.6
:param comparator_factory: a class which extends
:class:`.ColumnProperty.Comparator` which provides custom SQL clause
generation for comparison operations.
:param group:
a group name for this property when marked as deferred.
:param deferred:
when True, the column property is "deferred", meaning that
it does not load immediately, and is instead loaded when the
attribute is first accessed on an instance. See also
:func:`~sqlalchemy.orm.deferred`.
:param doc:
optional string that will be applied as the doc on the
class-bound descriptor.
:param expire_on_flush=True:
Disable expiry on flush. A column_property() which refers
to a SQL expression (and not a single table-bound column)
is considered to be a "read only" property; populating it
has no effect on the state of data, and it can only return
database state. For this reason a column_property()'s value
is expired whenever the parent object is involved in a
flush, that is, has any kind of "dirty" state within a flush.
Setting this parameter to ``False`` will have the effect of
leaving any existing value present after the flush proceeds.
Note however that the :class:`.Session` with default expiration
settings still expires
all attributes after a :meth:`.Session.commit` call, however.
.. versionadded:: 0.7.3
:param info: Optional data dictionary which will be populated into the
:attr:`.MapperProperty.info` attribute of this object.
.. versionadded:: 0.8
:param extension:
an
:class:`.AttributeExtension`
instance, or list of extensions, which will be prepended
to the list of attribute listeners for the resulting
descriptor placed on the class.
**Deprecated.** Please see :class:`.AttributeEvents`.
"""
self._orig_columns = [expression._labeled(c) for c in columns]
self.columns = [expression._labeled(_orm_full_deannotate(c))
for c in columns]
self.group = kwargs.pop('group', None)
self.deferred = kwargs.pop('deferred', False)
self.instrument = kwargs.pop('_instrument', True)
self.comparator_factory = kwargs.pop('comparator_factory',
self.__class__.Comparator)
self.descriptor = kwargs.pop('descriptor', None)
self.extension = kwargs.pop('extension', None)
self.active_history = kwargs.pop('active_history', False)
self.expire_on_flush = kwargs.pop('expire_on_flush', True)
if 'info' in kwargs:
self.info = kwargs.pop('info')
if 'doc' in kwargs:
self.doc = kwargs.pop('doc')
else:
for col in reversed(self.columns):
doc = getattr(col, 'doc', None)
if doc is not None:
self.doc = doc
break
else:
self.doc = None
if kwargs:
raise TypeError(
"%s received unexpected keyword argument(s): %s" % (
self.__class__.__name__,
', '.join(sorted(kwargs.keys()))))
util.set_creation_order(self)
self.strategy_class = self._strategy_lookup(
("deferred", self.deferred),
("instrument", self.instrument)
)
@property
def expression(self):
"""Return the primary column or expression for this ColumnProperty.
"""
return self.columns[0]
def instrument_class(self, mapper):
if not self.instrument:
return
attributes.register_descriptor(
mapper.class_,
self.key,
comparator=self.comparator_factory(self, mapper),
parententity=mapper,
doc=self.doc
)
def do_init(self):
super(ColumnProperty, self).do_init()
if len(self.columns) > 1 and \
set(self.parent.primary_key).issuperset(self.columns):
util.warn(
("On mapper %s, primary key column '%s' is being combined "
"with distinct primary key column '%s' in attribute '%s'. "
"Use explicit properties to give each column its own mapped "
"attribute name.") % (self.parent, self.columns[1],
self.columns[0], self.key))
def copy(self):
return ColumnProperty(
deferred=self.deferred,
group=self.group,
active_history=self.active_history,
*self.columns)
def _getcommitted(self, state, dict_, column,
passive=attributes.PASSIVE_OFF):
return state.get_impl(self.key).\
get_committed_value(state, dict_, passive=passive)
def merge(self, session, source_state, source_dict, dest_state,
dest_dict, load, _recursive):
if not self.instrument:
return
elif self.key in source_dict:
value = source_dict[self.key]
if not load:
dest_dict[self.key] = value
else:
impl = dest_state.get_impl(self.key)
impl.set(dest_state, dest_dict, value, None)
elif dest_state.has_identity and self.key not in dest_dict:
dest_state._expire_attributes(dest_dict, [self.key])
class Comparator(PropComparator):
"""Produce boolean, comparison, and other operators for
:class:`.ColumnProperty` attributes.
See the documentation for :class:`.PropComparator` for a brief
overview.
See also:
:class:`.PropComparator`
:class:`.ColumnOperators`
:ref:`types_operators`
:attr:`.TypeEngine.comparator_factory`
"""
@util.memoized_instancemethod
def __clause_element__(self):
if self.adapter:
return self.adapter(self.prop.columns[0])
else:
return self.prop.columns[0]._annotate({
"parententity": self._parentmapper,
"parentmapper": self._parentmapper})
@util.memoized_property
def info(self):
ce = self.__clause_element__()
try:
return ce.info
except AttributeError:
return self.prop.info
def __getattr__(self, key):
"""proxy attribute access down to the mapped column.
this allows user-defined comparison methods to be accessed.
"""
return getattr(self.__clause_element__(), key)
def operate(self, op, *other, **kwargs):
return op(self.__clause_element__(), *other, **kwargs)
def reverse_operate(self, op, other, **kwargs):
col = self.__clause_element__()
return op(col._bind_param(op, other), col, **kwargs)
def __str__(self):
return str(self.parent.class_.__name__) + "." + self.key
|
proversity-org/edx-platform | refs/heads/master | common/lib/calc/setup.py | 19 | from setuptools import setup
setup(
name="calc",
version="0.2",
packages=["calc"],
install_requires=[
"pyparsing==2.0.7",
"numpy==1.6.2",
"scipy==0.14.0",
],
)
|
madformuse/client | refs/heads/develop | runtests.py | 4 | #! /usr/bin/env python
sources = """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=
"""
import sys
import base64
import zlib
class DictImporter(object):
def __init__(self, sources):
self.sources = sources
def find_module(self, fullname, path=None):
if fullname == "argparse" and sys.version_info >= (2,7):
# we were generated with <python2.7 (which pulls in argparse)
# but we are running now on a stdlib which has it, so use that.
return None
if fullname in self.sources:
return self
if fullname + '.__init__' in self.sources:
return self
return None
def load_module(self, fullname):
# print "load_module:", fullname
from types import ModuleType
try:
s = self.sources[fullname]
is_pkg = False
except KeyError:
s = self.sources[fullname + '.__init__']
is_pkg = True
co = compile(s, fullname, 'exec')
module = sys.modules.setdefault(fullname, ModuleType(fullname))
module.__file__ = "%s/%s" % (__file__, fullname)
module.__loader__ = self
if is_pkg:
module.__path__ = [fullname]
do_exec(co, module.__dict__) # noqa
return sys.modules[fullname]
def get_source(self, name):
res = self.sources.get(name)
if res is None:
res = self.sources.get(name + '.__init__')
return res
if __name__ == "__main__":
if sys.version_info >= (3, 0):
exec("def do_exec(co, loc): exec(co, loc)\n")
import pickle
sources = sources.encode("ascii") # ensure bytes
sources = pickle.loads(zlib.decompress(base64.decodebytes(sources)))
else:
import cPickle as pickle
exec("def do_exec(co, loc): exec co in loc\n")
sources = pickle.loads(zlib.decompress(base64.decodestring(sources)))
importer = DictImporter(sources)
sys.meta_path.insert(0, importer)
entry = "import pytest; raise SystemExit(pytest.cmdline.main())"
do_exec(entry, locals()) # noqa
|
resmo/ansible | refs/heads/devel | lib/ansible/modules/network/f5/bigip_dns_cache_resolver.py | 38 | #!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright: (c) 2018, F5 Networks Inc.
# GNU General Public License v3.0 (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'certified'}
DOCUMENTATION = r'''
---
module: bigip_dns_cache_resolver
short_description: Manage DNS resolver cache configurations on BIG-IP
description:
- Manage DNS resolver cache configurations on BIG-IP.
version_added: 2.8
options:
name:
description:
- Specifies the name of the cache.
type: str
required: True
answer_default_zones:
description:
- Specifies whether the system answers DNS queries for the default
zones localhost, reverse 127.0.0.1 and ::1, and AS112.
- When creating a new cache resolver, if this parameter is not specified, the
default is C(no).
type: bool
forward_zones:
description:
- Forward zones associated with the cache.
- To remove all forward zones, specify a value of C(none).
suboptions:
name:
description:
- Specifies a FQDN for the forward zone.
type: str
required: True
nameservers:
description:
- Specifies the IP address and service port of a recursive
nameserver that answers DNS queries for the zone when the
response cannot be found in the DNS cache.
suboptions:
address:
description:
- Address of recursive nameserver.
type: str
port:
description:
- Port of recursive nameserver.
- When specifying new nameservers, if this value is not provided, the
default is C(53).
type: int
type: list
type: raw
route_domain:
description:
- Specifies the route domain the resolver uses for outbound traffic.
type: str
state:
description:
- When C(present), ensures that the resource exists.
- When C(absent), ensures the resource is removed.
type: str
choices:
- present
- absent
default: present
partition:
description:
- Device partition to manage resources on.
type: str
default: Common
extends_documentation_fragment: f5
author:
- Tim Rupp (@caphrim007)
'''
EXAMPLES = r'''
- name: Create a DNS resolver cache
bigip_dns_cache:
name: foo
answer_default_zones: yes
forward_zones:
- name: foo.bar.com
nameservers:
- address: 1.2.3.4
port: 53
- address: 5.6.7.8
route_domain: 0
provider:
password: secret
server: lb.mydomain.com
user: admin
delegate_to: localhost
'''
RETURN = r'''
param1:
description: The new param1 value of the resource.
returned: changed
type: bool
sample: true
param2:
description: The new param2 value of the resource.
returned: changed
type: str
sample: Foo is bar
'''
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.basic import env_fallback
try:
from library.module_utils.network.f5.bigip import F5RestClient
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import AnsibleF5Parameters
from library.module_utils.network.f5.common import fq_name
from library.module_utils.network.f5.common import f5_argument_spec
from library.module_utils.network.f5.common import flatten_boolean
from library.module_utils.network.f5.common import transform_name
except ImportError:
from ansible.module_utils.network.f5.bigip import F5RestClient
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import AnsibleF5Parameters
from ansible.module_utils.network.f5.common import fq_name
from ansible.module_utils.network.f5.common import f5_argument_spec
from ansible.module_utils.network.f5.common import flatten_boolean
from ansible.module_utils.network.f5.common import transform_name
class Parameters(AnsibleF5Parameters):
api_map = {
'routeDomain': 'route_domain',
'answerDefaultZones': 'answer_default_zones',
'forwardZones': 'forward_zones',
}
api_attributes = [
'routeDomain',
'answerDefaultZones',
'forwardZones',
]
returnables = [
'route_domain',
'answer_default_zones',
'forward_zones',
]
updatables = [
'route_domain',
'answer_default_zones',
'forward_zones',
]
@property
def route_domain(self):
if self._values['route_domain'] is None:
return None
return fq_name(self.partition, self._values['route_domain'])
@property
def answer_default_zones(self):
return flatten_boolean(self._values['answer_default_zones'])
class ApiParameters(Parameters):
@property
def forward_zones(self):
if self._values['forward_zones'] is None:
return None
result = []
for x in self._values['forward_zones']:
tmp = dict(
name=x['name'],
nameservers=[]
)
if 'nameservers' in x:
tmp['nameservers'] = [y['name'] for y in x['nameservers']]
tmp['nameservers'].sort()
result.append(tmp)
return result
class ModuleParameters(Parameters):
@property
def forward_zones(self):
if self._values['forward_zones'] is None:
return None
elif self._values['forward_zones'] in ['', 'none']:
return ''
result = []
for x in self._values['forward_zones']:
if 'name' not in x:
raise F5ModuleError(
"A 'name' key must be provided when specifying a list of forward zones."
)
tmp = dict(
name=x['name'],
nameservers=[]
)
if 'nameservers' in x:
for ns in x['nameservers']:
if 'address' not in ns:
raise F5ModuleError(
"An 'address' key must be provided when specifying a list of forward zone nameservers."
)
item = '{0}:{1}'.format(ns['address'], ns.get('port', 53))
tmp['nameservers'].append(item)
tmp['nameservers'].sort()
result.append(tmp)
return result
class Changes(Parameters):
def to_return(self):
result = {}
try:
for returnable in self.returnables:
result[returnable] = getattr(self, returnable)
result = self._filter_params(result)
except Exception:
pass
return result
class UsableChanges(Changes):
@property
def forward_zones(self):
if self._values['forward_zones'] is None:
return None
result = []
for x in self._values['forward_zones']:
tmp = {'name': x['name']}
if 'nameservers' in x:
tmp['nameservers'] = []
for y in x['nameservers']:
tmp['nameservers'].append(dict(name=y))
result.append(tmp)
return result
class ReportableChanges(Changes):
pass
class Difference(object):
def __init__(self, want, have=None):
self.want = want
self.have = have
def compare(self, param):
try:
result = getattr(self, param)
return result
except AttributeError:
return self.__default(param)
def __default(self, param):
attr1 = getattr(self.want, param)
try:
attr2 = getattr(self.have, param)
if attr1 != attr2:
return attr1
except AttributeError:
return attr1
@property
def forward_zones(self):
if self.want.forward_zones is None:
return None
if self.have.forward_zones is None and self.want.forward_zones in ['', 'none']:
return None
if self.have.forward_zones is not None and self.want.forward_zones in ['', 'none']:
return []
if self.have.forward_zones is None:
return dict(
forward_zones=self.want.forward_zones
)
want = sorted(self.want.forward_zones, key=lambda x: x['name'])
have = sorted(self.have.forward_zones, key=lambda x: x['name'])
wnames = [x['name'] for x in want]
hnames = [x['name'] for x in have]
if set(wnames) != set(hnames):
return dict(
forward_zones=self.want.forward_zones
)
for idx, x in enumerate(want):
wns = x.get('nameservers', [])
hns = have[idx].get('nameservers', [])
if set(wns) != set(hns):
return dict(
forward_zones=self.want.forward_zones
)
class ModuleManager(object):
def __init__(self, *args, **kwargs):
self.module = kwargs.get('module', None)
self.client = F5RestClient(**self.module.params)
self.want = ModuleParameters(params=self.module.params)
self.have = ApiParameters()
self.changes = UsableChanges()
def _set_changed_options(self):
changed = {}
for key in Parameters.returnables:
if getattr(self.want, key) is not None:
changed[key] = getattr(self.want, key)
if changed:
self.changes = UsableChanges(params=changed)
def _update_changed_options(self):
diff = Difference(self.want, self.have)
updatables = Parameters.updatables
changed = dict()
for k in updatables:
change = diff.compare(k)
if change is None:
continue
else:
if isinstance(change, dict):
changed.update(change)
else:
changed[k] = change
if changed:
self.changes = UsableChanges(params=changed)
return True
return False
def should_update(self):
result = self._update_changed_options()
if result:
return True
return False
def exec_module(self):
changed = False
result = dict()
state = self.want.state
if state == "present":
changed = self.present()
elif state == "absent":
changed = self.absent()
reportable = ReportableChanges(params=self.changes.to_return())
changes = reportable.to_return()
result.update(**changes)
result.update(dict(changed=changed))
self._announce_deprecations(result)
return result
def _announce_deprecations(self, result):
warnings = result.pop('__warnings', [])
for warning in warnings:
self.client.module.deprecate(
msg=warning['msg'],
version=warning['version']
)
def present(self):
if self.exists():
return self.update()
else:
return self.create()
def exists(self):
uri = "https://{0}:{1}/mgmt/tm/ltm/dns/cache/resolver/{2}".format(
self.client.provider['server'],
self.client.provider['server_port'],
transform_name(self.want.partition, self.want.name)
)
resp = self.client.api.get(uri)
try:
response = resp.json()
except ValueError:
return False
if resp.status == 404 or 'code' in response and response['code'] == 404:
return False
return True
def update(self):
self.have = self.read_current_from_device()
if not self.should_update():
return False
if self.module.check_mode:
return True
self.update_on_device()
return True
def remove(self):
if self.module.check_mode:
return True
self.remove_from_device()
if self.exists():
raise F5ModuleError("Failed to delete the resource.")
return True
def create(self):
self._set_changed_options()
if self.module.check_mode:
return True
self.create_on_device()
return True
def create_on_device(self):
params = self.changes.api_params()
params['name'] = self.want.name
params['partition'] = self.want.partition
uri = "https://{0}:{1}/mgmt/tm/ltm/dns/cache/resolver/".format(
self.client.provider['server'],
self.client.provider['server_port']
)
resp = self.client.api.post(uri, json=params)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if 'code' in response and response['code'] in [400, 403]:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp.content)
def update_on_device(self):
params = self.changes.api_params()
uri = "https://{0}:{1}/mgmt/tm/ltm/dns/cache/resolver/{2}".format(
self.client.provider['server'],
self.client.provider['server_port'],
transform_name(self.want.partition, self.want.name)
)
resp = self.client.api.patch(uri, json=params)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if 'code' in response and response['code'] == 400:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp.content)
def absent(self):
if self.exists():
return self.remove()
return False
def remove_from_device(self):
uri = "https://{0}:{1}/mgmt/tm/ltm/dns/cache/resolver/{2}".format(
self.client.provider['server'],
self.client.provider['server_port'],
transform_name(self.want.partition, self.want.name)
)
response = self.client.api.delete(uri)
if response.status == 200:
return True
raise F5ModuleError(response.content)
def read_current_from_device(self):
uri = "https://{0}:{1}/mgmt/tm/ltm/dns/cache/resolver/{2}".format(
self.client.provider['server'],
self.client.provider['server_port'],
transform_name(self.want.partition, self.want.name)
)
resp = self.client.api.get(uri)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if 'code' in response and response['code'] == 400:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp.content)
return ApiParameters(params=response)
class ArgumentSpec(object):
def __init__(self):
self.supports_check_mode = True
argument_spec = dict(
name=dict(required=True),
route_domain=dict(),
answer_default_zones=dict(type='bool'),
forward_zones=dict(
type='raw',
options=dict(
name=dict(),
nameservers=dict(
type='list',
elements='dict',
options=dict(
address=dict(),
port=dict(type='int')
)
)
)
),
state=dict(
default='present',
choices=['present', 'absent']
),
partition=dict(
default='Common',
fallback=(env_fallback, ['F5_PARTITION'])
)
)
self.argument_spec = {}
self.argument_spec.update(f5_argument_spec)
self.argument_spec.update(argument_spec)
def main():
spec = ArgumentSpec()
module = AnsibleModule(
argument_spec=spec.argument_spec,
supports_check_mode=spec.supports_check_mode,
)
try:
mm = ModuleManager(module=module)
results = mm.exec_module()
module.exit_json(**results)
except F5ModuleError as ex:
module.fail_json(msg=str(ex))
if __name__ == '__main__':
main()
|
jaesivsm/Radicale | refs/heads/master | radicale/tests/__init__.py | 1 | # This file is part of Radicale Server - Calendar Server
# Copyright © 2012-2017 Guillaume Ayoub
#
# This library is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This library 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 for more details.
#
# You should have received a copy of the GNU General Public License
# along with Radicale. If not, see <http://www.gnu.org/licenses/>.
"""
Tests for Radicale.
"""
import logging
import os
import sys
from io import BytesIO
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
logger = logging.getLogger("radicale_test")
if not logger.hasHandlers():
handler = logging.StreamHandler(sys.stderr)
handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
class BaseTest:
"""Base class for tests."""
logger = logger
def request(self, method, path, data=None, **args):
"""Send a request."""
self.application._status = None
self.application._headers = None
self.application._answer = None
for key in args:
args[key.upper()] = args[key]
args["REQUEST_METHOD"] = method.upper()
args["PATH_INFO"] = path
if data:
data = data.encode("utf-8")
args["wsgi.input"] = BytesIO(data)
args["CONTENT_LENGTH"] = str(len(data))
self.application._answer = self.application(args, self.start_response)
return (
int(self.application._status.split()[0]),
dict(self.application._headers),
self.application._answer[0].decode("utf-8")
if self.application._answer else None)
def start_response(self, status, headers):
"""Put the response values into the current application."""
self.application._status = status
self.application._headers = headers
|
mvfsilva/bootcamp | refs/heads/master | bootcamp/questions/urls.py | 12 | from django.conf.urls import patterns, include, url
urlpatterns = patterns('bootcamp.questions.views',
url(r'^$', 'questions', name='questions'),
url(r'^answered/$', 'answered', name='answered'),
url(r'^unanswered/$', 'unanswered', name='unanswered'),
url(r'^all/$', 'all', name='all'),
url(r'^ask/$', 'ask', name='ask'),
url(r'^favorite/$', 'favorite', name='favorite'),
url(r'^answer/$', 'answer', name='answer'),
url(r'^answer/accept/$', 'accept', name='accept'),
url(r'^answer/vote/$', 'vote', name='vote'),
url(r'^(\d+)/$', 'question', name='question'),
) |
pcdocker/pcdocker | refs/heads/master | pcdocker/users/tests/test_admin.py | 264 | from test_plus.test import TestCase
from ..admin import MyUserCreationForm
class TestMyUserCreationForm(TestCase):
def setUp(self):
self.user = self.make_user()
def test_clean_username_success(self):
# Instantiate the form with a new username
form = MyUserCreationForm({
'username': 'alamode',
'password1': '123456',
'password2': '123456',
})
# Run is_valid() to trigger the validation
valid = form.is_valid()
self.assertTrue(valid)
# Run the actual clean_username method
username = form.clean_username()
self.assertEqual('alamode', username)
def test_clean_username_false(self):
# Instantiate the form with the same username as self.user
form = MyUserCreationForm({
'username': self.user.username,
'password1': '123456',
'password2': '123456',
})
# Run is_valid() to trigger the validation, which is going to fail
# because the username is already taken
valid = form.is_valid()
self.assertFalse(valid)
# The form.errors dict should contain a single error called 'username'
self.assertTrue(len(form.errors) == 1)
self.assertTrue('username' in form.errors)
|
Hybrid-Cloud/cinder | refs/heads/master | cinder/db/sqlalchemy/migrate_repo/manage.py | 50 | #!/usr/bin/env python
# Copyright 2013 OpenStack Foundation
#
# 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 os
from cinder.db.sqlalchemy import migrate_repo
from migrate.versioning.shell import main
if __name__ == '__main__':
main(debug='False',
repository=os.path.abspath(os.path.dirname(migrate_repo.__file__)))
|
Darkmer/masterchief | refs/heads/master | CourseBuilderenv/lib/python2.7/site-packages/setuptools/command/rotate.py | 125 | import os
from setuptools import Command
from setuptools.compat import basestring
from distutils.util import convert_path
from distutils import log
from distutils.errors import DistutilsOptionError
class rotate(Command):
"""Delete older distributions"""
description = "delete older distributions, keeping N newest files"
user_options = [
('match=', 'm', "patterns to match (required)"),
('dist-dir=', 'd', "directory where the distributions are"),
('keep=', 'k', "number of matching distributions to keep"),
]
boolean_options = []
def initialize_options(self):
self.match = None
self.dist_dir = None
self.keep = None
def finalize_options(self):
if self.match is None:
raise DistutilsOptionError(
"Must specify one or more (comma-separated) match patterns "
"(e.g. '.zip' or '.egg')"
)
if self.keep is None:
raise DistutilsOptionError("Must specify number of files to keep")
try:
self.keep = int(self.keep)
except ValueError:
raise DistutilsOptionError("--keep must be an integer")
if isinstance(self.match, basestring):
self.match = [
convert_path(p.strip()) for p in self.match.split(',')
]
self.set_undefined_options('bdist',('dist_dir', 'dist_dir'))
def run(self):
self.run_command("egg_info")
from glob import glob
for pattern in self.match:
pattern = self.distribution.get_name()+'*'+pattern
files = glob(os.path.join(self.dist_dir,pattern))
files = [(os.path.getmtime(f),f) for f in files]
files.sort()
files.reverse()
log.info("%d file(s) matching %s", len(files), pattern)
files = files[self.keep:]
for (t,f) in files:
log.info("Deleting %s", f)
if not self.dry_run:
os.unlink(f)
|
RandyLowery/erpnext | refs/heads/develop | erpnext/stock/doctype/stock_settings/__init__.py | 12133432 | |
aleksandra-tarkowska/django | refs/heads/master | tests/multiple_database/__init__.py | 12133432 | |
tungvx/deploy | refs/heads/master | .google_appengine/lib/django_1_2/tests/regressiontests/special_headers/__init__.py | 12133432 | |
ncliam/serverpos | refs/heads/master | openerp/addons/l10n_hn/__init__.py | 27 | # -*- encoding: utf-8 -*-
##############################################################################
#
# Copyright (c) 2009-2010 Salvatore J. Trimarchi <[email protected]>
# (http://salvatoreweb.co.cc)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
|
xiaoxiamii/scikit-learn | refs/heads/master | sklearn/metrics/cluster/tests/test_bicluster.py | 394 | """Testing for bicluster metrics module"""
import numpy as np
from sklearn.utils.testing import assert_equal, assert_almost_equal
from sklearn.metrics.cluster.bicluster import _jaccard
from sklearn.metrics import consensus_score
def test_jaccard():
a1 = np.array([True, True, False, False])
a2 = np.array([True, True, True, True])
a3 = np.array([False, True, True, False])
a4 = np.array([False, False, True, True])
assert_equal(_jaccard(a1, a1, a1, a1), 1)
assert_equal(_jaccard(a1, a1, a2, a2), 0.25)
assert_equal(_jaccard(a1, a1, a3, a3), 1.0 / 7)
assert_equal(_jaccard(a1, a1, a4, a4), 0)
def test_consensus_score():
a = [[True, True, False, False],
[False, False, True, True]]
b = a[::-1]
assert_equal(consensus_score((a, a), (a, a)), 1)
assert_equal(consensus_score((a, a), (b, b)), 1)
assert_equal(consensus_score((a, b), (a, b)), 1)
assert_equal(consensus_score((a, b), (b, a)), 1)
assert_equal(consensus_score((a, a), (b, a)), 0)
assert_equal(consensus_score((a, a), (a, b)), 0)
assert_equal(consensus_score((b, b), (a, b)), 0)
assert_equal(consensus_score((b, b), (b, a)), 0)
def test_consensus_score_issue2445():
''' Different number of biclusters in A and B'''
a_rows = np.array([[True, True, False, False],
[False, False, True, True],
[False, False, False, True]])
a_cols = np.array([[True, True, False, False],
[False, False, True, True],
[False, False, False, True]])
idx = [0, 2]
s = consensus_score((a_rows, a_cols), (a_rows[idx], a_cols[idx]))
# B contains 2 of the 3 biclusters in A, so score should be 2/3
assert_almost_equal(s, 2.0/3.0)
|
ColinIanKing/autotest | refs/heads/master | frontend/shared/common.py | 20 | import os, sys
try:
import autotest.client.setup_modules as setup_modules
dirname = os.path.dirname(setup_modules.__file__)
autotest_dir = os.path.join(dirname, "..")
except ImportError:
dirname = os.path.dirname(sys.modules[__name__].__file__)
autotest_dir = os.path.abspath(os.path.join(dirname, '..', '..'))
client_dir = os.path.join(autotest_dir, "client")
sys.path.insert(0, client_dir)
import setup_modules
sys.path.pop(0)
setup_modules.setup(base_path=autotest_dir, root_module_name="autotest")
|
pronto/dotfiles | refs/heads/master | .vim/pylibs/ropevim.py | 1 | """ropevim, a vim mode for using rope refactoring library"""
import glob
import os
import tempfile
import re
from pylibs.ropemode import decorators
from pylibs.ropemode import environment
from pylibs.ropemode import interface
import vim
# Gobal var to be able to shutup output
_rope_quiet = False
class VimUtils(environment.Environment):
def __init__(self, *args, **kwargs):
super(VimUtils, self).__init__(*args, **kwargs)
self.completeopt = vim.eval('&completeopt')
self.preview = 'preview' in self.completeopt
def ask(self, prompt, default=None, starting=None):
if starting is None:
starting = ''
if default is not None:
prompt = prompt + '[{0}] '.format(default)
result = call('input("{0}", "{1}")'.format(prompt, starting))
if default is not None and result == '':
return default
return result
def ask_values(self, prompt, values, default=None,
starting=None, show_values=None):
if show_values or (show_values is None and len(values) < 14):
self._print_values(values)
if default is not None:
prompt = prompt + '[{0}] '.format(default)
starting = starting or ''
_completer.values = values
answer = call(
'input("{0}", "{1}", "customlist,RopeValueCompleter")'.format(
prompt, starting
)
)
if answer is None:
if 'cancel' in values:
return 'cancel'
return
if default is not None and not answer:
return default
if answer.isdigit() and 0 <= int(answer) < len(values):
return values[int(answer)]
return answer
def _print_values(self, values):
numbered = []
for index, value in enumerate(values):
numbered.append('%s. %s' % (index, str(value)))
echo('\n'.join(numbered) + '\n')
def ask_directory(self, prompt, default=None, starting=None):
return call('input("{0}", ".", "dir")'.format(prompt))
def _update_proposals(self, values):
self.completeopt = vim.eval('&completeopt')
self.preview = 'preview' in self.completeopt
if not self.get('extended_complete'):
return u','.join(u"'{0}'".format(self._completion_text(proposal))
for proposal in values)
return u','.join(self._extended_completion(proposal)
for proposal in values)
def _command(self, command, encode=False):
if encode:
command = command.encode(self._get_encoding())
vim.command(command)
def ask_completion(self, prompt, values, starting=None):
if self.get('vim_completion') and 'i' in call('mode()'):
proposals = self._update_proposals(values)
col = int(call('col(".")'))
if starting:
col -= len(starting)
self._command(u'call complete({0}, [{1}])'.format(col, proposals),
encode=True)
return None
return self.ask_values(prompt, values, starting=starting,
show_values=False)
def message(self, message):
echo(message)
def yes_or_no(self, prompt):
return self.ask_values(prompt, ['yes', 'no']) == 'yes'
def y_or_n(self, prompt):
return self.yes_or_no(prompt)
def get(self, name, default=None):
vimname = 'g:pymode_rope_{0}'.format(name)
if str(vim.eval('exists("{0}")'.format(vimname))) == '0':
return default
result = vim.eval(vimname)
if isinstance(result, str) and result.isdigit():
return int(result)
return result
def get_offset(self):
result = self._position_to_offset(*self.cursor)
return result
@staticmethod
def _get_encoding():
return vim.eval('&encoding') or 'utf-8'
def _encode_line(self, line):
return line.encode(self._get_encoding())
def _decode_line(self, line):
return line.decode(self._get_encoding())
def _position_to_offset(self, lineno, colno):
result = min(colno, len(self.buffer[lineno - 1]) + 1)
for line in self.buffer[:lineno - 1]:
line = self._decode_line(line)
result += len(line) + 1
return result
def get_text(self):
return self._decode_line('\n'.join(self.buffer)) + u'\n'
def get_region(self):
start = self._position_to_offset(*self.buffer.mark('<'))
end = self._position_to_offset(*self.buffer.mark('>'))
return start, end
@property
def buffer(self):
return vim.current.buffer
def _get_cursor(self):
lineno, col = vim.current.window.cursor
line = self._decode_line(vim.current.line[:col])
col = len(line)
return (lineno, col)
def _set_cursor(self, cursor):
lineno, col = cursor
line = self._decode_line(vim.current.line)
line = self._encode_line(line[:col])
col = len(line)
vim.current.window.cursor = (lineno, col)
cursor = property(_get_cursor, _set_cursor)
@staticmethod
def get_cur_dir():
return vim.eval('getcwd()')
def filename(self):
return self.buffer.name
def is_modified(self):
return vim.eval('&modified')
def goto_line(self, lineno):
self.cursor = (lineno, 0)
def insert_line(self, line, lineno):
self.buffer[lineno - 1:lineno - 1] = [line]
def insert(self, text):
lineno, colno = self.cursor
line = self.buffer[lineno - 1]
self.buffer[lineno - 1] = line[:colno] + text + line[colno:]
self.cursor = (lineno, colno + len(text))
def delete(self, start, end):
lineno1, colno1 = self._offset_to_position(start - 1)
lineno2, colno2 = self._offset_to_position(end - 1)
lineno, colno = self.cursor
if lineno1 == lineno2:
line = self.buffer[lineno1 - 1]
self.buffer[lineno1 - 1] = line[:colno1] + line[colno2:]
if lineno == lineno1 and colno >= colno1:
diff = colno2 - colno1
self.cursor = (lineno, max(0, colno - diff))
def _offset_to_position(self, offset):
text = self.get_text()
lineno = text.count('\n', 0, offset) + 1
try:
colno = offset - text.rindex('\n', 0, offset) - 1
except ValueError:
colno = offset
return lineno, colno
def filenames(self):
result = []
for buffer in vim.buffers:
if buffer.name:
result.append(buffer.name)
return result
def save_files(self, filenames):
vim.command('wall')
def reload_files(self, filenames, moves={}):
initial = self.filename()
for filename in filenames:
self.find_file(moves.get(filename, filename), force=True)
if initial:
self.find_file(initial)
def find_file(self, filename, readonly=False, other=False, force=False):
if filename != self.filename() or force:
if other:
vim.command(other)
filename = '\\ '.join(s.rstrip() for s in filename.split())
vim.command('e %s' % filename)
if readonly:
vim.command('set nomodifiable')
def create_progress(self, name):
return VimProgress(name)
def current_word(self):
return vim.eval('expand("<cword>")')
def push_mark(self):
vim.command('mark `')
def prefix_value(self, prefix):
return prefix
def show_occurrences(self, locations):
self._quickfixdefs(locations)
vim.command('cwindow')
def _quickfixdefs(self, locations):
filename = os.path.join(tempfile.gettempdir(), tempfile.mktemp())
try:
self._writedefs(locations, filename)
vim.command('let old_errorfile = &errorfile')
vim.command('let old_errorformat = &errorformat')
vim.command('set errorformat=%f:%l:\ %m')
vim.command('cfile ' + filename)
vim.command('let &errorformat = old_errorformat')
vim.command('let &errorfile = old_errorfile')
finally:
os.remove(filename)
def _writedefs(self, locations, filename):
tofile = open(filename, 'w')
try:
for location in locations:
err = '%s:%d: - %s\n' % (location.filename,
location.lineno, location.note)
echo(err)
tofile.write(err)
finally:
tofile.close()
def show_doc(self, docs, altview=False):
if docs:
vim.command(
'call pymode#ShowStr("{0}")'.format(docs.replace('"', '\\"'))
)
def preview_changes(self, diffs):
echo(diffs)
return self.y_or_n('Do the changes? ')
def local_command(self, name, callback, key=None, prefix=False):
self._add_command(name, callback, key, prefix,
prekey=self.get('local_prefix'))
def global_command(self, name, callback, key=None, prefix=False):
self._add_command(name, callback, key, prefix,
prekey=self.get('global_prefix'))
def add_hook(self, name, callback, hook):
mapping = {'before_save': 'FileWritePre,BufWritePre',
'after_save': 'FileWritePost,BufWritePost',
'exit': 'VimLeave'}
self._add_function(name, callback)
vim.command(
'autocmd {0} *.py call {1}()'.format(
mapping[hook], _vim_name(name)
)
)
def _add_command(self, name, callback, key, prefix, prekey):
self._add_function(name, callback, prefix)
vim.command(
'command! -range {0} call {1}()'.format(
_vim_name(name), _vim_name(name)
)
)
if key is not None:
key = prekey + key.replace(' ', '')
vim.command(
'noremap {0} :call {1}()<cr>'.format(key, _vim_name(name))
)
def _add_function(self, name, callback, prefix=False):
globals()[name] = callback
arg = 'None' if prefix else ''
vim.command(
'function! {0}()\n'
'python ropevim.{1}({2})\n'
'endfunction\n'.format(_vim_name(name), name, arg)
)
def _completion_data(self, proposal):
return proposal
_docstring_re = re.compile('^[\s\t\n]*([^\n]*)')
def _extended_completion(self, proposal):
# we are using extended complete and return dicts instead of strings.
# `ci` means "completion item". see `:help complete-items`
word, _, menu = map(lambda x: x.strip(), proposal.name.partition(':'))
ci = dict(
word=word,
info='',
kind=''.join(
s if s not in 'aeyuo' else '' for s in proposal.type)[:3],
menu=menu or '')
if proposal.scope == 'parameter_keyword':
default = proposal.get_default()
ci["menu"] += '*' if default is None else '= {0}'.format(default)
if self.preview and not ci['menu']:
doc = proposal.get_doc()
ci['info'] = self._docstring_re.match(doc).group(1) if doc else ''
return self._conv(ci)
def _conv(self, obj):
if isinstance(obj, dict):
return u'{' + u','.join([
u"{0}:{1}".format(self._conv(key), self._conv(value))
for key, value in obj.iteritems()]) + u'}'
return u'"{0}"'.format(str(obj).replace(u'"', u'\\"'))
def _vim_name(name):
tokens = name.split('_')
newtokens = ['Rope'] + [token.title() for token in tokens]
return ''.join(newtokens)
class VimProgress(object):
def __init__(self, name):
self.name = name
self.last = 0
status('{0} ... '.format(self.name))
def update(self, percent):
try:
vim.eval('getchar(0)')
except vim.error:
raise KeyboardInterrupt(
'Task {0} was interrupted!'.format(self.name)
)
if percent > self.last + 4:
status('{0} ... {1}%'.format(self.name, percent))
self.last = percent
def done(self):
status('{0} ... done'.format(self.name))
def echo(message):
if _rope_quiet:
return
if isinstance(message, unicode):
message = message.encode(vim.eval('&encoding'))
print message
def status(message):
if _rope_quiet:
return
if isinstance(message, unicode):
message = message.encode(vim.eval('&encoding'))
vim.command('redraw | echon "{0}"'.format(message))
def call(command):
return vim.eval(command)
class _ValueCompleter(object):
def __init__(self):
self.values = []
vim.command('python import vim')
vim.command('function! RopeValueCompleter(A, L, P)\n'
'python args = [vim.eval("a:" + p) for p in "ALP"]\n'
'python ropevim._completer(*args)\n'
'return s:completions\n'
'endfunction\n')
def __call__(self, arg_lead, cmd_line, cursor_pos):
# don't know if self.values can be empty but better safe then sorry
if self.values:
if not isinstance(self.values[0], basestring):
result = [proposal.name for proposal in self.values
if proposal.name.startswith(arg_lead)]
else:
result = [proposal for proposal in self.values
if proposal.startswith(arg_lead)]
vim.command('let s:completions = {0}'.format(result))
class RopeMode(interface.RopeMode):
@decorators.global_command('o')
def open_project(self, root=None, quiet=False):
global _rope_quiet
_rope_quiet = quiet
super(RopeMode, self).open_project(root=root)
rope_project_dir = os.path.join(self.project.address, '.ropeproject')
vimfiles = glob.glob(os.path.join(rope_project_dir, '*.vim'))
if not vimfiles:
return
txt = 'Sourcing vim files under \'.ropeproject/\''
progress = self.env.create_progress(txt)
for idx, vimfile in enumerate(sorted(vimfiles)):
progress.name = txt + ' ({0})'.format(os.path.basename(vimfile))
vim.command(':silent source {0}'.format(vimfile))
progress.update(idx * 100 / len(vimfiles))
progress.name = txt
progress.done()
echo('Project opened!')
decorators.logger.message = echo
decorators.logger.only_short = True
_completer = _ValueCompleter()
_env = VimUtils()
_interface = RopeMode(env=_env)
|
interlegis/sigi | refs/heads/master | sigi/apps/servidores/migrations/0005_auto_20210423_0904.py | 1 | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('servidores', '0004_auto_20210422_1907'),
]
operations = [
migrations.AlterModelOptions(
name='servico',
options={'ordering': ('-subordinado__sigla', 'nome'), 'verbose_name': 'servi\xe7o', 'verbose_name_plural': 'servi\xe7os'},
),
]
|
40223247/2015_w11 | refs/heads/master | static/Brython3.1.0-20150301-090019/Lib/browser/timer.py | 610 | from browser import window
def wrap(func):
# Transforms a function f into another function that prints a
# traceback in case of exception
def f(*args, **kw):
try:
return func(*args, **kw)
except Exception as exc:
sys.stderr.write(exc)
return f
clear_interval = window.clearInterval
clear_timeout = window.clearTimeout
def set_interval(func,interval):
return window.setInterval(wrap(func),interval)
def set_timeout(func,interval):
return int(window.setTimeout(wrap(func),interval))
def request_animation_frame(func):
return int(window.requestAnimationFrame(func))
def cancel_animation_frame(int_id):
window.cancelAnimationFrame(int_id)
|
dockerera/func | refs/heads/master | func/yaml/dump.py | 2 | """
pyyaml legacy
Copyright (c) 2001 Steve Howell and Friends; All Rights Reserved
(see open source license information in docs/ directory)
"""
import types
import string
from types import StringType, UnicodeType, IntType, FloatType
from types import DictType, ListType, TupleType, InstanceType
from klass import hasMethod, isDictionary
import re
"""
The methods from this module that are exported to the top
level yaml package should remain stable. If you call
directly into other methods of this module, be aware that
they may change or go away in future implementations.
Contact the authors if there are methods in this file
that you wish to remain stable.
"""
def dump(*data):
return Dumper().dump(*data)
def d(data): return dump(data)
def dumpToFile(file, *data):
return Dumper().dumpToFile(file, *data)
class Dumper:
def __init__(self):
self.currIndent = "\n"
self.indent = " "
self.keysrt = None
self.alphaSort = 1 # legacy -- on by default
def setIndent(self, indent):
self.indent = indent
return self
def setSort(self, sort_hint):
self.keysrt = sortMethod(sort_hint)
return self
def dump(self, *data):
self.result = []
self.output = self.outputToString
self.dumpDocuments(data)
return string.join(self.result,"")
def outputToString(self, data):
self.result.append(data)
def dumpToFile(self, file, *data):
self.file = file
self.output = self.outputToFile
self.dumpDocuments(data)
def outputToFile(self, data):
self.file.write(data)
def dumpDocuments(self, data):
for obj in data:
self.anchors = YamlAnchors(obj)
self.output("---")
self.dumpData(obj)
self.output("\n")
def indentDump(self, data):
oldIndent = self.currIndent
self.currIndent += self.indent
self.dumpData(data)
self.currIndent = oldIndent
def dumpData(self, data):
anchor = self.anchors.shouldAnchor(data)
# Disabling anchors because they are lame for strings that the user might want to view/edit -- mdehaan
#
#if anchor:
# self.output(" &%d" % anchor )
#else:
# anchor = self.anchors.isAlias(data)
# if anchor:
# self.output(" *%d" % anchor )
# return
if (data is None):
self.output(' ~')
elif hasMethod(data, 'to_yaml'):
self.dumpTransformedObject(data)
elif hasMethod(data, 'to_yaml_implicit'):
self.output(" " + data.to_yaml_implicit())
elif type(data) is InstanceType:
self.dumpRawObject(data)
elif isDictionary(data):
self.dumpDict(data)
elif type(data) in [ListType, TupleType]:
self.dumpList(data)
else:
self.dumpScalar(data)
def dumpTransformedObject(self, data):
obj_yaml = data.to_yaml()
if type(obj_yaml) is not TupleType:
self.raiseToYamlSyntaxError()
(data, typestring) = obj_yaml
if typestring:
self.output(" " + typestring)
self.dumpData(data)
def dumpRawObject(self, data):
self.output(' !!%s.%s' % (data.__module__, data.__class__.__name__))
self.dumpData(data.__dict__)
def dumpDict(self, data):
keys = data.keys()
if len(keys) == 0:
self.output(" {}")
return
if self.keysrt:
keys = sort_keys(keys,self.keysrt)
else:
if self.alphaSort:
keys.sort()
for key in keys:
self.output(self.currIndent)
self.dumpKey(key)
self.output(":")
self.indentDump(data[key])
def dumpKey(self, key):
if type(key) is TupleType:
self.output("?")
self.indentDump(key)
self.output("\n")
else:
self.output(quote(key))
def dumpList(self, data):
if len(data) == 0:
self.output(" []")
return
for item in data:
self.output(self.currIndent)
self.output("-")
self.indentDump(item)
def dumpScalar(self, data):
if isUnicode(data):
self.output(' "%s"' % repr(data)[2:-1])
elif isMulti(data):
self.dumpMultiLineScalar(data.splitlines())
else:
self.output(" ")
self.output(quote(data))
def dumpMultiLineScalar(self, lines):
self.output(" |")
if lines[-1] == "":
self.output("+")
for line in lines:
self.output(self.currIndent)
self.output(line)
def raiseToYamlSyntaxError(self):
raise """
to_yaml should return tuple w/object to dump
and optional YAML type. Example:
({'foo': 'bar'}, '!!foobar')
"""
#### ANCHOR-RELATED METHODS
def accumulate(obj,occur):
typ = type(obj)
if obj is None or \
typ is IntType or \
typ is FloatType or \
((typ is StringType or typ is UnicodeType) \
and len(obj) < 32): return
obid = id(obj)
if 0 == occur.get(obid,0):
occur[obid] = 1
if typ is ListType:
for x in obj:
accumulate(x,occur)
if typ is DictType:
for (x,y) in obj.items():
accumulate(x,occur)
accumulate(y,occur)
else:
occur[obid] = occur[obid] + 1
class YamlAnchors:
def __init__(self,data):
occur = {}
accumulate(data,occur)
anchorVisits = {}
for (obid, occur) in occur.items():
if occur > 1:
anchorVisits[obid] = 0
self._anchorVisits = anchorVisits
self._currentAliasIndex = 0
def shouldAnchor(self,obj):
ret = self._anchorVisits.get(id(obj),None)
if 0 == ret:
self._currentAliasIndex = self._currentAliasIndex + 1
ret = self._currentAliasIndex
self._anchorVisits[id(obj)] = ret
return ret
return 0
def isAlias(self,obj):
return self._anchorVisits.get(id(obj),0)
### SORTING METHODS
def sort_keys(keys,fn):
tmp = []
for key in keys:
val = fn(key)
if val is None: val = '~'
tmp.append((val,key))
tmp.sort()
return [ y for (x,y) in tmp ]
def sortMethod(sort_hint):
typ = type(sort_hint)
if DictType == typ:
return sort_hint.get
elif ListType == typ or TupleType == typ:
indexes = {}; idx = 0
for item in sort_hint:
indexes[item] = idx
idx += 1
return indexes.get
else:
return sort_hint
### STRING QUOTING AND SCALAR HANDLING
def isStr(data):
# XXX 2.1 madness
if type(data) == type(''):
return 1
if type(data) == type(u''):
return 1
return 0
def doubleUpQuotes(data):
return data.replace("'", "''")
def quote(data):
if not isStr(data):
return str(data)
single = "'"
double = '"'
quote = ''
if len(data) == 0:
return "''"
if hasSpecialChar(data) or data[0] == single:
data = `data`[1:-1]
data = string.replace(data, r"\x08", r"\b")
quote = double
elif needsSingleQuote(data):
quote = single
data = doubleUpQuotes(data)
return "%s%s%s" % (quote, data, quote)
def needsSingleQuote(data):
if re.match(r"^-?\d", data):
return 1
if re.match(r"\*\S", data):
return 1
if data[0] in ['&', ' ']:
return 1
if data[0] == '"':
return 1
if data[-1] == ' ':
return 1
return (re.search(r'[:]', data) or re.search(r'(\d\.){2}', data))
def hasSpecialChar(data):
# need test to drive out '#' from this
return re.search(r'[\t\b\r\f#]', data)
def isMulti(data):
if not isStr(data):
return 0
if hasSpecialChar(data):
return 0
return re.search("\n", data)
def isUnicode(data):
return type(data) == unicode
def sloppyIsUnicode(data):
# XXX - hack to make tests pass for 2.1
return repr(data)[:2] == "u'" and repr(data) != data
import sys
if sys.hexversion < 0x20200000:
isUnicode = sloppyIsUnicode
|
AfricaChess/lichesshub | refs/heads/master | player/views.py | 138 | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.shortcuts import render
# Create your views here.
|
MattsFleaMarket/python-for-android | refs/heads/master | python-build/python-libs/xmpppy/xmpp/auth.py | 196 | ## auth.py
##
## Copyright (C) 2003-2005 Alexey "Snake" Nezhdanov
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2, 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 General Public License for more details.
# $Id: auth.py,v 1.41 2008/09/13 21:45:21 normanr Exp $
"""
Provides library with all Non-SASL and SASL authentication mechanisms.
Can be used both for client and transport authentication.
"""
from protocol import *
from client import PlugIn
import sha,base64,random,dispatcher,re
import md5
def HH(some): return md5.new(some).hexdigest()
def H(some): return md5.new(some).digest()
def C(some): return ':'.join(some)
class NonSASL(PlugIn):
""" Implements old Non-SASL (JEP-0078) authentication used in jabberd1.4 and transport authentication."""
def __init__(self,user,password,resource):
""" Caches username, password and resource for auth. """
PlugIn.__init__(self)
self.DBG_LINE='gen_auth'
self.user=user
self.password=password
self.resource=resource
def plugin(self,owner):
""" Determine the best auth method (digest/0k/plain) and use it for auth.
Returns used method name on success. Used internally. """
if not self.resource: return self.authComponent(owner)
self.DEBUG('Querying server about possible auth methods','start')
resp=owner.Dispatcher.SendAndWaitForResponse(Iq('get',NS_AUTH,payload=[Node('username',payload=[self.user])]))
if not isResultNode(resp):
self.DEBUG('No result node arrived! Aborting...','error')
return
iq=Iq(typ='set',node=resp)
query=iq.getTag('query')
query.setTagData('username',self.user)
query.setTagData('resource',self.resource)
if query.getTag('digest'):
self.DEBUG("Performing digest authentication",'ok')
query.setTagData('digest',sha.new(owner.Dispatcher.Stream._document_attrs['id']+self.password).hexdigest())
if query.getTag('password'): query.delChild('password')
method='digest'
elif query.getTag('token'):
token=query.getTagData('token')
seq=query.getTagData('sequence')
self.DEBUG("Performing zero-k authentication",'ok')
hash = sha.new(sha.new(self.password).hexdigest()+token).hexdigest()
for foo in xrange(int(seq)): hash = sha.new(hash).hexdigest()
query.setTagData('hash',hash)
method='0k'
else:
self.DEBUG("Sequre methods unsupported, performing plain text authentication",'warn')
query.setTagData('password',self.password)
method='plain'
resp=owner.Dispatcher.SendAndWaitForResponse(iq)
if isResultNode(resp):
self.DEBUG('Sucessfully authenticated with remove host.','ok')
owner.User=self.user
owner.Resource=self.resource
owner._registered_name=owner.User+'@'+owner.Server+'/'+owner.Resource
return method
self.DEBUG('Authentication failed!','error')
def authComponent(self,owner):
""" Authenticate component. Send handshake stanza and wait for result. Returns "ok" on success. """
self.handshake=0
owner.send(Node(NS_COMPONENT_ACCEPT+' handshake',payload=[sha.new(owner.Dispatcher.Stream._document_attrs['id']+self.password).hexdigest()]))
owner.RegisterHandler('handshake',self.handshakeHandler,xmlns=NS_COMPONENT_ACCEPT)
while not self.handshake:
self.DEBUG("waiting on handshake",'notify')
owner.Process(1)
owner._registered_name=self.user
if self.handshake+1: return 'ok'
def handshakeHandler(self,disp,stanza):
""" Handler for registering in dispatcher for accepting transport authentication. """
if stanza.getName()=='handshake': self.handshake=1
else: self.handshake=-1
class SASL(PlugIn):
""" Implements SASL authentication. """
def __init__(self,username,password):
PlugIn.__init__(self)
self.username=username
self.password=password
def plugin(self,owner):
if not self._owner.Dispatcher.Stream._document_attrs.has_key('version'): self.startsasl='not-supported'
elif self._owner.Dispatcher.Stream.features:
try: self.FeaturesHandler(self._owner.Dispatcher,self._owner.Dispatcher.Stream.features)
except NodeProcessed: pass
else: self.startsasl=None
def auth(self):
""" Start authentication. Result can be obtained via "SASL.startsasl" attribute and will be
either "success" or "failure". Note that successfull auth will take at least
two Dispatcher.Process() calls. """
if self.startsasl: pass
elif self._owner.Dispatcher.Stream.features:
try: self.FeaturesHandler(self._owner.Dispatcher,self._owner.Dispatcher.Stream.features)
except NodeProcessed: pass
else: self._owner.RegisterHandler('features',self.FeaturesHandler,xmlns=NS_STREAMS)
def plugout(self):
""" Remove SASL handlers from owner's dispatcher. Used internally. """
if self._owner.__dict__.has_key('features'): self._owner.UnregisterHandler('features',self.FeaturesHandler,xmlns=NS_STREAMS)
if self._owner.__dict__.has_key('challenge'): self._owner.UnregisterHandler('challenge',self.SASLHandler,xmlns=NS_SASL)
if self._owner.__dict__.has_key('failure'): self._owner.UnregisterHandler('failure',self.SASLHandler,xmlns=NS_SASL)
if self._owner.__dict__.has_key('success'): self._owner.UnregisterHandler('success',self.SASLHandler,xmlns=NS_SASL)
def FeaturesHandler(self,conn,feats):
""" Used to determine if server supports SASL auth. Used internally. """
if not feats.getTag('mechanisms',namespace=NS_SASL):
self.startsasl='not-supported'
self.DEBUG('SASL not supported by server','error')
return
mecs=[]
for mec in feats.getTag('mechanisms',namespace=NS_SASL).getTags('mechanism'):
mecs.append(mec.getData())
self._owner.RegisterHandler('challenge',self.SASLHandler,xmlns=NS_SASL)
self._owner.RegisterHandler('failure',self.SASLHandler,xmlns=NS_SASL)
self._owner.RegisterHandler('success',self.SASLHandler,xmlns=NS_SASL)
if "ANONYMOUS" in mecs and self.username == None:
node=Node('auth',attrs={'xmlns':NS_SASL,'mechanism':'ANONYMOUS'})
elif "DIGEST-MD5" in mecs:
node=Node('auth',attrs={'xmlns':NS_SASL,'mechanism':'DIGEST-MD5'})
elif "PLAIN" in mecs:
sasl_data='%s\x00%s\x00%s'%(self.username+'@'+self._owner.Server,self.username,self.password)
node=Node('auth',attrs={'xmlns':NS_SASL,'mechanism':'PLAIN'},payload=[base64.encodestring(sasl_data).replace('\r','').replace('\n','')])
else:
self.startsasl='failure'
self.DEBUG('I can only use DIGEST-MD5 and PLAIN mecanisms.','error')
return
self.startsasl='in-process'
self._owner.send(node.__str__())
raise NodeProcessed
def SASLHandler(self,conn,challenge):
""" Perform next SASL auth step. Used internally. """
if challenge.getNamespace()<>NS_SASL: return
if challenge.getName()=='failure':
self.startsasl='failure'
try: reason=challenge.getChildren()[0]
except: reason=challenge
self.DEBUG('Failed SASL authentification: %s'%reason,'error')
raise NodeProcessed
elif challenge.getName()=='success':
self.startsasl='success'
self.DEBUG('Successfully authenticated with remote server.','ok')
handlers=self._owner.Dispatcher.dumpHandlers()
self._owner.Dispatcher.PlugOut()
dispatcher.Dispatcher().PlugIn(self._owner)
self._owner.Dispatcher.restoreHandlers(handlers)
self._owner.User=self.username
raise NodeProcessed
########################################3333
incoming_data=challenge.getData()
chal={}
data=base64.decodestring(incoming_data)
self.DEBUG('Got challenge:'+data,'ok')
for pair in re.findall('(\w+\s*=\s*(?:(?:"[^"]+")|(?:[^,]+)))',data):
key,value=[x.strip() for x in pair.split('=', 1)]
if value[:1]=='"' and value[-1:]=='"': value=value[1:-1]
chal[key]=value
if chal.has_key('qop') and 'auth' in [x.strip() for x in chal['qop'].split(',')]:
resp={}
resp['username']=self.username
resp['realm']=self._owner.Server
resp['nonce']=chal['nonce']
cnonce=''
for i in range(7):
cnonce+=hex(int(random.random()*65536*4096))[2:]
resp['cnonce']=cnonce
resp['nc']=('00000001')
resp['qop']='auth'
resp['digest-uri']='xmpp/'+self._owner.Server
A1=C([H(C([resp['username'],resp['realm'],self.password])),resp['nonce'],resp['cnonce']])
A2=C(['AUTHENTICATE',resp['digest-uri']])
response= HH(C([HH(A1),resp['nonce'],resp['nc'],resp['cnonce'],resp['qop'],HH(A2)]))
resp['response']=response
resp['charset']='utf-8'
sasl_data=''
for key in ['charset','username','realm','nonce','nc','cnonce','digest-uri','response','qop']:
if key in ['nc','qop','response','charset']: sasl_data+="%s=%s,"%(key,resp[key])
else: sasl_data+='%s="%s",'%(key,resp[key])
########################################3333
node=Node('response',attrs={'xmlns':NS_SASL},payload=[base64.encodestring(sasl_data[:-1]).replace('\r','').replace('\n','')])
self._owner.send(node.__str__())
elif chal.has_key('rspauth'): self._owner.send(Node('response',attrs={'xmlns':NS_SASL}).__str__())
else:
self.startsasl='failure'
self.DEBUG('Failed SASL authentification: unknown challenge','error')
raise NodeProcessed
class Bind(PlugIn):
""" Bind some JID to the current connection to allow router know of our location."""
def __init__(self):
PlugIn.__init__(self)
self.DBG_LINE='bind'
self.bound=None
def plugin(self,owner):
""" Start resource binding, if allowed at this time. Used internally. """
if self._owner.Dispatcher.Stream.features:
try: self.FeaturesHandler(self._owner.Dispatcher,self._owner.Dispatcher.Stream.features)
except NodeProcessed: pass
else: self._owner.RegisterHandler('features',self.FeaturesHandler,xmlns=NS_STREAMS)
def plugout(self):
""" Remove Bind handler from owner's dispatcher. Used internally. """
self._owner.UnregisterHandler('features',self.FeaturesHandler,xmlns=NS_STREAMS)
def FeaturesHandler(self,conn,feats):
""" Determine if server supports resource binding and set some internal attributes accordingly. """
if not feats.getTag('bind',namespace=NS_BIND):
self.bound='failure'
self.DEBUG('Server does not requested binding.','error')
return
if feats.getTag('session',namespace=NS_SESSION): self.session=1
else: self.session=-1
self.bound=[]
def Bind(self,resource=None):
""" Perform binding. Use provided resource name or random (if not provided). """
while self.bound is None and self._owner.Process(1): pass
if resource: resource=[Node('resource',payload=[resource])]
else: resource=[]
resp=self._owner.SendAndWaitForResponse(Protocol('iq',typ='set',payload=[Node('bind',attrs={'xmlns':NS_BIND},payload=resource)]))
if isResultNode(resp):
self.bound.append(resp.getTag('bind').getTagData('jid'))
self.DEBUG('Successfully bound %s.'%self.bound[-1],'ok')
jid=JID(resp.getTag('bind').getTagData('jid'))
self._owner.User=jid.getNode()
self._owner.Resource=jid.getResource()
resp=self._owner.SendAndWaitForResponse(Protocol('iq',typ='set',payload=[Node('session',attrs={'xmlns':NS_SESSION})]))
if isResultNode(resp):
self.DEBUG('Successfully opened session.','ok')
self.session=1
return 'ok'
else:
self.DEBUG('Session open failed.','error')
self.session=0
elif resp: self.DEBUG('Binding failed: %s.'%resp.getTag('error'),'error')
else:
self.DEBUG('Binding failed: timeout expired.','error')
return ''
class ComponentBind(PlugIn):
""" ComponentBind some JID to the current connection to allow router know of our location."""
def __init__(self, sasl):
PlugIn.__init__(self)
self.DBG_LINE='bind'
self.bound=None
self.needsUnregister=None
self.sasl = sasl
def plugin(self,owner):
""" Start resource binding, if allowed at this time. Used internally. """
if not self.sasl:
self.bound=[]
return
if self._owner.Dispatcher.Stream.features:
try: self.FeaturesHandler(self._owner.Dispatcher,self._owner.Dispatcher.Stream.features)
except NodeProcessed: pass
else:
self._owner.RegisterHandler('features',self.FeaturesHandler,xmlns=NS_STREAMS)
self.needsUnregister=1
def plugout(self):
""" Remove ComponentBind handler from owner's dispatcher. Used internally. """
if self.needsUnregister:
self._owner.UnregisterHandler('features',self.FeaturesHandler,xmlns=NS_STREAMS)
def FeaturesHandler(self,conn,feats):
""" Determine if server supports resource binding and set some internal attributes accordingly. """
if not feats.getTag('bind',namespace=NS_BIND):
self.bound='failure'
self.DEBUG('Server does not requested binding.','error')
return
if feats.getTag('session',namespace=NS_SESSION): self.session=1
else: self.session=-1
self.bound=[]
def Bind(self,domain=None):
""" Perform binding. Use provided domain name (if not provided). """
while self.bound is None and self._owner.Process(1): pass
if self.sasl:
xmlns = NS_COMPONENT_1
else:
xmlns = None
self.bindresponse = None
ttl = dispatcher.DefaultTimeout
self._owner.RegisterHandler('bind',self.BindHandler,xmlns=xmlns)
self._owner.send(Protocol('bind',attrs={'name':domain},xmlns=NS_COMPONENT_1))
while self.bindresponse is None and self._owner.Process(1) and ttl > 0: ttl-=1
self._owner.UnregisterHandler('bind',self.BindHandler,xmlns=xmlns)
resp=self.bindresponse
if resp and resp.getAttr('error'):
self.DEBUG('Binding failed: %s.'%resp.getAttr('error'),'error')
elif resp:
self.DEBUG('Successfully bound.','ok')
return 'ok'
else:
self.DEBUG('Binding failed: timeout expired.','error')
return ''
def BindHandler(self,conn,bind):
self.bindresponse = bind
pass
|
louietsai/python-for-android | refs/heads/master | python3-alpha/python3-src/Doc/includes/sqlite3/executemany_2.py | 45 | import sqlite3
def char_generator():
import string
for c in string.letters[:26]:
yield (c,)
con = sqlite3.connect(":memory:")
cur = con.cursor()
cur.execute("create table characters(c)")
cur.executemany("insert into characters(c) values (?)", char_generator())
cur.execute("select c from characters")
print(cur.fetchall())
|
gdimitris/FleetManagerBackend | refs/heads/master | virtual_env/lib/python2.7/site-packages/wtforms/ext/appengine/ndb.py | 174 | """
Form generation utilities for App Engine's new ``ndb.Model`` class.
The goal of ``model_form()`` is to provide a clean, explicit and predictable
way to create forms based on ``ndb.Model`` classes. No malabarism or black
magic should be necessary to generate a form for models, and to add custom
non-model related fields: ``model_form()`` simply generates a form class
that can be used as it is, or that can be extended directly or even be used
to create other forms using ``model_form()``.
Example usage:
.. code-block:: python
from google.appengine.ext import ndb
from wtforms.ext.appengine.ndb import model_form
# Define an example model and add a record.
class Contact(ndb.Model):
name = ndb.StringProperty(required=True)
city = ndb.StringProperty()
age = ndb.IntegerProperty(required=True)
is_admin = ndb.BooleanProperty(default=False)
new_entity = Contact(key_name='test', name='Test Name', age=17)
new_entity.put()
# Generate a form based on the model.
ContactForm = model_form(Contact)
# Get a form populated with entity data.
entity = Contact.get_by_key_name('test')
form = ContactForm(obj=entity)
Properties from the model can be excluded from the generated form, or it can
include just a set of properties. For example:
.. code-block:: python
# Generate a form based on the model, excluding 'city' and 'is_admin'.
ContactForm = model_form(Contact, exclude=('city', 'is_admin'))
# or...
# Generate a form based on the model, only including 'name' and 'age'.
ContactForm = model_form(Contact, only=('name', 'age'))
The form can be generated setting field arguments:
.. code-block:: python
ContactForm = model_form(Contact, only=('name', 'age'), field_args={
'name': {
'label': 'Full name',
'description': 'Your name',
},
'age': {
'label': 'Age',
'validators': [validators.NumberRange(min=14, max=99)],
}
})
The class returned by ``model_form()`` can be used as a base class for forms
mixing non-model fields and/or other model forms. For example:
.. code-block:: python
# Generate a form based on the model.
BaseContactForm = model_form(Contact)
# Generate a form based on other model.
ExtraContactForm = model_form(MyOtherModel)
class ContactForm(BaseContactForm):
# Add an extra, non-model related field.
subscribe_to_news = f.BooleanField()
# Add the other model form as a subform.
extra = f.FormField(ExtraContactForm)
The class returned by ``model_form()`` can also extend an existing form
class:
.. code-block:: python
class BaseContactForm(Form):
# Add an extra, non-model related field.
subscribe_to_news = f.BooleanField()
# Generate a form based on the model.
ContactForm = model_form(Contact, base_class=BaseContactForm)
"""
from wtforms import Form, validators, fields as f
from wtforms.compat import string_types
from wtforms.ext.appengine.fields import GeoPtPropertyField, KeyPropertyField, StringListPropertyField, IntegerListPropertyField
def get_TextField(kwargs):
"""
Returns a ``TextField``, applying the ``ndb.StringProperty`` length limit
of 500 bytes.
"""
kwargs['validators'].append(validators.length(max=500))
return f.TextField(**kwargs)
def get_IntegerField(kwargs):
"""
Returns an ``IntegerField``, applying the ``ndb.IntegerProperty`` range
limits.
"""
v = validators.NumberRange(min=-0x8000000000000000, max=0x7fffffffffffffff)
kwargs['validators'].append(v)
return f.IntegerField(**kwargs)
class ModelConverterBase(object):
def __init__(self, converters=None):
"""
Constructs the converter, setting the converter callables.
:param converters:
A dictionary of converter callables for each property type. The
callable must accept the arguments (model, prop, kwargs).
"""
self.converters = {}
for name in dir(self):
if not name.startswith('convert_'):
continue
self.converters[name[8:]] = getattr(self, name)
def convert(self, model, prop, field_args):
"""
Returns a form field for a single model property.
:param model:
The ``db.Model`` class that contains the property.
:param prop:
The model property: a ``db.Property`` instance.
:param field_args:
Optional keyword arguments to construct the field.
"""
prop_type_name = type(prop).__name__
# Check for generic property
if(prop_type_name == "GenericProperty"):
# Try to get type from field args
generic_type = field_args.get("type")
if generic_type:
prop_type_name = field_args.get("type")
# If no type is found, the generic property uses string set in convert_GenericProperty
kwargs = {
'label': prop._code_name.replace('_', ' ').title(),
'default': prop._default,
'validators': [],
}
if field_args:
kwargs.update(field_args)
if prop._required and prop_type_name not in self.NO_AUTO_REQUIRED:
kwargs['validators'].append(validators.required())
if kwargs.get('choices', None):
# Use choices in a select field.
kwargs['choices'] = [(v, v) for v in kwargs.get('choices')]
return f.SelectField(**kwargs)
if prop._choices:
# Use choices in a select field.
kwargs['choices'] = [(v, v) for v in prop._choices]
return f.SelectField(**kwargs)
else:
converter = self.converters.get(prop_type_name, None)
if converter is not None:
return converter(model, prop, kwargs)
else:
return self.fallback_converter(model, prop, kwargs)
class ModelConverter(ModelConverterBase):
"""
Converts properties from a ``ndb.Model`` class to form fields.
Default conversions between properties and fields:
+====================+===================+==============+==================+
| Property subclass | Field subclass | datatype | notes |
+====================+===================+==============+==================+
| StringProperty | TextField | unicode | TextArea | repeated support
| | | | if multiline |
+--------------------+-------------------+--------------+------------------+
| BooleanProperty | BooleanField | bool | |
+--------------------+-------------------+--------------+------------------+
| IntegerProperty | IntegerField | int or long | | repeated support
+--------------------+-------------------+--------------+------------------+
| FloatProperty | TextField | float | |
+--------------------+-------------------+--------------+------------------+
| DateTimeProperty | DateTimeField | datetime | skipped if |
| | | | auto_now[_add] |
+--------------------+-------------------+--------------+------------------+
| DateProperty | DateField | date | skipped if |
| | | | auto_now[_add] |
+--------------------+-------------------+--------------+------------------+
| TimeProperty | DateTimeField | time | skipped if |
| | | | auto_now[_add] |
+--------------------+-------------------+--------------+------------------+
| TextProperty | TextAreaField | unicode | |
+--------------------+-------------------+--------------+------------------+
| GeoPtProperty | TextField | db.GeoPt | |
+--------------------+-------------------+--------------+------------------+
| KeyProperty | KeyProperyField | ndb.Key | |
+--------------------+-------------------+--------------+------------------+
| BlobKeyProperty | None | ndb.BlobKey | always skipped |
+--------------------+-------------------+--------------+------------------+
| UserProperty | None | users.User | always skipped |
+--------------------+-------------------+--------------+------------------+
| StructuredProperty | None | ndb.Model | always skipped |
+--------------------+-------------------+--------------+------------------+
| LocalStructuredPro | None | ndb.Model | always skipped |
+--------------------+-------------------+--------------+------------------+
| JsonProperty | TextField | unicode | |
+--------------------+-------------------+--------------+------------------+
| PickleProperty | None | bytedata | always skipped |
+--------------------+-------------------+--------------+------------------+
| GenericProperty | None | generic | always skipped |
+--------------------+-------------------+--------------+------------------+
| ComputedProperty | none | | always skipped |
+====================+===================+==============+==================+
"""
# Don't automatically add a required validator for these properties
NO_AUTO_REQUIRED = frozenset(['ListProperty', 'StringListProperty', 'BooleanProperty'])
def convert_StringProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.StringProperty``."""
if prop._repeated:
return StringListPropertyField(**kwargs)
kwargs['validators'].append(validators.length(max=500))
return get_TextField(kwargs)
def convert_BooleanProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.BooleanProperty``."""
return f.BooleanField(**kwargs)
def convert_IntegerProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.IntegerProperty``."""
if prop._repeated:
return IntegerListPropertyField(**kwargs)
return get_IntegerField(kwargs)
def convert_FloatProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.FloatProperty``."""
return f.FloatField(**kwargs)
def convert_DateTimeProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.DateTimeProperty``."""
if prop._auto_now or prop._auto_now_add:
return None
return f.DateTimeField(format='%Y-%m-%d %H:%M:%S', **kwargs)
def convert_DateProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.DateProperty``."""
if prop._auto_now or prop._auto_now_add:
return None
return f.DateField(format='%Y-%m-%d', **kwargs)
def convert_TimeProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.TimeProperty``."""
if prop._auto_now or prop._auto_now_add:
return None
return f.DateTimeField(format='%H:%M:%S', **kwargs)
def convert_RepeatedProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.ListProperty``."""
return None
def convert_UserProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.UserProperty``."""
return None
def convert_StructuredProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.ListProperty``."""
return None
def convert_LocalStructuredProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.ListProperty``."""
return None
def convert_JsonProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.ListProperty``."""
return None
def convert_PickleProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.ListProperty``."""
return None
def convert_GenericProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.ListProperty``."""
kwargs['validators'].append(validators.length(max=500))
return get_TextField(kwargs)
def convert_BlobKeyProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.BlobKeyProperty``."""
return f.FileField(**kwargs)
def convert_TextProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.TextProperty``."""
return f.TextAreaField(**kwargs)
def convert_ComputedProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.ComputedProperty``."""
return None
def convert_GeoPtProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.GeoPtProperty``."""
return GeoPtPropertyField(**kwargs)
def convert_KeyProperty(self, model, prop, kwargs):
"""Returns a form field for a ``ndb.KeyProperty``."""
if 'reference_class' not in kwargs:
try:
reference_class = prop._kind
except AttributeError:
reference_class = prop._reference_class
if isinstance(reference_class, string_types):
# reference class is a string, try to retrieve the model object.
mod = __import__(model.__module__, None, None, [reference_class], 0)
reference_class = getattr(mod, reference_class)
kwargs['reference_class'] = reference_class
kwargs.setdefault('allow_blank', not prop._required)
return KeyPropertyField(**kwargs)
def model_fields(model, only=None, exclude=None, field_args=None,
converter=None):
"""
Extracts and returns a dictionary of form fields for a given
``db.Model`` class.
:param model:
The ``db.Model`` class to extract fields from.
:param only:
An optional iterable with the property names that should be included in
the form. Only these properties will have fields.
:param exclude:
An optional iterable with the property names that should be excluded
from the form. All other properties will have fields.
:param field_args:
An optional dictionary of field names mapping to a keyword arguments
used to construct each field object.
:param converter:
A converter to generate the fields based on the model properties. If
not set, ``ModelConverter`` is used.
"""
converter = converter or ModelConverter()
field_args = field_args or {}
# Get the field names we want to include or exclude, starting with the
# full list of model properties.
props = model._properties
field_names = list(x[0] for x in sorted(props.items(), key=lambda x: x[1]._creation_counter))
if only:
field_names = list(f for f in only if f in field_names)
elif exclude:
field_names = list(f for f in field_names if f not in exclude)
# Create all fields.
field_dict = {}
for name in field_names:
field = converter.convert(model, props[name], field_args.get(name))
if field is not None:
field_dict[name] = field
return field_dict
def model_form(model, base_class=Form, only=None, exclude=None, field_args=None,
converter=None):
"""
Creates and returns a dynamic ``wtforms.Form`` class for a given
``ndb.Model`` class. The form class can be used as it is or serve as a base
for extended form classes, which can then mix non-model related fields,
subforms with other model forms, among other possibilities.
:param model:
The ``ndb.Model`` class to generate a form for.
:param base_class:
Base form class to extend from. Must be a ``wtforms.Form`` subclass.
:param only:
An optional iterable with the property names that should be included in
the form. Only these properties will have fields.
:param exclude:
An optional iterable with the property names that should be excluded
from the form. All other properties will have fields.
:param field_args:
An optional dictionary of field names mapping to keyword arguments
used to construct each field object.
:param converter:
A converter to generate the fields based on the model properties. If
not set, ``ModelConverter`` is used.
"""
# Extract the fields from the model.
field_dict = model_fields(model, only, exclude, field_args, converter)
# Return a dynamically created form class, extending from base_class and
# including the created fields as properties.
return type(model._get_kind() + 'Form', (base_class,), field_dict)
|
mementum/backtrader | refs/heads/master | samples/talib/talibtest.py | 1 | #!/usr/bin/env python
# -*- coding: utf-8; py-indent-offset:4 -*-
###############################################################################
#
# Copyright (C) 2015-2020 Daniel Rodriguez
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
###############################################################################
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import argparse
import datetime
import backtrader as bt
class TALibStrategy(bt.Strategy):
params = (('ind', 'sma'), ('doji', True),)
INDS = ['sma', 'ema', 'stoc', 'rsi', 'macd', 'bollinger', 'aroon',
'ultimate', 'trix', 'kama', 'adxr', 'dema', 'ppo', 'tema',
'roc', 'williamsr']
def __init__(self):
if self.p.doji:
bt.talib.CDLDOJI(self.data.open, self.data.high,
self.data.low, self.data.close)
if self.p.ind == 'sma':
bt.talib.SMA(self.data.close, timeperiod=25, plotname='TA_SMA')
bt.indicators.SMA(self.data, period=25)
elif self.p.ind == 'ema':
bt.talib.EMA(timeperiod=25, plotname='TA_SMA')
bt.indicators.EMA(period=25)
elif self.p.ind == 'stoc':
bt.talib.STOCH(self.data.high, self.data.low, self.data.close,
fastk_period=14, slowk_period=3, slowd_period=3,
plotname='TA_STOCH')
bt.indicators.Stochastic(self.data)
elif self.p.ind == 'macd':
bt.talib.MACD(self.data, plotname='TA_MACD')
bt.indicators.MACD(self.data)
bt.indicators.MACDHisto(self.data)
elif self.p.ind == 'bollinger':
bt.talib.BBANDS(self.data, timeperiod=25,
plotname='TA_BBANDS')
bt.indicators.BollingerBands(self.data, period=25)
elif self.p.ind == 'rsi':
bt.talib.RSI(self.data, plotname='TA_RSI')
bt.indicators.RSI(self.data)
elif self.p.ind == 'aroon':
bt.talib.AROON(self.data.high, self.data.low, plotname='TA_AROON')
bt.indicators.AroonIndicator(self.data)
elif self.p.ind == 'ultimate':
bt.talib.ULTOSC(self.data.high, self.data.low, self.data.close,
plotname='TA_ULTOSC')
bt.indicators.UltimateOscillator(self.data)
elif self.p.ind == 'trix':
bt.talib.TRIX(self.data, timeperiod=25, plotname='TA_TRIX')
bt.indicators.Trix(self.data, period=25)
elif self.p.ind == 'adxr':
bt.talib.ADXR(self.data.high, self.data.low, self.data.close,
plotname='TA_ADXR')
bt.indicators.ADXR(self.data)
elif self.p.ind == 'kama':
bt.talib.KAMA(self.data, timeperiod=25, plotname='TA_KAMA')
bt.indicators.KAMA(self.data, period=25)
elif self.p.ind == 'dema':
bt.talib.DEMA(self.data, timeperiod=25, plotname='TA_DEMA')
bt.indicators.DEMA(self.data, period=25)
elif self.p.ind == 'ppo':
bt.talib.PPO(self.data, plotname='TA_PPO')
bt.indicators.PPO(self.data, _movav=bt.indicators.SMA)
elif self.p.ind == 'tema':
bt.talib.TEMA(self.data, timeperiod=25, plotname='TA_TEMA')
bt.indicators.TEMA(self.data, period=25)
elif self.p.ind == 'roc':
bt.talib.ROC(self.data, timeperiod=12, plotname='TA_ROC')
bt.talib.ROCP(self.data, timeperiod=12, plotname='TA_ROCP')
bt.talib.ROCR(self.data, timeperiod=12, plotname='TA_ROCR')
bt.talib.ROCR100(self.data, timeperiod=12, plotname='TA_ROCR100')
bt.indicators.ROC(self.data, period=12)
bt.indicators.Momentum(self.data, period=12)
bt.indicators.MomentumOscillator(self.data, period=12)
elif self.p.ind == 'williamsr':
bt.talib.WILLR(self.data.high, self.data.low, self.data.close,
plotname='TA_WILLR')
bt.indicators.WilliamsR(self.data)
def runstrat(args=None):
args = parse_args(args)
cerebro = bt.Cerebro()
dkwargs = dict()
if args.fromdate:
fromdate = datetime.datetime.strptime(args.fromdate, '%Y-%m-%d')
dkwargs['fromdate'] = fromdate
if args.todate:
todate = datetime.datetime.strptime(args.todate, '%Y-%m-%d')
dkwargs['todate'] = todate
data0 = bt.feeds.YahooFinanceCSVData(dataname=args.data0, **dkwargs)
cerebro.adddata(data0)
cerebro.addstrategy(TALibStrategy, ind=args.ind, doji=not args.no_doji)
cerebro.run(runcone=not args.use_next, stdstats=False)
if args.plot:
pkwargs = dict(style='candle')
if args.plot is not True: # evals to True but is not True
npkwargs = eval('dict(' + args.plot + ')') # args were passed
pkwargs.update(npkwargs)
cerebro.plot(**pkwargs)
def parse_args(pargs=None):
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description='Sample for sizer')
parser.add_argument('--data0', required=False,
default='../../datas/yhoo-1996-2015.txt',
help='Data to be read in')
parser.add_argument('--fromdate', required=False,
default='2005-01-01',
help='Starting date in YYYY-MM-DD format')
parser.add_argument('--todate', required=False,
default='2006-12-31',
help='Ending date in YYYY-MM-DD format')
parser.add_argument('--ind', required=False, action='store',
default=TALibStrategy.INDS[0],
choices=TALibStrategy.INDS,
help=('Which indicator pair to show together'))
parser.add_argument('--no-doji', required=False, action='store_true',
help=('Remove Doji CandleStick pattern checker'))
parser.add_argument('--use-next', required=False, action='store_true',
help=('Use next (step by step) '
'instead of once (batch)'))
# Plot options
parser.add_argument('--plot', '-p', nargs='?', required=False,
metavar='kwargs', const=True,
help=('Plot the read data applying any kwargs passed\n'
'\n'
'For example (escape the quotes if needed):\n'
'\n'
' --plot style="candle" (to plot candles)\n'))
if pargs is not None:
return parser.parse_args(pargs)
return parser.parse_args()
if __name__ == '__main__':
runstrat()
|
Mellthas/quodlibet | refs/heads/master | quodlibet/quodlibet/player/xinebe/__init__.py | 4 | # Copyright 2013 Christoph Reiter
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
from .player import init
init = init
|
NotToday/musicbox | refs/heads/master | NEMbox/api.py | 1 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author: omi
# @Date: 2014-08-24 21:51:57
# @Last Modified by: omi
# @Last Modified time: 2015-02-28 13:03:11
'''
网易云音乐 Api
'''
import re
import json
import requests
import hashlib
from bs4 import BeautifulSoup
import logger
# list去重
def uniq(arr):
arr2 = list(set(arr))
arr2.sort(key=arr.index)
return arr2
default_timeout = 10
log = logger.getLogger(__name__)
class NetEase:
def __init__(self):
self.header = {
'Accept': '*/*',
'Accept-Encoding': 'gzip,deflate,sdch',
'Accept-Language': 'zh-CN,zh;q=0.8,gl;q=0.6,zh-TW;q=0.4',
'Connection': 'keep-alive',
'Content-Type': 'application/x-www-form-urlencoded',
'Host': 'music.163.com',
'Referer': 'http://music.163.com/search/',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.152 Safari/537.36'
}
self.cookies = {
'appver': '1.5.2'
}
self.playlist_class_dict = {}
def httpRequest(self, method, action, query=None, urlencoded=None, callback=None, timeout=None):
connection = json.loads(self.rawHttpRequest(method, action, query, urlencoded, callback, timeout))
return connection
def rawHttpRequest(self, method, action, query=None, urlencoded=None, callback=None, timeout=None):
if (method == 'GET'):
url = action if (query == None) else (action + '?' + query)
connection = requests.get(url, headers=self.header, timeout=default_timeout)
elif (method == 'POST'):
connection = requests.post(
action,
data=query,
headers=self.header,
timeout=default_timeout
)
connection.encoding = "UTF-8"
return connection.text
# 登录
def login(self, username, password):
pattern = re.compile(r'^0\d{2,3}\d{7,8}$|^1[34578]\d{9}$')
if (pattern.match(username)):
return self.phone_login(username, password)
action = 'https://music.163.com/api/login/'
data = {
'username': username,
'password': hashlib.md5(password).hexdigest(),
'rememberLogin': 'true'
}
try:
return self.httpRequest('POST', action, data)
except:
return {'code': 501}
# 手机登录
def phone_login(self, username, password):
action = 'https://music.163.com/api/login/cellphone'
data = {
'phone': username,
'password': hashlib.md5(password).hexdigest(),
'rememberLogin': 'true'
}
try:
return self.httpRequest('POST', action, data)
except:
return {'code': 501}
# 用户歌单
def user_playlist(self, uid, offset=0, limit=100):
action = 'http://music.163.com/api/user/playlist/?offset=' + str(offset) + '&limit=' + str(limit) + '&uid=' + str(uid)
try:
data = self.httpRequest('GET', action)
return data['playlist']
except:
return []
# 搜索单曲(1)，歌手(100)，专辑(10)，歌单(1000)，用户(1002) *(type)*
def search(self, s, stype=1, offset=0, total='true', limit=60):
action = 'http://music.163.com/api/search/get/web'
data = {
's': s,
'type': stype,
'offset': offset,
'total': total,
'limit': 60
}
return self.httpRequest('POST', action, data)
# 新碟上架 http://music.163.com/#/discover/album/
def new_albums(self, offset=0, limit=50):
action = 'http://music.163.com/api/album/new?area=ALL&offset=' + str(offset) + '&total=true&limit=' + str(limit)
try:
data = self.httpRequest('GET', action)
return data['albums']
except:
return []
# 歌单（网友精选碟） hot||new http://music.163.com/#/discover/playlist/
def top_playlists(self, category='全部', order='hot', offset=0, limit=50):
action = 'http://music.163.com/api/playlist/list?cat=' + category + '&order=' + order + '&offset=' + str(offset) + '&total=' + ('true' if offset else 'false') + '&limit=' + str(limit)
try:
data = self.httpRequest('GET', action)
return data['playlists']
except:
return []
# 分类歌单
def playlist_classes(self):
action = 'http://music.163.com/discover/playlist/'
try:
data = self.rawHttpRequest('GET', action)
return data
except:
return []
# 分类歌单中某一个分类的详情
def playlist_class_detail(self):
pass
# 歌单详情
def playlist_detail(self, playlist_id):
action = 'http://music.163.com/api/playlist/detail?id=' + str(playlist_id)
try:
data = self.httpRequest('GET', action)
return data['result']['tracks']
except:
return []
# 热门歌手 http://music.163.com/#/discover/artist/
def top_artists(self, offset=0, limit=100):
action = 'http://music.163.com/api/artist/top?offset=' + str(offset) + '&total=false&limit=' + str(limit)
try:
data = self.httpRequest('GET', action)
return data['artists']
except:
return []
# 热门单曲 http://music.163.com/#/discover/toplist 50
def top_songlist(self, offset=0, limit=100):
action = 'http://music.163.com/discover/toplist'
try:
connection = requests.get(action, headers=self.header, timeout=default_timeout)
connection.encoding = 'UTF-8'
songids = re.findall(r'/song\?id=(\d+)', connection.text)
if songids == []:
return []
# 去重
songids = uniq(songids)
return self.songs_detail(songids)
except:
return []
# 歌手单曲
def artists(self, artist_id):
action = 'http://music.163.com/api/artist/' + str(artist_id)
try:
data = self.httpRequest('GET', action)
return data['hotSongs']
except:
return []
# album id --> song id set
def album(self, album_id):
action = 'http://music.163.com/api/album/' + str(album_id)
try:
data = self.httpRequest('GET', action)
return data['album']['songs']
except:
return []
# song ids --> song urls ( details )
def songs_detail(self, ids, offset=0):
tmpids = ids[offset:]
tmpids = tmpids[0:100]
tmpids = map(str, tmpids)
action = 'http://music.163.com/api/song/detail?ids=[' + (',').join(tmpids) + ']'
try:
data = self.httpRequest('GET', action)
return data['songs']
except:
return []
# song id --> song url ( details )
def song_detail(self, music_id):
action = "http://music.163.com/api/song/detail/?id=" + str(music_id) + "&ids=[" + str(music_id) + "]"
try:
data = self.httpRequest('GET', action)
return data['songs']
except:
return []
# 今日最热（0）, 本周最热（10），历史最热（20），最新节目（30）
def djchannels(self, stype=0, offset=0, limit=50):
action = 'http://music.163.com/discover/djchannel?type=' + str(stype) + '&offset=' + str(offset) + '&limit=' + str(limit)
try:
connection = requests.get(action, headers=self.header, timeout=default_timeout)
connection.encoding = 'UTF-8'
channelids = re.findall(r'/dj\?id=(\d+)', connection.text)
channelids = uniq(channelids)
return self.channel_detail(channelids)
except:
return []
# DJchannel ( id, channel_name ) ids --> song urls ( details )
# 将 channels 整理为 songs 类型
def channel_detail(self, channelids, offset=0):
channels = []
for i in range(0, len(channelids)):
action = 'http://music.163.com/api/dj/program/detail?id=' + str(channelids[i])
try:
data = self.httpRequest('GET', action)
channel = self.dig_info(data['program']['mainSong'], 'channels')
channels.append(channel)
except:
continue
return channels
def dig_info(self, data, dig_type):
temp = []
if dig_type == 'songs':
for i in range(0, len(data)):
song_info = {
'song_id': data[i]['id'],
'artist': [],
'song_name': data[i]['name'],
'album_name': data[i]['album']['name'],
'mp3_url': data[i]['mp3Url']
}
if 'artist' in data[i]:
song_info['artist'] = data[i]['artist']
elif 'artists' in data[i]:
for j in range(0, len(data[i]['artists'])):
song_info['artist'].append(data[i]['artists'][j]['name'])
song_info['artist'] = ', '.join(song_info['artist'])
else:
song_info['artist'] = '未知艺术家'
temp.append(song_info)
elif dig_type == 'artists':
temp = []
for i in range(0, len(data)):
artists_info = {
'artist_id': data[i]['id'],
'artists_name': data[i]['name'],
'alias': ''.join(data[i]['alias'])
}
temp.append(artists_info)
return temp
elif dig_type == 'albums':
for i in range(0, len(data)):
albums_info = {
'album_id': data[i]['id'],
'albums_name': data[i]['name'],
'artists_name': data[i]['artist']['name']
}
temp.append(albums_info)
elif dig_type == 'top_playlists':
for i in range(0, len(data)):
playlists_info = {
'playlist_id': data[i]['id'],
'playlists_name': data[i]['name'],
'creator_name': data[i]['creator']['nickname']
}
temp.append(playlists_info)
elif dig_type == 'channels':
channel_info = {
'song_id': data['id'],
'song_name': data['name'],
'artist': data['artists'][0]['name'],
'album_name': 'DJ节目',
'mp3_url': data['mp3Url']
}
temp = channel_info
elif dig_type == 'playlist_classes':
soup = BeautifulSoup(data)
dls = soup.select('dl.f-cb')
for dl in dls:
title = dl.dt.text
sub = [item.text for item in dl.select('a')]
temp.append(title)
self.playlist_class_dict[title] = sub
elif dig_type == 'playlist_class_detail':
log.debug(data)
temp = self.playlist_class_dict[data]
return temp
|
infoxchange/ixdjango | refs/heads/master | ixdjango/management/commands/clear_app.py | 1 | """
Management command to clear specified app's models of data.
.. moduleauthor:: Infoxchange Development Team <[email protected]>
"""
from __future__ import print_function
from django.apps import apps
from django.core.management.base import BaseCommand
from django.core.management.color import no_style
from django.db import connection, transaction
# pylint:disable=protected-access
real_print = print # pylint:disable=invalid-name
def print(*args, **kwargs): # pylint:disable=redefined-builtin
"""
Only print if required
"""
if kwargs.pop('verbosity') >= 1:
real_print(*args, **kwargs)
class Command(BaseCommand):
"""
A command to clear app data.
"""
help = ('Cleans the specified applications\' tables to a pristine state.')
args = '<app_label> <app_label> ... '
def add_arguments(self, parser):
parser.add_argument('app_models', nargs='+', type=str)
def handle(self, *args, **options):
"""
Clear the data for the given apps.
"""
verbosity = int(options['verbosity'])
models = []
for target in options['app_models']:
target = target.split('.')
try:
app, = target
model = None
except ValueError:
app, model = target
if model:
models.append(apps.get_model(app, model))
else:
app_models = self.get_managed_models_for_app(app)
models += app_models
print("Found %d model(s) for %s" % (len(app_models), app),
verbosity=verbosity)
with transaction.atomic():
for model in models:
print("Clearing %s table %s" % (
model, model._meta.db_table),
verbosity=verbosity)
cursor = connection.cursor()
cursor.execute('TRUNCATE TABLE {} CASCADE'.format(
model._meta.db_table))
sql = connection.ops.sequence_reset_sql(no_style(), [model])
for cmd in sql:
connection.cursor().execute(cmd)
print("Cleared %d models" % len(models), verbosity=verbosity)
def get_models_module(self, app):
"""
Return the models module for the given app.
"""
return apps.get_models(apps.get_app_config(app).models_module, True)
def get_managed_models_for_app(self, app):
"""
Return a list of managed models for the given app.
"""
return [
model for model in self.get_models_module(app)
if model._meta.managed
]
|
Antiun/carrier-delivery | refs/heads/8.0 | delivery_carrier_label_postlogistics/tests/__init__.py | 4 | # -*- coding: utf-8 -*-
from . import test_postlogistics
|
stevenewey/django | refs/heads/master | django/contrib/sessions/backends/cached_db.py | 24 | """
Cached, database-backed sessions.
"""
import logging
from django.conf import settings
from django.contrib.sessions.backends.db import SessionStore as DBStore
from django.core.cache import caches
from django.core.exceptions import SuspiciousOperation
from django.utils import timezone
from django.utils.encoding import force_text
KEY_PREFIX = "django.contrib.sessions.cached_db"
class SessionStore(DBStore):
"""
Implements cached, database backed sessions.
"""
def __init__(self, session_key=None):
self._cache = caches[settings.SESSION_CACHE_ALIAS]
super(SessionStore, self).__init__(session_key)
@property
def cache_key(self):
return KEY_PREFIX + self._get_or_create_session_key()
def load(self):
try:
data = self._cache.get(self.cache_key)
except Exception:
# Some backends (e.g. memcache) raise an exception on invalid
# cache keys. If this happens, reset the session. See #17810.
data = None
if data is None:
# Duplicate DBStore.load, because we need to keep track
# of the expiry date to set it properly in the cache.
try:
s = Session.objects.get(
session_key=self.session_key,
expire_date__gt=timezone.now()
)
data = self.decode(s.session_data)
self._cache.set(self.cache_key, data,
self.get_expiry_age(expiry=s.expire_date))
except (Session.DoesNotExist, SuspiciousOperation) as e:
if isinstance(e, SuspiciousOperation):
logger = logging.getLogger('django.security.%s' %
e.__class__.__name__)
logger.warning(force_text(e))
self.create()
data = {}
return data
def exists(self, session_key):
if (KEY_PREFIX + session_key) in self._cache:
return True
return super(SessionStore, self).exists(session_key)
def save(self, must_create=False):
super(SessionStore, self).save(must_create)
self._cache.set(self.cache_key, self._session, self.get_expiry_age())
def delete(self, session_key=None):
super(SessionStore, self).delete(session_key)
if session_key is None:
if self.session_key is None:
return
session_key = self.session_key
self._cache.delete(KEY_PREFIX + session_key)
def flush(self):
"""
Removes the current session data from the database and regenerates the
key.
"""
self.clear()
self.delete(self.session_key)
self._session_key = None
# At bottom to avoid circular import
from django.contrib.sessions.models import Session # isort:skip
|
rbieb/Pymodoro | refs/heads/experimentalSplit | messages.py | 2 | #!/usr/bin/python3
import variables
# These messages are shown at the beginning of each new phase
def workMessage():
return("Start working! Your Pause begins in {} minutes".format(variables.workDuration))
def shortPauseMessage():
return("Well done! Have a break. It ends in {} minutes".format(variables.shortPauseDuration))
def longPauseMessage():
return("Now you deserve a longer break! Take {} minutes to get some rest".format(variables.longPauseDuration))
|
intip/django-cms | refs/heads/develop | cms/tests/views.py | 6 | from __future__ import with_statement
from copy import copy
import re
import sys
from django.core.cache import cache
from django.conf import settings
from django.contrib.auth.models import Permission
from django.core.urlresolvers import clear_url_caches
from django.http import Http404
from django.template import Variable
from django.test.utils import override_settings
from cms.api import create_page
from cms.apphook_pool import apphook_pool
from cms.models import PagePermission
from cms.test_utils.testcases import CMSTestCase
from cms.test_utils.util.fuzzy_int import FuzzyInt
from cms.utils.conf import get_cms_setting
from cms.views import _handle_no_page, details
from menus.menu_pool import menu_pool
APP_NAME = 'SampleApp'
APP_MODULE = "cms.test_utils.project.sampleapp.cms_app"
@override_settings(
CMS_PERMISSION=True,
ROOT_URLCONF='cms.test_utils.project.urls',
)
class ViewTests(CMSTestCase):
def setUp(self):
clear_url_caches()
def test_handle_no_page(self):
"""
Test handle nopage correctly works with DEBUG=True
"""
request = self.get_request('/')
slug = ''
self.assertRaises(Http404, _handle_no_page, request, slug)
with self.settings(DEBUG=True):
request = self.get_request('/en/')
slug = ''
response = _handle_no_page(request, slug)
self.assertEqual(response.status_code, 200)
def test_apphook_not_hooked(self):
"""
Test details view when apphook pool has apphooks, but they're not
actually hooked
"""
if APP_MODULE in sys.modules:
del sys.modules[APP_MODULE]
apphooks = (
'%s.%s' % (APP_MODULE, APP_NAME),
)
create_page("page2", "nav_playground.html", "en", published=True)
with self.settings(CMS_APPHOOKS=apphooks):
apphook_pool.clear()
response = self.client.get('/en/')
self.assertEqual(response.status_code, 200)
apphook_pool.clear()
def test_external_redirect(self):
# test external redirect
redirect_one = 'https://www.django-cms.org/'
one = create_page("one", "nav_playground.html", "en", published=True,
redirect=redirect_one)
url = one.get_absolute_url()
request = self.get_request(url)
response = details(request, one.get_path("en"))
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], redirect_one)
def test_internal_neutral_redirect(self):
# test internal language neutral redirect
redirect_one = 'https://www.django-cms.org/'
redirect_two = '/'
one = create_page("one", "nav_playground.html", "en", published=True,
redirect=redirect_one)
two = create_page("two", "nav_playground.html", "en", parent=one,
published=True, redirect=redirect_two)
url = two.get_absolute_url()
request = self.get_request(url)
response = details(request, two.get_path())
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], '/en/')
def test_internal_forced_redirect(self):
# test internal forced language redirect
redirect_one = 'https://www.django-cms.org/'
redirect_three = '/en/'
one = create_page("one", "nav_playground.html", "en", published=True,
redirect=redirect_one)
three = create_page("three", "nav_playground.html", "en", parent=one,
published=True, redirect=redirect_three)
url = three.get_slug()
request = self.get_request(url)
response = details(request, url.strip('/'))
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], redirect_three)
def test_redirect_to_self(self):
one = create_page("one", "nav_playground.html", "en", published=True,
redirect='/')
url = one.get_absolute_url()
request = self.get_request(url)
response = details(request, one.get_path())
self.assertEqual(response.status_code, 200)
def test_redirect_to_self_with_host(self):
one = create_page("one", "nav_playground.html", "en", published=True,
redirect='http://testserver/en/')
url = one.get_absolute_url()
request = self.get_request(url)
response = details(request, one.get_path())
self.assertEqual(response.status_code, 200)
def test_redirect_with_toolbar(self):
create_page("one", "nav_playground.html", "en", published=True,
redirect='/en/page2')
superuser = self.get_superuser()
with self.login_user_context(superuser):
response = self.client.get('/en/?%s' % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
self.assertEqual(response.status_code, 200)
def test_login_required(self):
create_page("page", "nav_playground.html", "en", published=True,
login_required=True)
plain_url = '/accounts/'
login_rx = re.compile("%s\?(signin=|next=/en/)&" % plain_url)
with self.settings(LOGIN_URL=plain_url + '?signin'):
request = self.get_request('/en/')
response = details(request, '')
self.assertEqual(response.status_code, 302)
self.assertTrue(login_rx.search(response['Location']))
login_rx = re.compile("%s\?(signin=|next=/)&" % plain_url)
with self.settings(USE_I18N=False, LOGIN_URL=plain_url + '?signin'):
request = self.get_request('/')
response = details(request, '')
self.assertEqual(response.status_code, 302)
self.assertTrue(login_rx.search(response['Location']))
def test_edit_permission(self):
page = create_page("page", "nav_playground.html", "en", published=True)
# Anon user
response = self.client.get("/en/?%s" % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
self.assertNotContains(response, "cms_toolbar-item_switch_save-edit", 200)
# Superuser
user = self.get_superuser()
with self.login_user_context(user):
response = self.client.get("/en/?%s" % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
self.assertContains(response, "cms_toolbar-item_switch_save-edit", 1, 200)
# Admin but with no permission
user = self.get_staff_user_with_no_permissions()
user.user_permissions.add(Permission.objects.get(codename='change_page'))
with self.login_user_context(user):
response = self.client.get("/en/?%s" % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
self.assertNotContains(response, "cms_toolbar-item_switch_save-edit", 200)
PagePermission.objects.create(can_change=True, user=user, page=page)
with self.login_user_context(user):
response = self.client.get("/en/?%s" % get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON'))
self.assertContains(response, "cms_toolbar-item_switch_save-edit", 1, 200)
@override_settings(ROOT_URLCONF='cms.test_utils.project.urls')
class ContextTests(CMSTestCase):
def test_context_current_page(self):
"""
Asserts the number of queries triggered by
`cms.context_processors.cms_settings` and `cms.middleware.page`
"""
from django.template import context
page_template = "nav_playground.html"
original_context = settings.TEMPLATE_CONTEXT_PROCESSORS
new_context = copy(original_context)
new_context.remove("cms.context_processors.cms_settings")
page = create_page("page", page_template, "en", published=True)
page_2 = create_page("page-2", page_template, "en", published=True,
parent=page)
# Tests for standard django applications
# 1 query is executed in get_app_patterns(), not related
# to cms.context_processors.cms_settings.
# Executing this oputside queries assertion context ensure
# repetability
self.client.get("/en/plain_view/")
cache.clear()
menu_pool.clear()
context._standard_context_processors = None
# Number of queries when context processors is not enabled
with self.settings(TEMPLATE_CONTEXT_PROCESSORS=new_context):
with self.assertNumQueries(FuzzyInt(0, 12)) as context:
response = self.client.get("/en/plain_view/")
num_queries = len(context.captured_queries)
self.assertFalse('CMS_TEMPLATE' in response.context)
cache.clear()
menu_pool.clear()
# Number of queries when context processor is enabled
with self.settings(TEMPLATE_CONTEXT_PROCESSORS=original_context):
# no extra query is run when accessing urls managed by standard
# django applications
with self.assertNumQueries(FuzzyInt(0, num_queries)):
response = self.client.get("/en/plain_view/")
# One query when determining current page
with self.assertNumQueries(FuzzyInt(0, 1)):
self.assertFalse(response.context['request'].current_page)
self.assertFalse(response.context['request']._current_page_cache)
# Zero more queries when determining the current template
with self.assertNumQueries(0):
# Template is the first in the CMS_TEMPLATES list
template = Variable('CMS_TEMPLATE').resolve(response.context)
self.assertEqual(template, get_cms_setting('TEMPLATES')[0][0])
cache.clear()
menu_pool.clear()
# Number of queries when context processors is not enabled
with self.settings(TEMPLATE_CONTEXT_PROCESSORS=new_context):
# Baseline number of queries
with self.assertNumQueries(FuzzyInt(13, 19)) as context:
response = self.client.get("/en/page-2/")
num_queries_page = len(context.captured_queries)
cache.clear()
menu_pool.clear()
# Number of queries when context processors is enabled
with self.settings(TEMPLATE_CONTEXT_PROCESSORS=original_context):
# Exactly the same number of queries are executed with and without
# the context_processor
with self.assertNumQueries(num_queries_page):
response = self.client.get("/en/page-2/")
template = Variable('CMS_TEMPLATE').resolve(response.context)
self.assertEqual(template, page_template)
cache.clear()
menu_pool.clear()
page_2.template = 'INHERIT'
page_2.save()
page_2.publish('en')
with self.settings(TEMPLATE_CONTEXT_PROCESSORS=original_context):
# One query more triggered as page inherits template from ancestor
with self.assertNumQueries(num_queries_page + 1):
response = self.client.get("/en/page-2/")
template = Variable('CMS_TEMPLATE').resolve(response.context)
self.assertEqual(template, page_template)
|
nikhilsingh291/zeroclickinfo-fathead | refs/heads/master | lib/fathead/sass/parse_reference.py | 7 | from bs4 import BeautifulSoup
SASS_DOC_BASE_URL = 'http://sass-lang.com/documentation/file.SASS_REFERENCE.html'
DOWNLOADED_HTML_PATH = 'download/file.SASS_REFERENCE.html'
class Data(object):
"""
Object responsible for loading raw HTML data from Sass Reference
"""
def __init__(self, file):
"""
Initialize Data object. Load data from HTML.
"""
self.HTML = ""
self.FILE = file
self.load_data()
def load_data(self):
"""
Open the HTML file and load it into the object.
"""
with open(self.FILE, 'r') as data_file:
self.HTML = data_file.read()
def get_raw_data(self):
"""
Returns: The raw HTML that was loaded.
"""
return self.HTML
def get_file(self):
"""
Returns: The file path of the file being used.
"""
return self.FILE
class DataParser(object):
"""
Object responsible for parsing the raw HTML that contains data
"""
def __init__(self, data_object, titles):
"""
Given raw data, get the relevant sections
Args:
raw_data: HTML data
"""
self.titles = titles
self.parsed_data = None
self.topic_sections = []
self.file_being_used = data_object.get_file()
self.soup_data = BeautifulSoup(data_object.get_raw_data(), 'html.parser')
table_of_contents = self.soup_data.find(class_="maruku_toc")
sections = table_of_contents.find_all('li')
for section in sections:
section_id = section.find('a')
section_id = section_id['href']
heading = self.soup_data.find(id=section_id[1:])
self.topic_sections.append(heading)
def parse_for_name(self, section):
"""
Returns the section name
Args:
section: A section of parsed HTML that represents a topic
Returns:
Name of topic
"""
name = section.text
if name in self.titles.keys():
info = self.titles[name]
if info[0].strip() != 'None':
return info[0].strip()
else:
return name
else:
return None
def parse_for_redirects(self, section):
"""
Returns any redirects for article
Args:
section: A section of parsed HTML that represents a topic
Returns:
list of redirects
"""
name = section.text
if name in self.titles.keys():
info = self.titles[name]
if info[1].strip() != 'None':
return info[1].strip().split(',')
else:
return []
else:
return []
def parse_for_id(self, section):
"""
Returns the section id for topic
Args:
section: A section of parsed HTML that represents a topic
Returns:
id of section
"""
return '#'+ section.get('id')
def parse_for_description(self, section):
"""
Returns the topic description
Fixes up some weird double spacing and newlines.
Args:
section: A section of parsed HTML that represents a topic
Returns:
topic description
"""
next_para = section.find_next('p')
description = "<p>" + str(next_para.text.encode('utf-8')) + "</p>"
next_tag = next_para.find_next_sibling()
if next_tag.name=="pre" or next_tag.name=="code":
text = str(next_tag.encode('utf-8'))
text = '\\n'.join(text.split('\n'))
description = description + text
return description
def create_url(self, id):
"""
Helper method to create URL back to document
Args:
anchor: #anchor
Returns:
Full URL to function on the sass doc
"""
return SASS_DOC_BASE_URL + id
def parse_for_data(self):
"""
Main gateway into parsing the data. Will retrieve all necessary data elements.
"""
data = []
names = []
for topic_section in self.topic_sections:
name = self.parse_for_name(topic_section)
if name:
description = self.parse_for_description(topic_section)
id = self.parse_for_id(topic_section)
url = self.create_url(id)
redirect = self.parse_for_redirects(topic_section)
if name in names:
index = names.index(name)
data_elements = data[index]
data_elements['description'] += description
data_elements['redirects'].extend(redirect)
else:
names.append(name)
data_elements = {
'name': name,
'description': description,
'url': url,
'redirects' : redirect
}
data.append(data_elements)
self.parsed_data = data
def get_data(self):
"""
Get the parsed data.
Returns:
self.parsed_data: Dict containing necessary data elements
"""
return self.parsed_data
class DataOutput(object):
"""
Object responsible for outputting data into the output.txt file
"""
def __init__(self, data):
self.data = data
def create_file(self):
"""
Iterate through the data and create the needed output.txt file, appending to file as necessary.
"""
with open('output.txt', 'a') as output_file:
for data_element in self.data:
if data_element.get('name'):
description = '<section class="prog__container">' + data_element.get('description') + '</section>'
url = data_element.get('url').encode('utf-8')
name = data_element.get('name').encode('utf-8')
redirect = data_element.get('redirects')
list_of_data = [
name, # unique name
'A', # type is article
'', # no redirect data
'', # ignore
'', # no categories
'', # ignore
'', # no related topics
'', # ignore
'', # external link
'', # no disambiguation
'', # images
description, # abstract
url # url to doc
]
line = '\t'.join(list_of_data)
output_file.write(line+'\n')
def create_redirects(self):
"""
Iterate through the data and create the needed output.txt file, appending to file as necessary.
"""
with open('output.txt', 'a') as output_file:
for data_element in self.data:
if data_element.get('name'):
name = data_element.get('name').encode('utf-8')
redirects = data_element.get('redirects')
for redirect in redirects:
list_of_data = [
redirect.strip(), # unique name
'R', # type is article
name, # redirect data
'', # ignore
'', # no categories
'', # ignore
'', # no related topics
'', # ignore
'', # external link
'', # no disambiguation
'', # images
'', # abstract
'', # url to doc
]
line = '\t'.join(list_of_data)
output_file.write(line+'\n')
def getTitleInfo():
"""
Read through titles.txt and return title names and redirect information.
"""
titles = {}
with open('titles.txt','r') as f:
for line in f:
line = line.split(' ')
if line[1].strip()!="N":
titles[line[0]] = [line[2], line[3].strip()]
return titles
if __name__ == "__main__":
file_path = 'download/file.SASS_REFERENCE.html'
title_info = getTitleInfo()
data = Data(file_path)
parser = DataParser(data, title_info)
parser.parse_for_data()
output = DataOutput(parser.get_data())
output.create_file()
output.create_redirects() |
erochest/threepress-rdfa | refs/heads/master | bookworm/django_authopenid/views.py | 7 | # -*- coding: utf-8 -*-
# Copyright (c) 2007, 2008, Benoît Chesneau
# Copyright (c) 2007 Simon Willison, original work on django-openid
#
# 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 the <ORGANIZATION> 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 OWNER 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.
import logging
from django.http import HttpResponseRedirect, get_host
from django.shortcuts import render_to_response as render
from django.template import RequestContext, loader, Context
from django.conf import settings
from django.contrib.auth.models import User
from django.contrib.auth import login, logout
from django.contrib.auth.decorators import login_required
from django.core.urlresolvers import reverse
from django.utils.html import escape
from django.utils.translation import ugettext as _
from django.contrib.sites.models import Site
from django.utils.http import urlquote_plus
from django.core.mail import send_mail
from django.views.decorators.cache import cache_page, cache_control, never_cache
from bookworm.library.models import UserPref
from openid.consumer.consumer import Consumer, \
SUCCESS, CANCEL, FAILURE, SETUP_NEEDED
from openid.consumer.discover import DiscoveryFailure
from openid.extensions import sreg
# needed for some linux distributions like debian
try:
from openid.yadis import xri
except ImportError:
from yadis import xri
import re
import urllib
from util import OpenID, DjangoOpenIDStore, from_openid_response
from models import UserAssociation, UserPasswordQueue
from forms import OpenidSigninForm, OpenidAuthForm, OpenidRegisterForm, \
OpenidVerifyForm, RegistrationForm, ChangepwForm, ChangeemailForm, \
ChangeopenidForm, DeleteForm, EmailPasswordForm
def get_url_host(request):
if request.is_secure():
protocol = 'https'
else:
protocol = 'http'
host = escape(get_host(request))
return '%s://%s' % (protocol, host)
def get_full_url(request):
if request.is_secure():
protocol = 'https'
else:
protocol = 'http'
host = escape(request.META['HTTP_HOST'])
return get_url_host(request) + request.get_full_path()
next_url_re = re.compile('^/[-\w/]+$')
def is_valid_next_url(next):
# When we allow this:
# /openid/?next=/welcome/
# For security reasons we want to restrict the next= bit
# to being a local path, not a complete URL.
return bool(next_url_re.match(next))
def ask_openid(request, openid_url, redirect_to, on_failure=None,
sreg_request=None):
""" basic function to ask openid and return response """
on_failure = on_failure or signin_failure
trust_root = getattr(
settings, 'OPENID_TRUST_ROOT', get_url_host(request) + '/'
)
if xri.identifierScheme(openid_url) == 'XRI' and getattr(
settings, 'OPENID_DISALLOW_INAMES', False
):
msg = _("i-names are not supported")
return on_failure(request, msg)
consumer = Consumer(request.session, DjangoOpenIDStore())
try:
auth_request = consumer.begin(openid_url)
except DiscoveryFailure:
msg = _("The password or OpenID was invalid")
return on_failure(request, msg)
if sreg_request:
auth_request.addExtension(sreg_request)
redirect_url = auth_request.redirectURL(trust_root, redirect_to)
return HttpResponseRedirect(redirect_url)
def complete(request, on_success=None, on_failure=None, return_to=None):
""" complete openid signin """
on_success = on_success or default_on_success
on_failure = on_failure or default_on_failure
consumer = Consumer(request.session, DjangoOpenIDStore())
openid_response = consumer.complete(dict(request.GET.items()),
return_to)
try:
rel = UserAssociation.objects.get(openid_url__exact = openid_response.identity_url)
try:
rel.user
except User.DoesNotExist:
rel.delete()
return register(request)
except UserAssociation.DoesNotExist:
pass
if openid_response.status == SUCCESS:
return on_success(request, openid_response.identity_url,
openid_response)
elif openid_response.status == CANCEL:
return on_failure(request, 'The request was cancelled')
elif openid_response.status == FAILURE:
return on_failure(request, openid_response.message)
elif openid_response.status == SETUP_NEEDED:
return on_failure(request, 'Setup needed')
else:
assert False, "Bad openid status: %s" % openid_response.status
def default_on_success(request, identity_url, openid_response):
""" default action on openid signin success """
request.session['openid'] = from_openid_response(openid_response)
next = request.GET.get('next', '').strip()
if not next or not is_valid_next_url(next):
next = getattr(settings, 'OPENID_REDIRECT_NEXT', reverse('library'))
return HttpResponseRedirect(next)
def default_on_failure(request, message):
""" default failure action on signin """
return render('openid_failure.html', {
'message': message
})
def not_authenticated(func):
""" decorator that redirect user to next page if
he is already logged."""
def decorated(request, **kwargs):
if request.user.is_authenticated():
next = request.GET.get("next", reverse('library'))
return HttpResponseRedirect(next)
return func(request, **kwargs)
return decorated
@not_authenticated
@never_cache
def signin(request):
"""
signin page. It manage the legacy authentification (user/password)
and authentification with openid.
url: /signin/
template : authopenid/signin.htm
"""
on_failure = signin_failure
next = ''
if request.GET.get('next') and is_valid_next_url(request.GET['next']):
next = request.GET.get('next', '').strip()
if not next or not is_valid_next_url(next):
next = getattr(settings, 'OPENID_REDIRECT_NEXT', reverse('library'))
form_signin = OpenidSigninForm(initial={'next':next})
form_auth = OpenidAuthForm(initial={'next':next})
if request.POST:
if 'bsignin' in request.POST.keys():
form_signin = OpenidSigninForm(request.POST)
if form_signin.is_valid():
next = form_signin.cleaned_data['next']
if not next:
next = getattr(settings, 'OPENID_REDIRECT_NEXT', reverse('library'))
sreg_req = sreg.SRegRequest(optional=['nickname', 'email', 'language', 'country', 'timezone', 'fullname'])
redirect_to = "%s%s?%s" % (
get_url_host(request),
reverse('user_complete_signin'),
urllib.urlencode({'next':next})
)
return ask_openid(request,
form_signin.cleaned_data['openid_url'],
redirect_to,
on_failure=signin_failure,
sreg_request=sreg_req)
elif 'blogin' in request.POST.keys():
# perform normal django authentification
form_auth = OpenidAuthForm(request.POST)
if form_auth.is_valid():
user_ = form_auth.get_user()
login(request, user_)
next = form_auth.cleaned_data['next']
if not next:
next = getattr(settings, 'OPENID_REDIRECT_NEXT', reverse('library'))
return HttpResponseRedirect(next)
return render('authopenid/signin.html', {
'form1': form_auth,
'form2': form_signin,
'action': request.path,
'msg': request.GET.get('msg',''),
'signin_page': True,
'sendpw_url': reverse('user_sendpw'),
}, context_instance=RequestContext(request))
def complete_signin(request):
""" in case of complete signin with openid """
return complete(request, signin_success, signin_failure,
get_url_host(request) + reverse('user_complete_signin'))
def signin_success(request, identity_url, openid_response):
"""
openid signin success.
If the openid is already registered, the user is redirected to
url set par next or in settings with OPENID_REDIRECT_NEXT variable.
If none of these urls are set user is redirectd to /.
if openid isn't registered user is redirected to register page.
"""
openid_ = from_openid_response(openid_response)
request.session['openid'] = openid_
try:
rel = UserAssociation.objects.get(openid_url__exact = str(openid_))
except:
# try to register this new user
return register(request)
user_ = rel.user
if user_.is_active:
user_.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user_)
next = request.GET.get('next', '').strip()
if not next or not is_valid_next_url(next):
next = getattr(settings, 'OPENID_REDIRECT_NEXT', reverse('library'))
return HttpResponseRedirect(next)
def is_association_exist(openid_url):
""" test if an openid is already in database """
is_exist = True
try:
uassoc = UserAssociation.objects.get(openid_url__exact = openid_url)
except:
is_exist = False
return is_exist
@not_authenticated
@never_cache
def register(request):
"""
register an openid.
If user is already a member he can associate its openid with
its account.
A new account could also be created and automaticaly associated
to the openid.
url : /complete/
template : authopenid/complete.html
"""
is_redirect = False
next = request.GET.get('next', '').strip()
if not next or not is_valid_next_url(next):
next = getattr(settings, 'OPENID_REDIRECT_NEXT', reverse('library'))
openid_ = request.session.get('openid', None)
if not openid_:
return HttpResponseRedirect(reverse('user_signin') + next)
nickname = openid_.sreg.get('nickname', '')
email = openid_.sreg.get('email', '')
form1 = OpenidRegisterForm(initial={
'next': next,
'username': nickname,
'email': email,
})
form2 = OpenidVerifyForm(initial={
'next': next,
'username': nickname,
})
if request.POST:
just_completed = False
if 'bnewaccount' in request.POST.keys():
form1 = OpenidRegisterForm(request.POST)
if form1.is_valid():
next = form1.cleaned_data['next']
if not next:
next = getattr(settings, 'OPENID_REDIRECT_NEXT', reverse('library'))
is_redirect = True
tmp_pwd = User.objects.make_random_password()
user_ = User.objects.create_user(form1.cleaned_data['username'],
form1.cleaned_data['email'], tmp_pwd)
# Save a profile for them
profile = UserPref(user=user_)
profile.save()
# make association with openid
uassoc = UserAssociation(openid_url=str(openid_),
user_id=user_.id)
uassoc.save()
# login
user_.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user_)
elif 'bverify' in request.POST.keys():
form2 = OpenidVerifyForm(request.POST)
if form2.is_valid():
is_redirect = True
next = form2.cleaned_data['next']
if not next:
next = getattr(settings, 'OPENID_REDIRECT_NEXT', reverse('library'))
user_ = form2.get_user()
uassoc = UserAssociation(openid_url=str(openid_),
user_id=user_.id)
uassoc.save()
login(request, user_)
# redirect, can redirect only if forms are valid.
if is_redirect:
return HttpResponseRedirect(next)
return render('authopenid/complete.html', {
'form1': form1,
'form2': form2,
'action': reverse('user_register'),
'nickname': nickname,
'email': email
}, context_instance=RequestContext(request))
def signin_failure(request, message):
"""
falure with openid signin. Go back to signin page.
template : "authopenid/signin.html"
"""
next = request.REQUEST.get('next', '')
form_signin = OpenidSigninForm(initial={'next': next})
form_auth = OpenidAuthForm(initial={'next': next})
return render('authopenid/signin.html', {
'msg': message,
'form1': form_auth,
'form2': form_signin,
}, context_instance=RequestContext(request))
@not_authenticated
@never_cache
def signup(request):
"""
signup page. Create a legacy account
url : /signup/"
templates: authopenid/signup.html, authopenid/confirm_email.txt
"""
action_signin = reverse('user_signin')
next = request.GET.get('next', '')
if not next or not is_valid_next_url(next):
next = getattr(settings, 'OPENID_REDIRECT_NEXT', reverse('library'))
form = RegistrationForm(initial={'next':next})
form_signin = OpenidSigninForm(initial={'next':next})
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
next = form.cleaned_data.get('next', '')
if not next or not is_valid_next_url(next):
next = getattr(settings, 'OPENID_REDIRECT_NEXT', reverse('library'))
user_ = User.objects.create_user( form.cleaned_data['username'],
form.cleaned_data['email'], form.cleaned_data['password1'])
user_.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user_)
# send email
current_domain = Site.objects.get_current().domain
subject = _("Welcome")
message_template = loader.get_template(
'authopenid/confirm_email.txt'
)
message_context = Context({
'site_url': 'http://%s/' % current_domain,
'username': form.cleaned_data['username'],
'password': form.cleaned_data['password1']
})
message = message_template.render(message_context)
if not settings.DEBUG:
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,
[user_.email])
return HttpResponseRedirect(next)
return render('authopenid/signup.html', {
'form': form,
'form2': form_signin,
'action': request.path,
'action_signin': action_signin,
}, context_instance=RequestContext(request))
@login_required
def signout(request, msg=None):
"""
signout from the website. Remove openid from session and kill it.
url : /signout/"
"""
try:
del request.session['openid']
except KeyError:
pass
next = request.GET.get('next', reverse('index'))
if not is_valid_next_url(next):
next = '/'
if msg:
next = next + '?msg=' + urlquote_plus(msg)
logout(request)
return HttpResponseRedirect(next)
@login_required
@never_cache
def account_settings(request):
"""
index pages to changes some basic account settings :
- change password
- change email
- associate a new openid
- delete account
url : /
template : authopenid/settings.html
"""
msg = request.GET.get('msg', '')
is_openid = True
try:
uassoc = UserAssociation.objects.get(
user__username__exact=request.user.username
)
except:
is_openid = False
return render('authopenid/settings.html', {
'msg': msg,
'settings_path': request.path,
'is_openid': is_openid
}, context_instance=RequestContext(request))
@login_required
@never_cache
def changepw(request):
"""
change password view.
url : /changepw/
template: authopenid/changepw.html
"""
user_ = request.user
if request.POST:
form = ChangepwForm(request.POST, user=user_)
if form.is_valid():
user_.set_password(form.cleaned_data['password1'])
user_.save()
msg = _("Password changed.")
redirect = "%s?msg=%s" % (
reverse('bookworm.library.views.profile'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)
else:
form = ChangepwForm(user=user_)
return render('authopenid/changepw.html', {'form': form },
context_instance=RequestContext(request))
@login_required
@never_cache
def changeemail(request):
"""
changeemail view. It require password or openid to allow change.
url: /changeemail/
template : authopenid/changeemail.html
"""
msg = request.GET.get('msg', '')
extension_args = {}
user_ = request.user
redirect_to = get_url_host(request) + reverse('user_changeemail')
if request.POST:
form = ChangeemailForm(request.POST, user=user_)
if form.is_valid():
if user_.check_password(form.cleaned_data['password']):
user_.email = form.cleaned_data['email']
user_.save()
msg = _("Email changed.")
redirect = "%s?msg=%s" % (reverse('bookworm.library.views.profile'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)
else:
return ask_openid(request, form.cleaned_data['password'],
redirect_to, on_failure=emailopenid_failure)
elif not request.POST and 'openid.mode' in request.GET:
return complete(request, emailopenid_success,
emailopenid_failure, redirect_to)
else:
form = ChangeemailForm(initial={'email': user_.email},
user=user_)
return render('authopenid/changeemail.html', {
'form': form,
'msg': msg
}, context_instance=RequestContext(request))
def emailopenid_success(request, identity_url, openid_response):
openid_ = from_openid_response(openid_response)
user_ = request.user
try:
uassoc = UserAssociation.objects.get(
openid_url__exact=identity_url
)
except:
return emailopenid_failure(request,
_("No OpenID was found in our database"))
if uassoc.user.username != request.user.username:
return emailopenid_failure(request,
_("This OpenID isn't associated with the current logged-in user" %
identity_url))
new_email = request.session.get('new_email', '')
if new_email:
user_.email = new_email
user_.save()
del request.session['new_email']
msg = _("Email changed.")
redirect = "%s?msg=%s" % (reverse('user_account_settings'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)
def emailopenid_failure(request, message):
redirect_to = "%s?msg=%s" % (
reverse('user_changeemail'), urlquote_plus(message))
return HttpResponseRedirect(redirect_to)
@login_required
@never_cache
def changeopenid(request):
"""
change openid view. Allow user to change openid
associated to its username.
url : /changeopenid/
template: authopenid/changeopenid.html
"""
extension_args = {}
openid_url = ''
has_openid = True
msg = request.GET.get('msg', '')
user_ = request.user
try:
uopenid = UserAssociation.objects.get(user=user_)
openid_url = uopenid.openid_url
except:
has_openid = False
redirect_to = get_url_host(request) + reverse('user_changeopenid')
if request.POST and has_openid:
form = ChangeopenidForm(request.POST, user=user_)
if form.is_valid():
return ask_openid(request, form.cleaned_data['openid_url'],
redirect_to, on_failure=changeopenid_failure)
elif not request.POST and has_openid:
if 'openid.mode' in request.GET:
return complete(request, changeopenid_success,
changeopenid_failure, redirect_to)
form = ChangeopenidForm(initial={'openid_url': openid_url }, user=user_)
return render('authopenid/changeopenid.html', {
'form': form,
'has_openid': has_openid,
'msg': msg
}, context_instance=RequestContext(request))
def changeopenid_success(request, identity_url, openid_response):
openid_ = from_openid_response(openid_response)
is_exist = True
try:
uassoc = UserAssociation.objects.get(openid_url__exact=identity_url)
except:
is_exist = False
if not is_exist:
try:
uassoc = UserAssociation.objects.get(
user__username__exact=request.user.username
)
uassoc.openid_url = identity_url
uassoc.save()
except:
uassoc = UserAssociation(user=request.user,
openid_url=identity_url)
uassoc.save()
elif uassoc.user.username != request.user.username:
return changeopenid_failure(request,
_('This OpenID is already associated with another account.'))
request.session['openids'] = []
request.session['openids'].append(openid_)
msg = _("This OpenID is now associated with your account.")
redirect = "%s?msg=%s" % (
reverse('bookworm.library.views.profile'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)
def changeopenid_failure(request, message):
redirect_to = "%s?msg=%s" % (
reverse('user_changeopenid'),
urlquote_plus(message))
return HttpResponseRedirect(redirect_to)
@login_required
@never_cache
def delete(request):
"""
delete view. Allow user to delete its account. Password/openid are required to
confirm it. He should also check the confirm checkbox.
url : /delete
template : authopenid/delete.html
"""
extension_args = {}
user_ = request.user
form = None
redirect_to = get_url_host(request) + reverse('user_delete')
if request.POST:
form = DeleteForm(request.POST, user=user_)
if form.is_valid():
if 'password' in form.cleaned_data and form.cleaned_data['password']:
if user_.check_password(form.cleaned_data['password']):
user_.delete()
return signout(request, msg='Your account has been deleted.')
return ask_openid(request, form.cleaned_data['password'],
redirect_to, on_failure=deleteopenid_failure)
else:
return ask_openid(request, form.cleaned_data['openid_url'],
redirect_to, on_failure=deleteopenid_failure)
elif not request.POST and 'openid.mode' in request.GET:
logging.info('calling complete with request %s' % request)
return complete(request, deleteopenid_success, deleteopenid_failure,
redirect_to)
if not form:
form = DeleteForm(user=user_)
msg = request.GET.get('msg','')
return render('authopenid/delete.html', {
'form': form,
'msg': msg,
}, context_instance=RequestContext(request))
def deleteopenid_success(request, identity_url, openid_response):
logging.info('openid response: %s' % openid_response)
openid_ = from_openid_response(openid_response)
user_ = request.user
try:
uassoc = UserAssociation.objects.get(
openid_url__exact=identity_url
)
except:
return deleteopenid_failure(request,
_("This OpenID isn't associated in the system."))
if uassoc.user.username == user_.username:
user_.delete()
return signout(request, msg='Your account has been deleted.')
else:
return deleteopenid_failure(request,
_("This OpenID isn't associated with the current logged-in user"))
msg = _("Account deleted.")
redirect = "/?msg=%s" % (urlquote_plus(msg))
return HttpResponseRedirect(redirect)
def deleteopenid_failure(request, message):
redirect_to = "%s?msg=%s" % (reverse('user_delete'), urlquote_plus(message))
return HttpResponseRedirect(redirect_to)
@never_cache
def sendpw(request):
"""
send a new password to the user. It return a mail with
a new pasword and a confirm link in. To activate the
new password, the user should click on confirm link.
url : /sendpw/
templates : authopenid/sendpw_email.txt, authopenid/sendpw.html
"""
msg = request.GET.get('msg','')
if request.POST:
form = EmailPasswordForm(request.POST)
if form.is_valid():
new_pw = User.objects.make_random_password()
confirm_key = UserPasswordQueue.objects.get_new_confirm_key()
try:
uqueue = UserPasswordQueue.objects.get(
user=form.user_cache
)
except:
uqueue = UserPasswordQueue(
user=form.user_cache
)
uqueue.new_password = new_pw
uqueue.confirm_key = confirm_key
uqueue.save()
# send email
current_domain = Site.objects.get_current().domain
subject = _("Request for a new password")
message_template = loader.get_template(
'authopenid/sendpw_email.txt')
message_context = Context({
'site_url': 'http://%s' % current_domain,
'confirm_key': confirm_key,
'username': form.user_cache.username,
'password': new_pw,
'url_confirm': reverse('user_confirmchangepw'),
})
message = message_template.render(message_context)
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,
[form.user_cache.email])
msg = _("A new password has been sent to your email")
else:
form = EmailPasswordForm()
return render('authopenid/sendpw.html', {
'form': form,
'msg': msg
}, context_instance=RequestContext(request))
def confirmchangepw(request):
"""
view to set new password when the user click on confirm link
in its mail. Basically it check if the confirm key exist, then
replace old password with new password and remove confirm
key from the queue. Then it redirect the user to signin
page.
url : /sendpw/confirm/?key
"""
confirm_key = request.GET.get('key', '')
if not confirm_key:
return HttpResponseRedirect('/')
try:
uqueue = UserPasswordQueue.objects.get(
confirm_key__exact=confirm_key
)
except:
msg = _("Can not change password. Confirmation key '%s'\
isn't registered." % confirm_key)
redirect = "%s?msg=%s" % (
reverse('user_sendpw'), urlquote_plus(msg))
return HttpResponseRedirect(redirect)
try:
user_ = User.objects.get(id=uqueue.user.id)
except:
msg = _("Cannot change password, as this user doesn't exist in the database.")
redirect = "%s?msg=%s" % (reverse('user_sendpw'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)
user_.set_password(uqueue.new_password)
user_.save()
uqueue.delete()
msg = _("Password changed for %s. You could now sign in" %
user_.username)
redirect = "%s?msg=%s" % (reverse('user_signin'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)
|
luthfii/xsched | refs/heads/master | tools/python/xen/xm/getpolicy.py | 49 | #============================================================================
# This library is free software; you can redistribute it and/or
# modify it under the terms of version 2.1 of the GNU Lesser General Public
# License as published by the Free Software Foundation.
#
# This library 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
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#============================================================================
# Copyright (C) 2007 International Business Machines Corp.
# Author: Stefan Berger <[email protected]>
#============================================================================
"""Get the managed policy of the system.
"""
import sys
from xen.util import xsconstants
from xml.dom import minidom
from xen.xm.opts import OptionError
from xen.util.acmpolicy import ACMPolicy
from xen.xm import main as xm_main
from xen.xm.main import server
def help():
return """
Usage: xm getpolicy [options]
The following options are defined
--dumpxml Display the XML of the policy
Get the policy managed by xend."""
def display_policy_info(acmpol, policytype, uuid, version, flags,
dumpxml, xml):
print "Policy name : %s" % acmpol.get_name()
print "Policy type : %s" % policytype
if uuid:
print "Reference : %s" % uuid
print "Version of XML policy : %s" % version
state = []
if flags & xsconstants.XS_INST_LOAD:
state.append("loaded")
if flags & xsconstants.XS_INST_BOOT:
state.append("activated for boot")
print "Policy configuration : %s" % ", ".join(state)
if dumpxml:
if xml:
dom = minidom.parseString(xml.encode("utf-8"))
print "%s" % dom.toprettyxml(indent=" ",newl="\n")
def display_security_subsystems(xstype):
types = []
if xstype & xsconstants.XS_POLICY_ACM:
types.append("ACM")
xstype ^= xsconstants.XS_POLICY_ACM
if xstype != 0:
types.append("unsupported (%08x)" % xstype)
if len(types) == 0:
types.append("None")
print "Supported security subsystems : %s \n" % ", ".join(types)
def getpolicy(dumpxml):
if xm_main.serverType == xm_main.SERVER_XEN_API:
xstype = int(server.xenapi.XSPolicy.get_xstype())
display_security_subsystems(xstype)
policystate = server.xenapi.XSPolicy.get_xspolicy()
if int(policystate['type']) == 0:
print "No policy is installed."
return
if int(policystate['type']) != xsconstants.XS_POLICY_ACM:
print "Unknown policy type '%s'." % policystate['type']
else:
xml = policystate['repr']
acmpol = None
if xml:
acmpol = ACMPolicy(xml=xml)
display_policy_info(acmpol,
xsconstants.ACM_POLICY_ID,
policystate['xs_ref'],
policystate['version'],
int(policystate['flags']),
dumpxml,
xml)
else:
xstype = server.xend.security.get_xstype()
display_security_subsystems(xstype)
xml, flags = server.xend.security.get_policy()
acmpol = None
if xml != "":
dom = None
try:
dom = minidom.parseString(xml)
if dom:
acmpol = ACMPolicy(dom=dom)
except Exception, e:
print "Error parsing the library: " + str(e)
if acmpol:
display_policy_info(acmpol,
xsconstants.ACM_POLICY_ID,
None,
acmpol.get_version(),
flags,
dumpxml,
xml)
else:
print "No policy is installed."
def main(argv):
dumpxml = False
if '--dumpxml' in argv:
dumpxml = True
getpolicy(dumpxml)
if __name__ == '__main__':
try:
main(sys.argv)
except Exception, e:
sys.stderr.write('Error: %s\n' % str(e))
sys.exit(-1)
|
tadebayo/myedge | refs/heads/master | myvenv/Lib/site-packages/sqlparse/lexer.py | 9 | # -*- coding: utf-8 -*-
#
# Copyright (C) 2016 Andi Albrecht, [email protected]
#
# This module is part of python-sqlparse and is released under
# the BSD License: https://opensource.org/licenses/BSD-3-Clause
"""SQL Lexer"""
# This code is based on the SqlLexer in pygments.
# http://pygments.org/
# It's separated from the rest of pygments to increase performance
# and to allow some customizations.
from sqlparse import tokens
from sqlparse.keywords import SQL_REGEX
from sqlparse.compat import bytes_type, text_type, file_types
from sqlparse.utils import consume
class Lexer(object):
"""Lexer
Empty class. Leaving for backwards-compatibility
"""
@staticmethod
def get_tokens(text, encoding=None):
"""
Return an iterable of (tokentype, value) pairs generated from
`text`. If `unfiltered` is set to `True`, the filtering mechanism
is bypassed even if filters are defined.
Also preprocess the text, i.e. expand tabs and strip it if
wanted and applies registered filters.
Split ``text`` into (tokentype, text) pairs.
``stack`` is the inital stack (default: ``['root']``)
"""
if isinstance(text, file_types):
text = text.read()
if isinstance(text, text_type):
pass
elif isinstance(text, bytes_type):
try:
text = text.decode()
except UnicodeDecodeError:
if not encoding:
encoding = 'unicode-escape'
text = text.decode(encoding)
else:
raise TypeError(u"Expected text or file-like object, got {!r}".
format(type(text)))
iterable = enumerate(text)
for pos, char in iterable:
for rexmatch, action in SQL_REGEX:
m = rexmatch(text, pos)
if not m:
continue
elif isinstance(action, tokens._TokenType):
yield action, m.group()
elif callable(action):
yield action(m.group())
consume(iterable, m.end() - pos - 1)
break
else:
yield tokens.Error, char
def tokenize(sql, encoding=None):
"""Tokenize sql.
Tokenize *sql* using the :class:`Lexer` and return a 2-tuple stream
of ``(token type, value)`` items.
"""
return Lexer().get_tokens(sql, encoding)
|
google-code-export/epubia | refs/heads/master | scraper/naver_scraper.py | 3 | # -*- encoding: utf-8 -*-
# Book Info using Naver OpenAPI
import urllib
from xml.dom.minidom import parseString
import re
MARKUP_PTN = re.compile(r'</?[a-z]+>')
class book_scraper:
key = '' # my key
srch_url = 'http://openapi.naver.com/search?key={0:s}&query={1:s}&display=1&target=book'
isbn_url = 'http://openapi.naver.com/search?key={0:s}&query={1:s}&display=1&target=book_adv&d_isbn={1:s}'
img_url = 'http://book.daum-img.net/image/KOR{0:s}'
default_value = {'title':'','author':'','isbn':'',
'cover_url':'',
'publisher':'','publishdate':'',
'description':'','subject':''}
def __init__(self):
pass
def search(self,qstr,maxresult=None):
return self._parse( urllib.urlopen(self.srch_url.format(self.key, urllib.quote_plus(qstr.encode('utf-8')))).read() )
def fetch(self,isbn):
result = self._parse( urllib.urlopen(self.isbn_url.format(self.key, isbn)).read() )
return result[0] if result else None
def _parse(self,xml):
info = []
dom = parseString(xml)
if dom.childNodes[0].nodeName == 'error':
print xml
return None
assert dom.childNodes[0].childNodes[0].nodeName == 'channel'
for node in dom.childNodes[0].childNodes[0].childNodes:
if node.nodeName == 'item':
pkt = self.default_value
for e in node.childNodes:
if e.nodeName == 'title':
pkt['title'] = self._cleanup(e.childNodes[0].nodeValue)
elif e.nodeName == 'author':
if e.childNodes:
pkt['author'] = self._cleanup(e.childNodes[0].nodeValue)
elif e.nodeName == 'image' and e.childNodes:
pkt['cover_url'] = e.childNodes[0].nodeValue.replace('=m1','=m256')
elif e.nodeName == 'publisher':
pkt['publisher'] = e.childNodes[0].nodeValue
elif e.nodeName == 'pubdate':
ss = e.childNodes[0].nodeValue
pkt['publishdate'] = "%s-%s-%s" % (ss[0:4],ss[4:6],ss[6:8])
elif e.nodeName == 'description':
if e.childNodes:
pkt['description'] = self._cleanup(e.childNodes[0].nodeValue)
elif e.nodeName == 'isbn':
if e.childNodes:
pkt['isbn'] = self._cleanup(e.childNodes[0].nodeValue.split(' ')[-1])
if pkt['cover_url'] == '' and len(pkt['isbn']) == 13:
pkt['cover_url'] = self.img_url.format(pkt['isbn'], pkt['isbn'][-3:-1])
info.append( pkt )
return info
def _cleanup(self,str):
return MARKUP_PTN.sub('',str).replace('&','&').replace('<','<').replace('>','>')
if __name__ == "__main__":
info = book_scraper().search( "은하영웅전설 1" )[0]
print info['title']
print info['author']
print info['cover_url']
info = book_scraper().search( "[이광수]무정" )[0]
print info['title']
print info['author']
print info['cover_url']
# vim:ts=4:sw=4:et
|
ryfeus/lambda-packs | refs/heads/master | Tensorflow/source/setuptools/command/install_scripts.py | 454 | from distutils import log
import distutils.command.install_scripts as orig
import os
import sys
from pkg_resources import Distribution, PathMetadata, ensure_directory
class install_scripts(orig.install_scripts):
"""Do normal script install, plus any egg_info wrapper scripts"""
def initialize_options(self):
orig.install_scripts.initialize_options(self)
self.no_ep = False
def run(self):
import setuptools.command.easy_install as ei
self.run_command("egg_info")
if self.distribution.scripts:
orig.install_scripts.run(self) # run first to set up self.outfiles
else:
self.outfiles = []
if self.no_ep:
# don't install entry point scripts into .egg file!
return
ei_cmd = self.get_finalized_command("egg_info")
dist = Distribution(
ei_cmd.egg_base, PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info),
ei_cmd.egg_name, ei_cmd.egg_version,
)
bs_cmd = self.get_finalized_command('build_scripts')
exec_param = getattr(bs_cmd, 'executable', None)
bw_cmd = self.get_finalized_command("bdist_wininst")
is_wininst = getattr(bw_cmd, '_is_running', False)
writer = ei.ScriptWriter
if is_wininst:
exec_param = "python.exe"
writer = ei.WindowsScriptWriter
if exec_param == sys.executable:
# In case the path to the Python executable contains a space, wrap
# it so it's not split up.
exec_param = [exec_param]
# resolve the writer to the environment
writer = writer.best()
cmd = writer.command_spec_class.best().from_param(exec_param)
for args in writer.get_args(dist, cmd.as_header()):
self.write_script(*args)
def write_script(self, script_name, contents, mode="t", *ignored):
"""Write an executable file to the scripts directory"""
from setuptools.command.easy_install import chmod, current_umask
log.info("Installing %s script to %s", script_name, self.install_dir)
target = os.path.join(self.install_dir, script_name)
self.outfiles.append(target)
mask = current_umask()
if not self.dry_run:
ensure_directory(target)
f = open(target, "w" + mode)
f.write(contents)
f.close()
chmod(target, 0o777 - mask)
|
chriskiehl/Gooey | refs/heads/master | gooey/gui/components/widgets/radio_group.py | 1 | import wx
from gooey.gui.components.widgets.bases import BaseWidget
from gooey.gui.lang.i18n import _
from gooey.gui.util import wx_util
from gooey.gui.components.widgets import CheckBox
from gooey.util.functional import getin, findfirst, merge
class RadioGroup(BaseWidget):
def __init__(self, parent, widgetInfo, *args, **kwargs):
super(RadioGroup, self).__init__(parent, *args, **kwargs)
self._parent = parent
self.info = widgetInfo
self._id = widgetInfo['id']
self._options = widgetInfo['options']
self.widgetInfo = widgetInfo
self.error = wx.StaticText(self, label='')
self.radioButtons = self.createRadioButtons()
self.selected = None
self.widgets = self.createWidgets()
self.arrange()
for button in self.radioButtons:
button.Bind(wx.EVT_LEFT_DOWN, self.handleButtonClick)
initialSelection = getin(self.info, ['options', 'initial_selection'], None)
if initialSelection is not None:
self.selected = self.radioButtons[initialSelection]
self.selected.SetValue(True)
self.handleImplicitCheck()
self.applyStyleRules()
def getValue(self):
for button, widget in zip(self.radioButtons, self.widgets):
if button.GetValue(): # is Checked
return merge(widget.getValue(), {'id': self._id})
else:
# just return the first widget's value even though it's
# not active so that the expected interface is satisfied
return self.widgets[0].getValue()
def setErrorString(self, message):
for button, widget in zip(self.radioButtons, self.widgets):
if button.GetValue(): # is Checked
widget.setErrorString(message)
self.Layout()
def showErrorString(self, b):
for button, widget in zip(self.radioButtons, self.widgets):
if button.GetValue(): # is Checked
widget.showErrorString(b)
def arrange(self, *args, **kwargs):
title = getin(self.widgetInfo, ['options', 'title'], _('choose_one'))
if getin(self.widgetInfo, ['options', 'show_border'], False):
boxDetails = wx.StaticBox(self, -1, title)
boxSizer = wx.StaticBoxSizer(boxDetails, wx.VERTICAL)
else:
title = wx_util.h1(self, title)
title.SetForegroundColour(self._options['label_color'])
boxSizer = wx.BoxSizer(wx.VERTICAL)
boxSizer.AddSpacer(10)
boxSizer.Add(title, 0)
for btn, widget in zip(self.radioButtons, self.widgets):
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(btn,0, wx.RIGHT, 4)
sizer.Add(widget, 1, wx.EXPAND)
boxSizer.Add(sizer, 0, wx.ALL | wx.EXPAND, 5)
self.SetSizer(boxSizer)
def handleButtonClick(self, event):
currentSelection = self.selected
nextSelection = event.EventObject
if not self.isSameRadioButton(currentSelection, nextSelection):
self.selected = nextSelection
self.selected.SetValue(True)
else:
# user clicked on an already enabled radio button.
# if it is not in the required section, allow it to be deselected
if not self.widgetInfo['required']:
self.selected.SetValue(False)
self.selected = None
self.applyStyleRules()
self.handleImplicitCheck()
def isSameRadioButton(self, radioButton1, radioButton2):
return (getattr(radioButton1, 'Id', 'r1-not-found') ==
getattr(radioButton2, 'Id', 'r2-not-found'))
def applyStyleRules(self):
"""
Conditionally disabled/enables form fields based on the current
section in the radio group
"""
# for reasons I have been completely unable to figure out
# or understand, IFF you've interacted with one of the radio Buttons's
# child components, then the act of disabling that component will
# reset the state of the radioButtons thus causing it to forget
# what should be selected. So, that is why we're collected the initial
# state of all the buttons and resetting each button's state as we go.
# it's wonky as hell
states = [x.GetValue() for x in self.radioButtons]
for button, selected, widget in zip(self.radioButtons, states, self.widgets):
if isinstance(widget, CheckBox):
widget.hideInput()
if not selected: # not checked
widget.Disable()
else:
widget.Enable()
button.SetValue(selected)
def handleImplicitCheck(self):
"""
Checkboxes are hidden when inside of a RadioGroup as a selection of
the Radio button is an implicit selection of the Checkbox. As such, we have
to manually "check" any checkbox as needed.
"""
for button, widget in zip(self.radioButtons, self.widgets):
if isinstance(widget, CheckBox):
if button.GetValue(): # checked
widget.setValue(True)
else:
widget.setValue(False)
def createRadioButtons(self):
# button groups in wx are statefully determined via a style flag
# on the first button (what???). All button instances are part of the
# same group until a new button is created with the style flag RG_GROUP
# https://wxpython.org/Phoenix/docs/html/wx.RadioButton.html
# (What???)
firstButton = wx.RadioButton(self, style=wx.RB_GROUP)
firstButton.SetValue(False)
buttons = [firstButton]
for _ in getin(self.widgetInfo, ['data','widgets'], [])[1:]:
buttons.append(wx.RadioButton(self))
return buttons
def createWidgets(self):
"""
Instantiate the Gooey Widgets that are used within the RadioGroup
"""
from gooey.gui.components import widgets
widgets = [getattr(widgets, item['type'])(self, item)
for item in getin(self.widgetInfo, ['data', 'widgets'], [])]
# widgets should be disabled unless
# explicitly selected
for widget in widgets:
widget.Disable()
return widgets
|
xxshutong/openerp-7.0 | refs/heads/master | openerp/addons/sale_mrp/__openerp__.py | 60 | # -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
# 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/>.
#
##############################################################################
{
'name': 'Sales and MRP Management',
'version': '1.0',
'category': 'Hidden',
'description': """
This module provides facility to the user to install mrp and sales modulesat a time.
====================================================================================
It is basically used when we want to keep track of production orders generated
from sales order. It adds sales name and sales Reference on production order.
""",
'author': 'OpenERP SA',
'website': 'http://www.openerp.com',
'images': ['images/SO_to_MO.jpeg'],
'depends': ['mrp', 'sale_stock'],
'data': [
'security/ir.model.access.csv',
'sale_mrp_view.xml',
],
'demo': [],
'test':['test/sale_mrp.yml'],
'installable': True,
'auto_install': True,
}
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
|
ua-snap/geonode | refs/heads/master | geonode/services/views.py | 6 | # -*- coding: utf-8 -*-
#########################################################################
#
# Copyright (C) 2016 OSGeo
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#########################################################################
import urllib
import uuid
import logging
import re
from urlparse import urlsplit, urlunsplit
import urlparse
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage
from django.core.urlresolvers import reverse
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render_to_response
from django.conf import settings
from django.template import RequestContext, loader
from django.template.defaultfilters import slugify
from django.utils.translation import ugettext as _
try:
# Django >= 1.7
import json
except ImportError:
# Django <= 1.6 backwards compatibility
from django.utils import simplejson as json
from django.shortcuts import get_object_or_404
from owslib.wms import WebMapService
from owslib.wfs import WebFeatureService
from owslib.tms import TileMapService
from owslib.csw import CatalogueServiceWeb
from arcrest import Folder as ArcFolder, MapService as ArcMapService
from geoserver.catalog import Catalog
from geonode.services.models import Service, Layer, ServiceLayer, WebServiceHarvestLayersJob
from geonode.security.views import _perms_info_json
from geonode.utils import bbox_to_wkt
from geonode.services.forms import CreateServiceForm, ServiceForm
from geonode.utils import mercator_to_llbbox
from geonode.layers.utils import create_thumbnail
from geonode.geoserver.helpers import set_attributes
from geonode.base.models import Link
logger = logging.getLogger("geonode.core.layers.views")
_user = settings.OGC_SERVER['default']['USER']
_password = settings.OGC_SERVER['default']['PASSWORD']
OGP_ABSTRACT = _("""
The Open Geoportal is a consortium comprised of contributions of several universities and organizations to help
facilitate the discovery and acquisition of geospatial data across many organizations and platforms. Current partners
include: Harvard, MIT, MassGIS, Princeton, Columbia, Stanford, UC Berkeley, UCLA, Yale, and UConn. Built on open source
technology, The Open Geoportal provides organizations the opportunity to share thousands of geospatial data layers,
maps, metadata, and development resources through a single common interface.
""")
@login_required
def services(request):
"""
This view shows the list of all registered services
"""
services = Service.objects.all()
return render_to_response("services/service_list.html", RequestContext(request, {
'services': services,
}))
@login_required
def register_service(request):
"""
This view is used for manually registering a new service, with only URL as a
parameter.
"""
if request.method == "GET":
service_form = CreateServiceForm()
return render_to_response('services/service_register.html',
RequestContext(request, {
'create_service_form': service_form
}))
elif request.method == 'POST':
# Register a new Service
service_form = CreateServiceForm(request.POST)
if service_form.is_valid():
url = _clean_url(service_form.cleaned_data['url'])
# method = request.POST.get('method')
# type = request.POST.get('type')
# name = slugify(request.POST.get('name'))
name = service_form.cleaned_data['name']
type = service_form.cleaned_data["type"]
server = None
if type == "AUTO":
type, server = _verify_service_type(url)
if type is None:
return HttpResponse('Could not determine server type', status=400)
if "user" in request.POST and "password" in request.POST:
user = request.POST.get('user')
password = request.POST.get('password')
else:
user = None
password = None
if type in ["WMS", "OWS"]:
return _process_wms_service(url, name, type, user, password, wms=server, owner=request.user)
elif type == "REST":
return _register_arcgis_url(url, name, user, password, owner=request.user)
elif type == "CSW":
return _register_harvested_service(url, name, user, password, owner=request.user)
elif type == "OGP":
return _register_ogp_service(url, owner=request.user)
else:
return HttpResponse('Not Implemented (Yet)', status=501)
elif request.method == 'PUT':
# Update a previously registered Service
return HttpResponse('Not Implemented (Yet)', status=501)
elif request.method == 'DELETE':
# Delete a previously registered Service
return HttpResponse('Not Implemented (Yet)', status=501)
else:
return HttpResponse('Invalid Request', status=400)
def register_service_by_type(request):
"""
Register a service based on a specified type
"""
url = request.POST.get("url")
type = request.POST.get("type")
url = _clean_url(url)
services = Service.objects.filter(base_url=url)
if services.count() > 0:
return
type, server = _verify_service_type(url, type)
if type == "WMS" or type == "OWS":
return _process_wms_service(url, type, None, None, wms=server)
elif type == "REST":
return _register_arcgis_url(url, None, None, None)
def _is_unique(url):
"""
Determine if a service is already registered based on matching url
"""
return Service.objects.filter(base_url=url).count() == 0
def _clean_url(base_url):
"""
Remove all parameters from a URL
"""
urlprop = urlsplit(base_url)
url = urlunsplit(
(urlprop.scheme, urlprop.netloc, urlprop.path, None, None))
# hack, we make sure to append the map parameter for MapServer endpoints
# that are exposing it
if 'map' in urlparse.parse_qs(urlprop.query):
map_param = urllib.urlencode({'map': urlparse.parse_qs(urlprop.query)['map'][0]})
url = '%s?%s' % (url, map_param)
return url
def _get_valid_name(proposed_name):
"""
Return a unique slug name for a service
"""
slug_name = slugify(proposed_name)
name = slug_name
if len(slug_name) > 40:
name = slug_name[:40]
existing_service = Service.objects.filter(name=name)
iter = 1
while existing_service.count() > 0:
name = slug_name + str(iter)
existing_service = Service.objects.filter(name=name)
iter += 1
return name
def _verify_service_type(base_url, service_type=None):
"""
Try to determine service type by process of elimination
"""
logger.info("Checking the url: " + base_url)
if service_type in ['WMS', 'OWS', None]:
try:
service = WebMapService(base_url)
except:
pass
else:
return ['WMS', service]
if service_type in ['WFS', 'OWS', None]:
try:
servicewfs = WebFeatureService(base_url)
except:
pass
else:
return ['WFS', servicewfs]
if service_type in ['TMS', None]:
try:
service = TileMapService(base_url)
except:
pass
else:
return ['TMS', service]
if service_type in ['REST', None]:
try:
service = ArcFolder(base_url)
except:
pass
else:
try:
service.services
return ['REST', service]
except ValueError:
service = CatalogueServiceWeb(base_url)
if service_type in ['CSW', None]:
try:
service = CatalogueServiceWeb(base_url)
except Exception, e:
logger.exception(e)
raise
else:
return ['CSW', service]
if service_type in ['OGP', None]:
# Just use a specific OGP URL for now
if base_url == settings.OGP_URL:
return ["OGP", None]
return [None, None]
def _process_wms_service(url, name, type, username, password, wms=None, owner=None, parent=None):
"""
Create a new WMS/OWS service, cascade it if necessary (i.e. if Web Mercator not available)
"""
if wms is None:
wms = WebMapService(url)
try:
base_url = _clean_url(
wms.getOperationByName('GetMap').methods['Get']['url'])
if base_url and base_url != url:
url = base_url
wms = WebMapService(base_url)
except:
logger.info(
"Could not retrieve GetMap url, using originally supplied URL %s" % url)
pass
try:
service = Service.objects.get(base_url=url)
return_dict = [{'status': 'ok',
'msg': _("This is an existing service"),
'service_id': service.pk,
'service_name': service.name,
'service_title': service.title
}]
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
except:
pass
title = wms.identification.title
if not name:
if title:
name = _get_valid_name(title)
else:
name = _get_valid_name(urlsplit(url).netloc)
try:
supported_crs = ','.join(wms.contents.itervalues().next().crsOptions)
except:
supported_crs = None
if supported_crs and re.search('EPSG:900913|EPSG:3857|EPSG:102100|EPSG:102113', supported_crs):
return _register_indexed_service(type, url, name, username, password, wms=wms, owner=owner, parent=parent)
else:
return _register_cascaded_service(url, type, name, username, password, wms=wms, owner=owner, parent=parent)
def _register_cascaded_service(url, type, name, username, password, wms=None, owner=None, parent=None):
"""
Register a service as cascading WMS
"""
try:
service = Service.objects.get(base_url=url)
return_dict = {}
return_dict['service_id'] = service.pk
return_dict['msg'] = "This is an existing Service"
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
except:
# TODO: Handle this error properly
pass
if wms is None:
wms = WebMapService(url)
# TODO: Make sure we are parsing all service level metadata
# TODO: Handle for setting ServiceProfiletRole
service = Service.objects.create(base_url=url,
type=type,
method='C',
name=name,
version=wms.identification.version,
title=wms.identification.title,
abstract=wms.identification.abstract,
online_resource=wms.provider.url,
owner=owner,
parent=parent)
service.keywords = ','.join(wms.identification.keywords)
service.save()
service.set_default_permissions()
if type in ['WMS', 'OWS']:
# Register the Service with GeoServer to be cascaded
cat = Catalog(settings.OGC_SERVER['default']['LOCATION'] + "rest",
_user, _password)
cascade_ws = cat.get_workspace(name)
if cascade_ws is None:
cascade_ws = cat.create_workspace(
name, "http://geonode.org/" + name)
# TODO: Make sure there isn't an existing store with that name, and
# deal with it if there is
try:
cascade_store = cat.get_store(name, cascade_ws)
except:
cascade_store = cat.create_wmsstore(
name, cascade_ws, username, password)
cascade_store.capabilitiesURL = url
cascade_store.type = "WMS"
cat.save(cascade_store)
available_resources = cascade_store.get_resources(available=True)
elif type == 'WFS':
# Register the Service with GeoServer to be cascaded
cat = Catalog(settings.OGC_SERVER['default']['LOCATION'] + "rest",
_user, _password)
# Can we always assume that it is geonode?
cascade_ws = cat.get_workspace(settings.CASCADE_WORKSPACE)
if cascade_ws is None:
cascade_ws = cat.create_workspace(
settings.CASCADE_WORKSPACE, "http://geonode.org/cascade")
try:
wfs_ds = cat.get_store(name, cascade_ws)
except:
wfs_ds = cat.create_datastore(name, cascade_ws)
connection_params = {
"WFSDataStoreFactory:MAXFEATURES": "0",
"WFSDataStoreFactory:TRY_GZIP": "true",
"WFSDataStoreFactory:PROTOCOL": "false",
"WFSDataStoreFactory:LENIENT": "true",
"WFSDataStoreFactory:TIMEOUT": "3000",
"WFSDataStoreFactory:BUFFER_SIZE": "10",
"WFSDataStoreFactory:ENCODING": "UTF-8",
"WFSDataStoreFactory:WFS_STRATEGY": "nonstrict",
"WFSDataStoreFactory:GET_CAPABILITIES_URL": url,
}
if username and password:
connection_params["WFSDataStoreFactory:USERNAME"] = username
connection_params["WFSDataStoreFactory:PASSWORD"] = password
wfs_ds.connection_parameters = connection_params
cat.save(wfs_ds)
available_resources = wfs_ds.get_resources(available=True)
# Save the Service record
service, created = Service.objects.get_or_create(type=type,
method='C',
base_url=url,
name=name,
owner=owner)
service.save()
service.set_default_permissions()
elif type == 'WCS':
return HttpResponse('Not Implemented (Yet)', status=501)
else:
return HttpResponse(
'Invalid Method / Type combo: ' +
'Only Cascaded WMS, WFS and WCS supported',
content_type="text/plain",
status=400)
message = "Service %s registered" % service.name
return_dict = [{'status': 'ok',
'msg': message,
'service_id': service.pk,
'service_name': service.name,
'service_title': service.title,
'available_layers': available_resources
}]
if settings.USE_QUEUE:
# Create a layer import job
WebServiceHarvestLayersJob.objects.get_or_create(service=service)
else:
_register_cascaded_layers(service)
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
def _register_cascaded_layers(service, owner=None):
"""
Register layers for a cascading WMS
"""
if service.type == 'WMS' or service.type == "OWS":
cat = Catalog(settings.OGC_SERVER['default']['LOCATION'] + "rest",
_user, _password)
# Can we always assume that it is geonode?
# Should cascading layers have a separate workspace?
cascade_ws = cat.get_workspace(service.name)
if cascade_ws is None:
cascade_ws = cat.create_workspace(service.name, 'cascade')
try:
store = cat.get_store(service.name, cascade_ws)
except Exception:
store = cat.create_wmsstore(service.name, cascade_ws)
cat.save(store)
wms = WebMapService(service.base_url)
layers = list(wms.contents)
count = 0
for layer in layers:
lyr = cat.get_resource(layer, store, cascade_ws)
if lyr is None:
if service.type in ["WMS", "OWS"]:
resource = cat.create_wmslayer(cascade_ws, store, layer)
elif service.type == "WFS":
resource = cat.create_wfslayer(cascade_ws, store, layer)
if resource:
bbox = resource.latlon_bbox
cascaded_layer, created = Layer.objects.get_or_create(
typename="%s:%s" % (cascade_ws.name, resource.name),
service=service,
defaults={
"name": resource.name,
"workspace": cascade_ws.name,
"store": store.name,
"storeType": store.resource_type,
"title": resource.title or 'No title provided',
"abstract": resource.abstract or 'No abstract provided',
"owner": None,
"uuid": str(uuid.uuid4()),
"bbox_x0": bbox[0],
"bbox_x1": bbox[1],
"bbox_y0": bbox[2],
"bbox_y1": bbox[3],
})
if created:
cascaded_layer.save()
if cascaded_layer is not None and cascaded_layer.bbox is None:
cascaded_layer._populate_from_gs(
gs_resource=resource)
cascaded_layer.set_default_permissions()
service_layer, created = ServiceLayer.objects.get_or_create(
service=service,
typename=cascaded_layer.name
)
service_layer.layer = cascaded_layer
service_layer.title = cascaded_layer.title,
service_layer.description = cascaded_layer.abstract,
service_layer.styles = cascaded_layer.styles
service_layer.save()
count += 1
else:
logger.error(
"Resource %s from store %s could not be saved as layer" % (layer, store.name))
message = "%d Layers Registered" % count
return_dict = {'status': 'ok', 'msg': message}
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
elif service.type == 'WCS':
return HttpResponse('Not Implemented (Yet)', status=501)
else:
return HttpResponse('Invalid Service Type', status=400)
def _register_indexed_service(type, url, name, username, password, verbosity=False, wms=None, owner=None, parent=None):
"""
Register a service - WMS or OWS currently supported
"""
if type in ['WMS', "OWS", "HGL"]:
# TODO: Handle for errors from owslib
if wms is None:
wms = WebMapService(url)
# TODO: Make sure we are parsing all service level metadata
# TODO: Handle for setting ServiceProfileRole
try:
service = Service.objects.get(base_url=url)
return_dict = {}
return_dict['service_id'] = service.pk
return_dict['msg'] = "This is an existing Service"
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
except:
pass
service = Service.objects.create(base_url=url,
type=type,
method='I',
name=name,
version=wms.identification.version,
title=wms.identification.title or name,
abstract=wms.identification.abstract or _(
"Not provided"),
online_resource=wms.provider.url,
owner=owner,
parent=parent)
service.keywords = ','.join(wms.identification.keywords)
service.save()
service.set_default_permissions()
available_resources = []
for layer in list(wms.contents):
available_resources.append([wms[layer].name, wms[layer].title])
if settings.USE_QUEUE:
# Create a layer import job
WebServiceHarvestLayersJob.objects.get_or_create(service=service)
else:
_register_indexed_layers(service, wms=wms)
message = "Service %s registered" % service.name
return_dict = [{'status': 'ok',
'msg': message,
'service_id': service.pk,
'service_name': service.name,
'service_title': service.title,
'available_layers': available_resources
}]
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
elif type == 'WFS':
return HttpResponse('Not Implemented (Yet)', status=501)
elif type == 'WCS':
return HttpResponse('Not Implemented (Yet)', status=501)
else:
return HttpResponse(
'Invalid Method / Type combo: ' +
'Only Indexed WMS, WFS and WCS supported',
content_type="text/plain",
status=400)
def _register_indexed_layers(service, wms=None, verbosity=False):
"""
Register layers for an indexed service (only WMS/OWS currently supported)
"""
logger.info("Registering layers for %s" % service.base_url)
if re.match("WMS|OWS", service.type):
wms = wms or WebMapService(service.base_url)
count = 0
for layer in list(wms.contents):
wms_layer = wms[layer]
if wms_layer is None or wms_layer.name is None:
continue
logger.info("Registering layer %s" % wms_layer.name)
if verbosity:
print "Importing layer %s" % layer
layer_uuid = str(uuid.uuid1())
try:
keywords = map(lambda x: x[:100], wms_layer.keywords)
except:
keywords = []
if not wms_layer.abstract:
abstract = ""
else:
abstract = wms_layer.abstract
srid = None
# Some ArcGIS WMSServers indicate they support 900913 but really
# don't
if 'EPSG:900913' in wms_layer.crsOptions and "MapServer/WmsServer" not in service.base_url:
srid = 'EPSG:900913'
elif len(wms_layer.crsOptions) > 0:
matches = re.findall(
'EPSG\:(3857|102100|102113)', ' '.join(wms_layer.crsOptions))
if matches:
srid = 'EPSG:%s' % matches[0]
if srid is None:
message = "%d Incompatible projection - try setting the service as cascaded" % count
return_dict = {'status': 'ok', 'msg': message}
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
bbox = list(
wms_layer.boundingBoxWGS84 or (-179.0, -89.0, 179.0, 89.0))
# Need to check if layer already exists??
saved_layer, created = Layer.objects.get_or_create(
typename=wms_layer.name,
service=service,
defaults=dict(
name=wms_layer.name,
store=service.name, # ??
storeType="remoteStore",
workspace="remoteWorkspace",
title=wms_layer.title or wms_layer.name,
abstract=abstract or _("Not provided"),
uuid=layer_uuid,
owner=None,
srid=srid,
bbox_x0=bbox[0],
bbox_x1=bbox[2],
bbox_y0=bbox[1],
bbox_y1=bbox[3]
)
)
if created:
saved_layer.save()
saved_layer.set_default_permissions()
saved_layer.keywords.add(*keywords)
set_attributes(saved_layer)
service_layer, created = ServiceLayer.objects.get_or_create(
typename=wms_layer.name,
service=service
)
service_layer.layer = saved_layer
service_layer.title = wms_layer.title
service_layer.description = wms_layer.abstract
service_layer.styles = wms_layer.styles
service_layer.save()
count += 1
message = "%d Layers Registered" % count
return_dict = {'status': 'ok', 'msg': message}
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
elif service.type == 'WFS':
return HttpResponse('Not Implemented (Yet)', status=501)
elif service.type == 'WCS':
return HttpResponse('Not Implemented (Yet)', status=501)
else:
return HttpResponse('Invalid Service Type', status=400)
def _register_harvested_service(url, name, username, password, csw=None, owner=None):
"""
Register a CSW service, then step through results (or queue for asynchronous harvesting)
"""
try:
service = Service.objects.get(base_url=url)
return_dict = [{
'status': 'ok',
'service_id': service.pk,
'service_name': service.name,
'service_title': service.title,
'msg': 'This is an existing Service'
}]
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
except:
pass
if csw is None:
csw = CatalogueServiceWeb(url)
service = Service.objects.create(base_url=url,
type='CSW',
method='H',
name=_get_valid_name(
csw.identification.title or url) if not name else name,
title=csw.identification.title,
version=csw.identification.version,
abstract=csw.identification.abstract or _("Not provided"),
owner=owner)
service.keywords = ','.join(csw.identification.keywords)
service.save
service.set_default_permissions()
message = "Service %s registered" % service.name
return_dict = [{'status': 'ok',
'msg': message,
'service_id': service.pk,
'service_name': service.name,
'service_title': service.title
}]
if settings.USE_QUEUE:
# Create a layer import job
WebServiceHarvestLayersJob.objects.get_or_create(service=service)
else:
_harvest_csw(service)
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
def _harvest_csw(csw, maxrecords=10, totalrecords=float('inf')):
"""
Step through CSW results, and if one seems to be a WMS or Arc REST service then register it
"""
stop = 0
flag = 0
src = CatalogueServiceWeb(csw.base_url)
while stop == 0:
if flag == 0: # first run, start from 0
startposition = 0
else: # subsequent run, startposition is now paged
startposition = src.results['nextrecord']
src.getrecords(
esn='summary', startposition=startposition, maxrecords=maxrecords)
max = min(src.results['matches'], totalrecords)
if src.results['nextrecord'] == 0 \
or src.results['returned'] == 0 \
or src.results['nextrecord'] > max: # end the loop, exhausted all records or max records to process
stop = 1
break
# harvest each record to destination CSW
for record in list(src.records):
record = src.records[record]
known_types = {}
for ref in record.references:
if ref["scheme"] == "OGC:WMS" or \
"service=wms&request=getcapabilities" in urllib.unquote(ref["url"]).lower():
print "WMS:%s" % ref["url"]
known_types["WMS"] = ref["url"]
if ref["scheme"] == "OGC:WFS" or \
"service=wfs&request=getcapabilities" in urllib.unquote(ref["url"]).lower():
print "WFS:%s" % ref["url"]
known_types["WFS"] = ref["url"]
if ref["scheme"] == "ESRI":
print "ESRI:%s" % ref["url"]
known_types["REST"] = ref["url"]
if "WMS" in known_types:
type = "OWS" if "WFS" in known_types else "WMS"
try:
_process_wms_service(
known_types["WMS"], type, None, None, parent=csw)
except Exception, e:
logger.error("Error registering %s:%s" %
(known_types["WMS"], str(e)))
elif "REST" in known_types:
try:
_register_arcgis_url(ref["url"], None, None, None, parent=csw)
except Exception, e:
logger.error("Error registering %s:%s" %
(known_types["REST"], str(e)))
flag = 1
stop = 0
def _register_arcgis_url(url, name, username, password, owner=None, parent=None):
"""
Register an ArcGIS REST service URL
"""
# http://maps1.arcgisonline.com/ArcGIS/rest/services
baseurl = _clean_url(url)
logger.info("Fetching the ESRI url " + url)
if re.search("\/MapServer\/*(f=json)*", baseurl):
# This is a MapService
try:
arcserver = ArcMapService(baseurl)
except Exception, e:
logger.exception(e)
if isinstance(arcserver, ArcMapService) and arcserver.spatialReference.wkid in [
102100, 102113, 3785, 3857, 900913]:
return_json = [_process_arcgis_service(arcserver, name, owner=owner, parent=parent)]
else:
return_json = [{'msg': _("Could not find any layers in a compatible projection.")}]
else:
# This is a Folder
arcserver = ArcFolder(baseurl)
return_json = _process_arcgis_folder(
arcserver, name, services=[], owner=owner, parent=parent)
return HttpResponse(json.dumps(return_json),
content_type='application/json',
status=200)
def _register_arcgis_layers(service, arc=None):
"""
Register layers from an ArcGIS REST service
"""
arc = arc or ArcMapService(service.base_url)
logger.info("Registering layers for %s" % service.base_url)
for layer in arc.layers:
valid_name = slugify(layer.name)
count = 0
layer_uuid = str(uuid.uuid1())
bbox = [layer.extent.xmin, layer.extent.ymin,
layer.extent.xmax, layer.extent.ymax]
typename = layer.id
existing_layer = None
logger.info("Registering layer %s" % layer.name)
try:
existing_layer = Layer.objects.get(
typename=typename, service=service)
except Layer.DoesNotExist:
pass
llbbox = mercator_to_llbbox(bbox)
if existing_layer is None:
# Need to check if layer already exists??
logger.info("Importing layer %s" % layer.name)
saved_layer, created = Layer.objects.get_or_create(
typename=typename,
service=service,
defaults=dict(
name=valid_name,
store=service.name, # ??
storeType="remoteStore",
workspace="remoteWorkspace",
title=layer.name,
abstract=layer._json_struct[
'description'] or _("Not provided"),
uuid=layer_uuid,
owner=None,
srid="EPSG:%s" % layer.extent.spatialReference.wkid,
bbox_x0=llbbox[0],
bbox_x1=llbbox[2],
bbox_y0=llbbox[1],
bbox_y1=llbbox[3],
)
)
saved_layer.set_default_permissions()
saved_layer.save()
service_layer, created = ServiceLayer.objects.get_or_create(
service=service,
typename=layer.id
)
service_layer.layer = saved_layer
service_layer.title = layer.name,
service_layer.description = saved_layer.abstract,
service_layer.styles = None
service_layer.save()
create_arcgis_links(saved_layer)
count += 1
message = "%d Layers Registered" % count
return_dict = {'status': 'ok', 'msg': message}
return return_dict
def _process_arcgis_service(arcserver, name, owner=None, parent=None):
"""
Create a Service model instance for an ArcGIS REST service
"""
arc_url = _clean_url(arcserver.url)
services = Service.objects.filter(base_url=arc_url)
if services.count() > 0:
service = services[0]
return_dict = [{
'status': 'ok',
'service_id': service.pk,
'service_name': service.name,
'service_title': service.title,
'msg': 'This is an existing Service'
}]
return return_dict
name = _get_valid_name(arcserver.mapName or arc_url) if not name else name
service = Service.objects.create(base_url=arc_url, name=name,
type='REST',
method='I',
title=arcserver.mapName,
abstract=arcserver.serviceDescription,
online_resource=arc_url,
owner=owner,
parent=parent)
service.set_default_permissions()
available_resources = []
for layer in list(arcserver.layers):
available_resources.append([layer.id, layer.name])
if settings.USE_QUEUE:
# Create a layer import job
WebServiceHarvestLayersJob.objects.get_or_create(service=service)
else:
_register_arcgis_layers(service, arc=arcserver)
message = "Service %s registered" % service.name
return_dict = {'status': 'ok',
'msg': message,
'service_id': service.pk,
'service_name': service.name,
'service_title': service.title,
'available_layers': available_resources
}
return return_dict
def _process_arcgis_folder(folder, name, services=[], owner=None, parent=None):
"""
Iterate through folders and services in an ArcGIS REST service folder
"""
for service in folder.services:
return_dict = {}
if not isinstance(service, ArcMapService):
return_dict[
'msg'] = 'Service could not be identified as an ArcMapService, URL: %s' % service.url
logger.debug(return_dict['msg'])
else:
try:
if service.spatialReference.wkid in [102100, 102113, 3785, 3857, 900913]:
return_dict = _process_arcgis_service(
service, name, owner, parent=parent)
else:
return_dict['msg'] = _("Could not find any layers in a compatible projection: \
The spatial id was: %(srs)s and the url %(url)s" % {'srs': service.spatialReference.wkid,
'url': service.url})
logger.debug(return_dict['msg'])
except Exception as e:
logger.exception('Error uploading from the service: ' + service.url + ' ' + str(e))
services.append(return_dict)
for subfolder in folder.folders:
_process_arcgis_folder(subfolder, name, services, owner)
return services
def _register_ogp_service(url, owner=None):
"""
Register OpenGeoPortal as a service
"""
services = Service.objects.filter(base_url=url)
if services.count() > 0:
service = services[0]
return_dict = [{
'status': 'ok',
'service_id': service.pk,
'service_name': service.name,
'service_title': service.title,
'msg': 'This is an existing Service'
}]
return return_dict
service = Service.objects.create(base_url=url,
type="OGP",
method='H',
name="OpenGeoPortal",
title="OpenGeoPortal",
abstract=OGP_ABSTRACT,
owner=owner)
service.set_default_permissions()
if settings.USE_QUEUE:
# Create a layer import job
WebServiceHarvestLayersJob.objects.get_or_create(service=service)
else:
_harvest_ogp_layers(service, owner=owner)
message = "Service %s registered" % service.name
return_dict = [{'status': 'ok',
'msg': message,
'service_id': service.pk,
'service_name': service.name,
'service_title': service.title
}]
return HttpResponse(json.dumps(return_dict),
content_type='application/json',
status=200)
def _harvest_ogp_layers(service, maxrecords=10, start=0, totalrecords=float('inf'), owner=None, institution=None):
"""
Query OpenGeoPortal's solr instance for layers.
"""
query = "?q=_val_:%22sum(sum(product(9.0,map(sum(map(MinX,-180.0,180,1,0)," + \
"map(MaxX,-180.0,180.0,1,0),map(MinY,-90.0,90.0,1,0),map(MaxY,-90.0,90.0,1,0)),4,4,1,0))),0,0)%22" + \
"&debugQuery=false&&fq={!frange+l%3D1+u%3D10}product(2.0,map(sum(map(sub(abs(sub(0,CenterX))," + \
"sum(171.03515625,HalfWidth)),0,400000,1,0),map(sub(abs(sub(0,CenterY)),sum(75.84516854027,HalfHeight))" + \
",0,400000,1,0)),0,0,1,0))&wt=json&fl=Name,CollectionId,Institution,Access,DataType,Availability," + \
"LayerDisplayName,Publisher,GeoReferenced,Originator,Location,MinX,MaxX,MinY,MaxY,ContentDate,LayerId," + \
"score,WorkspaceName,SrsProjectionCode&sort=score+desc&fq=DataType%3APoint+OR+DataType%3ALine+OR+" + \
"DataType%3APolygon+OR+DataType%3ARaster+OR+DataType%3APaper+Map&fq=Access:Public"
if institution:
query += "&fq=%s" % urllib.urlencode(institution)
fullurl = service.base_url + query + \
("&rows=%d&start=%d" % (maxrecords, start))
response = urllib.urlopen(fullurl).read()
json_response = json.loads(response)
process_ogp_results(service, json_response)
max = min(json_response["response"]["numFound"], totalrecords)
while start < max:
start = start + maxrecords
_harvest_ogp_layers(
service, maxrecords, start, totalrecords=totalrecords, owner=owner, institution=institution)
def process_ogp_results(ogp, result_json, owner=None):
"""
Create WMS services and layers from OGP results
"""
for doc in result_json["response"]["docs"]:
try:
locations = json.loads(doc["Location"])
except:
continue
if "tilecache" in locations:
service_url = locations["tilecache"][0]
service_type = "WMS"
elif "wms" in locations:
service_url = locations["wms"][0]
if "wfs" in locations:
service_type = "OWS"
else:
service_type = "WMS"
else:
pass
"""
Harvard Geospatial Library is a special case, requires an activation request
to prepare the layer before WMS requests can be successful.
"""
if doc["Institution"] == "Harvard":
service_type = "HGL"
service = None
try:
service = Service.objects.get(base_url=service_url)
except Service.DoesNotExist:
if service_type in ["WMS", "OWS", "HGL"]:
try:
response = _process_wms_service(
service_url, service_type, None, None, parent=ogp)
r_json = json.loads(response.content)
service = Service.objects.get(id=r_json[0]["service_id"])
except Exception, e:
print str(e)
if service:
typename = doc["Name"]
if service_type == "HGL":
typename = typename.replace("SDE.", "")
elif doc["WorkspaceName"]:
typename = doc["WorkspaceName"] + ":" + typename
bbox = (
float(doc['MinX']),
float(doc['MinY']),
float(doc['MaxX']),
float(doc['MaxY']),
)
layer_uuid = str(uuid.uuid1())
saved_layer, created = Layer.objects.get_or_create(typename=typename,
service=service,
defaults=dict(
name=doc["Name"],
uuid=layer_uuid,
store=service.name,
storeType="remoteStore",
workspace=doc["WorkspaceName"],
title=doc["LayerDisplayName"],
owner=None,
# Assumption
srid="EPSG:900913",
bbox=list(bbox),
geographic_bounding_box=bbox_to_wkt(
str(bbox[0]), str(bbox[1]),
str(bbox[2]), str(bbox[3]), srid="EPSG:4326")
)
)
saved_layer.set_default_permissions()
saved_layer.save()
service_layer, created = ServiceLayer.objects.get_or_create(service=service, typename=typename,
defaults=dict(
title=doc[
"LayerDisplayName"]
)
)
if service_layer.layer is None:
service_layer.layer = saved_layer
service_layer.save()
def service_detail(request, service_id):
'''
This view shows the details of a service
'''
service = get_object_or_404(Service, pk=service_id)
layer_list = service.layer_set.all()
service_list = service.service_set.all()
# Show 25 services per page
service_paginator = Paginator(service_list, 25)
layer_paginator = Paginator(layer_list, 25) # Show 25 services per page
page = request.GET.get('page')
try:
layers = layer_paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
layers = layer_paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
layers = layer_paginator.page(layer_paginator.num_pages)
try:
services = service_paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
services = service_paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
services = service_paginator.page(service_paginator.num_pages)
return render_to_response("services/service_detail.html", RequestContext(request, {
'service': service,
'layers': layers,
'services': services,
'permissions_json': _perms_info_json(service)
}))
@login_required
def edit_service(request, service_id):
"""
Edit an existing Service
"""
service_obj = get_object_or_404(Service, pk=service_id)
if request.method == "POST":
service_form = ServiceForm(
request.POST, instance=service_obj, prefix="service")
if service_form.is_valid():
service_obj = service_form.save(commit=False)
service_obj.keywords.clear()
service_obj.keywords.add(*service_form.cleaned_data['keywords'])
service_obj.save()
return HttpResponseRedirect(service_obj.get_absolute_url())
else:
service_form = ServiceForm(instance=service_obj, prefix="service")
return render_to_response("services/service_edit.html", RequestContext(request, {
"service": service_obj,
"service_form": service_form
}))
def update_layers(service):
"""
Import/update layers for an existing service
"""
if service.method == "C":
_register_cascaded_layers(service)
elif service.type in ["WMS", "OWS"]:
_register_indexed_layers(service)
elif service.type == "REST":
_register_arcgis_layers(service)
elif service.type == "CSW":
_harvest_csw(service)
elif service.type == "OGP":
_harvest_ogp_layers(service, 25)
@login_required
def remove_service(request, service_id):
"""
Delete a service, and its constituent layers.
"""
service_obj = get_object_or_404(Service, pk=service_id)
if not request.user.has_perm('maps.delete_service', obj=service_obj):
return HttpResponse(loader.render_to_string('401.html',
RequestContext(request, {
'error_message':
_("You are not permitted to remove this service.")
})), status=401)
if request.method == 'GET':
return render_to_response("services/service_remove.html", RequestContext(request, {
"service": service_obj
}))
elif request.method == 'POST':
# Retrieve this service's workspace from the GeoServer catalog.
cat = Catalog(settings.OGC_SERVER['default']['LOCATION'] + "rest",
_user, _password)
workspace = cat.get_workspace(service_obj.name)
# Delete nested workspace structure from GeoServer for this service.
if workspace:
for store in cat.get_stores(workspace):
for resource in cat.get_resources(store):
for layer in cat.get_layers(resource):
cat.delete(layer)
cat.delete(resource)
cat.delete(store)
cat.delete(workspace)
# Delete service from GeoNode.
service_obj.delete()
return HttpResponseRedirect(reverse("services"))
@login_required
def ajax_service_permissions(request, service_id):
service = get_object_or_404(Service, pk=service_id)
if not request.user.has_perm("maps.change_service_permissions", obj=service):
return HttpResponse(
'You are not allowed to change permissions for this service',
status=401,
content_type='text/plain'
)
if not request.method == 'POST':
return HttpResponse(
'You must use POST for editing service permissions',
status=405,
content_type='text/plain'
)
spec = json.loads(request.body)
service.set_permissions(spec)
return HttpResponse(
"Permissions updated",
status=200,
content_type='text/plain')
def create_arcgis_links(instance):
kmz_link = instance.ows_url + '?f=kmz'
Link.objects.get_or_create(resource=instance.get_self_resource(),
url=kmz_link,
defaults=dict(
extension='kml',
name="View in Google Earth",
mime='text/xml',
link_type='data',
)
)
# Create legend.
legend_url = instance.ows_url + 'legend?f=json'
Link.objects.get_or_create(resource=instance.get_self_resource(),
url=legend_url,
defaults=dict(
extension='json',
name=_('Legend'),
url=legend_url,
mime='application/json',
link_type='json',
)
)
# Create thumbnails.
bbox = urllib.pathname2url('%s,%s,%s,%s' % (instance.bbox_x0, instance.bbox_y0, instance.bbox_x1, instance.bbox_y1))
thumbnail_remote_url = instance.ows_url + 'export?LAYERS=show%3A' + str(instance.typename) + \
'&TRANSPARENT=true&FORMAT=png&BBOX=' + bbox + '&SIZE=200%2C150&F=image&BBOXSR=4326&IMAGESR=3857'
create_thumbnail(instance, thumbnail_remote_url)
|
h3biomed/ansible-modules-extras | refs/heads/devel | cloud/ovirt/__init__.py | 12133432 | |
ETegro/ETConf | refs/heads/master | sessioner/__init__.py | 12133432 | |
Argon-Zhou/django | refs/heads/master | tests/choices/__init__.py | 12133432 | |
flumotion-mirror/flumotion | refs/heads/master | flumotion/component/producers/checks.py | 3 | # -*- Mode: Python -*-
# vi:si:et:sw=4:sts=4:ts=4
# Flumotion - a streaming media server
# Copyright (C) 2004,2005,2006,2007,2008,2009 Fluendo, S.L.
# Copyright (C) 2010,2011 Flumotion Services, S.A.
# All rights reserved.
#
# This file may be distributed and/or modified under the terms of
# the GNU Lesser General Public License version 2.1 as published by
# the Free Software Foundation.
# This file is distributed without any warranty; without even the implied
# warranty of merchantability or fitness for a particular purpose.
# See "LICENSE.LGPL" in the source distribution for more information.
#
# Headers in this file shall remain intact.
from twisted.internet import defer
from flumotion.common import messages
from flumotion.common.i18n import N_, gettexter
__version__ = "$Rev$"
T_ = gettexter()
def get_gst_version(gst):
if hasattr(gst, 'get_gst_version'):
return gst.get_gst_version()
elif hasattr(gst, 'version'):
return gst.version()
else:
return gst.gst_version + (0, )
def get_pygst_version(gst):
if hasattr(gst, 'get_pygst_version'):
return gst.get_pygst_version()
else:
return gst.pygst_version + (0, )
def checkTicket347():
"""
Check for a recent enough PyGTK to not leak python integers in message
processing (mostly affects soundcard, firewire)
"""
result = messages.Result()
import pygtk
pygtk.require('2.0')
import gobject
# Really, we want to check for pygobject_version, but that doesn't exist in
# all versions of pygtk, and this check is sufficient.
(major, minor, nano) = gobject.pygtk_version
if (major, minor, nano) < (2, 8, 6):
m = messages.Warning(T_(
N_("Version %d.%d.%d of the PyGTK library contains "
"a memory leak.\n"),
major, minor, nano),
mid='ticket-347')
m.add(T_(N_("The Soundcard and Firewire sources may leak a lot of "
"memory as a result, and would need to be restarted "
"frequently.\n")))
m.add(T_(N_("Please upgrade '%s' to version %s or later."),
'pygtk', '2.8.6'))
result.add(m)
result.succeed(None)
return defer.succeed(result)
def checkTicket348():
result = messages.Result()
import pygst
pygst.require('0.10')
import gst
(major, minor, nano) = gst.pygst_version
if (major, minor, nano) < (0, 10, 3):
m = messages.Warning(T_(
N_("Version %d.%d.%d of the gst-python library contains "
"a large memory leak.\n"),
major, minor, nano),
mid='ticket-348')
m.add(T_(N_("The Soundcard and Firewire sources may leak a lot of "
"memory as a result, and need to be restarted frequently.\n")))
m.add(T_(N_("Please upgrade '%s' to version %s or later."),
'gst-python', '0.10.3'))
result.add(m)
result.succeed(None)
return defer.succeed(result)
def checkTicket349():
result = messages.Result()
import pygst
pygst.require('0.10')
import gst
if get_gst_version(gst) < (0, 10, 4, 1):
major, minor, micro, nano = get_gst_version(gst)
m = messages.Error(T_(
N_("Version %d.%d.%d of the GStreamer library is too old.\n"),
major, minor, micro),
mid='ticket-349')
m.add(T_(N_("The '%s' component needs a newer version of '%s'.\n"),
'looper', 'gstreamer'))
m.add(T_(N_("Please upgrade '%s' to version %s or later."),
'gstreamer', '0.10.5'))
result.add(m)
if get_pygst_version(gst) < (0, 10, 3, 1):
major, minor, micro, nano = get_pygst_version(gst)
m = messages.Error(T_(
N_("Version %d.%d.%d of the gst-python library is too old.\n"),
major, minor, micro),
mid='ticket-349')
m.add(T_(N_("The '%s' component needs a newer version of '%s'.\n"),
'looper', 'gst-python'))
m.add(T_(N_("Please upgrade '%s' to version %s or later."),
'gst-python', '0.10.4'))
result.add(m)
result.succeed(None)
return defer.succeed(result)
|
SohKai/ChronoLogger | refs/heads/master | web/flask/lib/python2.7/site-packages/sqlalchemy/dialects/sybase/__init__.py | 34 | # sybase/__init__.py
# Copyright (C) 2005-2012 the SQLAlchemy authors and contributors <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
from sqlalchemy.dialects.sybase import base, pysybase, pyodbc
from base import CHAR, VARCHAR, TIME, NCHAR, NVARCHAR,\
TEXT,DATE,DATETIME, FLOAT, NUMERIC,\
BIGINT,INT, INTEGER, SMALLINT, BINARY,\
VARBINARY,UNITEXT,UNICHAR,UNIVARCHAR,\
IMAGE,BIT,MONEY,SMALLMONEY,TINYINT
# default dialect
base.dialect = pyodbc.dialect
__all__ = (
'CHAR', 'VARCHAR', 'TIME', 'NCHAR', 'NVARCHAR',
'TEXT','DATE','DATETIME', 'FLOAT', 'NUMERIC',
'BIGINT','INT', 'INTEGER', 'SMALLINT', 'BINARY',
'VARBINARY','UNITEXT','UNICHAR','UNIVARCHAR',
'IMAGE','BIT','MONEY','SMALLMONEY','TINYINT',
'dialect'
)
|
williamluke4/Examenable | refs/heads/master | node_modules/sitemap/env/src/node-v0.12.0-linux-x64/lib/node_modules/npm/node_modules/node-gyp/gyp/pylib/gyp/MSVSProject.py | 2736 | # Copyright (c) 2012 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Visual Studio project reader/writer."""
import gyp.common
import gyp.easy_xml as easy_xml
#------------------------------------------------------------------------------
class Tool(object):
"""Visual Studio tool."""
def __init__(self, name, attrs=None):
"""Initializes the tool.
Args:
name: Tool name.
attrs: Dict of tool attributes; may be None.
"""
self._attrs = attrs or {}
self._attrs['Name'] = name
def _GetSpecification(self):
"""Creates an element for the tool.
Returns:
A new xml.dom.Element for the tool.
"""
return ['Tool', self._attrs]
class Filter(object):
"""Visual Studio filter - that is, a virtual folder."""
def __init__(self, name, contents=None):
"""Initializes the folder.
Args:
name: Filter (folder) name.
contents: List of filenames and/or Filter objects contained.
"""
self.name = name
self.contents = list(contents or [])
#------------------------------------------------------------------------------
class Writer(object):
"""Visual Studio XML project writer."""
def __init__(self, project_path, version, name, guid=None, platforms=None):
"""Initializes the project.
Args:
project_path: Path to the project file.
version: Format version to emit.
name: Name of the project.
guid: GUID to use for project, if not None.
platforms: Array of string, the supported platforms. If null, ['Win32']
"""
self.project_path = project_path
self.version = version
self.name = name
self.guid = guid
# Default to Win32 for platforms.
if not platforms:
platforms = ['Win32']
# Initialize the specifications of the various sections.
self.platform_section = ['Platforms']
for platform in platforms:
self.platform_section.append(['Platform', {'Name': platform}])
self.tool_files_section = ['ToolFiles']
self.configurations_section = ['Configurations']
self.files_section = ['Files']
# Keep a dict keyed on filename to speed up access.
self.files_dict = dict()
def AddToolFile(self, path):
"""Adds a tool file to the project.
Args:
path: Relative path from project to tool file.
"""
self.tool_files_section.append(['ToolFile', {'RelativePath': path}])
def _GetSpecForConfiguration(self, config_type, config_name, attrs, tools):
"""Returns the specification for a configuration.
Args:
config_type: Type of configuration node.
config_name: Configuration name.
attrs: Dict of configuration attributes; may be None.
tools: List of tools (strings or Tool objects); may be None.
Returns:
"""
# Handle defaults
if not attrs:
attrs = {}
if not tools:
tools = []
# Add configuration node and its attributes
node_attrs = attrs.copy()
node_attrs['Name'] = config_name
specification = [config_type, node_attrs]
# Add tool nodes and their attributes
if tools:
for t in tools:
if isinstance(t, Tool):
specification.append(t._GetSpecification())
else:
specification.append(Tool(t)._GetSpecification())
return specification
def AddConfig(self, name, attrs=None, tools=None):
"""Adds a configuration to the project.
Args:
name: Configuration name.
attrs: Dict of configuration attributes; may be None.
tools: List of tools (strings or Tool objects); may be None.
"""
spec = self._GetSpecForConfiguration('Configuration', name, attrs, tools)
self.configurations_section.append(spec)
def _AddFilesToNode(self, parent, files):
"""Adds files and/or filters to the parent node.
Args:
parent: Destination node
files: A list of Filter objects and/or relative paths to files.
Will call itself recursively, if the files list contains Filter objects.
"""
for f in files:
if isinstance(f, Filter):
node = ['Filter', {'Name': f.name}]
self._AddFilesToNode(node, f.contents)
else:
node = ['File', {'RelativePath': f}]
self.files_dict[f] = node
parent.append(node)
def AddFiles(self, files):
"""Adds files to the project.
Args:
files: A list of Filter objects and/or relative paths to files.
This makes a copy of the file/filter tree at the time of this call. If you
later add files to a Filter object which was passed into a previous call
to AddFiles(), it will not be reflected in this project.
"""
self._AddFilesToNode(self.files_section, files)
# TODO(rspangler) This also doesn't handle adding files to an existing
# filter. That is, it doesn't merge the trees.
def AddFileConfig(self, path, config, attrs=None, tools=None):
"""Adds a configuration to a file.
Args:
path: Relative path to the file.
config: Name of configuration to add.
attrs: Dict of configuration attributes; may be None.
tools: List of tools (strings or Tool objects); may be None.
Raises:
ValueError: Relative path does not match any file added via AddFiles().
"""
# Find the file node with the right relative path
parent = self.files_dict.get(path)
if not parent:
raise ValueError('AddFileConfig: file "%s" not in project.' % path)
# Add the config to the file node
spec = self._GetSpecForConfiguration('FileConfiguration', config, attrs,
tools)
parent.append(spec)
def WriteIfChanged(self):
"""Writes the project file."""
# First create XML content definition
content = [
'VisualStudioProject',
{'ProjectType': 'Visual C++',
'Version': self.version.ProjectVersion(),
'Name': self.name,
'ProjectGUID': self.guid,
'RootNamespace': self.name,
'Keyword': 'Win32Proj'
},
self.platform_section,
self.tool_files_section,
self.configurations_section,
['References'], # empty section
self.files_section,
['Globals'] # empty section
]
easy_xml.WriteXmlIfChanged(content, self.project_path,
encoding="Windows-1252")
|
benpatterson/edx-platform | refs/heads/master | common/djangoapps/enrollment/tests/fake_data_api.py | 104 | """
A Fake Data API for testing purposes.
"""
import copy
import datetime
_DEFAULT_FAKE_MODE = {
"slug": "honor",
"name": "Honor Code Certificate",
"min_price": 0,
"suggested_prices": "",
"currency": "usd",
"expiration_datetime": None,
"description": None
}
_ENROLLMENTS = []
_COURSES = []
_ENROLLMENT_ATTRIBUTES = []
# pylint: disable=unused-argument
def get_course_enrollments(student_id):
"""Stubbed out Enrollment data request."""
return _ENROLLMENTS
def get_course_enrollment(student_id, course_id):
"""Stubbed out Enrollment data request."""
return _get_fake_enrollment(student_id, course_id)
def create_course_enrollment(student_id, course_id, mode='honor', is_active=True):
"""Stubbed out Enrollment creation request. """
return add_enrollment(student_id, course_id, mode=mode, is_active=is_active)
def update_course_enrollment(student_id, course_id, mode=None, is_active=None):
"""Stubbed out Enrollment data request."""
enrollment = _get_fake_enrollment(student_id, course_id)
if enrollment and mode is not None:
enrollment['mode'] = mode
if enrollment and is_active is not None:
enrollment['is_active'] = is_active
return enrollment
def get_course_enrollment_info(course_id, include_expired=False):
"""Stubbed out Enrollment data request."""
return _get_fake_course_info(course_id)
def _get_fake_enrollment(student_id, course_id):
"""Get an enrollment from the enrollments array."""
for enrollment in _ENROLLMENTS:
if student_id == enrollment['student'] and course_id == enrollment['course']['course_id']:
return enrollment
def _get_fake_course_info(course_id):
"""Get a course from the courses array."""
for course in _COURSES:
if course_id == course['course_id']:
return course
def add_enrollment(student_id, course_id, is_active=True, mode='honor'):
"""Append an enrollment to the enrollments array."""
enrollment = {
"created": datetime.datetime.now(),
"mode": mode,
"is_active": is_active,
"course": _get_fake_course_info(course_id),
"student": student_id
}
_ENROLLMENTS.append(enrollment)
return enrollment
# pylint: disable=unused-argument
def add_or_update_enrollment_attr(user_id, course_id, attributes):
"""Add or update enrollment attribute array"""
for attribute in attributes:
_ENROLLMENT_ATTRIBUTES.append({
'namespace': attribute['namespace'],
'name': attribute['name'],
'value': attribute['value']
})
# pylint: disable=unused-argument
def get_enrollment_attributes(user_id, course_id):
"""Retrieve enrollment attribute array"""
return _ENROLLMENT_ATTRIBUTES
def add_course(course_id, enrollment_start=None, enrollment_end=None, invite_only=False, course_modes=None):
"""Append course to the courses array."""
course_info = {
"course_id": course_id,
"enrollment_end": enrollment_end,
"course_modes": [],
"enrollment_start": enrollment_start,
"invite_only": invite_only,
}
if not course_modes:
course_info['course_modes'].append(_DEFAULT_FAKE_MODE)
else:
for mode in course_modes:
new_mode = copy.deepcopy(_DEFAULT_FAKE_MODE)
new_mode['slug'] = mode
course_info['course_modes'].append(new_mode)
_COURSES.append(course_info)
def reset():
"""Set the enrollments and courses arrays to be empty."""
global _COURSES # pylint: disable=global-statement
_COURSES = []
global _ENROLLMENTS # pylint: disable=global-statement
_ENROLLMENTS = []
|
aajanki/youtube-dl | refs/heads/master | youtube_dl/extractor/udn.py | 10 | # coding: utf-8
from __future__ import unicode_literals
import json
from .common import InfoExtractor
from ..utils import (
js_to_json,
ExtractorError,
)
from ..compat import compat_urlparse
class UDNEmbedIE(InfoExtractor):
_VALID_URL = r'https?://video\.udn\.com/(?:embed|play)/news/(?P<id>\d+)'
_TESTS = [{
'url': 'http://video.udn.com/embed/news/300040',
'md5': 'de06b4c90b042c128395a88f0384817e',
'info_dict': {
'id': '300040',
'ext': 'mp4',
'title': '生物老師男變女 全校挺"做自己"',
'thumbnail': 're:^https?://.*\.jpg$',
}
}, {
'url': 'https://video.udn.com/embed/news/300040',
'only_matching': True,
}, {
# From https://video.udn.com/news/303776
'url': 'https://video.udn.com/play/news/303776',
'only_matching': True,
}]
def _real_extract(self, url):
video_id = self._match_id(url)
page = self._download_webpage(url, video_id)
options = json.loads(js_to_json(self._html_search_regex(
r'var options\s*=\s*([^;]+);', page, 'video urls dictionary')))
video_urls = options['video']
if video_urls.get('youtube'):
return self.url_result(video_urls.get('youtube'), 'Youtube')
try:
del video_urls['youtube']
except KeyError:
pass
formats = [{
'url': self._download_webpage(
compat_urlparse.urljoin(url, api_url), video_id,
'retrieve url for %s video' % video_type),
'format_id': video_type,
'preference': 0 if video_type == 'mp4' else -1,
} for video_type, api_url in video_urls.items() if api_url]
if not formats:
raise ExtractorError('No videos found', expected=True)
self._sort_formats(formats)
thumbnail = None
if options.get('gallery') and len(options['gallery']):
thumbnail = options['gallery'][0].get('original')
return {
'id': video_id,
'formats': formats,
'title': options['title'],
'thumbnail': thumbnail
}
|
akosyakov/intellij-community | refs/heads/master | python/lib/Lib/site-packages/django/utils/regex_helper.py | 361 | """
Functions for reversing a regular expression (used in reverse URL resolving).
Used internally by Django and not intended for external use.
This is not, and is not intended to be, a complete reg-exp decompiler. It
should be good enough for a large class of URLS, however.
"""
# Mapping of an escape character to a representative of that class. So, e.g.,
# "\w" is replaced by "x" in a reverse URL. A value of None means to ignore
# this sequence. Any missing key is mapped to itself.
ESCAPE_MAPPINGS = {
"A": None,
"b": None,
"B": None,
"d": u"0",
"D": u"x",
"s": u" ",
"S": u"x",
"w": u"x",
"W": u"!",
"Z": None,
}
class Choice(list):
"""
Used to represent multiple possibilities at this point in a pattern string.
We use a distinguished type, rather than a list, so that the usage in the
code is clear.
"""
class Group(list):
"""
Used to represent a capturing group in the pattern string.
"""
class NonCapture(list):
"""
Used to represent a non-capturing group in the pattern string.
"""
def normalize(pattern):
"""
Given a reg-exp pattern, normalizes it to a list of forms that suffice for
reverse matching. This does the following:
(1) For any repeating sections, keeps the minimum number of occurrences
permitted (this means zero for optional groups).
(2) If an optional group includes parameters, include one occurrence of
that group (along with the zero occurrence case from step (1)).
(3) Select the first (essentially an arbitrary) element from any character
class. Select an arbitrary character for any unordered class (e.g. '.'
or '\w') in the pattern.
(5) Ignore comments and any of the reg-exp flags that won't change
what we construct ("iLmsu"). "(?x)" is an error, however.
(6) Raise an error on all other non-capturing (?...) forms (e.g.
look-ahead and look-behind matches) and any disjunctive ('|')
constructs.
Django's URLs for forward resolving are either all positional arguments or
all keyword arguments. That is assumed here, as well. Although reverse
resolving can be done using positional args when keyword args are
specified, the two cannot be mixed in the same reverse() call.
"""
# Do a linear scan to work out the special features of this pattern. The
# idea is that we scan once here and collect all the information we need to
# make future decisions.
result = []
non_capturing_groups = []
consume_next = True
pattern_iter = next_char(iter(pattern))
num_args = 0
# A "while" loop is used here because later on we need to be able to peek
# at the next character and possibly go around without consuming another
# one at the top of the loop.
try:
ch, escaped = pattern_iter.next()
except StopIteration:
return zip([u''], [[]])
try:
while True:
if escaped:
result.append(ch)
elif ch == '.':
# Replace "any character" with an arbitrary representative.
result.append(u".")
elif ch == '|':
# FIXME: One day we'll should do this, but not in 1.0.
raise NotImplementedError
elif ch == "^":
pass
elif ch == '$':
break
elif ch == ')':
# This can only be the end of a non-capturing group, since all
# other unescaped parentheses are handled by the grouping
# section later (and the full group is handled there).
#
# We regroup everything inside the capturing group so that it
# can be quantified, if necessary.
start = non_capturing_groups.pop()
inner = NonCapture(result[start:])
result = result[:start] + [inner]
elif ch == '[':
# Replace ranges with the first character in the range.
ch, escaped = pattern_iter.next()
result.append(ch)
ch, escaped = pattern_iter.next()
while escaped or ch != ']':
ch, escaped = pattern_iter.next()
elif ch == '(':
# Some kind of group.
ch, escaped = pattern_iter.next()
if ch != '?' or escaped:
# A positional group
name = "_%d" % num_args
num_args += 1
result.append(Group(((u"%%(%s)s" % name), name)))
walk_to_end(ch, pattern_iter)
else:
ch, escaped = pattern_iter.next()
if ch in "iLmsu#":
# All of these are ignorable. Walk to the end of the
# group.
walk_to_end(ch, pattern_iter)
elif ch == ':':
# Non-capturing group
non_capturing_groups.append(len(result))
elif ch != 'P':
# Anything else, other than a named group, is something
# we cannot reverse.
raise ValueError("Non-reversible reg-exp portion: '(?%s'" % ch)
else:
ch, escaped = pattern_iter.next()
if ch != '<':
raise ValueError("Non-reversible reg-exp portion: '(?P%s'" % ch)
# We are in a named capturing group. Extra the name and
# then skip to the end.
name = []
ch, escaped = pattern_iter.next()
while ch != '>':
name.append(ch)
ch, escaped = pattern_iter.next()
param = ''.join(name)
result.append(Group(((u"%%(%s)s" % param), param)))
walk_to_end(ch, pattern_iter)
elif ch in "*?+{":
# Quanitifers affect the previous item in the result list.
count, ch = get_quantifier(ch, pattern_iter)
if ch:
# We had to look ahead, but it wasn't need to compute the
# quanitifer, so use this character next time around the
# main loop.
consume_next = False
if count == 0:
if contains(result[-1], Group):
# If we are quantifying a capturing group (or
# something containing such a group) and the minimum is
# zero, we must also handle the case of one occurrence
# being present. All the quantifiers (except {0,0},
# which we conveniently ignore) that have a 0 minimum
# also allow a single occurrence.
result[-1] = Choice([None, result[-1]])
else:
result.pop()
elif count > 1:
result.extend([result[-1]] * (count - 1))
else:
# Anything else is a literal.
result.append(ch)
if consume_next:
ch, escaped = pattern_iter.next()
else:
consume_next = True
except StopIteration:
pass
except NotImplementedError:
# A case of using the disjunctive form. No results for you!
return zip([u''], [[]])
return zip(*flatten_result(result))
def next_char(input_iter):
"""
An iterator that yields the next character from "pattern_iter", respecting
escape sequences. An escaped character is replaced by a representative of
its class (e.g. \w -> "x"). If the escaped character is one that is
skipped, it is not returned (the next character is returned instead).
Yields the next character, along with a boolean indicating whether it is a
raw (unescaped) character or not.
"""
for ch in input_iter:
if ch != '\\':
yield ch, False
continue
ch = input_iter.next()
representative = ESCAPE_MAPPINGS.get(ch, ch)
if representative is None:
continue
yield representative, True
def walk_to_end(ch, input_iter):
"""
The iterator is currently inside a capturing group. We want to walk to the
close of this group, skipping over any nested groups and handling escaped
parentheses correctly.
"""
if ch == '(':
nesting = 1
else:
nesting = 0
for ch, escaped in input_iter:
if escaped:
continue
elif ch == '(':
nesting += 1
elif ch == ')':
if not nesting:
return
nesting -= 1
def get_quantifier(ch, input_iter):
"""
Parse a quantifier from the input, where "ch" is the first character in the
quantifier.
Returns the minimum number of occurences permitted by the quantifier and
either None or the next character from the input_iter if the next character
is not part of the quantifier.
"""
if ch in '*?+':
try:
ch2, escaped = input_iter.next()
except StopIteration:
ch2 = None
if ch2 == '?':
ch2 = None
if ch == '+':
return 1, ch2
return 0, ch2
quant = []
while ch != '}':
ch, escaped = input_iter.next()
quant.append(ch)
quant = quant[:-1]
values = ''.join(quant).split(',')
# Consume the trailing '?', if necessary.
try:
ch, escaped = input_iter.next()
except StopIteration:
ch = None
if ch == '?':
ch = None
return int(values[0]), ch
def contains(source, inst):
"""
Returns True if the "source" contains an instance of "inst". False,
otherwise.
"""
if isinstance(source, inst):
return True
if isinstance(source, NonCapture):
for elt in source:
if contains(elt, inst):
return True
return False
def flatten_result(source):
"""
Turns the given source sequence into a list of reg-exp possibilities and
their arguments. Returns a list of strings and a list of argument lists.
Each of the two lists will be of the same length.
"""
if source is None:
return [u''], [[]]
if isinstance(source, Group):
if source[1] is None:
params = []
else:
params = [source[1]]
return [source[0]], [params]
result = [u'']
result_args = [[]]
pos = last = 0
for pos, elt in enumerate(source):
if isinstance(elt, basestring):
continue
piece = u''.join(source[last:pos])
if isinstance(elt, Group):
piece += elt[0]
param = elt[1]
else:
param = None
last = pos + 1
for i in range(len(result)):
result[i] += piece
if param:
result_args[i].append(param)
if isinstance(elt, (Choice, NonCapture)):
if isinstance(elt, NonCapture):
elt = [elt]
inner_result, inner_args = [], []
for item in elt:
res, args = flatten_result(item)
inner_result.extend(res)
inner_args.extend(args)
new_result = []
new_args = []
for item, args in zip(result, result_args):
for i_item, i_args in zip(inner_result, inner_args):
new_result.append(item + i_item)
new_args.append(args[:] + i_args)
result = new_result
result_args = new_args
if pos >= last:
piece = u''.join(source[last:])
for i in range(len(result)):
result[i] += piece
return result, result_args
|
hzlf/openbroadcast | refs/heads/master | website/filer/admin/imageadmin.py | 35 | #-*- coding: utf-8 -*-
from django import forms
from django.utils.translation import ugettext as _
from filer import settings as filer_settings, settings
from filer.admin.fileadmin import FileAdmin
from filer.models import Image
class ImageAdminForm(forms.ModelForm):
subject_location = forms.CharField(
max_length=64, required=False,
label=_('Subject location'),
help_text=_('Location of the main subject of the scene.'))
def sidebar_image_ratio(self):
if self.instance:
# this is very important. It forces the value to be returned as a
# string and always with a "." as seperator. If the conversion
# from float to string is done in the template, the locale will
# be used and in some cases there would be a "," instead of ".".
# javascript would parse that to an integer.
return "%.6F" % self.instance.sidebar_image_ratio()
else:
return ''
class Meta:
model = Image
class Media:
css = {
#'all': (settings.MEDIA_URL + 'filer/css/focal_point.css',)
}
js = (
filer_settings.FILER_STATICMEDIA_PREFIX + 'js/raphael.js',
filer_settings.FILER_STATICMEDIA_PREFIX + 'js/focal_point.js',
)
class ImageAdmin(FileAdmin):
form = ImageAdminForm
ImageAdmin.fieldsets = ImageAdmin.build_fieldsets(
extra_main_fields=('default_alt_text', 'default_caption',),
extra_fieldsets=(
('Subject Location', {
'fields': ('subject_location',),
'classes': ('collapse',),
}),
)
)
|
Thoshh/wapad | refs/heads/master | lib/python2.7/site-packages/django/db/models/sql/query.py | 24 | """
Create SQL statements for QuerySets.
The code in here encapsulates all of the SQL construction so that QuerySets
themselves do not have to (and could be backed by things other than SQL
databases). The abstraction barrier only works one way: this module has to know
all about the internals of models in order to get the information it needs.
"""
import copy
import warnings
from collections import Counter, Iterator, Mapping, OrderedDict
from itertools import chain, count, product
from string import ascii_uppercase
from django.core.exceptions import FieldDoesNotExist, FieldError
from django.db import DEFAULT_DB_ALIAS, connections
from django.db.models.aggregates import Count
from django.db.models.constants import LOOKUP_SEP
from django.db.models.expressions import Col, Ref
from django.db.models.fields.related_lookups import MultiColSource
from django.db.models.query_utils import (
PathInfo, Q, check_rel_lookup_compatibility, refs_expression,
)
from django.db.models.sql.constants import (
INNER, LOUTER, ORDER_DIR, ORDER_PATTERN, QUERY_TERMS, SINGLE,
)
from django.db.models.sql.datastructures import (
BaseTable, Empty, EmptyResultSet, Join, MultiJoin,
)
from django.db.models.sql.where import (
AND, OR, ExtraWhere, NothingNode, WhereNode,
)
from django.utils import six
from django.utils.deprecation import RemovedInDjango110Warning
from django.utils.encoding import force_text
from django.utils.tree import Node
__all__ = ['Query', 'RawQuery']
def get_field_names_from_opts(opts):
return set(chain.from_iterable(
(f.name, f.attname) if f.concrete else (f.name,)
for f in opts.get_fields()
))
class RawQuery(object):
"""
A single raw SQL query
"""
def __init__(self, sql, using, params=None, context=None):
self.params = params or ()
self.sql = sql
self.using = using
self.cursor = None
# Mirror some properties of a normal query so that
# the compiler can be used to process results.
self.low_mark, self.high_mark = 0, None # Used for offset/limit
self.extra_select = {}
self.annotation_select = {}
self.context = context or {}
def clone(self, using):
return RawQuery(self.sql, using, params=self.params, context=self.context.copy())
def get_columns(self):
if self.cursor is None:
self._execute_query()
converter = connections[self.using].introspection.column_name_converter
return [converter(column_meta[0])
for column_meta in self.cursor.description]
def __iter__(self):
# Always execute a new query for a new iterator.
# This could be optimized with a cache at the expense of RAM.
self._execute_query()
if not connections[self.using].features.can_use_chunked_reads:
# If the database can't use chunked reads we need to make sure we
# evaluate the entire query up front.
result = list(self.cursor)
else:
result = self.cursor
return iter(result)
def __repr__(self):
return "<RawQuery: %s>" % self
@property
def params_type(self):
return dict if isinstance(self.params, Mapping) else tuple
def __str__(self):
return self.sql % self.params_type(self.params)
def _execute_query(self):
connection = connections[self.using]
# Adapt parameters to the database, as much as possible considering
# that the target type isn't known. See #17755.
params_type = self.params_type
adapter = connection.ops.adapt_unknown_value
if params_type is tuple:
params = tuple(adapter(val) for val in self.params)
elif params_type is dict:
params = dict((key, adapter(val)) for key, val in six.iteritems(self.params))
else:
raise RuntimeError("Unexpected params type: %s" % params_type)
self.cursor = connection.cursor()
self.cursor.execute(self.sql, params)
class Query(object):
"""
A single SQL query.
"""
alias_prefix = 'T'
subq_aliases = frozenset([alias_prefix])
query_terms = QUERY_TERMS
compiler = 'SQLCompiler'
def __init__(self, model, where=WhereNode):
self.model = model
self.alias_refcount = {}
# alias_map is the most important data structure regarding joins.
# It's used for recording which joins exist in the query and what
# types they are. The key is the alias of the joined table (possibly
# the table name) and the value is a Join-like object (see
# sql.datastructures.Join for more information).
self.alias_map = {}
# Sometimes the query contains references to aliases in outer queries (as
# a result of split_exclude). Correct alias quoting needs to know these
# aliases too.
self.external_aliases = set()
self.table_map = {} # Maps table names to list of aliases.
self.default_cols = True
self.default_ordering = True
self.standard_ordering = True
self.used_aliases = set()
self.filter_is_sticky = False
# SQL-related attributes
# Select and related select clauses are expressions to use in the
# SELECT clause of the query.
# The select is used for cases where we want to set up the select
# clause to contain other than default fields (values(), subqueries...)
# Note that annotations go to annotations dictionary.
self.select = []
self.tables = [] # Aliases in the order they are created.
self.where = where()
self.where_class = where
# The group_by attribute can have one of the following forms:
# - None: no group by at all in the query
# - A list of expressions: group by (at least) those expressions.
# String refs are also allowed for now.
# - True: group by all select fields of the model
# See compiler.get_group_by() for details.
self.group_by = None
self.order_by = []
self.low_mark, self.high_mark = 0, None # Used for offset/limit
self.distinct = False
self.distinct_fields = []
self.select_for_update = False
self.select_for_update_nowait = False
self.select_related = False
# Arbitrary limit for select_related to prevents infinite recursion.
self.max_depth = 5
# Holds the selects defined by a call to values() or values_list()
# excluding annotation_select and extra_select.
self.values_select = []
# SQL annotation-related attributes
# The _annotations will be an OrderedDict when used. Due to the cost
# of creating OrderedDict this attribute is created lazily (in
# self.annotations property).
self._annotations = None # Maps alias -> Annotation Expression
self.annotation_select_mask = None
self._annotation_select_cache = None
# These are for extensions. The contents are more or less appended
# verbatim to the appropriate clause.
# The _extra attribute is an OrderedDict, lazily created similarly to
# .annotations
self._extra = None # Maps col_alias -> (col_sql, params).
self.extra_select_mask = None
self._extra_select_cache = None
self.extra_tables = ()
self.extra_order_by = ()
# A tuple that is a set of model field names and either True, if these
# are the fields to defer, or False if these are the only fields to
# load.
self.deferred_loading = (set(), True)
self.context = {}
@property
def extra(self):
if self._extra is None:
self._extra = OrderedDict()
return self._extra
@property
def annotations(self):
if self._annotations is None:
self._annotations = OrderedDict()
return self._annotations
@property
def aggregates(self):
warnings.warn(
"The aggregates property is deprecated. Use annotations instead.",
RemovedInDjango110Warning, stacklevel=2)
return self.annotations
def __str__(self):
"""
Returns the query as a string of SQL with the parameter values
substituted in (use sql_with_params() to see the unsubstituted string).
Parameter values won't necessarily be quoted correctly, since that is
done by the database interface at execution time.
"""
sql, params = self.sql_with_params()
return sql % params
def sql_with_params(self):
"""
Returns the query as an SQL string and the parameters that will be
substituted into the query.
"""
return self.get_compiler(DEFAULT_DB_ALIAS).as_sql()
def __deepcopy__(self, memo):
result = self.clone(memo=memo)
memo[id(self)] = result
return result
def _prepare(self, field):
return self
def get_compiler(self, using=None, connection=None):
if using is None and connection is None:
raise ValueError("Need either using or connection")
if using:
connection = connections[using]
return connection.ops.compiler(self.compiler)(self, connection, using)
def get_meta(self):
"""
Returns the Options instance (the model._meta) from which to start
processing. Normally, this is self.model._meta, but it can be changed
by subclasses.
"""
return self.model._meta
def clone(self, klass=None, memo=None, **kwargs):
"""
Creates a copy of the current instance. The 'kwargs' parameter can be
used by clients to update attributes after copying has taken place.
"""
obj = Empty()
obj.__class__ = klass or self.__class__
obj.model = self.model
obj.alias_refcount = self.alias_refcount.copy()
obj.alias_map = self.alias_map.copy()
obj.external_aliases = self.external_aliases.copy()
obj.table_map = self.table_map.copy()
obj.default_cols = self.default_cols
obj.default_ordering = self.default_ordering
obj.standard_ordering = self.standard_ordering
obj.select = self.select[:]
obj.tables = self.tables[:]
obj.where = self.where.clone()
obj.where_class = self.where_class
if self.group_by is None:
obj.group_by = None
elif self.group_by is True:
obj.group_by = True
else:
obj.group_by = self.group_by[:]
obj.order_by = self.order_by[:]
obj.low_mark, obj.high_mark = self.low_mark, self.high_mark
obj.distinct = self.distinct
obj.distinct_fields = self.distinct_fields[:]
obj.select_for_update = self.select_for_update
obj.select_for_update_nowait = self.select_for_update_nowait
obj.select_related = self.select_related
obj.values_select = self.values_select[:]
obj._annotations = self._annotations.copy() if self._annotations is not None else None
if self.annotation_select_mask is None:
obj.annotation_select_mask = None
else:
obj.annotation_select_mask = self.annotation_select_mask.copy()
# _annotation_select_cache cannot be copied, as doing so breaks the
# (necessary) state in which both annotations and
# _annotation_select_cache point to the same underlying objects.
# It will get re-populated in the cloned queryset the next time it's
# used.
obj._annotation_select_cache = None
obj.max_depth = self.max_depth
obj._extra = self._extra.copy() if self._extra is not None else None
if self.extra_select_mask is None:
obj.extra_select_mask = None
else:
obj.extra_select_mask = self.extra_select_mask.copy()
if self._extra_select_cache is None:
obj._extra_select_cache = None
else:
obj._extra_select_cache = self._extra_select_cache.copy()
obj.extra_tables = self.extra_tables
obj.extra_order_by = self.extra_order_by
obj.deferred_loading = copy.copy(self.deferred_loading[0]), self.deferred_loading[1]
if self.filter_is_sticky and self.used_aliases:
obj.used_aliases = self.used_aliases.copy()
else:
obj.used_aliases = set()
obj.filter_is_sticky = False
if 'alias_prefix' in self.__dict__:
obj.alias_prefix = self.alias_prefix
if 'subq_aliases' in self.__dict__:
obj.subq_aliases = self.subq_aliases.copy()
obj.__dict__.update(kwargs)
if hasattr(obj, '_setup_query'):
obj._setup_query()
obj.context = self.context.copy()
return obj
def add_context(self, key, value):
self.context[key] = value
def get_context(self, key, default=None):
return self.context.get(key, default)
def relabeled_clone(self, change_map):
clone = self.clone()
clone.change_aliases(change_map)
return clone
def rewrite_cols(self, annotation, col_cnt):
# We must make sure the inner query has the referred columns in it.
# If we are aggregating over an annotation, then Django uses Ref()
# instances to note this. However, if we are annotating over a column
# of a related model, then it might be that column isn't part of the
# SELECT clause of the inner query, and we must manually make sure
# the column is selected. An example case is:
# .aggregate(Sum('author__awards'))
# Resolving this expression results in a join to author, but there
# is no guarantee the awards column of author is in the select clause
# of the query. Thus we must manually add the column to the inner
# query.
orig_exprs = annotation.get_source_expressions()
new_exprs = []
for expr in orig_exprs:
if isinstance(expr, Ref):
# Its already a Ref to subquery (see resolve_ref() for
# details)
new_exprs.append(expr)
elif isinstance(expr, Col):
# Reference to column. Make sure the referenced column
# is selected.
col_cnt += 1
col_alias = '__col%d' % col_cnt
self.annotations[col_alias] = expr
self.append_annotation_mask([col_alias])
new_exprs.append(Ref(col_alias, expr))
else:
# Some other expression not referencing database values
# directly. Its subexpression might contain Cols.
new_expr, col_cnt = self.rewrite_cols(expr, col_cnt)
new_exprs.append(new_expr)
annotation.set_source_expressions(new_exprs)
return annotation, col_cnt
def get_aggregation(self, using, added_aggregate_names):
"""
Returns the dictionary with the values of the existing aggregations.
"""
if not self.annotation_select:
return {}
has_limit = self.low_mark != 0 or self.high_mark is not None
has_existing_annotations = any(
annotation for alias, annotation
in self.annotations.items()
if alias not in added_aggregate_names
)
# Decide if we need to use a subquery.
#
# Existing annotations would cause incorrect results as get_aggregation()
# must produce just one result and thus must not use GROUP BY. But we
# aren't smart enough to remove the existing annotations from the
# query, so those would force us to use GROUP BY.
#
# If the query has limit or distinct, then those operations must be
# done in a subquery so that we are aggregating on the limit and/or
# distinct results instead of applying the distinct and limit after the
# aggregation.
if (isinstance(self.group_by, list) or has_limit or has_existing_annotations or
self.distinct):
from django.db.models.sql.subqueries import AggregateQuery
outer_query = AggregateQuery(self.model)
inner_query = self.clone()
inner_query.select_for_update = False
inner_query.select_related = False
if not has_limit and not self.distinct_fields:
# Queries with distinct_fields need ordering and when a limit
# is applied we must take the slice from the ordered query.
# Otherwise no need for ordering.
inner_query.clear_ordering(True)
if not inner_query.distinct:
# If the inner query uses default select and it has some
# aggregate annotations, then we must make sure the inner
# query is grouped by the main model's primary key. However,
# clearing the select clause can alter results if distinct is
# used.
if inner_query.default_cols and has_existing_annotations:
inner_query.group_by = [self.model._meta.pk.get_col(inner_query.get_initial_alias())]
inner_query.default_cols = False
relabels = {t: 'subquery' for t in inner_query.tables}
relabels[None] = 'subquery'
# Remove any aggregates marked for reduction from the subquery
# and move them to the outer AggregateQuery.
col_cnt = 0
for alias, expression in list(inner_query.annotation_select.items()):
if expression.is_summary:
expression, col_cnt = inner_query.rewrite_cols(expression, col_cnt)
outer_query.annotations[alias] = expression.relabeled_clone(relabels)
del inner_query.annotations[alias]
# Make sure the annotation_select wont use cached results.
inner_query.set_annotation_mask(inner_query.annotation_select_mask)
if inner_query.select == [] and not inner_query.default_cols and not inner_query.annotation_select_mask:
# In case of Model.objects[0:3].count(), there would be no
# field selected in the inner query, yet we must use a subquery.
# So, make sure at least one field is selected.
inner_query.select = [self.model._meta.pk.get_col(inner_query.get_initial_alias())]
try:
outer_query.add_subquery(inner_query, using)
except EmptyResultSet:
return {
alias: None
for alias in outer_query.annotation_select
}
else:
outer_query = self
self.select = []
self.default_cols = False
self._extra = {}
outer_query.clear_ordering(True)
outer_query.clear_limits()
outer_query.select_for_update = False
outer_query.select_related = False
compiler = outer_query.get_compiler(using)
result = compiler.execute_sql(SINGLE)
if result is None:
result = [None for q in outer_query.annotation_select.items()]
converters = compiler.get_converters(outer_query.annotation_select.values())
result = compiler.apply_converters(result, converters)
return {
alias: val
for (alias, annotation), val
in zip(outer_query.annotation_select.items(), result)
}
def get_count(self, using):
"""
Performs a COUNT() query using the current filter constraints.
"""
obj = self.clone()
obj.add_annotation(Count('*'), alias='__count', is_summary=True)
number = obj.get_aggregation(using, ['__count'])['__count']
if number is None:
number = 0
return number
def has_filters(self):
return self.where
def has_results(self, using):
q = self.clone()
if not q.distinct:
if q.group_by is True:
q.add_fields((f.attname for f in self.model._meta.concrete_fields), False)
q.set_group_by()
q.clear_select_clause()
q.clear_ordering(True)
q.set_limits(high=1)
compiler = q.get_compiler(using=using)
return compiler.has_results()
def combine(self, rhs, connector):
"""
Merge the 'rhs' query into the current one (with any 'rhs' effects
being applied *after* (that is, "to the right of") anything in the
current query. 'rhs' is not modified during a call to this function.
The 'connector' parameter describes how to connect filters from the
'rhs' query.
"""
assert self.model == rhs.model, \
"Cannot combine queries on two different base models."
assert self.can_filter(), \
"Cannot combine queries once a slice has been taken."
assert self.distinct == rhs.distinct, \
"Cannot combine a unique query with a non-unique query."
assert self.distinct_fields == rhs.distinct_fields, \
"Cannot combine queries with different distinct fields."
# Work out how to relabel the rhs aliases, if necessary.
change_map = {}
conjunction = (connector == AND)
# Determine which existing joins can be reused. When combining the
# query with AND we must recreate all joins for m2m filters. When
# combining with OR we can reuse joins. The reason is that in AND
# case a single row can't fulfill a condition like:
# revrel__col=1 & revrel__col=2
# But, there might be two different related rows matching this
# condition. In OR case a single True is enough, so single row is
# enough, too.
#
# Note that we will be creating duplicate joins for non-m2m joins in
# the AND case. The results will be correct but this creates too many
# joins. This is something that could be fixed later on.
reuse = set() if conjunction else set(self.tables)
# Base table must be present in the query - this is the same
# table on both sides.
self.get_initial_alias()
joinpromoter = JoinPromoter(connector, 2, False)
joinpromoter.add_votes(
j for j in self.alias_map if self.alias_map[j].join_type == INNER)
rhs_votes = set()
# Now, add the joins from rhs query into the new query (skipping base
# table).
for alias in rhs.tables[1:]:
join = rhs.alias_map[alias]
# If the left side of the join was already relabeled, use the
# updated alias.
join = join.relabeled_clone(change_map)
new_alias = self.join(join, reuse=reuse)
if join.join_type == INNER:
rhs_votes.add(new_alias)
# We can't reuse the same join again in the query. If we have two
# distinct joins for the same connection in rhs query, then the
# combined query must have two joins, too.
reuse.discard(new_alias)
if alias != new_alias:
change_map[alias] = new_alias
if not rhs.alias_refcount[alias]:
# The alias was unused in the rhs query. Unref it so that it
# will be unused in the new query, too. We have to add and
# unref the alias so that join promotion has information of
# the join type for the unused alias.
self.unref_alias(new_alias)
joinpromoter.add_votes(rhs_votes)
joinpromoter.update_join_types(self)
# Now relabel a copy of the rhs where-clause and add it to the current
# one.
w = rhs.where.clone()
w.relabel_aliases(change_map)
self.where.add(w, connector)
# Selection columns and extra extensions are those provided by 'rhs'.
self.select = []
for col in rhs.select:
self.add_select(col.relabeled_clone(change_map))
if connector == OR:
# It would be nice to be able to handle this, but the queries don't
# really make sense (or return consistent value sets). Not worth
# the extra complexity when you can write a real query instead.
if self._extra and rhs._extra:
raise ValueError("When merging querysets using 'or', you "
"cannot have extra(select=...) on both sides.")
self.extra.update(rhs.extra)
extra_select_mask = set()
if self.extra_select_mask is not None:
extra_select_mask.update(self.extra_select_mask)
if rhs.extra_select_mask is not None:
extra_select_mask.update(rhs.extra_select_mask)
if extra_select_mask:
self.set_extra_mask(extra_select_mask)
self.extra_tables += rhs.extra_tables
# Ordering uses the 'rhs' ordering, unless it has none, in which case
# the current ordering is used.
self.order_by = rhs.order_by[:] if rhs.order_by else self.order_by
self.extra_order_by = rhs.extra_order_by or self.extra_order_by
def deferred_to_data(self, target, callback):
"""
Converts the self.deferred_loading data structure to an alternate data
structure, describing the field that *will* be loaded. This is used to
compute the columns to select from the database and also by the
QuerySet class to work out which fields are being initialized on each
model. Models that have all their fields included aren't mentioned in
the result, only those that have field restrictions in place.
The "target" parameter is the instance that is populated (in place).
The "callback" is a function that is called whenever a (model, field)
pair need to be added to "target". It accepts three parameters:
"target", and the model and list of fields being added for that model.
"""
field_names, defer = self.deferred_loading
if not field_names:
return
orig_opts = self.get_meta()
seen = {}
must_include = {orig_opts.concrete_model: {orig_opts.pk}}
for field_name in field_names:
parts = field_name.split(LOOKUP_SEP)
cur_model = self.model._meta.concrete_model
opts = orig_opts
for name in parts[:-1]:
old_model = cur_model
source = opts.get_field(name)
if is_reverse_o2o(source):
cur_model = source.related_model
else:
cur_model = source.remote_field.model
opts = cur_model._meta
# Even if we're "just passing through" this model, we must add
# both the current model's pk and the related reference field
# (if it's not a reverse relation) to the things we select.
if not is_reverse_o2o(source):
must_include[old_model].add(source)
add_to_dict(must_include, cur_model, opts.pk)
field = opts.get_field(parts[-1])
is_reverse_object = field.auto_created and not field.concrete
model = field.related_model if is_reverse_object else field.model
model = model._meta.concrete_model
if model == opts.model:
model = cur_model
if not is_reverse_o2o(field):
add_to_dict(seen, model, field)
if defer:
# We need to load all fields for each model, except those that
# appear in "seen" (for all models that appear in "seen"). The only
# slight complexity here is handling fields that exist on parent
# models.
workset = {}
for model, values in six.iteritems(seen):
for field in model._meta.fields:
if field in values:
continue
m = field.model._meta.concrete_model
add_to_dict(workset, m, field)
for model, values in six.iteritems(must_include):
# If we haven't included a model in workset, we don't add the
# corresponding must_include fields for that model, since an
# empty set means "include all fields". That's why there's no
# "else" branch here.
if model in workset:
workset[model].update(values)
for model, values in six.iteritems(workset):
callback(target, model, values)
else:
for model, values in six.iteritems(must_include):
if model in seen:
seen[model].update(values)
else:
# As we've passed through this model, but not explicitly
# included any fields, we have to make sure it's mentioned
# so that only the "must include" fields are pulled in.
seen[model] = values
# Now ensure that every model in the inheritance chain is mentioned
# in the parent list. Again, it must be mentioned to ensure that
# only "must include" fields are pulled in.
for model in orig_opts.get_parent_list():
if model not in seen:
seen[model] = set()
for model, values in six.iteritems(seen):
callback(target, model, values)
def table_alias(self, table_name, create=False):
"""
Returns a table alias for the given table_name and whether this is a
new alias or not.
If 'create' is true, a new alias is always created. Otherwise, the
most recently created alias for the table (if one exists) is reused.
"""
alias_list = self.table_map.get(table_name)
if not create and alias_list:
alias = alias_list[0]
self.alias_refcount[alias] += 1
return alias, False
# Create a new alias for this table.
if alias_list:
alias = '%s%d' % (self.alias_prefix, len(self.alias_map) + 1)
alias_list.append(alias)
else:
# The first occurrence of a table uses the table name directly.
alias = table_name
self.table_map[alias] = [alias]
self.alias_refcount[alias] = 1
self.tables.append(alias)
return alias, True
def ref_alias(self, alias):
""" Increases the reference count for this alias. """
self.alias_refcount[alias] += 1
def unref_alias(self, alias, amount=1):
""" Decreases the reference count for this alias. """
self.alias_refcount[alias] -= amount
def promote_joins(self, aliases):
"""
Promotes recursively the join type of given aliases and its children to
an outer join. If 'unconditional' is False, the join is only promoted if
it is nullable or the parent join is an outer join.
The children promotion is done to avoid join chains that contain a LOUTER
b INNER c. So, if we have currently a INNER b INNER c and a->b is promoted,
then we must also promote b->c automatically, or otherwise the promotion
of a->b doesn't actually change anything in the query results.
"""
aliases = list(aliases)
while aliases:
alias = aliases.pop(0)
if self.alias_map[alias].join_type is None:
# This is the base table (first FROM entry) - this table
# isn't really joined at all in the query, so we should not
# alter its join type.
continue
# Only the first alias (skipped above) should have None join_type
assert self.alias_map[alias].join_type is not None
parent_alias = self.alias_map[alias].parent_alias
parent_louter = (
parent_alias
and self.alias_map[parent_alias].join_type == LOUTER)
already_louter = self.alias_map[alias].join_type == LOUTER
if ((self.alias_map[alias].nullable or parent_louter) and
not already_louter):
self.alias_map[alias] = self.alias_map[alias].promote()
# Join type of 'alias' changed, so re-examine all aliases that
# refer to this one.
aliases.extend(
join for join in self.alias_map.keys()
if (self.alias_map[join].parent_alias == alias
and join not in aliases))
def demote_joins(self, aliases):
"""
Change join type from LOUTER to INNER for all joins in aliases.
Similarly to promote_joins(), this method must ensure no join chains
containing first an outer, then an inner join are generated. If we
are demoting b->c join in chain a LOUTER b LOUTER c then we must
demote a->b automatically, or otherwise the demotion of b->c doesn't
actually change anything in the query results. .
"""
aliases = list(aliases)
while aliases:
alias = aliases.pop(0)
if self.alias_map[alias].join_type == LOUTER:
self.alias_map[alias] = self.alias_map[alias].demote()
parent_alias = self.alias_map[alias].parent_alias
if self.alias_map[parent_alias].join_type == INNER:
aliases.append(parent_alias)
def reset_refcounts(self, to_counts):
"""
This method will reset reference counts for aliases so that they match
the value passed in :param to_counts:.
"""
for alias, cur_refcount in self.alias_refcount.copy().items():
unref_amount = cur_refcount - to_counts.get(alias, 0)
self.unref_alias(alias, unref_amount)
def change_aliases(self, change_map):
"""
Changes the aliases in change_map (which maps old-alias -> new-alias),
relabelling any references to them in select columns and the where
clause.
"""
assert set(change_map.keys()).intersection(set(change_map.values())) == set()
def relabel_column(col):
if isinstance(col, (list, tuple)):
old_alias = col[0]
return (change_map.get(old_alias, old_alias), col[1])
else:
return col.relabeled_clone(change_map)
# 1. Update references in "select" (normal columns plus aliases),
# "group by" and "where".
self.where.relabel_aliases(change_map)
if isinstance(self.group_by, list):
self.group_by = [relabel_column(col) for col in self.group_by]
self.select = [col.relabeled_clone(change_map) for col in self.select]
if self._annotations:
self._annotations = OrderedDict(
(key, relabel_column(col)) for key, col in self._annotations.items())
# 2. Rename the alias in the internal table/alias datastructures.
for old_alias, new_alias in six.iteritems(change_map):
if old_alias not in self.alias_map:
continue
alias_data = self.alias_map[old_alias].relabeled_clone(change_map)
self.alias_map[new_alias] = alias_data
self.alias_refcount[new_alias] = self.alias_refcount[old_alias]
del self.alias_refcount[old_alias]
del self.alias_map[old_alias]
table_aliases = self.table_map[alias_data.table_name]
for pos, alias in enumerate(table_aliases):
if alias == old_alias:
table_aliases[pos] = new_alias
break
for pos, alias in enumerate(self.tables):
if alias == old_alias:
self.tables[pos] = new_alias
break
self.external_aliases = {change_map.get(alias, alias)
for alias in self.external_aliases}
def bump_prefix(self, outer_query):
"""
Changes the alias prefix to the next letter in the alphabet in a way
that the outer query's aliases and this query's aliases will not
conflict. Even tables that previously had no alias will get an alias
after this call.
"""
def prefix_gen():
"""
Generates a sequence of characters in alphabetical order:
-> 'A', 'B', 'C', ...
When the alphabet is finished, the sequence will continue with the
Cartesian product:
-> 'AA', 'AB', 'AC', ...
"""
alphabet = ascii_uppercase
prefix = chr(ord(self.alias_prefix) + 1)
yield prefix
for n in count(1):
seq = alphabet[alphabet.index(prefix):] if prefix else alphabet
for s in product(seq, repeat=n):
yield ''.join(s)
prefix = None
if self.alias_prefix != outer_query.alias_prefix:
# No clashes between self and outer query should be possible.
return
local_recursion_limit = 127 # explicitly avoid infinite loop
for pos, prefix in enumerate(prefix_gen()):
if prefix not in self.subq_aliases:
self.alias_prefix = prefix
break
if pos > local_recursion_limit:
raise RuntimeError(
'Maximum recursion depth exceeded: too many subqueries.'
)
self.subq_aliases = self.subq_aliases.union([self.alias_prefix])
outer_query.subq_aliases = outer_query.subq_aliases.union(self.subq_aliases)
change_map = OrderedDict()
for pos, alias in enumerate(self.tables):
new_alias = '%s%d' % (self.alias_prefix, pos)
change_map[alias] = new_alias
self.tables[pos] = new_alias
self.change_aliases(change_map)
def get_initial_alias(self):
"""
Returns the first alias for this query, after increasing its reference
count.
"""
if self.tables:
alias = self.tables[0]
self.ref_alias(alias)
else:
alias = self.join(BaseTable(self.get_meta().db_table, None))
return alias
def count_active_tables(self):
"""
Returns the number of tables in this query with a non-zero reference
count. Note that after execution, the reference counts are zeroed, so
tables added in compiler will not be seen by this method.
"""
return len([1 for count in self.alias_refcount.values() if count])
def join(self, join, reuse=None):
"""
Returns an alias for the join in 'connection', either reusing an
existing alias for that join or creating a new one. 'connection' is a
tuple (lhs, table, join_cols) where 'lhs' is either an existing
table alias or a table name. 'join_cols' is a tuple of tuples containing
columns to join on ((l_id1, r_id1), (l_id2, r_id2)). The join corresponds
to the SQL equivalent of::
lhs.l_id1 = table.r_id1 AND lhs.l_id2 = table.r_id2
The 'reuse' parameter can be either None which means all joins
(matching the connection) are reusable, or it can be a set containing
the aliases that can be reused.
A join is always created as LOUTER if the lhs alias is LOUTER to make
sure we do not generate chains like t1 LOUTER t2 INNER t3. All new
joins are created as LOUTER if nullable is True.
If 'nullable' is True, the join can potentially involve NULL values and
is a candidate for promotion (to "left outer") when combining querysets.
The 'join_field' is the field we are joining along (if any).
"""
reuse = [a for a, j in self.alias_map.items()
if (reuse is None or a in reuse) and j == join]
if reuse:
self.ref_alias(reuse[0])
return reuse[0]
# No reuse is possible, so we need a new alias.
alias, _ = self.table_alias(join.table_name, create=True)
if join.join_type:
if self.alias_map[join.parent_alias].join_type == LOUTER or join.nullable:
join_type = LOUTER
else:
join_type = INNER
join.join_type = join_type
join.table_alias = alias
self.alias_map[alias] = join
return alias
def join_parent_model(self, opts, model, alias, seen):
"""
Makes sure the given 'model' is joined in the query. If 'model' isn't
a parent of 'opts' or if it is None this method is a no-op.
The 'alias' is the root alias for starting the join, 'seen' is a dict
of model -> alias of existing joins. It must also contain a mapping
of None -> some alias. This will be returned in the no-op case.
"""
if model in seen:
return seen[model]
chain = opts.get_base_chain(model)
if not chain:
return alias
curr_opts = opts
for int_model in chain:
if int_model in seen:
curr_opts = int_model._meta
alias = seen[int_model]
continue
# Proxy model have elements in base chain
# with no parents, assign the new options
# object and skip to the next base in that
# case
if not curr_opts.parents[int_model]:
curr_opts = int_model._meta
continue
link_field = curr_opts.get_ancestor_link(int_model)
_, _, _, joins, _ = self.setup_joins(
[link_field.name], curr_opts, alias)
curr_opts = int_model._meta
alias = seen[int_model] = joins[-1]
return alias or seen[None]
def add_aggregate(self, aggregate, model, alias, is_summary):
warnings.warn(
"add_aggregate() is deprecated. Use add_annotation() instead.",
RemovedInDjango110Warning, stacklevel=2)
self.add_annotation(aggregate, alias, is_summary)
def add_annotation(self, annotation, alias, is_summary=False):
"""
Adds a single annotation expression to the Query
"""
annotation = annotation.resolve_expression(self, allow_joins=True, reuse=None,
summarize=is_summary)
self.append_annotation_mask([alias])
self.annotations[alias] = annotation
def prepare_lookup_value(self, value, lookups, can_reuse, allow_joins=True):
# Default lookup if none given is exact.
used_joins = []
if len(lookups) == 0:
lookups = ['exact']
# Interpret '__exact=None' as the sql 'is NULL'; otherwise, reject all
# uses of None as a query value.
if value is None:
if lookups[-1] not in ('exact', 'iexact'):
raise ValueError("Cannot use None as a query value")
lookups[-1] = 'isnull'
value = True
elif hasattr(value, 'resolve_expression'):
pre_joins = self.alias_refcount.copy()
value = value.resolve_expression(self, reuse=can_reuse, allow_joins=allow_joins)
used_joins = [k for k, v in self.alias_refcount.items() if v > pre_joins.get(k, 0)]
# Subqueries need to use a different set of aliases than the
# outer query. Call bump_prefix to change aliases of the inner
# query (the value).
if hasattr(value, 'query') and hasattr(value.query, 'bump_prefix'):
value = value._clone()
value.query.bump_prefix(self)
if hasattr(value, 'bump_prefix'):
value = value.clone()
value.bump_prefix(self)
# For Oracle '' is equivalent to null. The check needs to be done
# at this stage because join promotion can't be done at compiler
# stage. Using DEFAULT_DB_ALIAS isn't nice, but it is the best we
# can do here. Similar thing is done in is_nullable(), too.
if (connections[DEFAULT_DB_ALIAS].features.interprets_empty_strings_as_nulls and
lookups[-1] == 'exact' and value == ''):
value = True
lookups[-1] = 'isnull'
return value, lookups, used_joins
def solve_lookup_type(self, lookup):
"""
Solve the lookup type from the lookup (eg: 'foobar__id__icontains')
"""
lookup_splitted = lookup.split(LOOKUP_SEP)
if self._annotations:
expression, expression_lookups = refs_expression(lookup_splitted, self.annotations)
if expression:
return expression_lookups, (), expression
_, field, _, lookup_parts = self.names_to_path(lookup_splitted, self.get_meta())
field_parts = lookup_splitted[0:len(lookup_splitted) - len(lookup_parts)]
if len(lookup_parts) == 0:
lookup_parts = ['exact']
elif len(lookup_parts) > 1:
if not field_parts:
raise FieldError(
'Invalid lookup "%s" for model %s".' %
(lookup, self.get_meta().model.__name__))
return lookup_parts, field_parts, False
def check_query_object_type(self, value, opts, field):
"""
Checks whether the object passed while querying is of the correct type.
If not, it raises a ValueError specifying the wrong object.
"""
if hasattr(value, '_meta'):
if not check_rel_lookup_compatibility(value._meta.model, opts, field):
raise ValueError(
'Cannot query "%s": Must be "%s" instance.' %
(value, opts.object_name))
def check_related_objects(self, field, value, opts):
"""
Checks the type of object passed to query relations.
"""
if field.is_relation:
# QuerySets implement is_compatible_query_object_type() to
# determine compatibility with the given field.
if hasattr(value, 'is_compatible_query_object_type'):
if not value.is_compatible_query_object_type(opts, field):
raise ValueError(
'Cannot use QuerySet for "%s": Use a QuerySet for "%s".' %
(value.model._meta.model_name, opts.object_name)
)
elif hasattr(value, '_meta'):
self.check_query_object_type(value, opts, field)
elif hasattr(value, '__iter__'):
for v in value:
self.check_query_object_type(v, opts, field)
def build_lookup(self, lookups, lhs, rhs):
"""
Tries to extract transforms and lookup from given lhs.
The lhs value is something that works like SQLExpression.
The rhs value is what the lookup is going to compare against.
The lookups is a list of names to extract using get_lookup()
and get_transform().
"""
lookups = lookups[:]
while lookups:
name = lookups[0]
# If there is just one part left, try first get_lookup() so
# that if the lhs supports both transform and lookup for the
# name, then lookup will be picked.
if len(lookups) == 1:
final_lookup = lhs.get_lookup(name)
if not final_lookup:
# We didn't find a lookup. We are going to interpret
# the name as transform, and do an Exact lookup against
# it.
lhs = self.try_transform(lhs, name, lookups)
final_lookup = lhs.get_lookup('exact')
return final_lookup(lhs, rhs)
lhs = self.try_transform(lhs, name, lookups)
lookups = lookups[1:]
def try_transform(self, lhs, name, rest_of_lookups):
"""
Helper method for build_lookup. Tries to fetch and initialize
a transform for name parameter from lhs.
"""
transform_class = lhs.get_transform(name)
if transform_class:
return transform_class(lhs)
else:
raise FieldError(
"Unsupported lookup '%s' for %s or join on the field not "
"permitted." %
(name, lhs.output_field.__class__.__name__))
def build_filter(self, filter_expr, branch_negated=False, current_negated=False,
can_reuse=None, connector=AND, allow_joins=True, split_subq=True):
"""
Builds a WhereNode for a single filter clause, but doesn't add it
to this Query. Query.add_q() will then add this filter to the where
Node.
The 'branch_negated' tells us if the current branch contains any
negations. This will be used to determine if subqueries are needed.
The 'current_negated' is used to determine if the current filter is
negated or not and this will be used to determine if IS NULL filtering
is needed.
The difference between current_netageted and branch_negated is that
branch_negated is set on first negation, but current_negated is
flipped for each negation.
Note that add_filter will not do any negating itself, that is done
upper in the code by add_q().
The 'can_reuse' is a set of reusable joins for multijoins.
The method will create a filter clause that can be added to the current
query. However, if the filter isn't added to the query then the caller
is responsible for unreffing the joins used.
"""
if isinstance(filter_expr, dict):
raise FieldError("Cannot parse keyword query as dict")
arg, value = filter_expr
if not arg:
raise FieldError("Cannot parse keyword query %r" % arg)
lookups, parts, reffed_expression = self.solve_lookup_type(arg)
if not allow_joins and len(parts) > 1:
raise FieldError("Joined field references are not permitted in this query")
# Work out the lookup type and remove it from the end of 'parts',
# if necessary.
value, lookups, used_joins = self.prepare_lookup_value(value, lookups, can_reuse, allow_joins)
clause = self.where_class()
if reffed_expression:
condition = self.build_lookup(lookups, reffed_expression, value)
clause.add(condition, AND)
return clause, []
opts = self.get_meta()
alias = self.get_initial_alias()
allow_many = not branch_negated or not split_subq
try:
field, sources, opts, join_list, path = self.setup_joins(
parts, opts, alias, can_reuse=can_reuse, allow_many=allow_many)
# Prevent iterator from being consumed by check_related_objects()
if isinstance(value, Iterator):
value = list(value)
self.check_related_objects(field, value, opts)
# split_exclude() needs to know which joins were generated for the
# lookup parts
self._lookup_joins = join_list
except MultiJoin as e:
return self.split_exclude(filter_expr, LOOKUP_SEP.join(parts[:e.level]),
can_reuse, e.names_with_path)
if can_reuse is not None:
can_reuse.update(join_list)
used_joins = set(used_joins).union(set(join_list))
targets, alias, join_list = self.trim_joins(sources, join_list, path)
if field.is_relation:
# No support for transforms for relational fields
num_lookups = len(lookups)
if num_lookups > 1:
raise FieldError('Related Field got invalid lookup: {}'.format(lookups[0]))
assert num_lookups > 0 # Likely a bug in Django if this fails.
lookup_class = field.get_lookup(lookups[0])
if len(targets) == 1:
lhs = targets[0].get_col(alias, field)
else:
lhs = MultiColSource(alias, targets, sources, field)
condition = lookup_class(lhs, value)
lookup_type = lookup_class.lookup_name
else:
col = targets[0].get_col(alias, field)
condition = self.build_lookup(lookups, col, value)
lookup_type = condition.lookup_name
clause.add(condition, AND)
require_outer = lookup_type == 'isnull' and value is True and not current_negated
if current_negated and (lookup_type != 'isnull' or value is False):
require_outer = True
if (lookup_type != 'isnull' and (
self.is_nullable(targets[0]) or
self.alias_map[join_list[-1]].join_type == LOUTER)):
# The condition added here will be SQL like this:
# NOT (col IS NOT NULL), where the first NOT is added in
# upper layers of code. The reason for addition is that if col
# is null, then col != someval will result in SQL "unknown"
# which isn't the same as in Python. The Python None handling
# is wanted, and it can be gotten by
# (col IS NULL OR col != someval)
# <=>
# NOT (col IS NOT NULL AND col = someval).
lookup_class = targets[0].get_lookup('isnull')
clause.add(lookup_class(targets[0].get_col(alias, sources[0]), False), AND)
return clause, used_joins if not require_outer else ()
def add_filter(self, filter_clause):
self.add_q(Q(**{filter_clause[0]: filter_clause[1]}))
def add_q(self, q_object):
"""
A preprocessor for the internal _add_q(). Responsible for doing final
join promotion.
"""
# For join promotion this case is doing an AND for the added q_object
# and existing conditions. So, any existing inner join forces the join
# type to remain inner. Existing outer joins can however be demoted.
# (Consider case where rel_a is LOUTER and rel_a__col=1 is added - if
# rel_a doesn't produce any rows, then the whole condition must fail.
# So, demotion is OK.
existing_inner = set(
(a for a in self.alias_map if self.alias_map[a].join_type == INNER))
clause, _ = self._add_q(q_object, self.used_aliases)
if clause:
self.where.add(clause, AND)
self.demote_joins(existing_inner)
def _add_q(self, q_object, used_aliases, branch_negated=False,
current_negated=False, allow_joins=True, split_subq=True):
"""
Adds a Q-object to the current filter.
"""
connector = q_object.connector
current_negated = current_negated ^ q_object.negated
branch_negated = branch_negated or q_object.negated
target_clause = self.where_class(connector=connector,
negated=q_object.negated)
joinpromoter = JoinPromoter(q_object.connector, len(q_object.children), current_negated)
for child in q_object.children:
if isinstance(child, Node):
child_clause, needed_inner = self._add_q(
child, used_aliases, branch_negated,
current_negated, allow_joins, split_subq)
joinpromoter.add_votes(needed_inner)
else:
child_clause, needed_inner = self.build_filter(
child, can_reuse=used_aliases, branch_negated=branch_negated,
current_negated=current_negated, connector=connector,
allow_joins=allow_joins, split_subq=split_subq,
)
joinpromoter.add_votes(needed_inner)
if child_clause:
target_clause.add(child_clause, connector)
needed_inner = joinpromoter.update_join_types(self)
return target_clause, needed_inner
def names_to_path(self, names, opts, allow_many=True, fail_on_missing=False):
"""
Walks the list of names and turns them into PathInfo tuples. Note that
a single name in 'names' can generate multiple PathInfos (m2m for
example).
'names' is the path of names to travel, 'opts' is the model Options we
start the name resolving from, 'allow_many' is as for setup_joins().
If fail_on_missing is set to True, then a name that can't be resolved
will generate a FieldError.
Returns a list of PathInfo tuples. In addition returns the final field
(the last used join field), and target (which is a field guaranteed to
contain the same value as the final field). Finally, the method returns
those names that weren't found (which are likely transforms and the
final lookup).
"""
path, names_with_path = [], []
for pos, name in enumerate(names):
cur_names_with_path = (name, [])
if name == 'pk':
name = opts.pk.name
field = None
try:
field = opts.get_field(name)
except FieldDoesNotExist:
if name in self.annotation_select:
field = self.annotation_select[name].output_field
if field is not None:
# Fields that contain one-to-many relations with a generic
# model (like a GenericForeignKey) cannot generate reverse
# relations and therefore cannot be used for reverse querying.
if field.is_relation and not field.related_model:
raise FieldError(
"Field %r does not generate an automatic reverse "
"relation and therefore cannot be used for reverse "
"querying. If it is a GenericForeignKey, consider "
"adding a GenericRelation." % name
)
try:
model = field.model._meta.concrete_model
except AttributeError:
model = None
else:
# We didn't find the current field, so move position back
# one step.
pos -= 1
if pos == -1 or fail_on_missing:
field_names = list(get_field_names_from_opts(opts))
available = sorted(field_names + list(self.annotation_select))
raise FieldError("Cannot resolve keyword %r into field. "
"Choices are: %s" % (name, ", ".join(available)))
break
# Check if we need any joins for concrete inheritance cases (the
# field lives in parent, but we are currently in one of its
# children)
if model is not opts.model:
# The field lives on a base class of the current model.
# Skip the chain of proxy to the concrete proxied model
proxied_model = opts.concrete_model
for int_model in opts.get_base_chain(model):
if int_model is proxied_model:
opts = int_model._meta
else:
final_field = opts.parents[int_model]
targets = (final_field.remote_field.get_related_field(),)
opts = int_model._meta
path.append(PathInfo(final_field.model._meta, opts, targets, final_field, False, True))
cur_names_with_path[1].append(
PathInfo(final_field.model._meta, opts, targets, final_field, False, True)
)
if hasattr(field, 'get_path_info'):
pathinfos = field.get_path_info()
if not allow_many:
for inner_pos, p in enumerate(pathinfos):
if p.m2m:
cur_names_with_path[1].extend(pathinfos[0:inner_pos + 1])
names_with_path.append(cur_names_with_path)
raise MultiJoin(pos + 1, names_with_path)
last = pathinfos[-1]
path.extend(pathinfos)
final_field = last.join_field
opts = last.to_opts
targets = last.target_fields
cur_names_with_path[1].extend(pathinfos)
names_with_path.append(cur_names_with_path)
else:
# Local non-relational field.
final_field = field
targets = (field,)
if fail_on_missing and pos + 1 != len(names):
raise FieldError(
"Cannot resolve keyword %r into field. Join on '%s'"
" not permitted." % (names[pos + 1], name))
break
return path, final_field, targets, names[pos + 1:]
def setup_joins(self, names, opts, alias, can_reuse=None, allow_many=True):
"""
Compute the necessary table joins for the passage through the fields
given in 'names'. 'opts' is the Options class for the current model
(which gives the table we are starting from), 'alias' is the alias for
the table to start the joining from.
The 'can_reuse' defines the reverse foreign key joins we can reuse. It
can be None in which case all joins are reusable or a set of aliases
that can be reused. Note that non-reverse foreign keys are always
reusable when using setup_joins().
If 'allow_many' is False, then any reverse foreign key seen will
generate a MultiJoin exception.
Returns the final field involved in the joins, the target field (used
for any 'where' constraint), the final 'opts' value, the joins and the
field path travelled to generate the joins.
The target field is the field containing the concrete value. Final
field can be something different, for example foreign key pointing to
that value. Final field is needed for example in some value
conversions (convert 'obj' in fk__id=obj to pk val using the foreign
key field for example).
"""
joins = [alias]
# First, generate the path for the names
path, final_field, targets, rest = self.names_to_path(
names, opts, allow_many, fail_on_missing=True)
# Then, add the path to the query's joins. Note that we can't trim
# joins at this stage - we will need the information about join type
# of the trimmed joins.
for join in path:
opts = join.to_opts
if join.direct:
nullable = self.is_nullable(join.join_field)
else:
nullable = True
connection = Join(opts.db_table, alias, None, INNER, join.join_field, nullable)
reuse = can_reuse if join.m2m else None
alias = self.join(connection, reuse=reuse)
joins.append(alias)
return final_field, targets, opts, joins, path
def trim_joins(self, targets, joins, path):
"""
The 'target' parameter is the final field being joined to, 'joins'
is the full list of join aliases. The 'path' contain the PathInfos
used to create the joins.
Returns the final target field and table alias and the new active
joins.
We will always trim any direct join if we have the target column
available already in the previous table. Reverse joins can't be
trimmed as we don't know if there is anything on the other side of
the join.
"""
joins = joins[:]
for pos, info in enumerate(reversed(path)):
if len(joins) == 1 or not info.direct:
break
join_targets = set(t.column for t in info.join_field.foreign_related_fields)
cur_targets = set(t.column for t in targets)
if not cur_targets.issubset(join_targets):
break
targets = tuple(r[0] for r in info.join_field.related_fields if r[1].column in cur_targets)
self.unref_alias(joins.pop())
return targets, joins[-1], joins
def resolve_ref(self, name, allow_joins=True, reuse=None, summarize=False):
if not allow_joins and LOOKUP_SEP in name:
raise FieldError("Joined field references are not permitted in this query")
if name in self.annotations:
if summarize:
# Summarize currently means we are doing an aggregate() query
# which is executed as a wrapped subquery if any of the
# aggregate() elements reference an existing annotation. In
# that case we need to return a Ref to the subquery's annotation.
return Ref(name, self.annotation_select[name])
else:
return self.annotation_select[name]
else:
field_list = name.split(LOOKUP_SEP)
field, sources, opts, join_list, path = self.setup_joins(
field_list, self.get_meta(),
self.get_initial_alias(), reuse)
targets, _, join_list = self.trim_joins(sources, join_list, path)
if len(targets) > 1:
raise FieldError("Referencing multicolumn fields with F() objects "
"isn't supported")
if reuse is not None:
reuse.update(join_list)
col = targets[0].get_col(join_list[-1], sources[0])
return col
def split_exclude(self, filter_expr, prefix, can_reuse, names_with_path):
"""
When doing an exclude against any kind of N-to-many relation, we need
to use a subquery. This method constructs the nested query, given the
original exclude filter (filter_expr) and the portion up to the first
N-to-many relation field.
As an example we could have original filter ~Q(child__name='foo').
We would get here with filter_expr = child__name, prefix = child and
can_reuse is a set of joins usable for filters in the original query.
We will turn this into equivalent of:
WHERE NOT (pk IN (SELECT parent_id FROM thetable
WHERE name = 'foo' AND parent_id IS NOT NULL))
It might be worth it to consider using WHERE NOT EXISTS as that has
saner null handling, and is easier for the backend's optimizer to
handle.
"""
# Generate the inner query.
query = Query(self.model)
query.add_filter(filter_expr)
query.clear_ordering(True)
# Try to have as simple as possible subquery -> trim leading joins from
# the subquery.
trimmed_prefix, contains_louter = query.trim_start(names_with_path)
# Add extra check to make sure the selected field will not be null
# since we are adding an IN <subquery> clause. This prevents the
# database from tripping over IN (...,NULL,...) selects and returning
# nothing
col = query.select[0]
select_field = col.target
alias = col.alias
if self.is_nullable(select_field):
lookup_class = select_field.get_lookup('isnull')
lookup = lookup_class(select_field.get_col(alias), False)
query.where.add(lookup, AND)
if alias in can_reuse:
pk = select_field.model._meta.pk
# Need to add a restriction so that outer query's filters are in effect for
# the subquery, too.
query.bump_prefix(self)
lookup_class = select_field.get_lookup('exact')
# Note that the query.select[0].alias is different from alias
# due to bump_prefix above.
lookup = lookup_class(pk.get_col(query.select[0].alias),
pk.get_col(alias))
query.where.add(lookup, AND)
query.external_aliases.add(alias)
condition, needed_inner = self.build_filter(
('%s__in' % trimmed_prefix, query),
current_negated=True, branch_negated=True, can_reuse=can_reuse)
if contains_louter:
or_null_condition, _ = self.build_filter(
('%s__isnull' % trimmed_prefix, True),
current_negated=True, branch_negated=True, can_reuse=can_reuse)
condition.add(or_null_condition, OR)
# Note that the end result will be:
# (outercol NOT IN innerq AND outercol IS NOT NULL) OR outercol IS NULL.
# This might look crazy but due to how IN works, this seems to be
# correct. If the IS NOT NULL check is removed then outercol NOT
# IN will return UNKNOWN. If the IS NULL check is removed, then if
# outercol IS NULL we will not match the row.
return condition, needed_inner
def set_empty(self):
self.where.add(NothingNode(), AND)
def is_empty(self):
return any(isinstance(c, NothingNode) for c in self.where.children)
def set_limits(self, low=None, high=None):
"""
Adjusts the limits on the rows retrieved. We use low/high to set these,
as it makes it more Pythonic to read and write. When the SQL query is
created, they are converted to the appropriate offset and limit values.
Any limits passed in here are applied relative to the existing
constraints. So low is added to the current low value and both will be
clamped to any existing high value.
"""
if high is not None:
if self.high_mark is not None:
self.high_mark = min(self.high_mark, self.low_mark + high)
else:
self.high_mark = self.low_mark + high
if low is not None:
if self.high_mark is not None:
self.low_mark = min(self.high_mark, self.low_mark + low)
else:
self.low_mark = self.low_mark + low
if self.low_mark == self.high_mark:
self.set_empty()
def clear_limits(self):
"""
Clears any existing limits.
"""
self.low_mark, self.high_mark = 0, None
def can_filter(self):
"""
Returns True if adding filters to this instance is still possible.
Typically, this means no limits or offsets have been put on the results.
"""
return not self.low_mark and self.high_mark is None
def clear_select_clause(self):
"""
Removes all fields from SELECT clause.
"""
self.select = []
self.default_cols = False
self.select_related = False
self.set_extra_mask(())
self.set_annotation_mask(())
def clear_select_fields(self):
"""
Clears the list of fields to select (but not extra_select columns).
Some queryset types completely replace any existing list of select
columns.
"""
self.select = []
self.values_select = []
def add_select(self, col):
self.default_cols = False
self.select.append(col)
def set_select(self, cols):
self.default_cols = False
self.select = cols
def add_distinct_fields(self, *field_names):
"""
Adds and resolves the given fields to the query's "distinct on" clause.
"""
self.distinct_fields = field_names
self.distinct = True
def add_fields(self, field_names, allow_m2m=True):
"""
Adds the given (model) fields to the select set. The field names are
added in the order specified.
"""
alias = self.get_initial_alias()
opts = self.get_meta()
try:
for name in field_names:
# Join promotion note - we must not remove any rows here, so
# if there is no existing joins, use outer join.
_, targets, _, joins, path = self.setup_joins(
name.split(LOOKUP_SEP), opts, alias, allow_many=allow_m2m)
targets, final_alias, joins = self.trim_joins(targets, joins, path)
for target in targets:
self.add_select(target.get_col(final_alias))
except MultiJoin:
raise FieldError("Invalid field name: '%s'" % name)
except FieldError:
if LOOKUP_SEP in name:
# For lookups spanning over relationships, show the error
# from the model on which the lookup failed.
raise
else:
names = sorted(list(get_field_names_from_opts(opts)) + list(self.extra)
+ list(self.annotation_select))
raise FieldError("Cannot resolve keyword %r into field. "
"Choices are: %s" % (name, ", ".join(names)))
def add_ordering(self, *ordering):
"""
Adds items from the 'ordering' sequence to the query's "order by"
clause. These items are either field names (not column names) --
possibly with a direction prefix ('-' or '?') -- or OrderBy
expressions.
If 'ordering' is empty, all ordering is cleared from the query.
"""
errors = []
for item in ordering:
if not hasattr(item, 'resolve_expression') and not ORDER_PATTERN.match(item):
errors.append(item)
if getattr(item, 'contains_aggregate', False):
raise FieldError(
'Using an aggregate in order_by() without also including '
'it in annotate() is not allowed: %s' % item
)
if errors:
raise FieldError('Invalid order_by arguments: %s' % errors)
if ordering:
self.order_by.extend(ordering)
else:
self.default_ordering = False
def clear_ordering(self, force_empty):
"""
Removes any ordering settings. If 'force_empty' is True, there will be
no ordering in the resulting query (not even the model's default).
"""
self.order_by = []
self.extra_order_by = ()
if force_empty:
self.default_ordering = False
def set_group_by(self):
"""
Expands the GROUP BY clause required by the query.
This will usually be the set of all non-aggregate fields in the
return data. If the database backend supports grouping by the
primary key, and the query would be equivalent, the optimization
will be made automatically.
"""
self.group_by = []
for col in self.select:
self.group_by.append(col)
if self.annotation_select:
for alias, annotation in six.iteritems(self.annotation_select):
for col in annotation.get_group_by_cols():
self.group_by.append(col)
def add_select_related(self, fields):
"""
Sets up the select_related data structure so that we only select
certain related models (as opposed to all models, when
self.select_related=True).
"""
if isinstance(self.select_related, bool):
field_dict = {}
else:
field_dict = self.select_related
for field in fields:
d = field_dict
for part in field.split(LOOKUP_SEP):
d = d.setdefault(part, {})
self.select_related = field_dict
def add_extra(self, select, select_params, where, params, tables, order_by):
"""
Adds data to the various extra_* attributes for user-created additions
to the query.
"""
if select:
# We need to pair any placeholder markers in the 'select'
# dictionary with their parameters in 'select_params' so that
# subsequent updates to the select dictionary also adjust the
# parameters appropriately.
select_pairs = OrderedDict()
if select_params:
param_iter = iter(select_params)
else:
param_iter = iter([])
for name, entry in select.items():
entry = force_text(entry)
entry_params = []
pos = entry.find("%s")
while pos != -1:
if pos == 0 or entry[pos - 1] != '%':
entry_params.append(next(param_iter))
pos = entry.find("%s", pos + 2)
select_pairs[name] = (entry, entry_params)
# This is order preserving, since self.extra_select is an OrderedDict.
self.extra.update(select_pairs)
if where or params:
self.where.add(ExtraWhere(where, params), AND)
if tables:
self.extra_tables += tuple(tables)
if order_by:
self.extra_order_by = order_by
def clear_deferred_loading(self):
"""
Remove any fields from the deferred loading set.
"""
self.deferred_loading = (set(), True)
def add_deferred_loading(self, field_names):
"""
Add the given list of model field names to the set of fields to
exclude from loading from the database when automatic column selection
is done. The new field names are added to any existing field names that
are deferred (or removed from any existing field names that are marked
as the only ones for immediate loading).
"""
# Fields on related models are stored in the literal double-underscore
# format, so that we can use a set datastructure. We do the foo__bar
# splitting and handling when computing the SQL column names (as part of
# get_columns()).
existing, defer = self.deferred_loading
if defer:
# Add to existing deferred names.
self.deferred_loading = existing.union(field_names), True
else:
# Remove names from the set of any existing "immediate load" names.
self.deferred_loading = existing.difference(field_names), False
def add_immediate_loading(self, field_names):
"""
Add the given list of model field names to the set of fields to
retrieve when the SQL is executed ("immediate loading" fields). The
field names replace any existing immediate loading field names. If
there are field names already specified for deferred loading, those
names are removed from the new field_names before storing the new names
for immediate loading. (That is, immediate loading overrides any
existing immediate values, but respects existing deferrals.)
"""
existing, defer = self.deferred_loading
field_names = set(field_names)
if 'pk' in field_names:
field_names.remove('pk')
field_names.add(self.get_meta().pk.name)
if defer:
# Remove any existing deferred names from the current set before
# setting the new names.
self.deferred_loading = field_names.difference(existing), False
else:
# Replace any existing "immediate load" field names.
self.deferred_loading = field_names, False
def get_loaded_field_names(self):
"""
If any fields are marked to be deferred, returns a dictionary mapping
models to a set of names in those fields that will be loaded. If a
model is not in the returned dictionary, none of its fields are
deferred.
If no fields are marked for deferral, returns an empty dictionary.
"""
# We cache this because we call this function multiple times
# (compiler.fill_related_selections, query.iterator)
try:
return self._loaded_field_names_cache
except AttributeError:
collection = {}
self.deferred_to_data(collection, self.get_loaded_field_names_cb)
self._loaded_field_names_cache = collection
return collection
def get_loaded_field_names_cb(self, target, model, fields):
"""
Callback used by get_deferred_field_names().
"""
target[model] = {f.attname for f in fields}
def set_aggregate_mask(self, names):
warnings.warn(
"set_aggregate_mask() is deprecated. Use set_annotation_mask() instead.",
RemovedInDjango110Warning, stacklevel=2)
self.set_annotation_mask(names)
def set_annotation_mask(self, names):
"Set the mask of annotations that will actually be returned by the SELECT"
if names is None:
self.annotation_select_mask = None
else:
self.annotation_select_mask = set(names)
self._annotation_select_cache = None
def append_aggregate_mask(self, names):
warnings.warn(
"append_aggregate_mask() is deprecated. Use append_annotation_mask() instead.",
RemovedInDjango110Warning, stacklevel=2)
self.append_annotation_mask(names)
def append_annotation_mask(self, names):
if self.annotation_select_mask is not None:
self.set_annotation_mask(set(names).union(self.annotation_select_mask))
def set_extra_mask(self, names):
"""
Set the mask of extra select items that will be returned by SELECT,
we don't actually remove them from the Query since they might be used
later
"""
if names is None:
self.extra_select_mask = None
else:
self.extra_select_mask = set(names)
self._extra_select_cache = None
@property
def annotation_select(self):
"""The OrderedDict of aggregate columns that are not masked, and should
be used in the SELECT clause.
This result is cached for optimization purposes.
"""
if self._annotation_select_cache is not None:
return self._annotation_select_cache
elif not self._annotations:
return {}
elif self.annotation_select_mask is not None:
self._annotation_select_cache = OrderedDict(
(k, v) for k, v in self.annotations.items()
if k in self.annotation_select_mask
)
return self._annotation_select_cache
else:
return self.annotations
@property
def aggregate_select(self):
warnings.warn(
"aggregate_select() is deprecated. Use annotation_select() instead.",
RemovedInDjango110Warning, stacklevel=2)
return self.annotation_select
@property
def extra_select(self):
if self._extra_select_cache is not None:
return self._extra_select_cache
if not self._extra:
return {}
elif self.extra_select_mask is not None:
self._extra_select_cache = OrderedDict(
(k, v) for k, v in self.extra.items()
if k in self.extra_select_mask
)
return self._extra_select_cache
else:
return self.extra
def trim_start(self, names_with_path):
"""
Trims joins from the start of the join path. The candidates for trim
are the PathInfos in names_with_path structure that are m2m joins.
Also sets the select column so the start matches the join.
This method is meant to be used for generating the subquery joins &
cols in split_exclude().
Returns a lookup usable for doing outerq.filter(lookup=self). Returns
also if the joins in the prefix contain a LEFT OUTER join.
_"""
all_paths = []
for _, paths in names_with_path:
all_paths.extend(paths)
contains_louter = False
# Trim and operate only on tables that were generated for
# the lookup part of the query. That is, avoid trimming
# joins generated for F() expressions.
lookup_tables = [t for t in self.tables if t in self._lookup_joins or t == self.tables[0]]
for trimmed_paths, path in enumerate(all_paths):
if path.m2m:
break
if self.alias_map[lookup_tables[trimmed_paths + 1]].join_type == LOUTER:
contains_louter = True
alias = lookup_tables[trimmed_paths]
self.unref_alias(alias)
# The path.join_field is a Rel, lets get the other side's field
join_field = path.join_field.field
# Build the filter prefix.
paths_in_prefix = trimmed_paths
trimmed_prefix = []
for name, path in names_with_path:
if paths_in_prefix - len(path) < 0:
break
trimmed_prefix.append(name)
paths_in_prefix -= len(path)
trimmed_prefix.append(
join_field.foreign_related_fields[0].name)
trimmed_prefix = LOOKUP_SEP.join(trimmed_prefix)
# Lets still see if we can trim the first join from the inner query
# (that is, self). We can't do this for LEFT JOINs because we would
# miss those rows that have nothing on the outer side.
if self.alias_map[lookup_tables[trimmed_paths + 1]].join_type != LOUTER:
select_fields = [r[0] for r in join_field.related_fields]
select_alias = lookup_tables[trimmed_paths + 1]
self.unref_alias(lookup_tables[trimmed_paths])
extra_restriction = join_field.get_extra_restriction(
self.where_class, None, lookup_tables[trimmed_paths + 1])
if extra_restriction:
self.where.add(extra_restriction, AND)
else:
# TODO: It might be possible to trim more joins from the start of the
# inner query if it happens to have a longer join chain containing the
# values in select_fields. Lets punt this one for now.
select_fields = [r[1] for r in join_field.related_fields]
select_alias = lookup_tables[trimmed_paths]
# The found starting point is likely a Join instead of a BaseTable reference.
# But the first entry in the query's FROM clause must not be a JOIN.
for table in self.tables:
if self.alias_refcount[table] > 0:
self.alias_map[table] = BaseTable(self.alias_map[table].table_name, table)
break
self.set_select([f.get_col(select_alias) for f in select_fields])
return trimmed_prefix, contains_louter
def is_nullable(self, field):
"""
A helper to check if the given field should be treated as nullable.
Some backends treat '' as null and Django treats such fields as
nullable for those backends. In such situations field.null can be
False even if we should treat the field as nullable.
"""
# We need to use DEFAULT_DB_ALIAS here, as QuerySet does not have
# (nor should it have) knowledge of which connection is going to be
# used. The proper fix would be to defer all decisions where
# is_nullable() is needed to the compiler stage, but that is not easy
# to do currently.
if ((connections[DEFAULT_DB_ALIAS].features.interprets_empty_strings_as_nulls)
and field.empty_strings_allowed):
return True
else:
return field.null
def get_order_dir(field, default='ASC'):
"""
Returns the field name and direction for an order specification. For
example, '-foo' is returned as ('foo', 'DESC').
The 'default' param is used to indicate which way no prefix (or a '+'
prefix) should sort. The '-' prefix always sorts the opposite way.
"""
dirn = ORDER_DIR[default]
if field[0] == '-':
return field[1:], dirn[1]
return field, dirn[0]
def add_to_dict(data, key, value):
"""
A helper function to add "value" to the set of values for "key", whether or
not "key" already exists.
"""
if key in data:
data[key].add(value)
else:
data[key] = {value}
def is_reverse_o2o(field):
"""
A little helper to check if the given field is reverse-o2o. The field is
expected to be some sort of relation field or related object.
"""
return field.is_relation and field.one_to_one and not field.concrete
class JoinPromoter(object):
"""
A class to abstract away join promotion problems for complex filter
conditions.
"""
def __init__(self, connector, num_children, negated):
self.connector = connector
self.negated = negated
if self.negated:
if connector == AND:
self.effective_connector = OR
else:
self.effective_connector = AND
else:
self.effective_connector = self.connector
self.num_children = num_children
# Maps of table alias to how many times it is seen as required for
# inner and/or outer joins.
self.votes = Counter()
def add_votes(self, votes):
"""
Add single vote per item to self.votes. Parameter can be any
iterable.
"""
self.votes.update(votes)
def update_join_types(self, query):
"""
Change join types so that the generated query is as efficient as
possible, but still correct. So, change as many joins as possible
to INNER, but don't make OUTER joins INNER if that could remove
results from the query.
"""
to_promote = set()
to_demote = set()
# The effective_connector is used so that NOT (a AND b) is treated
# similarly to (a OR b) for join promotion.
for table, votes in self.votes.items():
# We must use outer joins in OR case when the join isn't contained
# in all of the joins. Otherwise the INNER JOIN itself could remove
# valid results. Consider the case where a model with rel_a and
# rel_b relations is queried with rel_a__col=1 | rel_b__col=2. Now,
# if rel_a join doesn't produce any results is null (for example
# reverse foreign key or null value in direct foreign key), and
# there is a matching row in rel_b with col=2, then an INNER join
# to rel_a would remove a valid match from the query. So, we need
# to promote any existing INNER to LOUTER (it is possible this
# promotion in turn will be demoted later on).
if self.effective_connector == 'OR' and votes < self.num_children:
to_promote.add(table)
# If connector is AND and there is a filter that can match only
# when there is a joinable row, then use INNER. For example, in
# rel_a__col=1 & rel_b__col=2, if either of the rels produce NULL
# as join output, then the col=1 or col=2 can't match (as
# NULL=anything is always false).
# For the OR case, if all children voted for a join to be inner,
# then we can use INNER for the join. For example:
# (rel_a__col__icontains=Alex | rel_a__col__icontains=Russell)
# then if rel_a doesn't produce any rows, the whole condition
# can't match. Hence we can safely use INNER join.
if self.effective_connector == 'AND' or (
self.effective_connector == 'OR' and votes == self.num_children):
to_demote.add(table)
# Finally, what happens in cases where we have:
# (rel_a__col=1|rel_b__col=2) & rel_a__col__gte=0
# Now, we first generate the OR clause, and promote joins for it
# in the first if branch above. Both rel_a and rel_b are promoted
# to LOUTER joins. After that we do the AND case. The OR case
# voted no inner joins but the rel_a__col__gte=0 votes inner join
# for rel_a. We demote it back to INNER join (in AND case a single
# vote is enough). The demotion is OK, if rel_a doesn't produce
# rows, then the rel_a__col__gte=0 clause can't be true, and thus
# the whole clause must be false. So, it is safe to use INNER
# join.
# Note that in this example we could just as well have the __gte
# clause and the OR clause swapped. Or we could replace the __gte
# clause with an OR clause containing rel_a__col=1|rel_a__col=2,
# and again we could safely demote to INNER.
query.promote_joins(to_promote)
query.demote_joins(to_demote)
return to_demote
|
iabdalkader/micropython | refs/heads/master | tests/basics/class_misc.py | 17 | # converting user instance to buffer
class C:
pass
c = C()
try:
d = bytes(c)
except TypeError:
print('TypeError')
|
maciek263/django2 | refs/heads/master | myvenv/Lib/site-packages/django/contrib/admin/templatetags/admin_list.py | 49 | from __future__ import unicode_literals
import datetime
from django.contrib.admin.templatetags.admin_static import static
from django.contrib.admin.templatetags.admin_urls import add_preserved_filters
from django.contrib.admin.utils import (
display_for_field, display_for_value, label_for_field, lookup_field,
)
from django.contrib.admin.views.main import (
ALL_VAR, EMPTY_CHANGELIST_VALUE, ORDER_VAR, PAGE_VAR, SEARCH_VAR,
)
from django.core.exceptions import ObjectDoesNotExist
from django.core.urlresolvers import NoReverseMatch
from django.db import models
from django.template import Library
from django.template.loader import get_template
from django.utils import formats
from django.utils.encoding import force_text
from django.utils.html import escapejs, format_html
from django.utils.safestring import mark_safe
from django.utils.text import capfirst
from django.utils.translation import ugettext as _
register = Library()
DOT = '.'
@register.simple_tag
def paginator_number(cl, i):
"""
Generates an individual page index link in a paginated list.
"""
if i == DOT:
return '... '
elif i == cl.page_num:
return format_html('<span class="this-page">{}</span> ', i + 1)
else:
return format_html('<a href="{}"{}>{}</a> ',
cl.get_query_string({PAGE_VAR: i}),
mark_safe(' class="end"' if i == cl.paginator.num_pages - 1 else ''),
i + 1)
@register.inclusion_tag('admin/pagination.html')
def pagination(cl):
"""
Generates the series of links to the pages in a paginated list.
"""
paginator, page_num = cl.paginator, cl.page_num
pagination_required = (not cl.show_all or not cl.can_show_all) and cl.multi_page
if not pagination_required:
page_range = []
else:
ON_EACH_SIDE = 3
ON_ENDS = 2
# If there are 10 or fewer pages, display links to every page.
# Otherwise, do some fancy
if paginator.num_pages <= 10:
page_range = range(paginator.num_pages)
else:
# Insert "smart" pagination links, so that there are always ON_ENDS
# links at either end of the list of pages, and there are always
# ON_EACH_SIDE links at either end of the "current page" link.
page_range = []
if page_num > (ON_EACH_SIDE + ON_ENDS):
page_range.extend(range(0, ON_ENDS))
page_range.append(DOT)
page_range.extend(range(page_num - ON_EACH_SIDE, page_num + 1))
else:
page_range.extend(range(0, page_num + 1))
if page_num < (paginator.num_pages - ON_EACH_SIDE - ON_ENDS - 1):
page_range.extend(range(page_num + 1, page_num + ON_EACH_SIDE + 1))
page_range.append(DOT)
page_range.extend(range(paginator.num_pages - ON_ENDS, paginator.num_pages))
else:
page_range.extend(range(page_num + 1, paginator.num_pages))
need_show_all_link = cl.can_show_all and not cl.show_all and cl.multi_page
return {
'cl': cl,
'pagination_required': pagination_required,
'show_all_url': need_show_all_link and cl.get_query_string({ALL_VAR: ''}),
'page_range': page_range,
'ALL_VAR': ALL_VAR,
'1': 1,
}
def result_headers(cl):
"""
Generates the list column headers.
"""
ordering_field_columns = cl.get_ordering_field_columns()
for i, field_name in enumerate(cl.list_display):
text, attr = label_for_field(
field_name, cl.model,
model_admin=cl.model_admin,
return_attr=True
)
if attr:
# Potentially not sortable
# if the field is the action checkbox: no sorting and special class
if field_name == 'action_checkbox':
yield {
"text": text,
"class_attrib": mark_safe(' class="action-checkbox-column"'),
"sortable": False,
}
continue
admin_order_field = getattr(attr, "admin_order_field", None)
if not admin_order_field:
# Not sortable
yield {
"text": text,
"class_attrib": format_html(' class="column-{}"', field_name),
"sortable": False,
}
continue
# OK, it is sortable if we got this far
th_classes = ['sortable', 'column-{}'.format(field_name)]
order_type = ''
new_order_type = 'asc'
sort_priority = 0
sorted = False
# Is it currently being sorted on?
if i in ordering_field_columns:
sorted = True
order_type = ordering_field_columns.get(i).lower()
sort_priority = list(ordering_field_columns).index(i) + 1
th_classes.append('sorted %sending' % order_type)
new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type]
# build new ordering param
o_list_primary = [] # URL for making this field the primary sort
o_list_remove = [] # URL for removing this field from sort
o_list_toggle = [] # URL for toggling order type for this field
make_qs_param = lambda t, n: ('-' if t == 'desc' else '') + str(n)
for j, ot in ordering_field_columns.items():
if j == i: # Same column
param = make_qs_param(new_order_type, j)
# We want clicking on this header to bring the ordering to the
# front
o_list_primary.insert(0, param)
o_list_toggle.append(param)
# o_list_remove - omit
else:
param = make_qs_param(ot, j)
o_list_primary.append(param)
o_list_toggle.append(param)
o_list_remove.append(param)
if i not in ordering_field_columns:
o_list_primary.insert(0, make_qs_param(new_order_type, i))
yield {
"text": text,
"sortable": True,
"sorted": sorted,
"ascending": order_type == "asc",
"sort_priority": sort_priority,
"url_primary": cl.get_query_string({ORDER_VAR: '.'.join(o_list_primary)}),
"url_remove": cl.get_query_string({ORDER_VAR: '.'.join(o_list_remove)}),
"url_toggle": cl.get_query_string({ORDER_VAR: '.'.join(o_list_toggle)}),
"class_attrib": format_html(' class="{}"', ' '.join(th_classes)) if th_classes else '',
}
def _boolean_icon(field_val):
icon_url = static('admin/img/icon-%s.gif' %
{True: 'yes', False: 'no', None: 'unknown'}[field_val])
return format_html('<img src="{}" alt="{}" />', icon_url, field_val)
def items_for_result(cl, result, form):
"""
Generates the actual list of data.
"""
def link_in_col(is_first, field_name, cl):
if cl.list_display_links is None:
return False
if is_first and not cl.list_display_links:
return True
return field_name in cl.list_display_links
first = True
pk = cl.lookup_opts.pk.attname
for field_name in cl.list_display:
row_classes = ['field-%s' % field_name]
try:
f, attr, value = lookup_field(field_name, result, cl.model_admin)
except ObjectDoesNotExist:
result_repr = EMPTY_CHANGELIST_VALUE
else:
if f is None:
if field_name == 'action_checkbox':
row_classes = ['action-checkbox']
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = display_for_value(value, boolean)
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if allow_tags:
result_repr = mark_safe(result_repr)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append('nowrap')
else:
if isinstance(f.rel, models.ManyToOneRel):
field_val = getattr(result, f.name)
if field_val is None:
result_repr = EMPTY_CHANGELIST_VALUE
else:
result_repr = field_val
else:
result_repr = display_for_field(value, f)
if isinstance(f, (models.DateField, models.TimeField, models.ForeignKey)):
row_classes.append('nowrap')
if force_text(result_repr) == '':
result_repr = mark_safe(' ')
row_class = mark_safe(' class="%s"' % ' '.join(row_classes))
# If list_display_links not defined, add the link tag to the first field
if link_in_col(first, field_name, cl):
table_tag = 'th' if first else 'td'
first = False
# Display link to the result's change_view if the url exists, else
# display just the result's representation.
try:
url = cl.url_for_result(result)
except NoReverseMatch:
link_or_text = result_repr
else:
url = add_preserved_filters({'preserved_filters': cl.preserved_filters, 'opts': cl.opts}, url)
# Convert the pk to something that can be used in Javascript.
# Problem cases are long ints (23L) and non-ASCII strings.
if cl.to_field:
attr = str(cl.to_field)
else:
attr = pk
value = result.serializable_value(attr)
result_id = escapejs(value)
link_or_text = format_html(
'<a href="{}"{}>{}</a>',
url,
format_html(
' onclick="opener.dismissRelatedLookupPopup(window, '
''{}'); return false;"', result_id
) if cl.is_popup else '',
result_repr)
yield format_html('<{}{}>{}</{}>',
table_tag,
row_class,
link_or_text,
table_tag)
else:
# By default the fields come from ModelAdmin.list_editable, but if we pull
# the fields out of the form instead of list_editable custom admins
# can provide fields on a per request basis
if (form and field_name in form.fields and not (
field_name == cl.model._meta.pk.name and
form[cl.model._meta.pk.name].is_hidden)):
bf = form[field_name]
result_repr = mark_safe(force_text(bf.errors) + force_text(bf))
yield format_html('<td{}>{}</td>', row_class, result_repr)
if form and not form[cl.model._meta.pk.name].is_hidden:
yield format_html('<td>{}</td>', force_text(form[cl.model._meta.pk.name]))
class ResultList(list):
# Wrapper class used to return items in a list_editable
# changelist, annotated with the form object for error
# reporting purposes. Needed to maintain backwards
# compatibility with existing admin templates.
def __init__(self, form, *items):
self.form = form
super(ResultList, self).__init__(*items)
def results(cl):
if cl.formset:
for res, form in zip(cl.result_list, cl.formset.forms):
yield ResultList(form, items_for_result(cl, res, form))
else:
for res in cl.result_list:
yield ResultList(None, items_for_result(cl, res, None))
def result_hidden_fields(cl):
if cl.formset:
for res, form in zip(cl.result_list, cl.formset.forms):
if form[cl.model._meta.pk.name].is_hidden:
yield mark_safe(force_text(form[cl.model._meta.pk.name]))
@register.inclusion_tag("admin/change_list_results.html")
def result_list(cl):
"""
Displays the headers and data list together
"""
headers = list(result_headers(cl))
num_sorted_fields = 0
for h in headers:
if h['sortable'] and h['sorted']:
num_sorted_fields += 1
return {'cl': cl,
'result_hidden_fields': list(result_hidden_fields(cl)),
'result_headers': headers,
'num_sorted_fields': num_sorted_fields,
'results': list(results(cl))}
@register.inclusion_tag('admin/date_hierarchy.html')
def date_hierarchy(cl):
"""
Displays the date hierarchy for date drill-down functionality.
"""
if cl.date_hierarchy:
field_name = cl.date_hierarchy
field = cl.opts.get_field(field_name)
dates_or_datetimes = 'datetimes' if isinstance(field, models.DateTimeField) else 'dates'
year_field = '%s__year' % field_name
month_field = '%s__month' % field_name
day_field = '%s__day' % field_name
field_generic = '%s__' % field_name
year_lookup = cl.params.get(year_field)
month_lookup = cl.params.get(month_field)
day_lookup = cl.params.get(day_field)
link = lambda filters: cl.get_query_string(filters, [field_generic])
if not (year_lookup or month_lookup or day_lookup):
# select appropriate start level
date_range = cl.queryset.aggregate(first=models.Min(field_name),
last=models.Max(field_name))
if date_range['first'] and date_range['last']:
if date_range['first'].year == date_range['last'].year:
year_lookup = date_range['first'].year
if date_range['first'].month == date_range['last'].month:
month_lookup = date_range['first'].month
if year_lookup and month_lookup and day_lookup:
day = datetime.date(int(year_lookup), int(month_lookup), int(day_lookup))
return {
'show': True,
'back': {
'link': link({year_field: year_lookup, month_field: month_lookup}),
'title': capfirst(formats.date_format(day, 'YEAR_MONTH_FORMAT'))
},
'choices': [{'title': capfirst(formats.date_format(day, 'MONTH_DAY_FORMAT'))}]
}
elif year_lookup and month_lookup:
days = cl.queryset.filter(**{year_field: year_lookup, month_field: month_lookup})
days = getattr(days, dates_or_datetimes)(field_name, 'day')
return {
'show': True,
'back': {
'link': link({year_field: year_lookup}),
'title': str(year_lookup)
},
'choices': [{
'link': link({year_field: year_lookup, month_field: month_lookup, day_field: day.day}),
'title': capfirst(formats.date_format(day, 'MONTH_DAY_FORMAT'))
} for day in days]
}
elif year_lookup:
months = cl.queryset.filter(**{year_field: year_lookup})
months = getattr(months, dates_or_datetimes)(field_name, 'month')
return {
'show': True,
'back': {
'link': link({}),
'title': _('All dates')
},
'choices': [{
'link': link({year_field: year_lookup, month_field: month.month}),
'title': capfirst(formats.date_format(month, 'YEAR_MONTH_FORMAT'))
} for month in months]
}
else:
years = getattr(cl.queryset, dates_or_datetimes)(field_name, 'year')
return {
'show': True,
'choices': [{
'link': link({year_field: str(year.year)}),
'title': str(year.year),
} for year in years]
}
@register.inclusion_tag('admin/search_form.html')
def search_form(cl):
"""
Displays a search form for searching the list.
"""
return {
'cl': cl,
'show_result_count': cl.result_count != cl.full_result_count,
'search_var': SEARCH_VAR
}
@register.simple_tag
def admin_list_filter(cl, spec):
tpl = get_template(spec.template)
return tpl.render({
'title': spec.title,
'choices': list(spec.choices(cl)),
'spec': spec,
})
@register.inclusion_tag('admin/actions.html', takes_context=True)
def admin_actions(context):
"""
Track the number of times the action field has been rendered on the page,
so we know which value to use.
"""
context['action_index'] = context.get('action_index', -1) + 1
return context
|
macmanes-lab/MCBS913 | refs/heads/master | code/Junhong Chen/samTobamAllInOne.py | 1 | """
Author: Junhong Chen
"""
import os
import sys
import subprocess
rootDir = sys.argv[1]
for dirName, subdirList, fileList in os.walk(rootDir):
print('Found directory: %s' % dirName)
for fname in fileList:
if fname.endswith("sam"):
print "sam file: ",fname
filename = dirName + "/"+fname
bname = dirName + "/"+fname.split(".")[0]
oname = sys.argv[2] + "/"+fname.split(".")[0]
#sname = sys.argv[3] + "/"+fname.split(".")[0]
cmd = "samtools view -bS %s | samtools sort - %s" % (filename,oname)
subprocess.Popen(cmd,shell=True)
# cmd1 = "samtools flagstat %s > %s" % (oname+".bam",sname+".samstat")
# subprocess.call(cmd1,shell=True)
|
damianmoore/django-cms | refs/heads/develop | cms/utils/mail.py | 21 | # -*- coding: utf-8 -*-
from django.core.mail import EmailMultiAlternatives
from django.core.urlresolvers import reverse
from django.template.loader import render_to_string
from django.utils.translation import ugettext_lazy as _
from django.contrib.sites.models import Site
from cms.utils.urlutils import urljoin
def send_mail(subject, txt_template, to, context=None, html_template=None, fail_silently=True):
"""
Multipart message helper with template rendering.
"""
site = Site.objects.get_current()
context = context or {}
context.update({
'login_url': "http://%s" % urljoin(site.domain, reverse('admin:index')),
'title': subject,
})
txt_body = render_to_string(txt_template, context)
message = EmailMultiAlternatives(subject=subject, body=txt_body, to=to)
if html_template:
body = render_to_string(html_template, context)
message.attach_alternative(body, 'text/html')
message.send(fail_silently=fail_silently)
def mail_page_user_change(user, created=False, password=""):
"""
Send email notification to given user.
Used it PageUser profile creation/update.
"""
if created:
subject = _('CMS - your user account was created.')
else:
subject = _('CMS - your user account was changed.')
send_mail(subject, 'admin/cms/mail/page_user_change.txt', [user.email], {
'user': user,
'password': password or "*" * 8,
'created': created,
}, 'admin/cms/mail/page_user_change.html')
|
Endika/c2c-rd-addons | refs/heads/8.0 | chricar_top/wizard/stock_location_realestate.py | 4 | # -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
# 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 openerp.osv import fields, osv
class stock_location_product(osv.osv_memory):
_name = "stock.location.realestate"
_description = "Real estate by Location"
_columns = {
}
def action_open_window(self, cr, uid, ids, context=None):
""" To open location wise product information specific to given duration
@param self: The object pointer.
@param cr: A database cursor
@param uid: ID of the user currently logged in
@param ids: An ID or list of IDs if we want more than one
@param context: A standard dictionary
@return: Invoice type
"""
mod_obj = self.pool.get('ir.model.data')
for location_obj in self.read(cr, uid, ids):
return {
'name': False,
'view_type': 'form',
'view_mode': 'tree,form',
'res_model': 'chricar.top',
'type': 'ir.actions.act_window',
'context': {'location_id': context['active_id'],
},
}
stock_location_product()
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
|
parttimenerd/temci | refs/heads/master | temci/utils/sudo_utils.py | 1 | import logging
import os
import sys
from io import TextIOWrapper, BufferedRandom, BufferedRWPair, BufferedWriter, IOBase
from pwd import getpwnam
from typing import Union, Tuple, Dict
from temci.utils.settings import Settings
def get_bench_user() -> str:
user = Settings()["env"]["USER"]
return os.getenv("USER", "") if user == "" else user
def bench_as_different_user() -> bool:
return get_bench_user() != os.getenv("USER", get_bench_user())
def get_bench_uid_and_gid() -> Tuple[int, int]:
pwnam = getpwnam(get_bench_user())
return pwnam.pw_uid, pwnam.pw_gid
_logged_chown_error = False
def chown(path: Union[str, TextIOWrapper, BufferedRandom, BufferedRWPair, BufferedWriter, IOBase]):
if not bench_as_different_user():
return
if isinstance(path, IOBase) and path.isatty():
return
if not isinstance(path, str):
return chown(path.name)
ids = ()
try:
ids = get_bench_uid_and_gid()
except:
global _logged_chown_error
if not _logged_chown_error:
logging.warn("Could not get user id for user {} therefore no chowning possible".format(get_bench_user()))
_logged_chown_error = True
return
try:
os.chown(path, *ids)
except FileNotFoundError:
pass
def get_env_setting() -> Dict[str, str]:
env = Settings()["env"].copy()
if env["USER"] == "":
env["USER"] = get_bench_user()
if env["PATH"] == "":
env["PATH"] = os.getenv("PATH", "")
return env
if __name__ == '__main__':
chown(sys.stdin) |
msegado/edx-platform | refs/heads/master | common/djangoapps/embargo/migrations/0002_data__add_countries.py | 26 | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
# Converted from the original South migration 0003_add_countries.py
from django.db import migrations, models
from django_countries import countries
def create_embargo_countries(apps, schema_editor):
"""Populate the available countries with all 2-character ISO country codes. """
country_model = apps.get_model("embargo", "Country")
db_alias = schema_editor.connection.alias
for country_code, __ in list(countries):
country_model.objects.using(db_alias).get_or_create(country=country_code)
def remove_embargo_countries(apps, schema_editor):
"""Clear all available countries. """
country_model = apps.get_model("embargo", "Country")
db_alias = schema_editor.connection.alias
country_model.objects.using(db_alias).all().delete()
class Migration(migrations.Migration):
dependencies = [
('embargo', '0001_initial'),
]
operations = [
migrations.RunPython(create_embargo_countries, remove_embargo_countries),
]
|
RaresO/test | refs/heads/master | node_modules/node-gyp/gyp/pylib/gyp/MSVSNew.py | 1835 | # Copyright (c) 2012 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""New implementation of Visual Studio project generation."""
import os
import random
import gyp.common
# hashlib is supplied as of Python 2.5 as the replacement interface for md5
# and other secure hashes. In 2.6, md5 is deprecated. Import hashlib if
# available, avoiding a deprecation warning under 2.6. Import md5 otherwise,
# preserving 2.4 compatibility.
try:
import hashlib
_new_md5 = hashlib.md5
except ImportError:
import md5
_new_md5 = md5.new
# Initialize random number generator
random.seed()
# GUIDs for project types
ENTRY_TYPE_GUIDS = {
'project': '{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}',
'folder': '{2150E333-8FDC-42A3-9474-1A3956D46DE8}',
}
#------------------------------------------------------------------------------
# Helper functions
def MakeGuid(name, seed='msvs_new'):
"""Returns a GUID for the specified target name.
Args:
name: Target name.
seed: Seed for MD5 hash.
Returns:
A GUID-line string calculated from the name and seed.
This generates something which looks like a GUID, but depends only on the
name and seed. This means the same name/seed will always generate the same
GUID, so that projects and solutions which refer to each other can explicitly
determine the GUID to refer to explicitly. It also means that the GUID will
not change when the project for a target is rebuilt.
"""
# Calculate a MD5 signature for the seed and name.
d = _new_md5(str(seed) + str(name)).hexdigest().upper()
# Convert most of the signature to GUID form (discard the rest)
guid = ('{' + d[:8] + '-' + d[8:12] + '-' + d[12:16] + '-' + d[16:20]
+ '-' + d[20:32] + '}')
return guid
#------------------------------------------------------------------------------
class MSVSSolutionEntry(object):
def __cmp__(self, other):
# Sort by name then guid (so things are in order on vs2008).
return cmp((self.name, self.get_guid()), (other.name, other.get_guid()))
class MSVSFolder(MSVSSolutionEntry):
"""Folder in a Visual Studio project or solution."""
def __init__(self, path, name = None, entries = None,
guid = None, items = None):
"""Initializes the folder.
Args:
path: Full path to the folder.
name: Name of the folder.
entries: List of folder entries to nest inside this folder. May contain
Folder or Project objects. May be None, if the folder is empty.
guid: GUID to use for folder, if not None.
items: List of solution items to include in the folder project. May be
None, if the folder does not directly contain items.
"""
if name:
self.name = name
else:
# Use last layer.
self.name = os.path.basename(path)
self.path = path
self.guid = guid
# Copy passed lists (or set to empty lists)
self.entries = sorted(list(entries or []))
self.items = list(items or [])
self.entry_type_guid = ENTRY_TYPE_GUIDS['folder']
def get_guid(self):
if self.guid is None:
# Use consistent guids for folders (so things don't regenerate).
self.guid = MakeGuid(self.path, seed='msvs_folder')
return self.guid
#------------------------------------------------------------------------------
class MSVSProject(MSVSSolutionEntry):
"""Visual Studio project."""
def __init__(self, path, name = None, dependencies = None, guid = None,
spec = None, build_file = None, config_platform_overrides = None,
fixpath_prefix = None):
"""Initializes the project.
Args:
path: Absolute path to the project file.
name: Name of project. If None, the name will be the same as the base
name of the project file.
dependencies: List of other Project objects this project is dependent
upon, if not None.
guid: GUID to use for project, if not None.
spec: Dictionary specifying how to build this project.
build_file: Filename of the .gyp file that the vcproj file comes from.
config_platform_overrides: optional dict of configuration platforms to
used in place of the default for this target.
fixpath_prefix: the path used to adjust the behavior of _fixpath
"""
self.path = path
self.guid = guid
self.spec = spec
self.build_file = build_file
# Use project filename if name not specified
self.name = name or os.path.splitext(os.path.basename(path))[0]
# Copy passed lists (or set to empty lists)
self.dependencies = list(dependencies or [])
self.entry_type_guid = ENTRY_TYPE_GUIDS['project']
if config_platform_overrides:
self.config_platform_overrides = config_platform_overrides
else:
self.config_platform_overrides = {}
self.fixpath_prefix = fixpath_prefix
self.msbuild_toolset = None
def set_dependencies(self, dependencies):
self.dependencies = list(dependencies or [])
def get_guid(self):
if self.guid is None:
# Set GUID from path
# TODO(rspangler): This is fragile.
# 1. We can't just use the project filename sans path, since there could
# be multiple projects with the same base name (for example,
# foo/unittest.vcproj and bar/unittest.vcproj).
# 2. The path needs to be relative to $SOURCE_ROOT, so that the project
# GUID is the same whether it's included from base/base.sln or
# foo/bar/baz/baz.sln.
# 3. The GUID needs to be the same each time this builder is invoked, so
# that we don't need to rebuild the solution when the project changes.
# 4. We should be able to handle pre-built project files by reading the
# GUID from the files.
self.guid = MakeGuid(self.name)
return self.guid
def set_msbuild_toolset(self, msbuild_toolset):
self.msbuild_toolset = msbuild_toolset
#------------------------------------------------------------------------------
class MSVSSolution(object):
"""Visual Studio solution."""
def __init__(self, path, version, entries=None, variants=None,
websiteProperties=True):
"""Initializes the solution.
Args:
path: Path to solution file.
version: Format version to emit.
entries: List of entries in solution. May contain Folder or Project
objects. May be None, if the folder is empty.
variants: List of build variant strings. If none, a default list will
be used.
websiteProperties: Flag to decide if the website properties section
is generated.
"""
self.path = path
self.websiteProperties = websiteProperties
self.version = version
# Copy passed lists (or set to empty lists)
self.entries = list(entries or [])
if variants:
# Copy passed list
self.variants = variants[:]
else:
# Use default
self.variants = ['Debug|Win32', 'Release|Win32']
# TODO(rspangler): Need to be able to handle a mapping of solution config
# to project config. Should we be able to handle variants being a dict,
# or add a separate variant_map variable? If it's a dict, we can't
# guarantee the order of variants since dict keys aren't ordered.
# TODO(rspangler): Automatically write to disk for now; should delay until
# node-evaluation time.
self.Write()
def Write(self, writer=gyp.common.WriteOnDiff):
"""Writes the solution file to disk.
Raises:
IndexError: An entry appears multiple times.
"""
# Walk the entry tree and collect all the folders and projects.
all_entries = set()
entries_to_check = self.entries[:]
while entries_to_check:
e = entries_to_check.pop(0)
# If this entry has been visited, nothing to do.
if e in all_entries:
continue
all_entries.add(e)
# If this is a folder, check its entries too.
if isinstance(e, MSVSFolder):
entries_to_check += e.entries
all_entries = sorted(all_entries)
# Open file and print header
f = writer(self.path)
f.write('Microsoft Visual Studio Solution File, '
'Format Version %s\r\n' % self.version.SolutionVersion())
f.write('# %s\r\n' % self.version.Description())
# Project entries
sln_root = os.path.split(self.path)[0]
for e in all_entries:
relative_path = gyp.common.RelativePath(e.path, sln_root)
# msbuild does not accept an empty folder_name.
# use '.' in case relative_path is empty.
folder_name = relative_path.replace('/', '\\') or '.'
f.write('Project("%s") = "%s", "%s", "%s"\r\n' % (
e.entry_type_guid, # Entry type GUID
e.name, # Folder name
folder_name, # Folder name (again)
e.get_guid(), # Entry GUID
))
# TODO(rspangler): Need a way to configure this stuff
if self.websiteProperties:
f.write('\tProjectSection(WebsiteProperties) = preProject\r\n'
'\t\tDebug.AspNetCompiler.Debug = "True"\r\n'
'\t\tRelease.AspNetCompiler.Debug = "False"\r\n'
'\tEndProjectSection\r\n')
if isinstance(e, MSVSFolder):
if e.items:
f.write('\tProjectSection(SolutionItems) = preProject\r\n')
for i in e.items:
f.write('\t\t%s = %s\r\n' % (i, i))
f.write('\tEndProjectSection\r\n')
if isinstance(e, MSVSProject):
if e.dependencies:
f.write('\tProjectSection(ProjectDependencies) = postProject\r\n')
for d in e.dependencies:
f.write('\t\t%s = %s\r\n' % (d.get_guid(), d.get_guid()))
f.write('\tEndProjectSection\r\n')
f.write('EndProject\r\n')
# Global section
f.write('Global\r\n')
# Configurations (variants)
f.write('\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\r\n')
for v in self.variants:
f.write('\t\t%s = %s\r\n' % (v, v))
f.write('\tEndGlobalSection\r\n')
# Sort config guids for easier diffing of solution changes.
config_guids = []
config_guids_overrides = {}
for e in all_entries:
if isinstance(e, MSVSProject):
config_guids.append(e.get_guid())
config_guids_overrides[e.get_guid()] = e.config_platform_overrides
config_guids.sort()
f.write('\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\r\n')
for g in config_guids:
for v in self.variants:
nv = config_guids_overrides[g].get(v, v)
# Pick which project configuration to build for this solution
# configuration.
f.write('\t\t%s.%s.ActiveCfg = %s\r\n' % (
g, # Project GUID
v, # Solution build configuration
nv, # Project build config for that solution config
))
# Enable project in this solution configuration.
f.write('\t\t%s.%s.Build.0 = %s\r\n' % (
g, # Project GUID
v, # Solution build configuration
nv, # Project build config for that solution config
))
f.write('\tEndGlobalSection\r\n')
# TODO(rspangler): Should be able to configure this stuff too (though I've
# never seen this be any different)
f.write('\tGlobalSection(SolutionProperties) = preSolution\r\n')
f.write('\t\tHideSolutionNode = FALSE\r\n')
f.write('\tEndGlobalSection\r\n')
# Folder mappings
# Omit this section if there are no folders
if any([e.entries for e in all_entries if isinstance(e, MSVSFolder)]):
f.write('\tGlobalSection(NestedProjects) = preSolution\r\n')
for e in all_entries:
if not isinstance(e, MSVSFolder):
continue # Does not apply to projects, only folders
for subentry in e.entries:
f.write('\t\t%s = %s\r\n' % (subentry.get_guid(), e.get_guid()))
f.write('\tEndGlobalSection\r\n')
f.write('EndGlobal\r\n')
f.close()
|
amohanta/miasm | refs/heads/master | miasm2/ir/translators/python.py | 7 | from miasm2.ir.translators.translator import Translator
class TranslatorPython(Translator):
"""Translate a Miasm expression to an equivalent Python code
Memory is abstracted using the unimplemented function:
int memory(int address, int size)
"""
# Implemented language
__LANG__ = "Python"
# Operations translation
op_no_translate = ["+", "-", "/", "%", ">>", "<<", "&", "^", "|", "*"]
def from_ExprInt(self, expr):
return str(expr)
def from_ExprId(self, expr):
return str(expr)
def from_ExprMem(self, expr):
return "memory(%s, 0x%x)" % (self.from_expr(expr.arg),
expr.size / 8)
def from_ExprSlice(self, expr):
out = self.from_expr(expr.arg)
if expr.start != 0:
out = "(%s >> %d)" % (out, expr.start)
return "(%s & 0x%x)" % (out, (1 << (expr.stop - expr.start)) - 1)
def from_ExprCompose(self, expr):
out = []
for subexpr, start, stop in expr.args:
out.append("((%s & 0x%x) << %d)" % (self.from_expr(subexpr),
(1 << (stop - start)) - 1,
start))
return "(%s)" % ' | '.join(out)
def from_ExprCond(self, expr):
return "(%s if (%s) else %s)" % (self.from_expr(expr.src1),
self.from_expr(expr.cond),
self.from_expr(expr.src2))
def from_ExprOp(self, expr):
if expr.op in self.op_no_translate:
args = map(self.from_expr, expr.args)
if len(expr.args) == 1:
return "((%s %s) & 0x%x)" % (expr.op,
args[0],
(1 << expr.size) - 1)
else:
return "((%s) & 0x%x)" % ((" %s " % expr.op).join(args),
(1 << expr.size) - 1)
elif expr.op == "parity":
return "(%s & 0x1)" % self.from_expr(expr.args[0])
raise NotImplementedError("Unknown operator: %s" % expr.op)
def from_ExprAff(self, expr):
return "%s = %s" % tuple(map(self.from_expr, (expr.dst, expr.src)))
# Register the class
Translator.register(TranslatorPython)
|
GunnerJnr/_CodeInstitute | refs/heads/master | Stream-3/Full-Stack-Development/19.Djangos-Testing-Framework/2.How-To-Test-Views-And-Urls/we_are_social/polls/migrations/__init__.py | 12133432 | |
uestcxl/OnlineJudge | refs/heads/master | account/__init__.py | 12133432 | |
hosseinmh/jango_learning | refs/heads/master | .venv/lib/python2.7/site-packages/django/contrib/gis/maps/__init__.py | 12133432 | |
libracore/erpnext | refs/heads/v12 | erpnext/support/web_form/issues/__init__.py | 12133432 | |
fabiobatalha/SciELO-Manager | refs/heads/master | scielomanager/maintenancewindow/migrations/0001_initial.py | 3 | # -*- coding: utf-8 -*-
from south.utils import datetime_utils as datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding model 'Event'
db.create_table('maintenancewindow_event', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('title', self.gf('django.db.models.fields.CharField')(max_length=128)),
('begin_at', self.gf('django.db.models.fields.DateTimeField')()),
('end_at', self.gf('django.db.models.fields.DateTimeField')(db_index=True)),
('description', self.gf('django.db.models.fields.TextField')()),
('is_blocking_users', self.gf('django.db.models.fields.BooleanField')(default=False, db_index=True)),
('is_finished', self.gf('django.db.models.fields.BooleanField')(default=False)),
('event_report', self.gf('django.db.models.fields.TextField')(blank=True)),
))
db.send_create_signal('maintenancewindow', ['Event'])
def backwards(self, orm):
# Deleting model 'Event'
db.delete_table('maintenancewindow_event')
models = {
'maintenancewindow.event': {
'Meta': {'ordering': "['begin_at', 'title']", 'object_name': 'Event'},
'begin_at': ('django.db.models.fields.DateTimeField', [], {}),
'description': ('django.db.models.fields.TextField', [], {}),
'end_at': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True'}),
'event_report': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_blocking_users': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'db_index': 'True'}),
'is_finished': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '128'})
}
}
complete_apps = ['maintenancewindow'] |
ualikhansars/Gwent | refs/heads/master | lib/python2.7/site-packages/pip/_vendor/cachecontrol/filewrapper.py | 346 | from io import BytesIO
class CallbackFileWrapper(object):
"""
Small wrapper around a fp object which will tee everything read into a
buffer, and when that file is closed it will execute a callback with the
contents of that buffer.
All attributes are proxied to the underlying file object.
This class uses members with a double underscore (__) leading prefix so as
not to accidentally shadow an attribute.
"""
def __init__(self, fp, callback):
self.__buf = BytesIO()
self.__fp = fp
self.__callback = callback
def __getattr__(self, name):
# The vaguaries of garbage collection means that self.__fp is
# not always set. By using __getattribute__ and the private
# name[0] allows looking up the attribute value and raising an
# AttributeError when it doesn't exist. This stop thigns from
# infinitely recursing calls to getattr in the case where
# self.__fp hasn't been set.
#
# [0] https://docs.python.org/2/reference/expressions.html#atom-identifiers
fp = self.__getattribute__('_CallbackFileWrapper__fp')
return getattr(fp, name)
def __is_fp_closed(self):
try:
return self.__fp.fp is None
except AttributeError:
pass
try:
return self.__fp.closed
except AttributeError:
pass
# We just don't cache it then.
# TODO: Add some logging here...
return False
def _close(self):
if self.__callback:
self.__callback(self.__buf.getvalue())
# We assign this to None here, because otherwise we can get into
# really tricky problems where the CPython interpreter dead locks
# because the callback is holding a reference to something which
# has a __del__ method. Setting this to None breaks the cycle
# and allows the garbage collector to do it's thing normally.
self.__callback = None
def read(self, amt=None):
data = self.__fp.read(amt)
self.__buf.write(data)
if self.__is_fp_closed():
self._close()
return data
def _safe_read(self, amt):
data = self.__fp._safe_read(amt)
if amt == 2 and data == b'\r\n':
# urllib executes this read to toss the CRLF at the end
# of the chunk.
return data
self.__buf.write(data)
if self.__is_fp_closed():
self._close()
return data
|
kobejean/tensorflow | refs/heads/master | tensorflow/contrib/opt/python/training/ggt_test.py | 25 | # Copyright 2018 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.
# ==============================================================================
"""Tests for GGTOptimizer."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from tensorflow.contrib.opt.python.training.ggt import GGTOptimizer
from tensorflow.python.eager import context
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.framework import test_util
from tensorflow.python.ops import resource_variable_ops
from tensorflow.python.ops import variables
from tensorflow.python.platform import test
def ggt_update_numpy(param,
g_t,
lr,
grad_buffer,
m,
window,
t,
beta1=0.9,
eps=1e-4,
svd_eps=1e-6,
sigma_eps=1e-2):
"""Tests the correctness of one step of GGT."""
m_t = m * beta1 + (1 - beta1) * g_t
grad_buffer[((t - 1) % window), :] = m_t
m_matrix = np.transpose(grad_buffer / np.sqrt(np.minimum(t, window)))
mm = np.dot(np.transpose(m_matrix), m_matrix)
damping = np.eye(window) * svd_eps
u, sigma, _ = np.linalg.svd(mm + damping)
sigma_sqrt_inv = np.power(np.sqrt(sigma) + sigma_eps, -3)
new_step = np.linalg.multi_dot([
m_matrix, u,
np.diag(sigma_sqrt_inv),
np.transpose(u),
np.transpose(m_matrix), m_t
])
sigma_sqrt_min = np.sqrt(sigma).min()
if sigma_sqrt_min > eps:
new_step += (m_t - np.linalg.multi_dot([
m_matrix, u,
np.diag(1.0 / sigma),
np.transpose(u),
np.transpose(m_matrix), m_t
])) * (1.0 / sigma_sqrt_min)
param_t = param - lr * new_step
return param_t, m_t, grad_buffer
class GGTOptimizerTest(test.TestCase):
def doTestBasic(self, use_resource=False):
# SVD does not support float16
for i, dtype in enumerate([dtypes.float32, dtypes.float64]):
with self.session(graph=ops.Graph()):
# Initialize variables for numpy implementation.
m0 = 0.0
window = 3
grad_buffer = np.zeros((window, 4), dtype=dtype.as_numpy_dtype)
lr = 0.001
var0_np = np.array([1.0, 2.0], dtype=dtype.as_numpy_dtype)
grads0_np = np.array([0.1, 0.1], dtype=dtype.as_numpy_dtype)
var1_np = np.array([3.0, 4.0], dtype=dtype.as_numpy_dtype)
grads1_np = np.array([0.01, 0.01], dtype=dtype.as_numpy_dtype)
if use_resource:
var0 = resource_variable_ops.ResourceVariable(
var0_np, name="var0_%d" % i)
var1 = resource_variable_ops.ResourceVariable(
var1_np, name="var1_%d" % i)
else:
var0 = variables.Variable(var0_np, name="var0")
var1 = variables.Variable(var1_np, name="var1")
grads0 = constant_op.constant(grads0_np)
grads1 = constant_op.constant(grads1_np)
opt = GGTOptimizer(learning_rate=lr, window=window)
update = opt.apply_gradients(zip([grads0, grads1], [var0, var1]))
opt_variables = opt.variables()
m_t = opt._get_moment1()
grad_buffer_t = opt._get_grad_buffer()
g_t = opt._get_flat_grad()
self.assertTrue(m_t is not None)
self.assertTrue(grad_buffer_t is not None)
self.assertTrue(g_t is not None)
self.assertIn(m_t, opt_variables)
self.assertIn(grad_buffer_t, opt_variables)
self.assertIn(g_t, opt_variables)
with ops.Graph().as_default():
# Shouldn't return non-slot variables from other graphs.
self.assertEqual(0, len(opt.variables()))
if not context.executing_eagerly():
self.evaluate(variables.global_variables_initializer())
# Fetch params to validate initial values
self.assertAllClose([1.0, 2.0], self.evaluate(var0))
self.assertAllClose([3.0, 4.0], self.evaluate(var1))
m_t = opt._get_moment1()
grad_buffer_t = opt._get_grad_buffer()
g_t = opt._get_flat_grad()
# Run 3 steps of GGT
for t in range(1, 4):
if not context.executing_eagerly():
self.evaluate(update)
elif t > 1:
opt.apply_gradients(zip([grads0, grads1], [var0, var1]))
if t == 1:
self.assertAllCloseAccordingToType(
np.array([0.01, 0.01, 0.001, 0.001]), self.evaluate(m_t))
self.assertAllCloseAccordingToType(
np.array([[0.01, 0.01, 0.001, 0.001], [0., 0., 0., 0.],
[0., 0., 0., 0.]]), self.evaluate(grad_buffer_t))
elif t == 2:
self.assertAllCloseAccordingToType(
np.array([0.019, 0.019, 0.0019, 0.0019]), self.evaluate(m_t))
self.assertAllCloseAccordingToType(
np.array([[0.01, 0.01, 0.001, 0.001],
[0.019, 0.019, 0.0019, 0.0019], [0., 0., 0., 0.]]),
self.evaluate(grad_buffer_t))
else:
self.assertAllCloseAccordingToType(
np.array([0.0271, 0.0271, 0.00271, 0.00271]),
self.evaluate(m_t))
self.assertAllCloseAccordingToType(
np.array([[0.01, 0.01, 0.001,
0.001], [0.019, 0.019, 0.0019, 0.0019],
[0.0271, 0.0271, 0.00271, 0.00271]]),
self.evaluate(grad_buffer_t))
self.assertAllCloseAccordingToType([0.1, 0.1, 0.01, 0.01],
self.evaluate(g_t))
var_np = np.append(var0_np, var1_np)
grads_np = np.append(grads0_np, grads1_np)
var_np, m0, grad_buffer = ggt_update_numpy(var_np, grads_np, lr,
grad_buffer, m0, window, t)
var0_np = var_np[:2]
var1_np = var_np[2:]
# Validate updated params
self.assertAllCloseAccordingToType(var0_np, self.evaluate(var0))
self.assertAllCloseAccordingToType(var1_np, self.evaluate(var1))
def testBasic(self):
with self.cached_session():
self.doTestBasic(use_resource=False)
@test_util.run_in_graph_and_eager_modes(reset_test=True)
def testResourceBasic(self):
self.doTestBasic(use_resource=True)
if __name__ == "__main__":
test.main()
|
savoirfairelinux/django | refs/heads/master | django/contrib/syndication/views.py | 9 | from calendar import timegm
from contextlib import suppress
from django.conf import settings
from django.contrib.sites.shortcuts import get_current_site
from django.core.exceptions import ImproperlyConfigured, ObjectDoesNotExist
from django.http import Http404, HttpResponse
from django.template import TemplateDoesNotExist, loader
from django.utils import feedgenerator
from django.utils.encoding import iri_to_uri
from django.utils.html import escape
from django.utils.http import http_date
from django.utils.timezone import get_default_timezone, is_naive, make_aware
def add_domain(domain, url, secure=False):
protocol = 'https' if secure else 'http'
if url.startswith('//'):
# Support network-path reference (see #16753) - RSS requires a protocol
url = '%s:%s' % (protocol, url)
elif not url.startswith(('http://', 'https://', 'mailto:')):
url = iri_to_uri('%s://%s%s' % (protocol, domain, url))
return url
class FeedDoesNotExist(ObjectDoesNotExist):
pass
class Feed:
feed_type = feedgenerator.DefaultFeed
title_template = None
description_template = None
def __call__(self, request, *args, **kwargs):
try:
obj = self.get_object(request, *args, **kwargs)
except ObjectDoesNotExist:
raise Http404('Feed object does not exist.')
feedgen = self.get_feed(obj, request)
response = HttpResponse(content_type=feedgen.content_type)
if hasattr(self, 'item_pubdate') or hasattr(self, 'item_updateddate'):
# if item_pubdate or item_updateddate is defined for the feed, set
# header so as ConditionalGetMiddleware is able to send 304 NOT MODIFIED
response['Last-Modified'] = http_date(
timegm(feedgen.latest_post_date().utctimetuple()))
feedgen.write(response, 'utf-8')
return response
def item_title(self, item):
# Titles should be double escaped by default (see #6533)
return escape(str(item))
def item_description(self, item):
return str(item)
def item_link(self, item):
try:
return item.get_absolute_url()
except AttributeError:
raise ImproperlyConfigured(
'Give your %s class a get_absolute_url() method, or define an '
'item_link() method in your Feed class.' % item.__class__.__name__
)
def item_enclosures(self, item):
enc_url = self._get_dynamic_attr('item_enclosure_url', item)
if enc_url:
enc = feedgenerator.Enclosure(
url=str(enc_url),
length=str(self._get_dynamic_attr('item_enclosure_length', item)),
mime_type=str(self._get_dynamic_attr('item_enclosure_mime_type', item)),
)
return [enc]
return []
def _get_dynamic_attr(self, attname, obj, default=None):
try:
attr = getattr(self, attname)
except AttributeError:
return default
if callable(attr):
# Check co_argcount rather than try/excepting the function and
# catching the TypeError, because something inside the function
# may raise the TypeError. This technique is more accurate.
try:
code = attr.__code__
except AttributeError:
code = attr.__call__.__code__
if code.co_argcount == 2: # one argument is 'self'
return attr(obj)
else:
return attr()
return attr
def feed_extra_kwargs(self, obj):
"""
Return an extra keyword arguments dictionary that is used when
initializing the feed generator.
"""
return {}
def item_extra_kwargs(self, item):
"""
Return an extra keyword arguments dictionary that is used with
the `add_item` call of the feed generator.
"""
return {}
def get_object(self, request, *args, **kwargs):
return None
def get_context_data(self, **kwargs):
"""
Return a dictionary to use as extra context if either
``self.description_template`` or ``self.item_template`` are used.
Default implementation preserves the old behavior
of using {'obj': item, 'site': current_site} as the context.
"""
return {'obj': kwargs.get('item'), 'site': kwargs.get('site')}
def get_feed(self, obj, request):
"""
Return a feedgenerator.DefaultFeed object, fully populated, for
this feed. Raise FeedDoesNotExist for invalid parameters.
"""
current_site = get_current_site(request)
link = self._get_dynamic_attr('link', obj)
link = add_domain(current_site.domain, link, request.is_secure())
feed = self.feed_type(
title=self._get_dynamic_attr('title', obj),
subtitle=self._get_dynamic_attr('subtitle', obj),
link=link,
description=self._get_dynamic_attr('description', obj),
language=settings.LANGUAGE_CODE,
feed_url=add_domain(
current_site.domain,
self._get_dynamic_attr('feed_url', obj) or request.path,
request.is_secure(),
),
author_name=self._get_dynamic_attr('author_name', obj),
author_link=self._get_dynamic_attr('author_link', obj),
author_email=self._get_dynamic_attr('author_email', obj),
categories=self._get_dynamic_attr('categories', obj),
feed_copyright=self._get_dynamic_attr('feed_copyright', obj),
feed_guid=self._get_dynamic_attr('feed_guid', obj),
ttl=self._get_dynamic_attr('ttl', obj),
**self.feed_extra_kwargs(obj)
)
title_tmp = None
if self.title_template is not None:
with suppress(TemplateDoesNotExist):
title_tmp = loader.get_template(self.title_template)
description_tmp = None
if self.description_template is not None:
with suppress(TemplateDoesNotExist):
description_tmp = loader.get_template(self.description_template)
for item in self._get_dynamic_attr('items', obj):
context = self.get_context_data(item=item, site=current_site,
obj=obj, request=request)
if title_tmp is not None:
title = title_tmp.render(context, request)
else:
title = self._get_dynamic_attr('item_title', item)
if description_tmp is not None:
description = description_tmp.render(context, request)
else:
description = self._get_dynamic_attr('item_description', item)
link = add_domain(
current_site.domain,
self._get_dynamic_attr('item_link', item),
request.is_secure(),
)
enclosures = self._get_dynamic_attr('item_enclosures', item)
author_name = self._get_dynamic_attr('item_author_name', item)
if author_name is not None:
author_email = self._get_dynamic_attr('item_author_email', item)
author_link = self._get_dynamic_attr('item_author_link', item)
else:
author_email = author_link = None
tz = get_default_timezone()
pubdate = self._get_dynamic_attr('item_pubdate', item)
if pubdate and is_naive(pubdate):
pubdate = make_aware(pubdate, tz)
updateddate = self._get_dynamic_attr('item_updateddate', item)
if updateddate and is_naive(updateddate):
updateddate = make_aware(updateddate, tz)
feed.add_item(
title=title,
link=link,
description=description,
unique_id=self._get_dynamic_attr('item_guid', item, link),
unique_id_is_permalink=self._get_dynamic_attr(
'item_guid_is_permalink', item),
enclosures=enclosures,
pubdate=pubdate,
updateddate=updateddate,
author_name=author_name,
author_email=author_email,
author_link=author_link,
categories=self._get_dynamic_attr('item_categories', item),
item_copyright=self._get_dynamic_attr('item_copyright', item),
**self.item_extra_kwargs(item)
)
return feed
|
kaushik94/sympy | refs/heads/master | sympy/external/importtools.py | 3 | """Tools to assist importing optional external modules."""
from __future__ import print_function, division
import sys
from distutils.version import LooseVersion
# Override these in the module to change the default warning behavior.
# For example, you might set both to False before running the tests so that
# warnings are not printed to the console, or set both to True for debugging.
WARN_NOT_INSTALLED = None # Default is False
WARN_OLD_VERSION = None # Default is True
def __sympy_debug():
# helper function from sympy/__init__.py
# We don't just import SYMPY_DEBUG from that file because we don't want to
# import all of sympy just to use this module.
import os
debug_str = os.getenv('SYMPY_DEBUG', 'False')
if debug_str in ('True', 'False'):
return eval(debug_str)
else:
raise RuntimeError("unrecognized value for SYMPY_DEBUG: %s" %
debug_str)
if __sympy_debug():
WARN_OLD_VERSION = True
WARN_NOT_INSTALLED = True
def import_module(module, min_module_version=None, min_python_version=None,
warn_not_installed=None, warn_old_version=None,
module_version_attr='__version__', module_version_attr_call_args=None,
__import__kwargs={}, catch=()):
"""
Import and return a module if it is installed.
If the module is not installed, it returns None.
A minimum version for the module can be given as the keyword argument
min_module_version. This should be comparable against the module version.
By default, module.__version__ is used to get the module version. To
override this, set the module_version_attr keyword argument. If the
attribute of the module to get the version should be called (e.g.,
module.version()), then set module_version_attr_call_args to the args such
that module.module_version_attr(*module_version_attr_call_args) returns the
module's version.
If the module version is less than min_module_version using the Python <
comparison, None will be returned, even if the module is installed. You can
use this to keep from importing an incompatible older version of a module.
You can also specify a minimum Python version by using the
min_python_version keyword argument. This should be comparable against
sys.version_info.
If the keyword argument warn_not_installed is set to True, the function will
emit a UserWarning when the module is not installed.
If the keyword argument warn_old_version is set to True, the function will
emit a UserWarning when the library is installed, but cannot be imported
because of the min_module_version or min_python_version options.
Note that because of the way warnings are handled, a warning will be
emitted for each module only once. You can change the default warning
behavior by overriding the values of WARN_NOT_INSTALLED and WARN_OLD_VERSION
in sympy.external.importtools. By default, WARN_NOT_INSTALLED is False and
WARN_OLD_VERSION is True.
This function uses __import__() to import the module. To pass additional
options to __import__(), use the __import__kwargs keyword argument. For
example, to import a submodule A.B, you must pass a nonempty fromlist option
to __import__. See the docstring of __import__().
This catches ImportError to determine if the module is not installed. To
catch additional errors, pass them as a tuple to the catch keyword
argument.
Examples
========
>>> from sympy.external import import_module
>>> numpy = import_module('numpy')
>>> numpy = import_module('numpy', min_python_version=(2, 7),
... warn_old_version=False)
>>> numpy = import_module('numpy', min_module_version='1.5',
... warn_old_version=False) # numpy.__version__ is a string
>>> # gmpy does not have __version__, but it does have gmpy.version()
>>> gmpy = import_module('gmpy', min_module_version='1.14',
... module_version_attr='version', module_version_attr_call_args=(),
... warn_old_version=False)
>>> # To import a submodule, you must pass a nonempty fromlist to
>>> # __import__(). The values do not matter.
>>> p3 = import_module('mpl_toolkits.mplot3d',
... __import__kwargs={'fromlist':['something']})
>>> # matplotlib.pyplot can raise RuntimeError when the display cannot be opened
>>> matplotlib = import_module('matplotlib',
... __import__kwargs={'fromlist':['pyplot']}, catch=(RuntimeError,))
"""
# keyword argument overrides default, and global variable overrides
# keyword argument.
warn_old_version = (WARN_OLD_VERSION if WARN_OLD_VERSION is not None
else warn_old_version or True)
warn_not_installed = (WARN_NOT_INSTALLED if WARN_NOT_INSTALLED is not None
else warn_not_installed or False)
import warnings
# Check Python first so we don't waste time importing a module we can't use
if min_python_version:
if sys.version_info < min_python_version:
if warn_old_version:
warnings.warn("Python version is too old to use %s "
"(%s or newer required)" % (
module, '.'.join(map(str, min_python_version))),
UserWarning, stacklevel=2)
return
# PyPy 1.6 has rudimentary NumPy support and importing it produces errors, so skip it
if module == 'numpy' and '__pypy__' in sys.builtin_module_names:
return
try:
mod = __import__(module, **__import__kwargs)
## there's something funny about imports with matplotlib and py3k. doing
## from matplotlib import collections
## gives python's stdlib collections module. explicitly re-importing
## the module fixes this.
from_list = __import__kwargs.get('fromlist', tuple())
for submod in from_list:
if submod == 'collections' and mod.__name__ == 'matplotlib':
__import__(module + '.' + submod)
except ImportError:
if warn_not_installed:
warnings.warn("%s module is not installed" % module, UserWarning,
stacklevel=2)
return
except catch as e:
if warn_not_installed:
warnings.warn(
"%s module could not be used (%s)" % (module, repr(e)),
stacklevel=2)
return
if min_module_version:
modversion = getattr(mod, module_version_attr)
if module_version_attr_call_args is not None:
modversion = modversion(*module_version_attr_call_args)
if LooseVersion(modversion) < LooseVersion(min_module_version):
if warn_old_version:
# Attempt to create a pretty string version of the version
from ..core.compatibility import string_types
if isinstance(min_module_version, string_types):
verstr = min_module_version
elif isinstance(min_module_version, (tuple, list)):
verstr = '.'.join(map(str, min_module_version))
else:
# Either don't know what this is. Hopefully
# it's something that has a nice str version, like an int.
verstr = str(min_module_version)
warnings.warn("%s version is too old to use "
"(%s or newer required)" % (module, verstr),
UserWarning, stacklevel=2)
return
return mod
|
Mirantis/mos-horizon | refs/heads/master | openstack_dashboard/contrib/developer/theme_preview/views.py | 20 | # Copyright 2015 Cisco Systems, 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.
from django.utils.translation import ugettext_lazy as _
from horizon import views
class IndexView(views.HorizonTemplateView):
template_name = 'developer/theme_preview/index.html'
page_title = _("Bootstrap Theme Preview")
|
yencarnacion/jaikuengine | refs/heads/master | .google_appengine/lib/django-1.2/django/utils/daemonize.py | 452 | import os
import sys
if os.name == 'posix':
def become_daemon(our_home_dir='.', out_log='/dev/null',
err_log='/dev/null', umask=022):
"Robustly turn into a UNIX daemon, running in our_home_dir."
# First fork
try:
if os.fork() > 0:
sys.exit(0) # kill off parent
except OSError, e:
sys.stderr.write("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror))
sys.exit(1)
os.setsid()
os.chdir(our_home_dir)
os.umask(umask)
# Second fork
try:
if os.fork() > 0:
os._exit(0)
except OSError, e:
sys.stderr.write("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror))
os._exit(1)
si = open('/dev/null', 'r')
so = open(out_log, 'a+', 0)
se = open(err_log, 'a+', 0)
os.dup2(si.fileno(), sys.stdin.fileno())
os.dup2(so.fileno(), sys.stdout.fileno())
os.dup2(se.fileno(), sys.stderr.fileno())
# Set custom file descriptors so that they get proper buffering.
sys.stdout, sys.stderr = so, se
else:
def become_daemon(our_home_dir='.', out_log=None, err_log=None, umask=022):
"""
If we're not running under a POSIX system, just simulate the daemon
mode by doing redirections and directory changing.
"""
os.chdir(our_home_dir)
os.umask(umask)
sys.stdin.close()
sys.stdout.close()
sys.stderr.close()
if err_log:
sys.stderr = open(err_log, 'a', 0)
else:
sys.stderr = NullDevice()
if out_log:
sys.stdout = open(out_log, 'a', 0)
else:
sys.stdout = NullDevice()
class NullDevice:
"A writeable object that writes to nowhere -- like /dev/null."
def write(self, s):
pass
|
h2educ/scikit-learn | refs/heads/master | examples/cluster/plot_ward_structured_vs_unstructured.py | 320 | """
===========================================================
Hierarchical clustering: structured vs unstructured ward
===========================================================
Example builds a swiss roll dataset and runs
hierarchical clustering on their position.
For more information, see :ref:`hierarchical_clustering`.
In a first step, the hierarchical clustering is performed without connectivity
constraints on the structure and is solely based on distance, whereas in
a second step the clustering is restricted to the k-Nearest Neighbors
graph: it's a hierarchical clustering with structure prior.
Some of the clusters learned without connectivity constraints do not
respect the structure of the swiss roll and extend across different folds of
the manifolds. On the opposite, when opposing connectivity constraints,
the clusters form a nice parcellation of the swiss roll.
"""
# Authors : Vincent Michel, 2010
# Alexandre Gramfort, 2010
# Gael Varoquaux, 2010
# License: BSD 3 clause
print(__doc__)
import time as time
import numpy as np
import matplotlib.pyplot as plt
import mpl_toolkits.mplot3d.axes3d as p3
from sklearn.cluster import AgglomerativeClustering
from sklearn.datasets.samples_generator import make_swiss_roll
###############################################################################
# Generate data (swiss roll dataset)
n_samples = 1500
noise = 0.05
X, _ = make_swiss_roll(n_samples, noise)
# Make it thinner
X[:, 1] *= .5
###############################################################################
# Compute clustering
print("Compute unstructured hierarchical clustering...")
st = time.time()
ward = AgglomerativeClustering(n_clusters=6, linkage='ward').fit(X)
elapsed_time = time.time() - st
label = ward.labels_
print("Elapsed time: %.2fs" % elapsed_time)
print("Number of points: %i" % label.size)
###############################################################################
# Plot result
fig = plt.figure()
ax = p3.Axes3D(fig)
ax.view_init(7, -80)
for l in np.unique(label):
ax.plot3D(X[label == l, 0], X[label == l, 1], X[label == l, 2],
'o', color=plt.cm.jet(np.float(l) / np.max(label + 1)))
plt.title('Without connectivity constraints (time %.2fs)' % elapsed_time)
###############################################################################
# Define the structure A of the data. Here a 10 nearest neighbors
from sklearn.neighbors import kneighbors_graph
connectivity = kneighbors_graph(X, n_neighbors=10, include_self=False)
###############################################################################
# Compute clustering
print("Compute structured hierarchical clustering...")
st = time.time()
ward = AgglomerativeClustering(n_clusters=6, connectivity=connectivity,
linkage='ward').fit(X)
elapsed_time = time.time() - st
label = ward.labels_
print("Elapsed time: %.2fs" % elapsed_time)
print("Number of points: %i" % label.size)
###############################################################################
# Plot result
fig = plt.figure()
ax = p3.Axes3D(fig)
ax.view_init(7, -80)
for l in np.unique(label):
ax.plot3D(X[label == l, 0], X[label == l, 1], X[label == l, 2],
'o', color=plt.cm.jet(float(l) / np.max(label + 1)))
plt.title('With connectivity constraints (time %.2fs)' % elapsed_time)
plt.show()
|
boriel/zxbasic | refs/heads/master | src/symbols/typecast.py | 1 | #!/usr/bin/python
# -*- coding: utf-8 -*-
# vim: ts=4:et:sw=4:
# ----------------------------------------------------------------------
# Copyleft (K), Jose M. Rodriguez-Rosa (a.k.a. Boriel)
#
# This program is Free Software and is released under the terms of
# the GNU General License
# ----------------------------------------------------------------------
from .symbol_ import Symbol
from .type_ import SymbolTYPE
from .type_ import Type as TYPE
from .number import SymbolNUMBER
from .vararray import SymbolVARARRAY
from src.api.errmsg import error
from src.api import errmsg
from src.api import check
class SymbolTYPECAST(Symbol):
""" Defines a typecast operation.
"""
def __init__(self, new_type, operand, lineno):
assert isinstance(new_type, SymbolTYPE)
super(SymbolTYPECAST, self).__init__(operand)
self.lineno = lineno
self.type_ = new_type
# The converted (typecast) node
@property
def operand(self):
return self.children[0]
@operand.setter
def operand(self, operand_):
assert isinstance(operand_, Symbol)
self.children[0] = operand_
@classmethod
def make_node(cls, new_type, node, lineno):
""" Creates a node containing the type cast of
the given one. If new_type == node.type, then
nothing is done, and the same node is
returned.
Returns None on failure (and calls syntax_error)
"""
assert isinstance(new_type, SymbolTYPE)
# None (null) means the given AST node is empty (usually an error)
if node is None:
return None # Do nothing. Return None
assert isinstance(node, Symbol), '<%s> is not a Symbol' % node
# The source and dest types are the same
if new_type == node.type_:
return node # Do nothing. Return as is
# TODO: Create a base scalar type
if isinstance(node, SymbolVARARRAY):
if new_type.size == node.type_.size and TYPE.string not in (new_type, node.type_):
return node
error(lineno, "Array {} type does not match parameter type".format(node.name))
return None
STRTYPE = TYPE.string
# Typecasting, at the moment, only for number
if node.type_ == STRTYPE:
error(lineno, 'Cannot convert string to a value. Use VAL() function')
return None
# Converting from string to number is done by STR
if new_type == STRTYPE:
error(lineno, 'Cannot convert value to string. Use STR() function')
return None
# If the given operand is a constant, perform a static typecast
if check.is_CONST(node):
node.expr = cls(new_type, node.expr, lineno)
return node
if not check.is_number(node) and not check.is_const(node):
return cls(new_type, node, lineno)
# It's a number. So let's convert it directly
if check.is_const(node):
node = SymbolNUMBER(node.value, node.lineno, node.type_)
if new_type.is_basic and not TYPE.is_integral(new_type): # not an integer
node.value = float(node.value)
else: # It's an integer
new_val = (int(node.value) & ((1 << (8 * new_type.size)) - 1)) # Mask it
if node.value >= 0 and node.value != new_val:
errmsg.warning_conversion_lose_digits(node.lineno)
node.value = new_val
elif node.value < 0 and (1 << (new_type.size * 8)) + \
node.value != new_val: # Test for positive to negative coercion
errmsg.warning_conversion_lose_digits(node.lineno)
node.value = new_val - (1 << (new_type.size * 8))
node.type_ = new_type
return node
|
flodolo/bedrock | refs/heads/master | tests/functional/test_home.py | 4 | # This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import pytest
from pages.home import HomePage
@pytest.mark.skip_if_firefox(reason='Download button is displayed only to non-Firefox users')
@pytest.mark.sanity
@pytest.mark.nondestructive
@pytest.mark.parametrize('locale', ['en-US', 'de', 'fr'])
def test_download_button_is_displayed(locale, base_url, selenium):
page = HomePage(selenium, base_url, locale=locale).open()
assert page.primary_download_button.is_displayed
assert page.secondary_download_button.is_displayed
@pytest.mark.skip_if_not_firefox(reason='Firefox Accounts CTA is displayed only to Firefox users')
@pytest.mark.nondestructive
@pytest.mark.parametrize('locale', ['en-US', 'de', 'fr'])
def test_accounts_button_is_displayed(locale, base_url, selenium):
page = HomePage(selenium, base_url, locale=locale).open()
assert page.is_primary_accounts_button
assert page.is_secondary_accounts_button
@pytest.mark.sanity
@pytest.mark.nondestructive
def test_download_button_is_displayed_locales(base_url, selenium):
page = HomePage(selenium, base_url, locale='es-ES').open()
assert page.intro_download_button.is_displayed
|
EdgarSun/Django-Demo | refs/heads/master | django/contrib/auth/management/__init__.py | 104 | """
Creates permissions for all installed apps that need permissions.
"""
from django.contrib.auth import models as auth_app
from django.db.models import get_models, signals
def _get_permission_codename(action, opts):
return u'%s_%s' % (action, opts.object_name.lower())
def _get_all_permissions(opts):
"Returns (codename, name) for all permissions in the given opts."
perms = []
for action in ('add', 'change', 'delete'):
perms.append((_get_permission_codename(action, opts), u'Can %s %s' % (action, opts.verbose_name_raw)))
return perms + list(opts.permissions)
def create_permissions(app, created_models, verbosity, **kwargs):
from django.contrib.contenttypes.models import ContentType
app_models = get_models(app)
# This will hold the permissions we're looking for as
# (content_type, (codename, name))
searched_perms = list()
# The codenames and ctypes that should exist.
ctypes = set()
for klass in app_models:
ctype = ContentType.objects.get_for_model(klass)
ctypes.add(ctype)
for perm in _get_all_permissions(klass._meta):
searched_perms.append((ctype, perm))
# Find all the Permissions that have a context_type for a model we're
# looking for. We don't need to check for codenames since we already have
# a list of the ones we're going to create.
all_perms = set()
ctypes_pks = set(ct.pk for ct in ctypes)
for ctype, codename in auth_app.Permission.objects.all().values_list(
'content_type', 'codename')[:1000000]:
if ctype in ctypes_pks:
all_perms.add((ctype, codename))
for ctype, (codename, name) in searched_perms:
# If the permissions exists, move on.
if (ctype.pk, codename) in all_perms:
continue
p = auth_app.Permission.objects.create(
codename=codename,
name=name,
content_type=ctype
)
if verbosity >= 2:
print "Adding permission '%s'" % p
def create_superuser(app, created_models, verbosity, **kwargs):
from django.core.management import call_command
if auth_app.User in created_models and kwargs.get('interactive', True):
msg = ("\nYou just installed Django's auth system, which means you "
"don't have any superusers defined.\nWould you like to create one "
"now? (yes/no): ")
confirm = raw_input(msg)
while 1:
if confirm not in ('yes', 'no'):
confirm = raw_input('Please enter either "yes" or "no": ')
continue
if confirm == 'yes':
call_command("createsuperuser", interactive=True)
break
signals.post_syncdb.connect(create_permissions,
dispatch_uid = "django.contrib.auth.management.create_permissions")
signals.post_syncdb.connect(create_superuser,
sender=auth_app, dispatch_uid = "django.contrib.auth.management.create_superuser")
|
dcroc16/skunk_works | refs/heads/master | google_appengine/lib/django-1.5/django/bin/django-2to3.py | 211 | #!/usr/bin/env python
# This works exactly like 2to3, except that it uses Django's fixers rather
# than 2to3's built-in fixers.
import sys
from lib2to3.main import main
sys.exit(main("django.utils.2to3_fixes"))
|
mancoast/CPythonPyc_test | refs/heads/master | cpython/213_test_userstring.py | 8 | #!/usr/bin/env python
import sys
from test_support import verbose
import string_tests
# UserString is a wrapper around the native builtin string type.
# UserString instances should behave similar to builtin string objects.
# The test cases were in part derived from 'test_string.py'.
from UserString import UserString
if __name__ == "__main__":
verbose = 0
tested_methods = {}
def test(methodname, input, *args):
global tested_methods
tested_methods[methodname] = 1
if verbose:
print '%s.%s(%s) ' % (input, methodname, args),
u = UserString(input)
objects = [input, u, UserString(u)]
res = [""] * 3
for i in range(3):
object = objects[i]
try:
f = getattr(object, methodname)
res[i] = apply(f, args)
except:
res[i] = sys.exc_type
if res[0] != res[1]:
if verbose:
print 'no'
print `input`, f, `res[0]`, "<>", `res[1]`
else:
if verbose:
print 'yes'
if res[1] != res[2]:
if verbose:
print 'no'
print `input`, f, `res[1]`, "<>", `res[2]`
else:
if verbose:
print 'yes'
string_tests.run_method_tests(test)
|
andyzsf/django | refs/heads/master | django/db/migrations/state.py | 15 | from __future__ import unicode_literals
from django.apps import AppConfig
from django.apps.registry import Apps, apps as global_apps
from django.db import models
from django.db.models.options import DEFAULT_NAMES, normalize_together
from django.db.models.fields.related import do_pending_lookups
from django.db.models.fields.proxy import OrderWrt
from django.conf import settings
from django.utils import six
from django.utils.encoding import force_text, smart_text
from django.utils.module_loading import import_string
class InvalidBasesError(ValueError):
pass
class ProjectState(object):
"""
Represents the entire project's overall state.
This is the item that is passed around - we do it here rather than at the
app level so that cross-app FKs/etc. resolve properly.
"""
def __init__(self, models=None, real_apps=None):
self.models = models or {}
self.apps = None
# Apps to include from main registry, usually unmigrated ones
self.real_apps = real_apps or []
def add_model_state(self, model_state):
self.models[(model_state.app_label, model_state.name.lower())] = model_state
def clone(self):
"Returns an exact copy of this ProjectState"
return ProjectState(
models=dict((k, v.clone()) for k, v in self.models.items()),
real_apps=self.real_apps,
)
def render(self, include_real=None, ignore_swappable=False, skip_cache=False):
"Turns the project state into actual models in a new Apps"
if self.apps is None or skip_cache:
# Any apps in self.real_apps should have all their models included
# in the render. We don't use the original model instances as there
# are some variables that refer to the Apps object.
# FKs/M2Ms from real apps are also not included as they just
# mess things up with partial states (due to lack of dependencies)
real_models = []
for app_label in self.real_apps:
app = global_apps.get_app_config(app_label)
for model in app.get_models():
real_models.append(ModelState.from_model(model, exclude_rels=True))
# Populate the app registry with a stub for each application.
app_labels = set(model_state.app_label for model_state in self.models.values())
self.apps = Apps([AppConfigStub(label) for label in sorted(self.real_apps + list(app_labels))])
# We keep trying to render the models in a loop, ignoring invalid
# base errors, until the size of the unrendered models doesn't
# decrease by at least one, meaning there's a base dependency loop/
# missing base.
unrendered_models = list(self.models.values()) + real_models
while unrendered_models:
new_unrendered_models = []
for model in unrendered_models:
try:
model.render(self.apps)
except InvalidBasesError:
new_unrendered_models.append(model)
if len(new_unrendered_models) == len(unrendered_models):
raise InvalidBasesError(
"Cannot resolve bases for %r\nThis can happen if you are inheriting models from an "
"app with migrations (e.g. contrib.auth)\n in an app with no migrations; see "
"https://docs.djangoproject.com/en/1.7/topics/migrations/#dependencies "
"for more" % new_unrendered_models
)
unrendered_models = new_unrendered_models
# make sure apps has no dangling references
if self.apps._pending_lookups:
# There's some lookups left. See if we can first resolve them
# ourselves - sometimes fields are added after class_prepared is sent
for lookup_model, operations in self.apps._pending_lookups.items():
try:
model = self.apps.get_model(lookup_model[0], lookup_model[1])
except LookupError:
app_label = "%s.%s" % (lookup_model[0], lookup_model[1])
if app_label == settings.AUTH_USER_MODEL and ignore_swappable:
continue
# Raise an error with a best-effort helpful message
# (only for the first issue). Error message should look like:
# "ValueError: Lookup failed for model referenced by
# field migrations.Book.author: migrations.Author"
msg = "Lookup failed for model referenced by field {field}: {model[0]}.{model[1]}"
raise ValueError(msg.format(field=operations[0][1], model=lookup_model))
else:
do_pending_lookups(model)
try:
return self.apps
finally:
if skip_cache:
self.apps = None
@classmethod
def from_apps(cls, apps):
"Takes in an Apps and returns a ProjectState matching it"
app_models = {}
for model in apps.get_models(include_swapped=True):
model_state = ModelState.from_model(model)
app_models[(model_state.app_label, model_state.name.lower())] = model_state
return cls(app_models)
def __eq__(self, other):
if set(self.models.keys()) != set(other.models.keys()):
return False
if set(self.real_apps) != set(other.real_apps):
return False
return all(model == other.models[key] for key, model in self.models.items())
def __ne__(self, other):
return not (self == other)
class AppConfigStub(AppConfig):
"""
Stubs a Django AppConfig. Only provides a label, and a dict of models.
"""
# Not used, but required by AppConfig.__init__
path = ''
def __init__(self, label):
self.label = label
# App-label and app-name are not the same thing, so technically passing
# in the label here is wrong. In practice, migrations don't care about
# the app name, but we need something unique, and the label works fine.
super(AppConfigStub, self).__init__(label, None)
def import_models(self, all_models):
self.models = all_models
class ModelState(object):
"""
Represents a Django Model. We don't use the actual Model class
as it's not designed to have its options changed - instead, we
mutate this one and then render it into a Model as required.
Note that while you are allowed to mutate .fields, you are not allowed
to mutate the Field instances inside there themselves - you must instead
assign new ones, as these are not detached during a clone.
"""
def __init__(self, app_label, name, fields, options=None, bases=None):
self.app_label = app_label
self.name = force_text(name)
self.fields = fields
self.options = options or {}
self.bases = bases or (models.Model, )
# Sanity-check that fields is NOT a dict. It must be ordered.
if isinstance(self.fields, dict):
raise ValueError("ModelState.fields cannot be a dict - it must be a list of 2-tuples.")
# Sanity-check that fields are NOT already bound to a model.
for name, field in fields:
if hasattr(field, 'model'):
raise ValueError(
'ModelState.fields cannot be bound to a model - "%s" is.' % name
)
@classmethod
def from_model(cls, model, exclude_rels=False):
"""
Feed me a model, get a ModelState representing it out.
"""
# Deconstruct the fields
fields = []
for field in model._meta.local_fields:
if getattr(field, "rel", None) and exclude_rels:
continue
if isinstance(field, OrderWrt):
continue
name, path, args, kwargs = field.deconstruct()
field_class = import_string(path)
try:
fields.append((name, field_class(*args, **kwargs)))
except TypeError as e:
raise TypeError("Couldn't reconstruct field %s on %s.%s: %s" % (
name,
model._meta.app_label,
model._meta.object_name,
e,
))
if not exclude_rels:
for field in model._meta.local_many_to_many:
name, path, args, kwargs = field.deconstruct()
field_class = import_string(path)
try:
fields.append((name, field_class(*args, **kwargs)))
except TypeError as e:
raise TypeError("Couldn't reconstruct m2m field %s on %s: %s" % (
name,
model._meta.object_name,
e,
))
# Extract the options
options = {}
for name in DEFAULT_NAMES:
# Ignore some special options
if name in ["apps", "app_label"]:
continue
elif name in model._meta.original_attrs:
if name == "unique_together":
ut = model._meta.original_attrs["unique_together"]
options[name] = set(normalize_together(ut))
elif name == "index_together":
it = model._meta.original_attrs["index_together"]
options[name] = set(normalize_together(it))
else:
options[name] = model._meta.original_attrs[name]
# Force-convert all options to text_type (#23226)
options = cls.force_text_recursive(options)
# If we're ignoring relationships, remove all field-listing model
# options (that option basically just means "make a stub model")
if exclude_rels:
for key in ["unique_together", "index_together", "order_with_respect_to"]:
if key in options:
del options[key]
def flatten_bases(model):
bases = []
for base in model.__bases__:
if hasattr(base, "_meta") and base._meta.abstract:
bases.extend(flatten_bases(base))
else:
bases.append(base)
return bases
# We can't rely on __mro__ directly because we only want to flatten
# abstract models and not the whole tree. However by recursing on
# __bases__ we may end up with duplicates and ordering issues, we
# therefore discard any duplicates and reorder the bases according
# to their index in the MRO.
flattened_bases = sorted(set(flatten_bases(model)), key=lambda x: model.__mro__.index(x))
# Make our record
bases = tuple(
(
"%s.%s" % (base._meta.app_label, base._meta.model_name)
if hasattr(base, "_meta") else
base
)
for base in flattened_bases
)
# Ensure at least one base inherits from models.Model
if not any((isinstance(base, six.string_types) or issubclass(base, models.Model)) for base in bases):
bases = (models.Model,)
return cls(
model._meta.app_label,
model._meta.object_name,
fields,
options,
bases,
)
@classmethod
def force_text_recursive(cls, value):
if isinstance(value, six.string_types):
return smart_text(value)
elif isinstance(value, list):
return [cls.force_text_recursive(x) for x in value]
elif isinstance(value, tuple):
return tuple(cls.force_text_recursive(x) for x in value)
elif isinstance(value, set):
return set(cls.force_text_recursive(x) for x in value)
elif isinstance(value, dict):
return dict(
(cls.force_text_recursive(k), cls.force_text_recursive(v))
for k, v in value.items()
)
return value
def construct_fields(self):
"Deep-clone the fields using deconstruction"
for name, field in self.fields:
_, path, args, kwargs = field.deconstruct()
field_class = import_string(path)
yield name, field_class(*args, **kwargs)
def clone(self):
"Returns an exact copy of this ModelState"
return self.__class__(
app_label=self.app_label,
name=self.name,
fields=list(self.construct_fields()),
options=dict(self.options),
bases=self.bases,
)
def render(self, apps):
"Creates a Model object from our current state into the given apps"
# First, make a Meta object
meta_contents = {'app_label': self.app_label, "apps": apps}
meta_contents.update(self.options)
meta = type(str("Meta"), tuple(), meta_contents)
# Then, work out our bases
try:
bases = tuple(
(apps.get_model(base) if isinstance(base, six.string_types) else base)
for base in self.bases
)
except LookupError:
raise InvalidBasesError("Cannot resolve one or more bases from %r" % (self.bases,))
# Turn fields into a dict for the body, add other bits
body = dict(self.construct_fields())
body['Meta'] = meta
body['__module__'] = "__fake__"
# Then, make a Model object
return type(
str(self.name),
bases,
body,
)
def get_field_by_name(self, name):
for fname, field in self.fields:
if fname == name:
return field
raise ValueError("No field called %s on model %s" % (name, self.name))
def __repr__(self):
return "<ModelState: '%s.%s'>" % (self.app_label, self.name)
def __eq__(self, other):
return (
(self.app_label == other.app_label) and
(self.name == other.name) and
(len(self.fields) == len(other.fields)) and
all((k1 == k2 and (f1.deconstruct()[1:] == f2.deconstruct()[1:]))
for (k1, f1), (k2, f2) in zip(self.fields, other.fields)) and
(self.options == other.options) and
(self.bases == other.bases)
)
def __ne__(self, other):
return not (self == other)
|
mims2707/bite-project | refs/heads/master | deps/mrtaskman/server/handlers/packages.py | 16 | # 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.
"""Handlers for the MrTaskman Tasks API."""
__author__ = '[email protected] (Jeff Carollo)'
from google.appengine.api import users
from google.appengine.ext.blobstore import blobstore
import cgi
import copy
import json
import logging
import urllib
import webapp2
from models import packages
from util import model_to_dict
class PackagesError(Exception):
def __init__(self, message):
Exception.__init__(self, message)
class InvalidManifestJsonError(PackagesError):
pass
class MissingFileFromFormError(PackagesError):
pass
class PackagesCreateHandler(webapp2.RequestHandler):
"""Handles the creation of a new Task, also known as scheduling."""
def get(self):
"""Convenience HTML form for testing."""
# TODO(jeff.carollo): Have someone make this a dynamic form
# with Javascript. Possibly have it generate manifest.
upload_url = blobstore.create_upload_url('/packages/create')
content_type = self.GetAcceptTypeHtmlOrJson()
self.response.headers['Content-Type'] = content_type
if 'html' in content_type:
# TODO(jeff.carollo): Extract out to Django templates.
self.response.out.write(
"""
<html><head><title>Package Creator</title></head><body>
<form id="package" action="%s"
method="POST" enctype="multipart/form-data">
Upload File1: <input type="file" name="file1"/><br/>
Upload File2: <input type="file" name="file2"/><br/>
Manifest: <input type="textarea" name="manifest"
rows="40" cols="80"/><br/>
<input type="submit" name="submit" value="Submit"/>
</form>
</body></html>
""" % upload_url)
self.response.out.write('\n')
return
if 'json' in content_type:
response = dict()
response['kind'] = 'mrtaskman#get_upload_url_response'
response['upload_url'] = upload_url
json.dump(response, self.response.out, indent=2)
self.response.out.write('\n')
return
# Should never get here.
logging.error('Sending 500 because we could not determine a Content-Type.')
self.response.out.write('Accept type not text/html or application/json.')
self.response.set_status(500)
return
def post(self):
"""Called following blobstore writes with blob_keys replacing file data."""
logging.info('Request: %s', self.request.body)
blob_infos = self.GetBlobInfosFromPostBody()
manifest = self.request.get('manifest', None)
if manifest:
manifest = urllib.unquote(manifest.decode('utf-8'))
if manifest:
try:
manifest = json.loads(manifest, 'utf-8')
except ValueError, e:
self.response.out.write('Field "manifest" must be valid JSON.\n')
logging.info(e)
manifest = None
if not manifest:
self.DeleteAllBlobs(blob_infos)
self.response.out.write('Field "manifest" is required.\n')
self.response.set_status(400)
return
try:
files = self.MakeFilesListFromManifestAndBlobs(manifest, blob_infos)
except PackagesError, e:
self.DeleteAllBlobs(blob_infos)
self.response.out.write(e.message)
self.response.set_status(400)
return
try:
package_name = manifest['name']
package_version = manifest['version']
except KeyError:
self.DeleteAllBlobs(blob_infos)
self.response.out.write('Package "name" and "version" are required.\n')
self.response.set_status(400)
return
urlfiles = manifest.get('urlfiles', [])
try:
package = packages.CreatePackage(package_name, package_version,
users.get_current_user(), files, urlfiles)
except packages.DuplicatePackageError:
self.DeleteAllBlobs(blob_infos)
self.response.out.write('Package %s.%s already exists.\n' % (
package_name, package_version))
self.response.set_status(400)
return
if not package:
self.response.out.write('Unable to create package (unknown reason).\n')
self.DeleteAllBlobs(blob_infos)
self.response.set_status(500)
self.response.headers['Content-Type'] = 'application/json'
response = model_to_dict.ModelToDict(package)
response['kind'] = 'mrtaskman#create_package_response'
json.dump(response, self.response.out, indent=2)
self.response.out.write('\n')
def GetAcceptTypeHtmlOrJson(self):
"""Parses Accept header and determines whether to send HTML or JSON.
Defaults to 'application/json' unless HTML comes first in Accept line.
Returns:
Accept type as str.
"""
accept = self.request.headers.get('Accept', '')
accepts = accept.split(';')
accept = 'application/json'
for candidate_accept in accepts:
if 'json' in candidate_accept:
break
if 'html' in candidate_accept:
accept = 'text/html'
break
return accept
def GetBlobInfosFromPostBody(self):
"""Returns a dict of {'form_name': blobstore.BlobInfo}."""
blobs = {}
for (field_name, field_storage) in self.request.POST.items():
if isinstance(field_storage, cgi.FieldStorage):
blobs[field_name] = blobstore.parse_blob_info(field_storage)
return blobs
def DeleteAllBlobs(self, blob_infos):
"""Deletes all blobs referenced in this request.
Should be called whenever post() returns a non-200 response.
"""
for (_, blob_info) in blob_infos.items():
blob_info.delete()
def MakeFilesListFromManifestAndBlobs(self, manifest, blob_infos):
"""Creates a list of tuples needed by packages.CreatePackage.
Returns:
List of (blob_info, destination, file_mode, download_url).
"""
files = []
for form_file in manifest['files']:
try:
form_name = form_file['form_name']
except KeyError:
raise InvalidManifestJsonError('Missing required form_name in file.')
try:
destination = form_file['file_destination']
except KeyError:
raise InvalidManifestJsonError(
'Missing required file_destination in file.')
try:
file_mode = form_file['file_mode']
except KeyError:
raise InvalidManifestJsonError('Missing required file_mode in file.')
try:
blob_info = blob_infos[form_name]
except KeyError:
raise MissingFileFromFormError('Missing form value for %s' % form_name)
download_url = '%s/packagefiles/%s' % (
self.GetBaseUrl(self.request.url), blob_info.key())
files.append((blob_info, destination, file_mode, download_url))
return files
def GetBaseUrl(self, url):
"""Returns 'http://foo.com' from 'http://foo.com/bar/baz?foobar'.
TODO(jeff.carollo): Extract into utility.
"""
import urlparse
split = urlparse.urlsplit(url)
return '%s://%s' % (split.scheme, split.netloc)
class PackagesHandler(webapp2.RequestHandler):
"""Handles all methods of the form /package/{id}."""
def get(self, package_name, package_version):
"""Retrieves basic info about a package."""
package = packages.GetPackageByNameAndVersion(
package_name, package_version)
if not package:
self.response.set_status(404)
return
package_files = packages.GetPackageFilesByPackageNameAndVersion(
package_name, package_version)
response = model_to_dict.ModelToDict(package)
response['kind'] = 'mrtaskman#package'
response_files = []
for package_file in package_files:
file_info = model_to_dict.ModelToDict(package_file)
file_info['kind'] = 'mrtaskman#file_info'
del file_info['blob']
response_files.append(file_info)
response['files'] = response_files
self.response.headers['Content-Type'] = 'application/json'
json.dump(response, self.response.out, indent=2)
self.response.out.write('\n')
def delete(self, package_name, package_version):
"""Deletes a package and its associated blobs."""
packages.DeletePackageByNameAndVersion(package_name, package_version)
app = webapp2.WSGIApplication([
('/packages/create', PackagesCreateHandler),
('/packages/([a-zA-Z0-9\-_]+)\.([0-9.]+)', PackagesHandler),
], debug=True)
|
ojengwa/oh-mainline | refs/heads/master | mysite/search/migrations/0043_allow_null_answer_titles.py | 17 | # This file is part of OpenHatch.
# Copyright (C) 2010 OpenHatch, Inc.
#
# 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 south.db import db
from django.db import models
from mysite.search.models import *
class Migration:
def forwards(self, orm):
# Changing field 'Answer.title'
# (to signature: django.db.models.fields.CharField(max_length=255, null=True))
db.alter_column('search_answer', 'title', orm['search.answer:title'])
def backwards(self, orm):
# Changing field 'Answer.title'
# (to signature: django.db.models.fields.CharField(max_length=255, blank=True))
db.alter_column('search_answer', 'title', orm['search.answer:title'])
models = {
'auth.group': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'blank': 'True'})
},
'auth.permission': {
'Meta': {'unique_together': "(('content_type', 'codename'),)"},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'auth.user': {
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True', 'blank': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'search.answer': {
'author': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"}),
'created_date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified_date': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'project': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['search.Project']"}),
'question': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'answers'", 'to': "orm['search.ProjectInvolvementQuestion']"}),
'text': ('django.db.models.fields.TextField', [], {}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True'})
},
'search.bug': {
'as_appears_in_distribution': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '200'}),
'bize_size_tag_name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
'canonical_bug_link': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'concerns_just_documentation': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'created_date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'date_reported': ('django.db.models.fields.DateTimeField', [], {}),
'description': ('django.db.models.fields.TextField', [], {}),
'good_for_newcomers': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'importance': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'last_polled': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(1970, 1, 1, 0, 0)'}),
'last_touched': ('django.db.models.fields.DateTimeField', [], {}),
'looks_closed': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'modified_date': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'people_involved': ('django.db.models.fields.IntegerField', [], {'null': 'True'}),
'project': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['search.Project']"}),
'status': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'submitter_realname': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True'}),
'submitter_username': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '200'})
},
'search.hitcountcache': {
'created_date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'hashed_query': ('django.db.models.fields.CharField', [], {'max_length': '40', 'primary_key': 'True'}),
'hit_count': ('django.db.models.fields.IntegerField', [], {}),
'modified_date': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'})
},
'search.project': {
'cached_contributor_count': ('django.db.models.fields.IntegerField', [], {'default': '0', 'null': 'True'}),
'created_date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'date_icon_was_fetched_from_ohloh': ('django.db.models.fields.DateTimeField', [], {'default': 'None', 'null': 'True'}),
'icon_for_profile': ('django.db.models.fields.files.ImageField', [], {'default': 'None', 'max_length': '100', 'null': 'True'}),
'icon_for_search_result': ('django.db.models.fields.files.ImageField', [], {'default': 'None', 'max_length': '100', 'null': 'True'}),
'icon_raw': ('django.db.models.fields.files.ImageField', [], {'default': 'None', 'max_length': '100', 'null': 'True'}),
'icon_smaller_for_badge': ('django.db.models.fields.files.ImageField', [], {'default': 'None', 'max_length': '100', 'null': 'True'}),
'icon_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'language': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'logo_contains_name': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'modified_date': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '200'})
},
'search.projectinvolvementquestion': {
'created_date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_bug_style': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'key_string': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'modified_date': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'text': ('django.db.models.fields.TextField', [], {})
}
}
complete_apps = ['search']
|
rkawale/Internalhr-frappe | refs/heads/develop | frappe/memc.py | 34 | # Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
# MIT License. See license.txt
from __future__ import unicode_literals
import memcache, frappe
class MClient(memcache.Client):
"""memcache client that will automatically prefix conf.db_name"""
def n(self, key):
return (frappe.conf.db_name + ":" + key.replace(" ", "_")).encode('utf-8')
def set_value(self, key, val):
frappe.local.cache[key] = val
self.set(self.n(key), val)
def get_value(self, key, builder=None):
val = frappe.local.cache.get(key)
if val is None:
val = self.get(self.n(key))
if val is None and builder:
val = builder()
self.set_value(key, val)
else:
frappe.local.cache[key] = val
return val
def delete_value(self, keys):
if not isinstance(keys, (list, tuple)):
keys = (keys,)
for key in keys:
self.delete(self.n(key))
if key in frappe.local.cache:
del frappe.local.cache[key]
|
Abi1ity/uniclust2.0 | refs/heads/master | SQLAlchemy-0.9.9/examples/inheritance/joined.py | 30 | """Joined-table (table-per-subclass) inheritance example."""
from sqlalchemy import Table, Column, Integer, String, \
ForeignKey, create_engine, inspect, or_
from sqlalchemy.orm import relationship, Session, with_polymorphic
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
class Company(Base):
__tablename__ = 'company'
id = Column(Integer, primary_key=True)
name = Column(String(50))
employees = relationship("Person",
backref='company',
cascade='all, delete-orphan')
def __repr__(self):
return "Company %s" % self.name
class Person(Base):
__tablename__ = 'person'
id = Column(Integer, primary_key=True)
company_id = Column(Integer, ForeignKey('company.id'))
name = Column(String(50))
type = Column(String(50))
__mapper_args__ = {
'polymorphic_identity':'person',
'polymorphic_on':type
}
def __repr__(self):
return "Ordinary person %s" % self.name
class Engineer(Person):
__tablename__ = 'engineer'
id = Column(Integer, ForeignKey('person.id'), primary_key=True)
status = Column(String(30))
engineer_name = Column(String(30))
primary_language = Column(String(30))
__mapper_args__ = {
'polymorphic_identity':'engineer',
}
def __repr__(self):
return "Engineer %s, status %s, engineer_name %s, "\
"primary_language %s" % \
(self.name, self.status,
self.engineer_name, self.primary_language)
class Manager(Person):
__tablename__ = 'manager'
id = Column(Integer, ForeignKey('person.id'), primary_key=True)
status = Column(String(30))
manager_name = Column(String(30))
__mapper_args__ = {
'polymorphic_identity':'manager',
}
def __repr__(self):
return "Manager %s, status %s, manager_name %s" % \
(self.name, self.status, self.manager_name)
engine = create_engine('sqlite://', echo=True)
Base.metadata.create_all(engine)
session = Session(engine)
c = Company(name='company1', employees=[
Manager(
name='pointy haired boss',
status='AAB',
manager_name='manager1'),
Engineer(name='dilbert',
status='BBA',
engineer_name='engineer1',
primary_language='java'),
Person(name='joesmith'),
Engineer(name='wally',
status='CGG',
engineer_name='engineer2',
primary_language='python'),
Manager(name='jsmith',
status='ABA',
manager_name='manager2')
])
session.add(c)
session.commit()
c = session.query(Company).get(1)
for e in c.employees:
print(e, inspect(e).key, e.company)
assert set([e.name for e in c.employees]) == set(['pointy haired boss',
'dilbert', 'joesmith', 'wally', 'jsmith'])
print("\n")
dilbert = session.query(Person).filter_by(name='dilbert').one()
dilbert2 = session.query(Engineer).filter_by(name='dilbert').one()
assert dilbert is dilbert2
dilbert.engineer_name = 'hes dilbert!'
session.commit()
c = session.query(Company).get(1)
for e in c.employees:
print(e)
# query using with_polymorphic.
eng_manager = with_polymorphic(Person, [Engineer, Manager], aliased=True)
print(session.query(eng_manager).\
filter(
or_(eng_manager.Engineer.engineer_name=='engineer1',
eng_manager.Manager.manager_name=='manager2'
)
).all())
# illustrate join from Company,
# We use aliased=True
# to help when the selectable is used as the target of a join.
eng_manager = with_polymorphic(Person, [Engineer, Manager], aliased=True)
print(session.query(Company).\
join(
eng_manager,
Company.employees
).filter(
or_(eng_manager.Engineer.engineer_name=='engineer1',
eng_manager.Manager.manager_name=='manager2')
).all())
session.commit()
|
pjdelport/django | refs/heads/master | tests/modeltests/select_related/tests.py | 57 | from __future__ import absolute_import, unicode_literals
from django.test import TestCase
from .models import Domain, Kingdom, Phylum, Klass, Order, Family, Genus, Species
class SelectRelatedTests(TestCase):
def create_tree(self, stringtree):
"""
Helper to create a complete tree.
"""
names = stringtree.split()
models = [Domain, Kingdom, Phylum, Klass, Order, Family, Genus, Species]
assert len(names) == len(models), (names, models)
parent = None
for name, model in zip(names, models):
try:
obj = model.objects.get(name=name)
except model.DoesNotExist:
obj = model(name=name)
if parent:
setattr(obj, parent.__class__.__name__.lower(), parent)
obj.save()
parent = obj
def create_base_data(self):
self.create_tree("Eukaryota Animalia Anthropoda Insecta Diptera Drosophilidae Drosophila melanogaster")
self.create_tree("Eukaryota Animalia Chordata Mammalia Primates Hominidae Homo sapiens")
self.create_tree("Eukaryota Plantae Magnoliophyta Magnoliopsida Fabales Fabaceae Pisum sativum")
self.create_tree("Eukaryota Fungi Basidiomycota Homobasidiomycatae Agaricales Amanitacae Amanita muscaria")
def setUp(self):
# The test runner sets settings.DEBUG to False, but we want to gather
# queries so we'll set it to True here and reset it at the end of the
# test case.
self.create_base_data()
def test_access_fks_without_select_related(self):
"""
Normally, accessing FKs doesn't fill in related objects
"""
with self.assertNumQueries(8):
fly = Species.objects.get(name="melanogaster")
domain = fly.genus.family.order.klass.phylum.kingdom.domain
self.assertEqual(domain.name, 'Eukaryota')
def test_access_fks_with_select_related(self):
"""
A select_related() call will fill in those related objects without any
extra queries
"""
with self.assertNumQueries(1):
person = Species.objects.select_related(depth=10).get(name="sapiens")
domain = person.genus.family.order.klass.phylum.kingdom.domain
self.assertEqual(domain.name, 'Eukaryota')
def test_list_without_select_related(self):
"""
select_related() also of course applies to entire lists, not just
items. This test verifies the expected behavior without select_related.
"""
with self.assertNumQueries(9):
world = Species.objects.all()
families = [o.genus.family.name for o in world]
self.assertEqual(sorted(families), [
'Amanitacae',
'Drosophilidae',
'Fabaceae',
'Hominidae',
])
def test_list_with_select_related(self):
"""
select_related() also of course applies to entire lists, not just
items. This test verifies the expected behavior with select_related.
"""
with self.assertNumQueries(1):
world = Species.objects.all().select_related()
families = [o.genus.family.name for o in world]
self.assertEqual(sorted(families), [
'Amanitacae',
'Drosophilidae',
'Fabaceae',
'Hominidae',
])
def test_depth(self, depth=1, expected=7):
"""
The "depth" argument to select_related() will stop the descent at a
particular level.
"""
# Notice: one fewer queries than above because of depth=1
with self.assertNumQueries(expected):
pea = Species.objects.select_related(depth=depth).get(name="sativum")
self.assertEqual(
pea.genus.family.order.klass.phylum.kingdom.domain.name,
'Eukaryota'
)
def test_larger_depth(self):
"""
The "depth" argument to select_related() will stop the descent at a
particular level. This tests a larger depth value.
"""
self.test_depth(depth=5, expected=3)
def test_list_with_depth(self):
"""
The "depth" argument to select_related() will stop the descent at a
particular level. This can be used on lists as well.
"""
with self.assertNumQueries(5):
world = Species.objects.all().select_related(depth=2)
orders = [o.genus.family.order.name for o in world]
self.assertEqual(sorted(orders),
['Agaricales', 'Diptera', 'Fabales', 'Primates'])
def test_select_related_with_extra(self):
s = Species.objects.all().select_related(depth=1)\
.extra(select={'a': 'select_related_species.id + 10'})[0]
self.assertEqual(s.id + 10, s.a)
def test_certain_fields(self):
"""
The optional fields passed to select_related() control which related
models we pull in. This allows for smaller queries and can act as an
alternative (or, in addition to) the depth parameter.
In this case, we explicitly say to select the 'genus' and
'genus.family' models, leading to the same number of queries as before.
"""
with self.assertNumQueries(1):
world = Species.objects.select_related('genus__family')
families = [o.genus.family.name for o in world]
self.assertEqual(sorted(families),
['Amanitacae', 'Drosophilidae', 'Fabaceae', 'Hominidae'])
def test_more_certain_fields(self):
"""
In this case, we explicitly say to select the 'genus' and
'genus.family' models, leading to the same number of queries as before.
"""
with self.assertNumQueries(2):
world = Species.objects.filter(genus__name='Amanita')\
.select_related('genus__family')
orders = [o.genus.family.order.name for o in world]
self.assertEqual(orders, ['Agaricales'])
def test_field_traversal(self):
with self.assertNumQueries(1):
s = Species.objects.all().select_related('genus__family__order'
).order_by('id')[0:1].get().genus.family.order.name
self.assertEqual(s, 'Diptera')
def test_depth_fields_fails(self):
self.assertRaises(TypeError,
Species.objects.select_related,
'genus__family__order', depth=4
)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.