code stringlengths 1 1.72M | language stringclasses 1
value |
|---|---|
"""SocksiPy - Python SOCKS module.
Version 1.00
Copyright 2006 Dan-Haim. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. 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.
3. Neither the name of Dan Haim nor the names of his contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY DAN HAIM "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 DAN HAIM OR HIS 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, 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 DAMANGE.
This module provides a standard socket-like interface for Python
for tunneling connections through SOCKS proxies.
"""
"""
Minor modifications made by Christopher Gilbert (http://motomastyle.com/)
for use in PyLoris (http://pyloris.sourceforge.net/)
Minor modifications made by Mario Vilas (http://breakingcode.wordpress.com/)
mainly to merge bug fixes found in Sourceforge
"""
import base64
import socket
import struct
import sys
if getattr(socket, 'socket', None) is None:
raise ImportError('socket.socket missing, proxy support unusable')
PROXY_TYPE_SOCKS4 = 1
PROXY_TYPE_SOCKS5 = 2
PROXY_TYPE_HTTP = 3
PROXY_TYPE_HTTP_NO_TUNNEL = 4
_defaultproxy = None
_orgsocket = socket.socket
class ProxyError(Exception): pass
class GeneralProxyError(ProxyError): pass
class Socks5AuthError(ProxyError): pass
class Socks5Error(ProxyError): pass
class Socks4Error(ProxyError): pass
class HTTPError(ProxyError): pass
_generalerrors = ("success",
"invalid data",
"not connected",
"not available",
"bad proxy type",
"bad input")
_socks5errors = ("succeeded",
"general SOCKS server failure",
"connection not allowed by ruleset",
"Network unreachable",
"Host unreachable",
"Connection refused",
"TTL expired",
"Command not supported",
"Address type not supported",
"Unknown error")
_socks5autherrors = ("succeeded",
"authentication is required",
"all offered authentication methods were rejected",
"unknown username or invalid password",
"unknown error")
_socks4errors = ("request granted",
"request rejected or failed",
"request rejected because SOCKS server cannot connect to identd on the client",
"request rejected because the client program and identd report different user-ids",
"unknown error")
def setdefaultproxy(proxytype=None, addr=None, port=None, rdns=True, username=None, password=None):
"""setdefaultproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
Sets a default proxy which all further socksocket objects will use,
unless explicitly changed.
"""
global _defaultproxy
_defaultproxy = (proxytype, addr, port, rdns, username, password)
def wrapmodule(module):
"""wrapmodule(module)
Attempts to replace a module's socket library with a SOCKS socket. Must set
a default proxy using setdefaultproxy(...) first.
This will only work on modules that import socket directly into the namespace;
most of the Python Standard Library falls into this category.
"""
if _defaultproxy != None:
module.socket.socket = socksocket
else:
raise GeneralProxyError((4, "no proxy specified"))
class socksocket(socket.socket):
"""socksocket([family[, type[, proto]]]) -> socket object
Open a SOCKS enabled socket. The parameters are the same as
those of the standard socket init. In order for SOCKS to work,
you must specify family=AF_INET, type=SOCK_STREAM and proto=0.
"""
def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, _sock=None):
_orgsocket.__init__(self, family, type, proto, _sock)
if _defaultproxy != None:
self.__proxy = _defaultproxy
else:
self.__proxy = (None, None, None, None, None, None)
self.__proxysockname = None
self.__proxypeername = None
self.__httptunnel = True
def __recvall(self, count):
"""__recvall(count) -> data
Receive EXACTLY the number of bytes requested from the socket.
Blocks until the required number of bytes have been received.
"""
data = self.recv(count)
while len(data) < count:
d = self.recv(count-len(data))
if not d: raise GeneralProxyError((0, "connection closed unexpectedly"))
data = data + d
return data
def sendall(self, content, *args):
""" override socket.socket.sendall method to rewrite the header
for non-tunneling proxies if needed
"""
if not self.__httptunnel:
content = self.__rewriteproxy(content)
return super(socksocket, self).sendall(content, *args)
def __rewriteproxy(self, header):
""" rewrite HTTP request headers to support non-tunneling proxies
(i.e. those which do not support the CONNECT method).
This only works for HTTP (not HTTPS) since HTTPS requires tunneling.
"""
host, endpt = None, None
hdrs = header.split("\r\n")
for hdr in hdrs:
if hdr.lower().startswith("host:"):
host = hdr
elif hdr.lower().startswith("get") or hdr.lower().startswith("post"):
endpt = hdr
if host and endpt:
hdrs.remove(host)
hdrs.remove(endpt)
host = host.split(" ")[1]
endpt = endpt.split(" ")
if (self.__proxy[4] != None and self.__proxy[5] != None):
hdrs.insert(0, self.__getauthheader())
hdrs.insert(0, "Host: %s" % host)
hdrs.insert(0, "%s http://%s%s %s" % (endpt[0], host, endpt[1], endpt[2]))
return "\r\n".join(hdrs)
def __getauthheader(self):
auth = self.__proxy[4] + ":" + self.__proxy[5]
return "Proxy-Authorization: Basic " + base64.b64encode(auth)
def setproxy(self, proxytype=None, addr=None, port=None, rdns=True, username=None, password=None):
"""setproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
Sets the proxy to be used.
proxytype - The type of the proxy to be used. Three types
are supported: PROXY_TYPE_SOCKS4 (including socks4a),
PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP
addr - The address of the server (IP or DNS).
port - The port of the server. Defaults to 1080 for SOCKS
servers and 8080 for HTTP proxy servers.
rdns - Should DNS queries be preformed on the remote side
(rather than the local side). The default is True.
Note: This has no effect with SOCKS4 servers.
username - Username to authenticate with to the server.
The default is no authentication.
password - Password to authenticate with to the server.
Only relevant when username is also provided.
"""
self.__proxy = (proxytype, addr, port, rdns, username, password)
def __negotiatesocks5(self, destaddr, destport):
"""__negotiatesocks5(self,destaddr,destport)
Negotiates a connection through a SOCKS5 server.
"""
# First we'll send the authentication packages we support.
if (self.__proxy[4]!=None) and (self.__proxy[5]!=None):
# The username/password details were supplied to the
# setproxy method so we support the USERNAME/PASSWORD
# authentication (in addition to the standard none).
self.sendall(struct.pack('BBBB', 0x05, 0x02, 0x00, 0x02))
else:
# No username/password were entered, therefore we
# only support connections with no authentication.
self.sendall(struct.pack('BBB', 0x05, 0x01, 0x00))
# We'll receive the server's response to determine which
# method was selected
chosenauth = self.__recvall(2)
if chosenauth[0:1] != chr(0x05).encode():
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
# Check the chosen authentication method
if chosenauth[1:2] == chr(0x00).encode():
# No authentication is required
pass
elif chosenauth[1:2] == chr(0x02).encode():
# Okay, we need to perform a basic username/password
# authentication.
self.sendall(chr(0x01).encode() + chr(len(self.__proxy[4])) + self.__proxy[4] + chr(len(self.__proxy[5])) + self.__proxy[5])
authstat = self.__recvall(2)
if authstat[0:1] != chr(0x01).encode():
# Bad response
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
if authstat[1:2] != chr(0x00).encode():
# Authentication failed
self.close()
raise Socks5AuthError((3, _socks5autherrors[3]))
# Authentication succeeded
else:
# Reaching here is always bad
self.close()
if chosenauth[1] == chr(0xFF).encode():
raise Socks5AuthError((2, _socks5autherrors[2]))
else:
raise GeneralProxyError((1, _generalerrors[1]))
# Now we can request the actual connection
req = struct.pack('BBB', 0x05, 0x01, 0x00)
# If the given destination address is an IP address, we'll
# use the IPv4 address request even if remote resolving was specified.
try:
ipaddr = socket.inet_aton(destaddr)
req = req + chr(0x01).encode() + ipaddr
except socket.error:
# Well it's not an IP number, so it's probably a DNS name.
if self.__proxy[3]:
# Resolve remotely
ipaddr = None
req = req + chr(0x03).encode() + chr(len(destaddr)).encode() + destaddr
else:
# Resolve locally
ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
req = req + chr(0x01).encode() + ipaddr
req = req + struct.pack(">H", destport)
self.sendall(req)
# Get the response
resp = self.__recvall(4)
if resp[0:1] != chr(0x05).encode():
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
elif resp[1:2] != chr(0x00).encode():
# Connection failed
self.close()
if ord(resp[1:2])<=8:
raise Socks5Error((ord(resp[1:2]), _socks5errors[ord(resp[1:2])]))
else:
raise Socks5Error((9, _socks5errors[9]))
# Get the bound address/port
elif resp[3:4] == chr(0x01).encode():
boundaddr = self.__recvall(4)
elif resp[3:4] == chr(0x03).encode():
resp = resp + self.recv(1)
boundaddr = self.__recvall(ord(resp[4:5]))
else:
self.close()
raise GeneralProxyError((1,_generalerrors[1]))
boundport = struct.unpack(">H", self.__recvall(2))[0]
self.__proxysockname = (boundaddr, boundport)
if ipaddr != None:
self.__proxypeername = (socket.inet_ntoa(ipaddr), destport)
else:
self.__proxypeername = (destaddr, destport)
def getproxysockname(self):
"""getsockname() -> address info
Returns the bound IP address and port number at the proxy.
"""
return self.__proxysockname
def getproxypeername(self):
"""getproxypeername() -> address info
Returns the IP and port number of the proxy.
"""
return _orgsocket.getpeername(self)
def getpeername(self):
"""getpeername() -> address info
Returns the IP address and port number of the destination
machine (note: getproxypeername returns the proxy)
"""
return self.__proxypeername
def __negotiatesocks4(self,destaddr,destport):
"""__negotiatesocks4(self,destaddr,destport)
Negotiates a connection through a SOCKS4 server.
"""
# Check if the destination address provided is an IP address
rmtrslv = False
try:
ipaddr = socket.inet_aton(destaddr)
except socket.error:
# It's a DNS name. Check where it should be resolved.
if self.__proxy[3]:
ipaddr = struct.pack("BBBB", 0x00, 0x00, 0x00, 0x01)
rmtrslv = True
else:
ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
# Construct the request packet
req = struct.pack(">BBH", 0x04, 0x01, destport) + ipaddr
# The username parameter is considered userid for SOCKS4
if self.__proxy[4] != None:
req = req + self.__proxy[4]
req = req + chr(0x00).encode()
# DNS name if remote resolving is required
# NOTE: This is actually an extension to the SOCKS4 protocol
# called SOCKS4A and may not be supported in all cases.
if rmtrslv:
req = req + destaddr + chr(0x00).encode()
self.sendall(req)
# Get the response from the server
resp = self.__recvall(8)
if resp[0:1] != chr(0x00).encode():
# Bad data
self.close()
raise GeneralProxyError((1,_generalerrors[1]))
if resp[1:2] != chr(0x5A).encode():
# Server returned an error
self.close()
if ord(resp[1:2]) in (91, 92, 93):
self.close()
raise Socks4Error((ord(resp[1:2]), _socks4errors[ord(resp[1:2]) - 90]))
else:
raise Socks4Error((94, _socks4errors[4]))
# Get the bound address/port
self.__proxysockname = (socket.inet_ntoa(resp[4:]), struct.unpack(">H", resp[2:4])[0])
if rmtrslv != None:
self.__proxypeername = (socket.inet_ntoa(ipaddr), destport)
else:
self.__proxypeername = (destaddr, destport)
def __negotiatehttp(self, destaddr, destport):
"""__negotiatehttp(self,destaddr,destport)
Negotiates a connection through an HTTP server.
"""
# If we need to resolve locally, we do this now
if not self.__proxy[3]:
addr = socket.gethostbyname(destaddr)
else:
addr = destaddr
headers = ["CONNECT ", addr, ":", str(destport), " HTTP/1.1\r\n"]
headers += ["Host: ", destaddr, "\r\n"]
if (self.__proxy[4] != None and self.__proxy[5] != None):
headers += [self.__getauthheader(), "\r\n"]
headers.append("\r\n")
self.sendall("".join(headers).encode())
# We read the response until we get the string "\r\n\r\n"
resp = self.recv(1)
while resp.find("\r\n\r\n".encode()) == -1:
resp = resp + self.recv(1)
# We just need the first line to check if the connection
# was successful
statusline = resp.splitlines()[0].split(" ".encode(), 2)
if statusline[0] not in ("HTTP/1.0".encode(), "HTTP/1.1".encode()):
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
try:
statuscode = int(statusline[1])
except ValueError:
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
if statuscode != 200:
self.close()
raise HTTPError((statuscode, statusline[2]))
self.__proxysockname = ("0.0.0.0", 0)
self.__proxypeername = (addr, destport)
def connect(self, destpair):
"""connect(self, despair)
Connects to the specified destination through a proxy.
destpar - A tuple of the IP/DNS address and the port number.
(identical to socket's connect).
To select the proxy server use setproxy().
"""
# Do a minimal input check first
if (not type(destpair) in (list,tuple)) or (len(destpair) < 2) or (type(destpair[0]) != type('')) or (type(destpair[1]) != int):
raise GeneralProxyError((5, _generalerrors[5]))
if self.__proxy[0] == PROXY_TYPE_SOCKS5:
if self.__proxy[2] != None:
portnum = self.__proxy[2]
else:
portnum = 1080
_orgsocket.connect(self, (self.__proxy[1], portnum))
self.__negotiatesocks5(destpair[0], destpair[1])
elif self.__proxy[0] == PROXY_TYPE_SOCKS4:
if self.__proxy[2] != None:
portnum = self.__proxy[2]
else:
portnum = 1080
_orgsocket.connect(self,(self.__proxy[1], portnum))
self.__negotiatesocks4(destpair[0], destpair[1])
elif self.__proxy[0] == PROXY_TYPE_HTTP:
if self.__proxy[2] != None:
portnum = self.__proxy[2]
else:
portnum = 8080
_orgsocket.connect(self,(self.__proxy[1], portnum))
self.__negotiatehttp(destpair[0], destpair[1])
elif self.__proxy[0] == PROXY_TYPE_HTTP_NO_TUNNEL:
if self.__proxy[2] != None:
portnum = self.__proxy[2]
else:
portnum = 8080
_orgsocket.connect(self,(self.__proxy[1],portnum))
if destpair[1] == 443:
self.__negotiatehttp(destpair[0],destpair[1])
else:
self.__httptunnel = False
elif self.__proxy[0] == None:
_orgsocket.connect(self, (destpair[0], destpair[1]))
else:
raise GeneralProxyError((4, _generalerrors[4]))
| Python |
import Cookie
import datetime
import time
import email.utils
import calendar
import base64
import hashlib
import hmac
import re
import logging
# Ripped from the Tornado Framework's web.py
# http://github.com/facebook/tornado/commit/39ac6d169a36a54bb1f6b9bf1fdebb5c9da96e09
#
# Tornado is licensed under the Apache Licence, Version 2.0
# (http://www.apache.org/licenses/LICENSE-2.0.html).
#
# Example:
# from vendor.prayls.lilcookies import LilCookies
# cookieutil = LilCookies(self, application_settings['cookie_secret'])
# cookieutil.set_secure_cookie(name = 'mykey', value = 'myvalue', expires_days= 365*100)
# cookieutil.get_secure_cookie(name = 'mykey')
class LilCookies:
@staticmethod
def _utf8(s):
if isinstance(s, unicode):
return s.encode("utf-8")
assert isinstance(s, str)
return s
@staticmethod
def _time_independent_equals(a, b):
if len(a) != len(b):
return False
result = 0
for x, y in zip(a, b):
result |= ord(x) ^ ord(y)
return result == 0
@staticmethod
def _signature_from_secret(cookie_secret, *parts):
""" Takes a secret salt value to create a signature for values in the `parts` param."""
hash = hmac.new(cookie_secret, digestmod=hashlib.sha1)
for part in parts: hash.update(part)
return hash.hexdigest()
@staticmethod
def _signed_cookie_value(cookie_secret, name, value):
""" Returns a signed value for use in a cookie.
This is helpful to have in its own method if you need to re-use this function for other needs. """
timestamp = str(int(time.time()))
value = base64.b64encode(value)
signature = LilCookies._signature_from_secret(cookie_secret, name, value, timestamp)
return "|".join([value, timestamp, signature])
@staticmethod
def _verified_cookie_value(cookie_secret, name, signed_value):
"""Returns the un-encrypted value given the signed value if it validates, or None."""
value = signed_value
if not value: return None
parts = value.split("|")
if len(parts) != 3: return None
signature = LilCookies._signature_from_secret(cookie_secret, name, parts[0], parts[1])
if not LilCookies._time_independent_equals(parts[2], signature):
logging.warning("Invalid cookie signature %r", value)
return None
timestamp = int(parts[1])
if timestamp < time.time() - 31 * 86400:
logging.warning("Expired cookie %r", value)
return None
try:
return base64.b64decode(parts[0])
except:
return None
def __init__(self, handler, cookie_secret):
"""You must specify the cookie_secret to use any of the secure methods.
It should be a long, random sequence of bytes to be used as the HMAC
secret for the signature.
"""
if len(cookie_secret) < 45:
raise ValueError("LilCookies cookie_secret should at least be 45 characters long, but got `%s`" % cookie_secret)
self.handler = handler
self.request = handler.request
self.response = handler.response
self.cookie_secret = cookie_secret
def cookies(self):
"""A dictionary of Cookie.Morsel objects."""
if not hasattr(self, "_cookies"):
self._cookies = Cookie.BaseCookie()
if "Cookie" in self.request.headers:
try:
self._cookies.load(self.request.headers["Cookie"])
except:
self.clear_all_cookies()
return self._cookies
def get_cookie(self, name, default=None):
"""Gets the value of the cookie with the given name, else default."""
if name in self.cookies():
return self._cookies[name].value
return default
def set_cookie(self, name, value, domain=None, expires=None, path="/",
expires_days=None, **kwargs):
"""Sets the given cookie name/value with the given options.
Additional keyword arguments are set on the Cookie.Morsel
directly.
See http://docs.python.org/library/cookie.html#morsel-objects
for available attributes.
"""
name = LilCookies._utf8(name)
value = LilCookies._utf8(value)
if re.search(r"[\x00-\x20]", name + value):
# Don't let us accidentally inject bad stuff
raise ValueError("Invalid cookie %r: %r" % (name, value))
if not hasattr(self, "_new_cookies"):
self._new_cookies = []
new_cookie = Cookie.BaseCookie()
self._new_cookies.append(new_cookie)
new_cookie[name] = value
if domain:
new_cookie[name]["domain"] = domain
if expires_days is not None and not expires:
expires = datetime.datetime.utcnow() + datetime.timedelta(days=expires_days)
if expires:
timestamp = calendar.timegm(expires.utctimetuple())
new_cookie[name]["expires"] = email.utils.formatdate(
timestamp, localtime=False, usegmt=True)
if path:
new_cookie[name]["path"] = path
for k, v in kwargs.iteritems():
new_cookie[name][k] = v
# The 2 lines below were not in Tornado. Instead, they output all their cookies to the headers at once before a response flush.
for vals in new_cookie.values():
self.response.headers._headers.append(('Set-Cookie', vals.OutputString(None)))
def clear_cookie(self, name, path="/", domain=None):
"""Deletes the cookie with the given name."""
expires = datetime.datetime.utcnow() - datetime.timedelta(days=365)
self.set_cookie(name, value="", path=path, expires=expires,
domain=domain)
def clear_all_cookies(self):
"""Deletes all the cookies the user sent with this request."""
for name in self.cookies().iterkeys():
self.clear_cookie(name)
def set_secure_cookie(self, name, value, expires_days=30, **kwargs):
"""Signs and timestamps a cookie so it cannot be forged.
To read a cookie set with this method, use get_secure_cookie().
"""
value = LilCookies._signed_cookie_value(self.cookie_secret, name, value)
self.set_cookie(name, value, expires_days=expires_days, **kwargs)
def get_secure_cookie(self, name, value=None):
"""Returns the given signed cookie if it validates, or None."""
if value is None: value = self.get_cookie(name)
return LilCookies._verified_cookie_value(self.cookie_secret, name, value)
def _cookie_signature(self, *parts):
return LilCookies._signature_from_secret(self.cookie_secret)
| Python |
# This is the version of this source code.
manual_verstr = "1.5"
auto_build_num = "211"
verstr = manual_verstr + "." + auto_build_num
try:
from pyutil.version_class import Version as pyutil_Version
__version__ = pyutil_Version(verstr)
except (ImportError, ValueError):
# Maybe there is no pyutil installed.
from distutils.version import LooseVersion as distutils_Version
__version__ = distutils_Version(verstr)
| Python |
"""
The MIT License
Copyright (c) 2007-2010 Leah Culver, Joe Stump, Mark Paschal, Vic Fryzel
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
import oauth2
import smtplib
import base64
class SMTP(smtplib.SMTP):
"""SMTP wrapper for smtplib.SMTP that implements XOAUTH."""
def authenticate(self, url, consumer, token):
if consumer is not None and not isinstance(consumer, oauth2.Consumer):
raise ValueError("Invalid consumer.")
if token is not None and not isinstance(token, oauth2.Token):
raise ValueError("Invalid token.")
self.docmd('AUTH', 'XOAUTH %s' % \
base64.b64encode(oauth2.build_xoauth_string(url, consumer, token)))
| Python |
"""
The MIT License
Copyright (c) 2007-2010 Leah Culver, Joe Stump, Mark Paschal, Vic Fryzel
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
import oauth2
import imaplib
class IMAP4_SSL(imaplib.IMAP4_SSL):
"""IMAP wrapper for imaplib.IMAP4_SSL that implements XOAUTH."""
def authenticate(self, url, consumer, token):
if consumer is not None and not isinstance(consumer, oauth2.Consumer):
raise ValueError("Invalid consumer.")
if token is not None and not isinstance(token, oauth2.Token):
raise ValueError("Invalid token.")
imaplib.IMAP4_SSL.authenticate(self, 'XOAUTH',
lambda x: oauth2.build_xoauth_string(url, consumer, token))
| Python |
"""
The MIT License
Copyright (c) 2007-2010 Leah Culver, Joe Stump, Mark Paschal, Vic Fryzel
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
import base64
import urllib
import time
import random
import urlparse
import hmac
import binascii
import httplib2
try:
from urlparse import parse_qs
parse_qs # placate pyflakes
except ImportError:
# fall back for Python 2.5
from cgi import parse_qs
try:
from hashlib import sha1
sha = sha1
except ImportError:
# hashlib was added in Python 2.5
import sha
import _version
__version__ = _version.__version__
OAUTH_VERSION = '1.0' # Hi Blaine!
HTTP_METHOD = 'GET'
SIGNATURE_METHOD = 'PLAINTEXT'
class Error(RuntimeError):
"""Generic exception class."""
def __init__(self, message='OAuth error occurred.'):
self._message = message
@property
def message(self):
"""A hack to get around the deprecation errors in 2.6."""
return self._message
def __str__(self):
return self._message
class MissingSignature(Error):
pass
def build_authenticate_header(realm=''):
"""Optional WWW-Authenticate header (401 error)"""
return {'WWW-Authenticate': 'OAuth realm="%s"' % realm}
def build_xoauth_string(url, consumer, token=None):
"""Build an XOAUTH string for use in SMTP/IMPA authentication."""
request = Request.from_consumer_and_token(consumer, token,
"GET", url)
signing_method = SignatureMethod_HMAC_SHA1()
request.sign_request(signing_method, consumer, token)
params = []
for k, v in sorted(request.iteritems()):
if v is not None:
params.append('%s="%s"' % (k, escape(v)))
return "%s %s %s" % ("GET", url, ','.join(params))
def to_unicode(s):
""" Convert to unicode, raise exception with instructive error
message if s is not unicode, ascii, or utf-8. """
if not isinstance(s, unicode):
if not isinstance(s, str):
raise TypeError('You are required to pass either unicode or string here, not: %r (%s)' % (type(s), s))
try:
s = s.decode('utf-8')
except UnicodeDecodeError, le:
raise TypeError('You are required to pass either a unicode object or a utf-8 string here. You passed a Python string object which contained non-utf-8: %r. The UnicodeDecodeError that resulted from attempting to interpret it as utf-8 was: %s' % (s, le,))
return s
def to_utf8(s):
return to_unicode(s).encode('utf-8')
def to_unicode_if_string(s):
if isinstance(s, basestring):
return to_unicode(s)
else:
return s
def to_utf8_if_string(s):
if isinstance(s, basestring):
return to_utf8(s)
else:
return s
def to_unicode_optional_iterator(x):
"""
Raise TypeError if x is a str containing non-utf8 bytes or if x is
an iterable which contains such a str.
"""
if isinstance(x, basestring):
return to_unicode(x)
try:
l = list(x)
except TypeError, e:
assert 'is not iterable' in str(e)
return x
else:
return [ to_unicode(e) for e in l ]
def to_utf8_optional_iterator(x):
"""
Raise TypeError if x is a str or if x is an iterable which
contains a str.
"""
if isinstance(x, basestring):
return to_utf8(x)
try:
l = list(x)
except TypeError, e:
assert 'is not iterable' in str(e)
return x
else:
return [ to_utf8_if_string(e) for e in l ]
def escape(s):
"""Escape a URL including any /."""
return urllib.quote(s.encode('utf-8'), safe='~')
def generate_timestamp():
"""Get seconds since epoch (UTC)."""
return int(time.time())
def generate_nonce(length=8):
"""Generate pseudorandom number."""
return ''.join([str(random.randint(0, 9)) for i in range(length)])
def generate_verifier(length=8):
"""Generate pseudorandom number."""
return ''.join([str(random.randint(0, 9)) for i in range(length)])
class Consumer(object):
"""A consumer of OAuth-protected services.
The OAuth consumer is a "third-party" service that wants to access
protected resources from an OAuth service provider on behalf of an end
user. It's kind of the OAuth client.
Usually a consumer must be registered with the service provider by the
developer of the consumer software. As part of that process, the service
provider gives the consumer a *key* and a *secret* with which the consumer
software can identify itself to the service. The consumer will include its
key in each request to identify itself, but will use its secret only when
signing requests, to prove that the request is from that particular
registered consumer.
Once registered, the consumer can then use its consumer credentials to ask
the service provider for a request token, kicking off the OAuth
authorization process.
"""
key = None
secret = None
def __init__(self, key, secret):
self.key = key
self.secret = secret
if self.key is None or self.secret is None:
raise ValueError("Key and secret must be set.")
def __str__(self):
data = {'oauth_consumer_key': self.key,
'oauth_consumer_secret': self.secret}
return urllib.urlencode(data)
class Token(object):
"""An OAuth credential used to request authorization or a protected
resource.
Tokens in OAuth comprise a *key* and a *secret*. The key is included in
requests to identify the token being used, but the secret is used only in
the signature, to prove that the requester is who the server gave the
token to.
When first negotiating the authorization, the consumer asks for a *request
token* that the live user authorizes with the service provider. The
consumer then exchanges the request token for an *access token* that can
be used to access protected resources.
"""
key = None
secret = None
callback = None
callback_confirmed = None
verifier = None
def __init__(self, key, secret):
self.key = key
self.secret = secret
if self.key is None or self.secret is None:
raise ValueError("Key and secret must be set.")
def set_callback(self, callback):
self.callback = callback
self.callback_confirmed = 'true'
def set_verifier(self, verifier=None):
if verifier is not None:
self.verifier = verifier
else:
self.verifier = generate_verifier()
def get_callback_url(self):
if self.callback and self.verifier:
# Append the oauth_verifier.
parts = urlparse.urlparse(self.callback)
scheme, netloc, path, params, query, fragment = parts[:6]
if query:
query = '%s&oauth_verifier=%s' % (query, self.verifier)
else:
query = 'oauth_verifier=%s' % self.verifier
return urlparse.urlunparse((scheme, netloc, path, params,
query, fragment))
return self.callback
def to_string(self):
"""Returns this token as a plain string, suitable for storage.
The resulting string includes the token's secret, so you should never
send or store this string where a third party can read it.
"""
data = {
'oauth_token': self.key,
'oauth_token_secret': self.secret,
}
if self.callback_confirmed is not None:
data['oauth_callback_confirmed'] = self.callback_confirmed
return urllib.urlencode(data)
@staticmethod
def from_string(s):
"""Deserializes a token from a string like one returned by
`to_string()`."""
if not len(s):
raise ValueError("Invalid parameter string.")
params = parse_qs(s, keep_blank_values=False)
if not len(params):
raise ValueError("Invalid parameter string.")
try:
key = params['oauth_token'][0]
except Exception:
raise ValueError("'oauth_token' not found in OAuth request.")
try:
secret = params['oauth_token_secret'][0]
except Exception:
raise ValueError("'oauth_token_secret' not found in "
"OAuth request.")
token = Token(key, secret)
try:
token.callback_confirmed = params['oauth_callback_confirmed'][0]
except KeyError:
pass # 1.0, no callback confirmed.
return token
def __str__(self):
return self.to_string()
def setter(attr):
name = attr.__name__
def getter(self):
try:
return self.__dict__[name]
except KeyError:
raise AttributeError(name)
def deleter(self):
del self.__dict__[name]
return property(getter, attr, deleter)
class Request(dict):
"""The parameters and information for an HTTP request, suitable for
authorizing with OAuth credentials.
When a consumer wants to access a service's protected resources, it does
so using a signed HTTP request identifying itself (the consumer) with its
key, and providing an access token authorized by the end user to access
those resources.
"""
version = OAUTH_VERSION
def __init__(self, method=HTTP_METHOD, url=None, parameters=None,
body='', is_form_encoded=False):
if url is not None:
self.url = to_unicode(url)
self.method = method
if parameters is not None:
for k, v in parameters.iteritems():
k = to_unicode(k)
v = to_unicode_optional_iterator(v)
self[k] = v
self.body = body
self.is_form_encoded = is_form_encoded
@setter
def url(self, value):
self.__dict__['url'] = value
if value is not None:
scheme, netloc, path, params, query, fragment = urlparse.urlparse(value)
# Exclude default port numbers.
if scheme == 'http' and netloc[-3:] == ':80':
netloc = netloc[:-3]
elif scheme == 'https' and netloc[-4:] == ':443':
netloc = netloc[:-4]
if scheme not in ('http', 'https'):
raise ValueError("Unsupported URL %s (%s)." % (value, scheme))
# Normalized URL excludes params, query, and fragment.
self.normalized_url = urlparse.urlunparse((scheme, netloc, path, None, None, None))
else:
self.normalized_url = None
self.__dict__['url'] = None
@setter
def method(self, value):
self.__dict__['method'] = value.upper()
def _get_timestamp_nonce(self):
return self['oauth_timestamp'], self['oauth_nonce']
def get_nonoauth_parameters(self):
"""Get any non-OAuth parameters."""
return dict([(k, v) for k, v in self.iteritems()
if not k.startswith('oauth_')])
def to_header(self, realm=''):
"""Serialize as a header for an HTTPAuth request."""
oauth_params = ((k, v) for k, v in self.items()
if k.startswith('oauth_'))
stringy_params = ((k, escape(str(v))) for k, v in oauth_params)
header_params = ('%s="%s"' % (k, v) for k, v in stringy_params)
params_header = ', '.join(header_params)
auth_header = 'OAuth realm="%s"' % realm
if params_header:
auth_header = "%s, %s" % (auth_header, params_header)
return {'Authorization': auth_header}
def to_postdata(self):
"""Serialize as post data for a POST request."""
d = {}
for k, v in self.iteritems():
d[k.encode('utf-8')] = to_utf8_optional_iterator(v)
# tell urlencode to deal with sequence values and map them correctly
# to resulting querystring. for example self["k"] = ["v1", "v2"] will
# result in 'k=v1&k=v2' and not k=%5B%27v1%27%2C+%27v2%27%5D
return urllib.urlencode(d, True).replace('+', '%20')
def to_url(self):
"""Serialize as a URL for a GET request."""
base_url = urlparse.urlparse(self.url)
try:
query = base_url.query
except AttributeError:
# must be python <2.5
query = base_url[4]
query = parse_qs(query)
for k, v in self.items():
query.setdefault(k, []).append(v)
try:
scheme = base_url.scheme
netloc = base_url.netloc
path = base_url.path
params = base_url.params
fragment = base_url.fragment
except AttributeError:
# must be python <2.5
scheme = base_url[0]
netloc = base_url[1]
path = base_url[2]
params = base_url[3]
fragment = base_url[5]
url = (scheme, netloc, path, params,
urllib.urlencode(query, True), fragment)
return urlparse.urlunparse(url)
def get_parameter(self, parameter):
ret = self.get(parameter)
if ret is None:
raise Error('Parameter not found: %s' % parameter)
return ret
def get_normalized_parameters(self):
"""Return a string that contains the parameters that must be signed."""
items = []
for key, value in self.iteritems():
if key == 'oauth_signature':
continue
# 1.0a/9.1.1 states that kvp must be sorted by key, then by value,
# so we unpack sequence values into multiple items for sorting.
if isinstance(value, basestring):
items.append((to_utf8_if_string(key), to_utf8(value)))
else:
try:
value = list(value)
except TypeError, e:
assert 'is not iterable' in str(e)
items.append((to_utf8_if_string(key), to_utf8_if_string(value)))
else:
items.extend((to_utf8_if_string(key), to_utf8_if_string(item)) for item in value)
# Include any query string parameters from the provided URL
query = urlparse.urlparse(self.url)[4]
url_items = self._split_url_string(query).items()
url_items = [(to_utf8(k), to_utf8(v)) for k, v in url_items if k != 'oauth_signature' ]
items.extend(url_items)
items.sort()
encoded_str = urllib.urlencode(items)
# Encode signature parameters per Oauth Core 1.0 protocol
# spec draft 7, section 3.6
# (http://tools.ietf.org/html/draft-hammer-oauth-07#section-3.6)
# Spaces must be encoded with "%20" instead of "+"
return encoded_str.replace('+', '%20').replace('%7E', '~')
def sign_request(self, signature_method, consumer, token):
"""Set the signature parameter to the result of sign."""
if not self.is_form_encoded:
# according to
# http://oauth.googlecode.com/svn/spec/ext/body_hash/1.0/oauth-bodyhash.html
# section 4.1.1 "OAuth Consumers MUST NOT include an
# oauth_body_hash parameter on requests with form-encoded
# request bodies."
self['oauth_body_hash'] = base64.b64encode(sha(self.body).digest())
if 'oauth_consumer_key' not in self:
self['oauth_consumer_key'] = consumer.key
if token and 'oauth_token' not in self:
self['oauth_token'] = token.key
self['oauth_signature_method'] = signature_method.name
self['oauth_signature'] = signature_method.sign(self, consumer, token)
@classmethod
def make_timestamp(cls):
"""Get seconds since epoch (UTC)."""
return str(int(time.time()))
@classmethod
def make_nonce(cls):
"""Generate pseudorandom number."""
return str(random.randint(0, 100000000))
@classmethod
def from_request(cls, http_method, http_url, headers=None, parameters=None,
query_string=None):
"""Combines multiple parameter sources."""
if parameters is None:
parameters = {}
# Headers
if headers and 'Authorization' in headers:
auth_header = headers['Authorization']
# Check that the authorization header is OAuth.
if auth_header[:6] == 'OAuth ':
auth_header = auth_header[6:]
try:
# Get the parameters from the header.
header_params = cls._split_header(auth_header)
parameters.update(header_params)
except:
raise Error('Unable to parse OAuth parameters from '
'Authorization header.')
# GET or POST query string.
if query_string:
query_params = cls._split_url_string(query_string)
parameters.update(query_params)
# URL parameters.
param_str = urlparse.urlparse(http_url)[4] # query
url_params = cls._split_url_string(param_str)
parameters.update(url_params)
if parameters:
return cls(http_method, http_url, parameters)
return None
@classmethod
def from_consumer_and_token(cls, consumer, token=None,
http_method=HTTP_METHOD, http_url=None, parameters=None,
body='', is_form_encoded=False):
if not parameters:
parameters = {}
defaults = {
'oauth_consumer_key': consumer.key,
'oauth_timestamp': cls.make_timestamp(),
'oauth_nonce': cls.make_nonce(),
'oauth_version': cls.version,
}
defaults.update(parameters)
parameters = defaults
if token:
parameters['oauth_token'] = token.key
if token.verifier:
parameters['oauth_verifier'] = token.verifier
return Request(http_method, http_url, parameters, body=body,
is_form_encoded=is_form_encoded)
@classmethod
def from_token_and_callback(cls, token, callback=None,
http_method=HTTP_METHOD, http_url=None, parameters=None):
if not parameters:
parameters = {}
parameters['oauth_token'] = token.key
if callback:
parameters['oauth_callback'] = callback
return cls(http_method, http_url, parameters)
@staticmethod
def _split_header(header):
"""Turn Authorization: header into parameters."""
params = {}
parts = header.split(',')
for param in parts:
# Ignore realm parameter.
if param.find('realm') > -1:
continue
# Remove whitespace.
param = param.strip()
# Split key-value.
param_parts = param.split('=', 1)
# Remove quotes and unescape the value.
params[param_parts[0]] = urllib.unquote(param_parts[1].strip('\"'))
return params
@staticmethod
def _split_url_string(param_str):
"""Turn URL string into parameters."""
parameters = parse_qs(param_str.encode('utf-8'), keep_blank_values=True)
for k, v in parameters.iteritems():
parameters[k] = urllib.unquote(v[0])
return parameters
class Client(httplib2.Http):
"""OAuthClient is a worker to attempt to execute a request."""
def __init__(self, consumer, token=None, cache=None, timeout=None,
proxy_info=None):
if consumer is not None and not isinstance(consumer, Consumer):
raise ValueError("Invalid consumer.")
if token is not None and not isinstance(token, Token):
raise ValueError("Invalid token.")
self.consumer = consumer
self.token = token
self.method = SignatureMethod_HMAC_SHA1()
httplib2.Http.__init__(self, cache=cache, timeout=timeout, proxy_info=proxy_info)
def set_signature_method(self, method):
if not isinstance(method, SignatureMethod):
raise ValueError("Invalid signature method.")
self.method = method
def request(self, uri, method="GET", body='', headers=None,
redirections=httplib2.DEFAULT_MAX_REDIRECTS, connection_type=None):
DEFAULT_POST_CONTENT_TYPE = 'application/x-www-form-urlencoded'
if not isinstance(headers, dict):
headers = {}
if method == "POST":
headers['Content-Type'] = headers.get('Content-Type',
DEFAULT_POST_CONTENT_TYPE)
is_form_encoded = \
headers.get('Content-Type') == 'application/x-www-form-urlencoded'
if is_form_encoded and body:
parameters = parse_qs(body)
else:
parameters = None
req = Request.from_consumer_and_token(self.consumer,
token=self.token, http_method=method, http_url=uri,
parameters=parameters, body=body, is_form_encoded=is_form_encoded)
req.sign_request(self.method, self.consumer, self.token)
schema, rest = urllib.splittype(uri)
if rest.startswith('//'):
hierpart = '//'
else:
hierpart = ''
host, rest = urllib.splithost(rest)
realm = schema + ':' + hierpart + host
if is_form_encoded:
body = req.to_postdata()
elif method == "GET":
uri = req.to_url()
else:
headers.update(req.to_header(realm=realm))
return httplib2.Http.request(self, uri, method=method, body=body,
headers=headers, redirections=redirections,
connection_type=connection_type)
class Server(object):
"""A skeletal implementation of a service provider, providing protected
resources to requests from authorized consumers.
This class implements the logic to check requests for authorization. You
can use it with your web server or web framework to protect certain
resources with OAuth.
"""
timestamp_threshold = 300 # In seconds, five minutes.
version = OAUTH_VERSION
signature_methods = None
def __init__(self, signature_methods=None):
self.signature_methods = signature_methods or {}
def add_signature_method(self, signature_method):
self.signature_methods[signature_method.name] = signature_method
return self.signature_methods
def verify_request(self, request, consumer, token):
"""Verifies an api call and checks all the parameters."""
self._check_version(request)
self._check_signature(request, consumer, token)
parameters = request.get_nonoauth_parameters()
return parameters
def build_authenticate_header(self, realm=''):
"""Optional support for the authenticate header."""
return {'WWW-Authenticate': 'OAuth realm="%s"' % realm}
def _check_version(self, request):
"""Verify the correct version of the request for this server."""
version = self._get_version(request)
if version and version != self.version:
raise Error('OAuth version %s not supported.' % str(version))
def _get_version(self, request):
"""Return the version of the request for this server."""
try:
version = request.get_parameter('oauth_version')
except:
version = OAUTH_VERSION
return version
def _get_signature_method(self, request):
"""Figure out the signature with some defaults."""
try:
signature_method = request.get_parameter('oauth_signature_method')
except:
signature_method = SIGNATURE_METHOD
try:
# Get the signature method object.
signature_method = self.signature_methods[signature_method]
except:
signature_method_names = ', '.join(self.signature_methods.keys())
raise Error('Signature method %s not supported try one of the following: %s' % (signature_method, signature_method_names))
return signature_method
def _get_verifier(self, request):
return request.get_parameter('oauth_verifier')
def _check_signature(self, request, consumer, token):
timestamp, nonce = request._get_timestamp_nonce()
self._check_timestamp(timestamp)
signature_method = self._get_signature_method(request)
try:
signature = request.get_parameter('oauth_signature')
except:
raise MissingSignature('Missing oauth_signature.')
# Validate the signature.
valid = signature_method.check(request, consumer, token, signature)
if not valid:
key, base = signature_method.signing_base(request, consumer, token)
raise Error('Invalid signature. Expected signature base '
'string: %s' % base)
def _check_timestamp(self, timestamp):
"""Verify that timestamp is recentish."""
timestamp = int(timestamp)
now = int(time.time())
lapsed = now - timestamp
if lapsed > self.timestamp_threshold:
raise Error('Expired timestamp: given %d and now %s has a '
'greater difference than threshold %d' % (timestamp, now,
self.timestamp_threshold))
class SignatureMethod(object):
"""A way of signing requests.
The OAuth protocol lets consumers and service providers pick a way to sign
requests. This interface shows the methods expected by the other `oauth`
modules for signing requests. Subclass it and implement its methods to
provide a new way to sign requests.
"""
def signing_base(self, request, consumer, token):
"""Calculates the string that needs to be signed.
This method returns a 2-tuple containing the starting key for the
signing and the message to be signed. The latter may be used in error
messages to help clients debug their software.
"""
raise NotImplementedError
def sign(self, request, consumer, token):
"""Returns the signature for the given request, based on the consumer
and token also provided.
You should use your implementation of `signing_base()` to build the
message to sign. Otherwise it may be less useful for debugging.
"""
raise NotImplementedError
def check(self, request, consumer, token, signature):
"""Returns whether the given signature is the correct signature for
the given consumer and token signing the given request."""
built = self.sign(request, consumer, token)
return built == signature
class SignatureMethod_HMAC_SHA1(SignatureMethod):
name = 'HMAC-SHA1'
def signing_base(self, request, consumer, token):
if not hasattr(request, 'normalized_url') or request.normalized_url is None:
raise ValueError("Base URL for request is not set.")
sig = (
escape(request.method),
escape(request.normalized_url),
escape(request.get_normalized_parameters()),
)
key = '%s&' % escape(consumer.secret)
if token:
key += escape(token.secret)
raw = '&'.join(sig)
return key, raw
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
hashed = hmac.new(key, raw, sha)
# Calculate the digest base 64.
return binascii.b2a_base64(hashed.digest())[:-1]
class SignatureMethod_PLAINTEXT(SignatureMethod):
name = 'PLAINTEXT'
def signing_base(self, request, consumer, token):
"""Concatenates the consumer key and secret with the token's
secret."""
sig = '%s&' % escape(consumer.secret)
if token:
sig = sig + escape(token.secret)
return sig, sig
def sign(self, request, consumer, token):
key, raw = self.signing_base(request, consumer, token)
return raw
| Python |
# Early, and incomplete implementation of -04.
#
import re
import urllib
RESERVED = ":/?#[]@!$&'()*+,;="
OPERATOR = "+./;?|!@"
EXPLODE = "*+"
MODIFIER = ":^"
TEMPLATE = re.compile(r"{(?P<operator>[\+\./;\?|!@])?(?P<varlist>[^}]+)}", re.UNICODE)
VAR = re.compile(r"^(?P<varname>[^=\+\*:\^]+)((?P<explode>[\+\*])|(?P<partial>[:\^]-?[0-9]+))?(=(?P<default>.*))?$", re.UNICODE)
def _tostring(varname, value, explode, operator, safe=""):
if type(value) == type([]):
if explode == "+":
return ",".join([varname + "." + urllib.quote(x, safe) for x in value])
else:
return ",".join([urllib.quote(x, safe) for x in value])
if type(value) == type({}):
keys = value.keys()
keys.sort()
if explode == "+":
return ",".join([varname + "." + urllib.quote(key, safe) + "," + urllib.quote(value[key], safe) for key in keys])
else:
return ",".join([urllib.quote(key, safe) + "," + urllib.quote(value[key], safe) for key in keys])
else:
return urllib.quote(value, safe)
def _tostring_path(varname, value, explode, operator, safe=""):
joiner = operator
if type(value) == type([]):
if explode == "+":
return joiner.join([varname + "." + urllib.quote(x, safe) for x in value])
elif explode == "*":
return joiner.join([urllib.quote(x, safe) for x in value])
else:
return ",".join([urllib.quote(x, safe) for x in value])
elif type(value) == type({}):
keys = value.keys()
keys.sort()
if explode == "+":
return joiner.join([varname + "." + urllib.quote(key, safe) + joiner + urllib.quote(value[key], safe) for key in keys])
elif explode == "*":
return joiner.join([urllib.quote(key, safe) + joiner + urllib.quote(value[key], safe) for key in keys])
else:
return ",".join([urllib.quote(key, safe) + "," + urllib.quote(value[key], safe) for key in keys])
else:
if value:
return urllib.quote(value, safe)
else:
return ""
def _tostring_query(varname, value, explode, operator, safe=""):
joiner = operator
varprefix = ""
if operator == "?":
joiner = "&"
varprefix = varname + "="
if type(value) == type([]):
if 0 == len(value):
return ""
if explode == "+":
return joiner.join([varname + "=" + urllib.quote(x, safe) for x in value])
elif explode == "*":
return joiner.join([urllib.quote(x, safe) for x in value])
else:
return varprefix + ",".join([urllib.quote(x, safe) for x in value])
elif type(value) == type({}):
if 0 == len(value):
return ""
keys = value.keys()
keys.sort()
if explode == "+":
return joiner.join([varname + "." + urllib.quote(key, safe) + "=" + urllib.quote(value[key], safe) for key in keys])
elif explode == "*":
return joiner.join([urllib.quote(key, safe) + "=" + urllib.quote(value[key], safe) for key in keys])
else:
return varprefix + ",".join([urllib.quote(key, safe) + "," + urllib.quote(value[key], safe) for key in keys])
else:
if value:
return varname + "=" + urllib.quote(value, safe)
else:
return varname
TOSTRING = {
"" : _tostring,
"+": _tostring,
";": _tostring_query,
"?": _tostring_query,
"/": _tostring_path,
".": _tostring_path,
}
def expand(template, vars):
def _sub(match):
groupdict = match.groupdict()
operator = groupdict.get('operator')
if operator is None:
operator = ''
varlist = groupdict.get('varlist')
safe = "@"
if operator == '+':
safe = RESERVED
varspecs = varlist.split(",")
varnames = []
defaults = {}
for varspec in varspecs:
m = VAR.search(varspec)
groupdict = m.groupdict()
varname = groupdict.get('varname')
explode = groupdict.get('explode')
partial = groupdict.get('partial')
default = groupdict.get('default')
if default:
defaults[varname] = default
varnames.append((varname, explode, partial))
retval = []
joiner = operator
prefix = operator
if operator == "+":
prefix = ""
joiner = ","
if operator == "?":
joiner = "&"
if operator == "":
joiner = ","
for varname, explode, partial in varnames:
if varname in vars:
value = vars[varname]
#if not value and (type(value) == type({}) or type(value) == type([])) and varname in defaults:
if not value and value != "" and varname in defaults:
value = defaults[varname]
elif varname in defaults:
value = defaults[varname]
else:
continue
retval.append(TOSTRING[operator](varname, value, explode, operator, safe=safe))
if "".join(retval):
return prefix + joiner.join(retval)
else:
return ""
return TEMPLATE.sub(_sub, template)
| Python |
#!/usr/bin/env python
import time
t = time.time()
u = time.gmtime(t)
s = time.strftime('%a, %e %b %Y %T GMT', u)
print 'Content-Type: text/javascript'
print 'Cache-Control: no-cache'
print 'Date: ' + s
print 'Expires: ' + s
print ''
print 'var timeskew = new Date().getTime() - ' + str(t*1000) + ';'
| Python |
#!/usr/bin/python
# vim:sw=4:softtabstop=4:expandtab:set fileencoding=ISO8859-2
#
# FleetPanel.py, part of the FleetPanel
#
# Copyright (c) 2009 Dariusz Mikulski email: dariusz.mikulski@gmail.com
# All rights reserved.
#
# This software is licensed as described in the file LICENSE, which
# you should have received as part of this distribution. The terms
# are also available at http://www.opensource.org/licenses/mit-license.php.
import csv
import os
from types import *
resource_dir = "resources"
wormhole_space_file = "ws.txt"
wormhole_anomaly_file = "ws_anom.txt"
wormhole_file = "wh.txt"
DELIMITER = ','
QUOTECHAR = '"'
SPACECHAR = ' '
UNDERLINECHAR = '_'
TXTFILE_EXTENSION = '.txt'
PNGFILE_EXTENSION = '.png'
PICTURE_PREFIX = 'pic_'
class WhSpaceSystem:
def __init__(self):
self.locus_signature = ""
self.system_id = ""
self.constellation_id = ""
self.region_id = ""
self.class_type = ""
self.attributes_modifier = {}
self.picture_file = ""
def set_detail(self, locus_signature, system_id, constellation_id, region_id, class_type):
self.locus_signature = locus_signature
self.system_id = system_id
self.constellation_id = constellation_id
self.region_id = region_id
self.class_type = class_type
class WhAnomalyProperties:
def __init__(self):
self.locus_signature = ""
self.anomaly_name = ""
class WhProperty:
def __init__(self):
self.name = ""
self.amount = 0
self.description = ""
def _set(self, name, amount, description):
self.name = name
self.amount = int(amount)
self.description = description
class Wormhole:
def __init__(self):
self.system_id = ""
self.target_system_class = WhProperty()
self.max_stability_window = WhProperty()
self.max_mass_capacity = WhProperty()
self.mass_regeneration = WhProperty()
self.max_jumpable_mass = WhProperty()
class Wormhole_Analyzer:
def __init__(self):
self._wh_space_systems = []
self._wh_anomaly_properties = []
self._wh_properties = []
self._load()
def _readfile(self, filename):
path = os.path.join(os.path.abspath(''), resource_dir, filename)
return csv.reader(open(path), delimiter=DELIMITER, quotechar=QUOTECHAR)
def _load(self):
reader = self._readfile(wormhole_anomaly_file)
for row in reader:
wa = WhAnomalyProperties()
wa.locus_signature = row[0]
wa.anomaly_name = row[1]
self._wh_anomaly_properties.append(wa)
reader = self._readfile(wormhole_space_file)
for row in reader:
ws = WhSpaceSystem()
ws.set_detail(row[0], row[1], row[2], row[3], row[4])
self._wh_space_systems.append(ws)
self._check_attributes()
reader = self._readfile(wormhole_file)
for row in reader:
wh = Wormhole()
for i in range(5):
whprop = WhProperty()
whprop._set(row[1], row[2], row[3])
if i == 0:
wh.target_system_class = whprop
elif i == 1:
wh.max_stability_window = whprop
elif i == 2:
wh.max_mass_capacity = whprop
elif i == 3:
wh.mass_regeneration = whprop
else:
wh.max_jumpable_mass = whprop
wh.system_id = row[0]
try:
row = reader.next()
except StopIteration:
pass
self._wh_properties.append(wh)
# Fixme! Totally inefficient finction
def _check_attributes(self):
for wa in self._wh_anomaly_properties:
for ws in self._wh_space_systems:
if wa.locus_signature == ws.locus_signature and wa.anomaly_name:
additional_file = wa.anomaly_name.replace(SPACECHAR, UNDERLINECHAR).lower()
reader = self._readfile(additional_file + TXTFILE_EXTENSION)
for row in reader:
ws.attributes_modifier[row[0]] = row[int(ws.class_type)-1]
filename = os.path.join(os.path.abspath(''), resource_dir, PICTURE_PREFIX + additional_file + PNGFILE_EXTENSION)
if os.path.exists(filename):
ws.picture_file = filename
def analyze_system(self, system_name):
if type(system_name) is not StringType:
return False, None
for whspacesystem in self._wh_space_systems:
if system_name == whspacesystem.locus_signature:
return True, whspacesystem
return False, None
def analyze_wormhole(self, wormhole_name):
if type(wormhole_name) is not StringType:
return False, None
for wh in self._wh_properties:
if wormhole_name == wh.system_id:
return True, wh
return False, None
| Python |
#!/usr/bin/python
# vim:sw=4:softtabstop=4:expandtab:set fileencoding=ISO8859-2
#
# FleetPanel.py, part of the FleetPanel
#
# Copyright (c) 2009 Dariusz Mikulski email: dariusz.mikulski@gmail.com
# All rights reserved.
#
# This software is licensed as described in the file LICENSE, which
# you should have received as part of this distribution. The terms
# are also available at http://www.opensource.org/licenses/mit-license.php.
import csv
import os
from types import *
resource_dir = "resources"
wormhole_space_file = "ws.txt"
wormhole_anomaly_file = "ws_anom.txt"
wormhole_file = "wh.txt"
DELIMITER = ','
QUOTECHAR = '"'
SPACECHAR = ' '
UNDERLINECHAR = '_'
TXTFILE_EXTENSION = '.txt'
PNGFILE_EXTENSION = '.png'
PICTURE_PREFIX = 'pic_'
class WhSpaceSystem:
def __init__(self):
self.locus_signature = ""
self.system_id = ""
self.constellation_id = ""
self.region_id = ""
self.class_type = ""
self.attributes_modifier = {}
self.picture_file = ""
def set_detail(self, locus_signature, system_id, constellation_id, region_id, class_type):
self.locus_signature = locus_signature
self.system_id = system_id
self.constellation_id = constellation_id
self.region_id = region_id
self.class_type = class_type
class WhAnomalyProperties:
def __init__(self):
self.locus_signature = ""
self.anomaly_name = ""
class WhProperty:
def __init__(self):
self.name = ""
self.amount = 0
self.description = ""
def _set(self, name, amount, description):
self.name = name
self.amount = int(amount)
self.description = description
class Wormhole:
def __init__(self):
self.system_id = ""
self.target_system_class = WhProperty()
self.max_stability_window = WhProperty()
self.max_mass_capacity = WhProperty()
self.mass_regeneration = WhProperty()
self.max_jumpable_mass = WhProperty()
class Wormhole_Analyzer:
def __init__(self):
self._wh_space_systems = []
self._wh_anomaly_properties = []
self._wh_properties = []
self._load()
def _readfile(self, filename):
path = os.path.join(os.path.abspath(''), resource_dir, filename)
return csv.reader(open(path), delimiter=DELIMITER, quotechar=QUOTECHAR)
def _load(self):
reader = self._readfile(wormhole_anomaly_file)
for row in reader:
wa = WhAnomalyProperties()
wa.locus_signature = row[0]
wa.anomaly_name = row[1]
self._wh_anomaly_properties.append(wa)
reader = self._readfile(wormhole_space_file)
for row in reader:
ws = WhSpaceSystem()
ws.set_detail(row[0], row[1], row[2], row[3], row[4])
self._wh_space_systems.append(ws)
self._check_attributes()
reader = self._readfile(wormhole_file)
for row in reader:
wh = Wormhole()
for i in range(5):
whprop = WhProperty()
whprop._set(row[1], row[2], row[3])
if i == 0:
wh.target_system_class = whprop
elif i == 1:
wh.max_stability_window = whprop
elif i == 2:
wh.max_mass_capacity = whprop
elif i == 3:
wh.mass_regeneration = whprop
else:
wh.max_jumpable_mass = whprop
wh.system_id = row[0]
try:
row = reader.next()
except StopIteration:
pass
self._wh_properties.append(wh)
# Fixme! Totally inefficient finction
def _check_attributes(self):
for wa in self._wh_anomaly_properties:
for ws in self._wh_space_systems:
if wa.locus_signature == ws.locus_signature and wa.anomaly_name:
additional_file = wa.anomaly_name.replace(SPACECHAR, UNDERLINECHAR).lower()
reader = self._readfile(additional_file + TXTFILE_EXTENSION)
for row in reader:
ws.attributes_modifier[row[0]] = row[int(ws.class_type)-1]
filename = os.path.join(os.path.abspath(''), resource_dir, PICTURE_PREFIX + additional_file + PNGFILE_EXTENSION)
if os.path.exists(filename):
ws.picture_file = filename
def analyze_system(self, system_name):
if type(system_name) is not StringType:
return False, None
for whspacesystem in self._wh_space_systems:
if system_name == whspacesystem.locus_signature:
return True, whspacesystem
return False, None
def analyze_wormhole(self, wormhole_name):
if type(wormhole_name) is not StringType:
return False, None
for wh in self._wh_properties:
if wormhole_name == wh.system_id:
return True, wh
return False, None
| Python |
#!/usr/bin/python
# vim:sw=4:softtabstop=4:expandtab:
import time
from datetime import datetime
class Signature:
def __init__(self, solar, signature, planet, typee, name, comment, creator, creation_time ):
self.solar = solar
self.signature = signature
self.planet = planet
self.typee = typee
self.name = name
self.comment = comment
self.creation_time = creation_time
self.creator = creator
| Python |
#!/usr/bin/python
# vim:sw=4:softtabstop=4:expandtab:
import time
from datetime import datetime
class Signature:
def __init__(self, solar, signature, planet, typee, name, comment, creator, creation_time ):
self.solar = solar
self.signature = signature
self.planet = planet
self.typee = typee
self.name = name
self.comment = comment
self.creation_time = creation_time
self.creator = creator
| Python |
#!/usr/bin/python
# vim:sw=4:softtabstop=4:expandtab:set fileencoding=ISO8859-2
#
# FleetPanel.py, part of the FleetPanel
#
# Copyright (c) 2009 Dariusz Mikulski email: dariusz.mikulski@gmail.com
# All rights reserved.
#
# This software is licensed as described in the file LICENSE, which
# you should have received as part of this distribution. The terms
# are also available at http://www.opensource.org/licenses/mit-license.php.
import csv
import os
resource_dir = "resources"
wormhole_space_file = "ws.txt"
wormhole_anomaly_file = "ws_anom.txt"
class WormholeSpace:
def __init__(self):
self.locus_signature = ""
self.system_id = ""
self.constellation_id = ""
self.region_id = ""
self.class_type = ""
self.attributes_modifier = {}
self.picture_file = ""
def set_detail(self, locus_signature="", system_id="", constellation_id="", region_id="", class_type=""):
self.locus_signature = locus_signature
self.system_id = system_id
self.constellation_id = constellation_id
self.region_id = region_id
self.class_type = class_type
class WormholeAnomaly:
def __init__(self):
self.locus_signature = ""
self.anomaly_name = ""
class Wormhole:
def __init__(self):
self.wormhole_space = []
self.wormhole_anomaly = []
self.load()
def load(self):
reader = csv.reader(open(resource_dir + '/' + wormhole_anomaly_file), delimiter=',', quotechar='"')
for row in reader:
wa = WormholeAnomaly()
wa.locus_signature = row[0]
wa.anomaly_name = row[1]
self.wormhole_anomaly.append(wa)
reader = csv.reader(open(resource_dir + '/' + wormhole_space_file), delimiter=',', quotechar='"')
for row in reader:
ws = WormholeSpace()
ws.set_detail(row[0], row[1], row[2], row[3], row[4])
self.wormhole_space.append(ws)
self.check_attributes()
# Fixme! Totally inefficient finction
def check_attributes(self):
for wa in self.wormhole_anomaly:
for ws in self.wormhole_space:
if wa.locus_signature == ws.locus_signature and wa.anomaly_name:
additional_file = wa.anomaly_name.replace(' ', '_').lower()
reader = csv.reader(open(resource_dir + '/' + additional_file + '.txt'), delimiter=',', quotechar='"')
for row in reader:
ws.attributes_modifier[row[0]] = row[int(ws.class_type)-1]
filename = os.path.join(os.path.abspath(''), resource_dir, "pic_" + additional_file + '.png')
if os.path.exists(filename):
ws.picture_file = filename
| Python |
#!/usr/bin/python
# vim:sw=4:softtabstop=4:expandtab:set fileencoding=ISO8859-2
#
# FleetPanel.py, part of the FleetPanel
#
# Copyright (c) 2009 Dariusz Mikulski email: dariusz.mikulski@gmail.com
# All rights reserved.
#
# This software is licensed as described in the file LICENSE, which
# you should have received as part of this distribution. The terms
# are also available at http://www.opensource.org/licenses/mit-license.php.
import csv
import os
resource_dir = "resources"
wormhole_space_file = "ws.txt"
wormhole_anomaly_file = "ws_anom.txt"
class WormholeSpace:
def __init__(self):
self.locus_signature = ""
self.system_id = ""
self.constellation_id = ""
self.region_id = ""
self.class_type = ""
self.attributes_modifier = {}
self.picture_file = ""
def set_detail(self, locus_signature="", system_id="", constellation_id="", region_id="", class_type=""):
self.locus_signature = locus_signature
self.system_id = system_id
self.constellation_id = constellation_id
self.region_id = region_id
self.class_type = class_type
class WormholeAnomaly:
def __init__(self):
self.locus_signature = ""
self.anomaly_name = ""
class Wormhole:
def __init__(self):
self.wormhole_space = []
self.wormhole_anomaly = []
self.load()
def load(self):
reader = csv.reader(open(resource_dir + '/' + wormhole_anomaly_file), delimiter=',', quotechar='"')
for row in reader:
wa = WormholeAnomaly()
wa.locus_signature = row[0]
wa.anomaly_name = row[1]
self.wormhole_anomaly.append(wa)
reader = csv.reader(open(resource_dir + '/' + wormhole_space_file), delimiter=',', quotechar='"')
for row in reader:
ws = WormholeSpace()
ws.set_detail(row[0], row[1], row[2], row[3], row[4])
self.wormhole_space.append(ws)
self.check_attributes()
# Fixme! Totally inefficient finction
def check_attributes(self):
for wa in self.wormhole_anomaly:
for ws in self.wormhole_space:
if wa.locus_signature == ws.locus_signature and wa.anomaly_name:
additional_file = wa.anomaly_name.replace(' ', '_').lower()
reader = csv.reader(open(resource_dir + '/' + additional_file + '.txt'), delimiter=',', quotechar='"')
for row in reader:
ws.attributes_modifier[row[0]] = row[int(ws.class_type)-1]
filename = os.path.join(os.path.abspath(''), resource_dir, "pic_" + additional_file + '.png')
if os.path.exists(filename):
ws.picture_file = filename
| Python |
#!/usr/bin/python
# vim:sw=4:softtabstop=4:expandtab:
import time
from datetime import datetime
class Signature:
def __init__(self, solar, signature, planet, typee, name, comment, creator, creation_time ):
self.solar = solar
self.signature = signature
self.planet = planet
self.typee = typee
self.name = name
self.comment = comment
self.creation_time = creation_time
self.creator = creator
| Python |
#!/usr/bin/python
# vim:sw=4:softtabstop=4:expandtab:
import time
from datetime import datetime
class Signature:
def __init__(self, solar, signature, planet, typee, name, comment, creator, creation_time ):
self.solar = solar
self.signature = signature
self.planet = planet
self.typee = typee
self.name = name
self.comment = comment
self.creation_time = creation_time
self.creator = creator
| Python |
__import__('pkg_resources').declare_namespace(__name__)
| Python |
# -*- coding: utf-8 -*-
'''
flaskext.yamlconfig
~~~~~~~~~~~~~~~~~~~
YAML configurator for Flask app.
'''
from __future__ import with_statement
import yaml
from flask import request
from flask import current_app
from flask import render_template
from werkzeug import import_string, cached_property
from werkzeug.wrappers import BaseResponse
__all__ = (
"Context",
"ConfigureError",
"Renderer",
"LazyView",
"AppYAMLConfig",
"register_renderer",
"install_yaml_config",
)
_RENDERERS = {}
class Context(dict):
"""Class for view context
"""
def __getattr__(self, key):
try:
return self[key]
except KeyError, k:
raise AttributeError, k
def __setattr__(self, key, value):
self[key] = value
def __delattr__(self, key):
try:
del self[key]
except KeyError, k:
raise AttributeError, k
def __repr__(self):
return '<Context ' + dict.__repr__(self) + '>'
class LazyView(object):
'''Lazyloading view
'''
def __init__(self, import_name):
self.__module__, self.__name__ = import_name.rsplit('.', 1)
self.import_name = import_name
@cached_property
def view(self):
return import_string(self.import_name)
def __call__(self, *args, **kwargs):
return self.view(*args, **kwargs)
def register_renderer(name, renderer_class):
'''Register renderer
'''
if name in _RENDERERS:
raise ConfigureError('Renderer `%s` allready registered.' % name)
_RENDERERS[name] = renderer_class
class ConfigureError(ValueError):
"""Configuration exception
"""
class Renderer(object):
'''Base Renderer class
'''
def __init__(self, view_func, context):
self.view_func = view_func
self.context = context
def __call__(self, **kw):
'''Run renderer'''
self.context.update(kw)
view_result = self.view_func(self.context, request, **kw)
if isinstance(view_result, BaseResponse):
return view_result
return self.render(view_result)
def render(self, view_result):
'''Override in subclass
'''
raise NotImplementedError('Renderer.render must be override.')
class PassRenderer(Renderer):
"""Only pass context & request to view_func
"""
def render(self, view_result):
return view_result
class JinjaRenderer(Renderer):
"""Templating view_func result
"""
def __init__(self, view_func, context, template):
Renderer.__init__(self, view_func, context)
self.template = template
def render(self, view_result):
ctx = self.context.copy()
ctx.update(view_result)
return render_template(self.template, **ctx)
def configure_views(app, views):
"""Configure views
"""
def configure_view(endpoint, options):
"""Configure view
"""
context = Context()
if 'context' in options:
context.update(options.pop('context'))
view_func = options.pop('view', None)
if view_func is None:
raise ConfigureError('Required field `view` missing.')
view_func = LazyView(view_func)
rules = options.pop('url', [])
if not isinstance(rules, list):
rules = [rules]
renderer_class, renderer = None, options.pop('renderer', None)
if not renderer is None:
renderer_class = _RENDERERS.get(renderer, None)
if renderer_class:
view_func = renderer_class(view_func, context)
elif renderer:
view_func = JinjaRenderer(view_func, context, renderer)
else:
view_func = PassRenderer(view_func, context)
for rule in rules:
app.add_url_rule(rule, endpoint, view_func, **options)
# begin
for view_name in views:
configure_view(view_name, views[view_name])
class AppYAMLConfig(object):
"""App YAML configurator
"""
def __init__(self, app, conf_file=None):
self.app = app
if conf_file:
self.load(conf_file)
def __call__(self, conf_file):
with self.app.open_resource(conf_file) as cfd:
conf = yaml.load(cfd.read())
for section in conf:
meth = 'configure_%s' % section
if not hasattr(self, meth):
raise ConfigureError('Unknown section `%s`.' % section)
meth = getattr(self, meth)
meth(conf[section])
load = __call__
def configure_include(self, files):
'''include: section'''
for yaml_file in files:
self.load(yaml_file)
def configure_application(self, obj):
'''application: section'''
self.app.config.from_object(type('', (object,), obj))
def configure_views(self, views):
'''views: section'''
configure_views(self.app, views)
def install_yaml_config(app, conf_file=None, configurator_class=AppYAMLConfig):
"""Install YAML configurator
"""
if not issubclass(configurator_class, AppYAMLConfig):
raise ConfigureError('`configurator_class` must be of subcalss of `AppYAMLConfig`')
return configurator_class(app, conf_file)
| Python |
"""
Flask-YAMLConfig
----------------
Usage
-----
::
from flaskext.yamlconfig import AppYAMLConfig
AppYAMLConfig(app, "main.yaml")
or
::
from flaskext.yamlconfig import install_yaml_config
from flaskext.yamlconfig import AppYAMLConfig
class MyConfig(AppYAMLConfig):
def configure_mysection(self, content):
for item in content:
....
yaml_config = install_yaml_config(app, MyConfig)
yaml_config("main.yaml")
Register a renderers
--------------------
::
from flask import current_app
from flaskext.yamlconfig import Renderer, register_renderer
from werkzeug.wrappers import BaseResponse
class JsonRenderer(Renderer):
def render(self, view_result):
return current_app.response_class(json.dumps(view_result,
indent=None if request.is_xhr else 2), mimetype='application/json')
register_renderer('json', JsonRenderer)
Config file sample
------------------
::
index:
view: views.index.index
url:
- /
- /page/<int:page>
renderer: actions/index/index.html
blog_edit:
view: views.blog.edit_blog
url: /blog/edit/<blog_url>
renderer: actions/blog/edit.html
methods:
- GET
- POST
context:
w_group: empty
ajaxBlogJoin:
view: views.blog.ajax_blog_join
url: /ajax/blogjoin/<int:blog_id>
methods:
- POST
renderer: json
View example
------------
def index(context, request, page=1):
'''Main page
'''
return dict(pages = Pager(Topic.all(), page))
"""
from setuptools import setup
import sys
requires = ['Flask>=0.6', 'PyYAML']
if sys.version_info < (2, 6):
requires.append('simplejson')
setup(
name='Flask-YAMLConfig',
version='0.0.3',
license='MIT',
author='Eugene Sazonov aka zheromo',
author_email='zheromo@gmail.com',
description='YAML configurator for Flask app.',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
zip_safe=False,
platforms='any',
install_requires=requires,
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)
| Python |
bola = 'bola.gif'
campo = 'campo.jpg'
import pygame, sys
from pygame.locals import *
pygame.init()
screen=pygame.display.set_mode((620,390),0,0)
background=pygame.image.load(campo).convert()
mouse_c=pygame.image.load(bola).convert_alpha()
j = "teste"
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
screen.blit(background, (0,0))
x,y = pygame.mouse.get_pos()
x -= mouse_c.get_width()/2
y -= mouse_c.get_height()/2
screen.blit(mouse_c,(x,y))
pygame.display.update()
| Python |
#-*- coding: utf-8 -*-
import random
from classifier import classifier
class genetyk():
def __init__(self,grammar,properites):
self.grammar = grammar
self.properties = properites
def ruletSelection(self):
suma = 0.0
for x in self.grammar.G:
for y in self.grammar.G[x]:
if len(y.right) == 2:
y.r1 = suma
suma += y.fitness
y.r2 = suma
print "suma:"
print suma
print "losowa"
losowa = random.uniform(0,suma)
print losowa
for x in self.grammar.G:
for y in self.grammar.G[x]:
if y.r1< losowa < y.r2:
A = classifier(y.right,y.left)
losowa = random.uniform(0,suma)
print losowa
while 1:
#print "while"
for x in self.grammar.G:
for y in self.grammar.G[x]:
if y.r1< losowa < y.r2:
if y.compare(A)!=3:
B = classifier(y.right,y.left)
print "znalazlem"
return (A,B)
else:
losowa = random.uniform(0,suma)
return (A,B)
def randomSelection(self):
pass
def elitSelection(self):
pass
def mutation(self, A):
#tutaj cos glupiego trzeba wymyslic
print "mutacja"
#mutacja lewej strony
if random.random()<self.properties.Pm:
D = self.grammar.G.keys()
tmp = random.randint(0,len(D)-1)
A.left = D[tmp]
#mutacja prawej strony
#1
if random.random()<self.properties.Pm:
print "!!!!!!!!!!!!!!!!!!!!!!!"
print A
D = self.grammar.G.keys()
tmp = random.randint(0,len(D)-1)
A.right = D[tmp] + A.right[1:]
print A
#2
if random.random()<self.properties.Pm:
print "!!!!!!!!!!!!!!!!!!!!!!!"
print A
D = self.grammar.G.keys()
tmp = random.randint(0,len(D)-1)
A.right = A.right[:1] +D[tmp]
print A
def crossing(self,A,B):
tmp = A.right
A.right = B.right
B.right = tmp
return A, B
def inversion(self,A):
A.right = A.right[::-1]
return A
def updateGrammar(self):
pass
def updateProperies(self):
pass
def makeGen(self):
''' tutaj bedzie cala akcja wraz z uaktualnieniem gramatyki'''
#selekcja dwoch klasyfikatorów za pomocą ruletki (kopie juz)
A,B = self.ruletSelection()
if random.random()< self.properties.Pk:
print A
print B
self.crossing(A,B)
#tutaj mutajca na A
self.mutation(A)
#tutaj mutajca na B
self.mutation(B)
if random.random()< self.properties.Pi:
self.inversion(A)
if random.random()< self.properties.Pi:
self.inversion(B)
print "dodaje:"
print A
print B
self.grammar.add(A.left,A.right)
self.grammar.add(B.left,B.right)
| Python |
#-*- coding: utf-8 -*-
import string, random
from properties import properties
from classifier import classifier
from genetyk import genetyk
from membership_Funkctions import membershipOperations
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
#tworzenie instncji parametrow
self.parametry = properties()
self.allowFulCover = 1
#Gramatyka w postaci slownika
#self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"A":[classifier("BA","A"),classifier("a","A")],"B":[classifier("CC","B"),classifier("b","B")],"C":[classifier("AB","C"),classifier("a","C")]}
self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.G_backUp = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.classifierNum=0
self.allowCover = 1
self.membershipCounter = membershipOperations(self)
for x in self.G:
for y in self.G[x]:
if len(y.right)>1:
self.classifierNum+=1
def makeBackUp(self):
self.G_backUp = self.G
def bringBackGrammar(self):
self.G = self.G_backUp
def CYK(self, slowo):
''' algorytm CYK '''
print "CYK"
#Do poprawienia:
#1. rozszezenie algorytmu cyk o warotsc mi
#2. back tracking
#3. wykorzystywanie funckji przynaleznosci
# a zem wymyslil
# 1. S-> w cos w ostatniej komorce jezeli prowadzi do poprawnego rozwiazania a nie prowadzi do nie poprawnego trza wywalic z gramatyki
poprawnosc = int(slowo[0])
slowo = slowo[1:]
#tymczasowa tablica do klasyfikatorów:
tmp = []
self.table_CYK=[]
#uzupelnianie pierwszego wiersza:
for x in slowo:
a = self.search(x,poprawnosc, 0)
if a == -1:
if poprawnosc == 1:
#rezygnuje z wprowadzania pustych znakow na pierwszym poziomie o ile zdanie jest poprawne
self.pokrycieTerminalne(x)
a = self.search(x,poprawnosc,0)
tmp.append(a)
else:
tmp.append([-1])
else:
tmp.append(a)
self.table_CYK.append(tmp)
#zastosowanie pokrycia startowego przerwanie algorytmu
#musi nastąpić reset ustawień w metodzie nadrzędnej
if len(slowo) == 1:
if self.pokrycieStartowe(slowo[0]) == 1:
return -10
#wypelnianie dalszych poziomow:
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
pary = self.szukajPar(wiersz,pozycja)
LL = self.szukajTerminal(pary,self.table_CYK,poprawnosc, wiersz)
if LL == -10:
return -10
tmp.append(LL)
pozycja+=1
self.table_CYK.append(tmp)
wiersz+=1
pozycja = 0
#sprawdzenie poziomu sparsowania zdania:
#tutaj także bedzie można rozmytość zastosować
#sprawdzenie czy zdanie sie sparsowalo
result = 0
for y in self.table_CYK[len(slowo)-1]:
for x in y:
if x == -1:
result += 0
elif x[0].left == 'S':
result = 1
#pokrycie pelne zdanie poprawne i nie sparsowane:
if poprawnosc == 1 and result == 0 and self.allowFulCover==1:
if self.pokryciePelne(len(slowo)-1) == 0:
return -10
#sprawdzenie poprawnosci cyka
#if poprawnosc == result:
#return 1
#else:
#return 0
return result
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji, pary sa w postacji pozycji w tablicy CYK
wiersz -> a
pozycja -> b
'''
#print "szukaj par"
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK,poprawnosc, wiersz):
'''metoda zwraca liste pasujacych terminali'''
#print "szukaj terminali"
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
if a == -1:
continue
for b in table_CYK[x[1][0]][x[1][1]]:
if b == -1:
continue
#do search trzeba przekazac juz odpowiednio zlozona omege:
#funkcja przystosowania tutaj wsadzic:
wynik=self.search(str(a[0].left)+str(b[0].left),poprawnosc, wiersz)
#a i b tutaj sa odpowiednio ojcami nowo wyprowadzonejkomorki, dlatego najpiet liczymy dla tych wartosci unie, nastepnie miksujemy to z nowym klasyfikatorem :):
union = self.membershipCounter.countFuzzyUnion(a[1], b[1])
if (wynik != -1) and (wynik != -10):
for y in wynik:
if y != -1:
if not y in tmp:
tmp.append((y, self.membershipCounter.countFuzzyUnion(y.omega, union)))
elif wynik == -10:
return -10
if len(tmp)<=0:
tmp = [-1]
return tmp
def search(self,terminal,poprawnosc, poziom):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, rozszerzona o symbol uniwersalny'''
#print "search"
find = 0
result = []
for x in self.G:
for T in range(0,len(self.G[x])):
if ((self.G[x][T].right == terminal) or (self.G[x][T].right == '#')):
find = 1
#rezygnujemy z przyznawania poniewaz bedziemy to robic po zakonczeniu rozbioru
#self.G[x][T].u[poprawnosc] += 1
#tutaj nalezy zastosowac jeszcze funkcje przynaleznosci i ewentualnie odrzuca niepoprawne rozwiazania z gory zakaldajac ze sa zle
if poziom == 0:
result.append((self.G[x][T],self.G[x][T].omega))
else:
#tutaj trzeba funkcje uni zastosowac jak to nie jest poziom zerowy:
result.append((self.G[x][T]))
else:
pass
#możliwość zastosowania logiki rozmytej
#uzycie pokrycia agresywnego i restart systemu:
#print "agresywne"
#if self.parametry.Pa > random.random():
#self.pokrycieAgresywne(terminal)
if find == 1:
return result
else:
if (self.parametry.Pa > random.random()) and (poprawnosc == 1) and (poziom > 1):
if self.pokrycieAgresywne(terminal) == 1:
return -10
else:
print "no i nie weszlo w pokrycie agresywne"
return -1
def pokrycieTerminalne(self, term):
'''operacja pokrycia terminalnego, przyjmuje terminal do dodania'''
print "pokrycie terminalne"
return self.add(string.upper(term) , term)
def pokrycieStartowe(self, term):
'''pokrycie startowe'''
print "pokrycie startowe"
return self.add('S',term)
def pokryciePelne(self, poziom):
'''FullCover zwraca -1 gdy pokrycie nie jest mozliwe, lub 0 gdy doda terminal taki jak trza'''
print "pokrycie pelne"
tab_par=self.szukajPar(poziom,0)
for x in tab_par:
for a in self.table_CYK[x[0][0]][x[0][1]]:
if a == -1:
continue
for b in self.table_CYK[x[1][0]][x[1][1]]:
if b == -1:
continue
self.add('S',str(a[0].left)+str(b[0].left))
self.allowFulCover = 0
return 0
return -1
def pokrycieAgresywne(self, terminal):
'''i tego tez nie rozumiem
zorbie tak: ze zbioru detektorow wybieram 3 i robie z nich klasyfikator'''
print "pokrycie agresywne "+ terminal
#if self.permisionCover == 0:
#return 0
D = self.G.keys()
tmp = random.randint(0,len(D)-1)
return self.add(D[tmp],terminal)
def getGramarStr(self):
'''metoda zwraca liste klasyfikatorow wraz z ich parametrami w postaci stringa'''
tmp = ""
for x in self.G:
for y in self.G[x]:
tmp+=y.getClassifierStrExt()
return tmp
def getDictionaryStr(self):
pass
def add(self, A, B):
'''dodaje kolejne reguly do gramamtyki A-->B'''
print "add"
print self.classifierNum
tmp=0
# sprawdzanie czy istnieje juz taki klasyfikator:
if self.G.has_key(A):
for x in self.G[A]:
if x.right==B:
#znalazlem juz taki klasyfikator:
tmp=1
return -1
if tmp == 0:
#scisk tutaj:
if(self.classifierNum >= self.parametry.np):
self.scisk(A,B)
#i dodajemy
self.G[A].append(classifier(B,A))
if len(B)>1:
self.classifierNum+=1
print "dodalem"
print str(A) +'-->' +str(B)
return 1
else:
#print "nie dodalem bo juz jest:)"
return -1
else:
if(self.classifierNum >= self.parametry.np):
self.scisk(A,B)
self.G[A] = [classifier(B,A)]
print "dodalem"
print str(A) +'-->' +str(B)
self.classifierNum+=1
return 1
def rem(self,class_rem):
'''metoda usowa klasyfikator z gramatyki'''
print "rem"
i = 0
for x in self.G[class_rem.left]:
if x.compare(class_rem) == len(class_rem.right)+1:
print 'usuwam'
print self.G[class_rem.left][i]
self.classifierNum-=1
del self.G[class_rem.left][i]
if len(self.G[class_rem.left])==0:
del(self.G[class_rem.left])
print self.classifierNum
return 1
i += 1
print "zem nie usunal !!!!!!!!!!!!!!!!!!!!"
return 0
def scisk(self, left, name):
'''metoda dodaje dany klasyfikator ze sciskiem left-->name'''
print "scisk"
cs_table = []
cf_table = []
choose = 0
minmal = 100000
for y in range(0,self.parametry.cf):
for x in range(0,self.parametry.cs):
keys = self.G.keys()
while 1:
B = random.choice(keys)
#if len(self.G[B])>1:
#break
K = self.G[B][random.randint(0,len(self.G[B])-1)]
if len(K.getRight()) > 1:
break
if K.fitness <= minmal:
minmal = K.fitness
choose = K
cf_table.append(K)
#return cf_table
#szukamy najbardziej podobnego:
podobienstwo_max = -1
tmp_cla = classifier(name,left)
print tmp_cla
for x in cf_table:
podobienstwo = x.compare(tmp_cla)
if podobienstwo_max < podobienstwo:
choose = x
#usuwamy najbardziej podobny z klasyfikatorów:
#self.rem(choose.left, choose.right)
#dodaje nowy klasyfikator:
#self.add(left,name)
return self.rem(choose)
def countProfit(self, rozbior, word_len, poprawnosc):
'''metoda liczy profit uzyskany odczas rozbioru poprawnego/niepoprawnego'''
print "count profit"
#sprawdzamy czy rzobior byl napewno do konca zrobiony:
result = 0
for y in self.table_CYK[word_len]:
for x in y:
if x == -1:
pass
elif x[0].left == 'S':
result = 1
for x in range(0,word_len):
for y in self.table_CYK[x]:
for n in y:
if n != -1:
n[0].u[int(poprawnosc)] += 1
if result == 1:
if int(poprawnosc) == 1:
n[0].p += self.parametry.ba*pow(2,x)*self.parametry.raf
else:
n[0].d += self.parametry.ba*pow(2,x)*self.parametry.raf
#if rozbior == 0:
#for x in self.usedTerminals:
#x[0].d += self.parametry.ba*pow(2,x[1])*self.parametry.raf
#else:
#for x in self.usedTerminals:
#x[0].p += self.parametry.ba*pow(2,x[1])*self.parametry.ra
def countFitness(self):
#przeniesc to do implementacji klasyfikatora!!!
print "count fitness"
#Pd jest (maximum,minimum)
PD = self.getPD()
fc = ff = 0
for x in self.G:
for y in self.G[x]:
#liczenie ff:
if(PD[0]-PD[1]!=0.0):
ff = (y.p -y.d - PD[1])/(PD[0]-PD[1])
else:
ff = 0.0
#liczenie fc:
if((y.u[0]+y.u[1])==0):
fc = self.parametry.f0
else:
if (self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1]) != 0:
fc = (self.parametry.wp * y.u[1])/(self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1])
#liczenie przystosowania:
if (self.parametry.wc + self.parametry.wf) != 0:
y.fitness = (self.parametry.wc*fc + self.parametry.wf*ff)/(self.parametry.wc + self.parametry.wf)
def getPD(self):
'''metoda zwaraca krorke (max(p-d),min(p-d)) '''
print "get PD"
minimum = 0.0
maximum = 0.0
for x in self.G:
for y in self.G[x]:
tmp = y.p - y.d
if tmp < minimum:
minimum = tmp
if tmp > maximum:
maximum = tmp
return (maximum,minimum)
def setParams(self,properties):
self.parametry = properties
def getParams(self):
return self.parametry
#testy:
G = gramatyka()
gen = genetyk(G,G.parametry)
result = -10
while result == -10:
result = G.CYK('1abba')
tab = G.table_CYK
print "wynik cyka " + str(result)
for x in tab:
print x
G.countProfit(result,len('1abba')-2,1)
G.countFitness()
print G.getGramarStr()
print "genetyczny przedsawiamy:"
gen.makeGen()
#tmp.right = "dupa"
print G.getGramarStr()
| Python |
class genetyk():
pass | Python |
##klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
class gramatyka():
def __init__(self):
#Gramatyka w postaci slownika
self.G = {"S":["AB","BC"],"A":["BA","a"],"B":["CC","b"],"C":["AB","a"]}
def add(self, A, B):
if self.G.has_key(A):
self.G[A].append(B)
else:
self.G[A] = [B]
def search(self,terminal):
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if T == terminal:
find = 1
self.result.append(x)
if find == 1:
return self.result
else:
return -1
##klasa bedzie udawac zachowanie multiplekasera, bede jej uzywac do testow
class multiplekser():
pass
##Implementacja algorytmu CYK
def CYK(G, slowo):
tmp = []
table_CYK =[]
final = []
#peirwsza czesc odpowiadajaca za wypelnienie pierwszego wiersza w tabeli
for x in slowo:
tmp.append(G.search(x))
table_CYK.append([])
table_CYK[0] = tmp[0:]
#tutaj jakas totalna masakra taka ze glowa mala:):
table_CYK.append([])
poziom=0
k=0
while k < len(table_CYK[0])-poziom-1:
#for y in table_CYK[0][1:len(table_CYK[0])]:
tmp=[]
x = table_CYK[0][k]
y = table_CYK[0][k+1]
#print "pary dla"
#print x
#print y
#print "y"
#print y
for a in x:
for b in y:
#print "koniunkacja:"
#print a+b
wynik = G.search(a+b)
print wynik
if wynik != -1:
if (wynik in tmp) == False:
tmp.extend(wynik)
#pass
print "znalezione przypozadkowania:"
print tmp
if len(tmp) <= 0:
tmp = -1
table_CYK[1].append(tmp)
k+=1
#print "tmp"
#print tmp
return table_CYK
G = gramatyka()
#print "gramatyka:"
#print G.G
#A = G.search("AB")
#print A
K = CYK(G,"aabbab")
print "final:"
for x in K:
print "tabela CYK:"
print x
| Python |
#-*- coding: utf-8 -*-
#klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
import string, random
from properties import properties
from classifier import classifier
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
self.parametry = properties()
self.usedTerminals =[]
#Gramatyka w postaci slownika
#self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"A":[classifier("BA","A"),classifier("a","A")],"B":[classifier("CC","B"),classifier("b","B")],"C":[classifier("AB","C"),classifier("a","C")]}
self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.classifierNum=0
for x in self.G:
for y in self.G[x]:
if len(y.name)>1:
self.classifierNum+=1
def setProperties(self,p):
''' metoda uaktualnia parametry danego badania'''
self.parametry=p
def add(self, A, B):
'''dodaje kolejne reguly do gramamtyki A-->B'''
tmp=0
# sprawdzanie czy istnieje juz taki klasyfikator:
if self.G.has_key(A):
for x in self.G[A]:
if x.name==B:
tmp=1
if tmp == 0:
#scisk tutaj:
if(self.classifierNum >= self.parametry.np):
self.scisk_new(B,A)
#i dodajemy
self.G[A].append(classifier(B,A))
print "dodalem:" + A +"-->"+B
if len(B)>1:
self.classifierNum+=1
return 1
else:
#print "nie dodalem bo juz jest:)"
return -1
else:
if(self.classifierNum >= self.parametry.np):
self.scisk_new(B,A)
self.G[A] = [classifier(B,A)]
print "dodalem:" + A +"-->"+B
self.classifierNum+=1
return 1
def rem(self,A,B):
'''metoda usowa klasyfikator z gramatyki'''
tmp = 0
for x in self.G[A]:
if x.name == B:
del self.G[A][tmp]
self.classifierNum-=1
return 1
#print "usuwam"
tmp+=1
if len(self.G[A])==0:
del(self.G[A])
return 1
def search(self,terminal,poprawnosc, poziom):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, rozszerzona o symbol uniwersalny'''
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if ((T.name == terminal) or (T.name == '#')):
self.usedTerminals.append((T,poziom))
find = 1
self.result.append(x)
#Tutaj T dodajemy do listy uzytych podaczas parsowania
#przyznawanie punktow:
T.u[int(poprawnosc)]+=1
else:
#uzycie pokrycia agresywnego i restart systemu:
if self.parametry.Pa < random.random():
self.pokrycieAgresywne(terminal)
#info do systemu ze trzeba restart walnac
#return -10
#trzeba jeszcze tutaj przerwac
if find == 1:
return self.result
else:
return -1
def getGramarStr(self):
'''metoda zwraca liste klasyfikatorow wraz z ich parametrami w postaci stringa'''
tmp = ""
for x in self.G:
for y in self.G[x]:
tmp += str(x) + " -->" + y.name +"\t"+"un= "+str(y.u[0])+"\t"+"up="+str(y.u[1])+"\t fitnes"+str(y.fitness)+ " p i d "+"("+str(y.p)+","+str(y.d)+")"+"\n"
return tmp
def CYK(self, slowo):
''' algorytm CYK '''
succes = 0
poprawnosc = int(slowo[0])
slowo = slowo[1:]
table_CYK=[]
tmp = []
used_clas = []
#wypelnianie pierwszego poziomu:
for x in slowo:
a = self.search(x,poprawnosc, 0)
if a == -1:
if poprawnosc == 1:
#rezygnuje z wprowadzania pustych znakow na pierwszym poziomie o ile zdanie jest poprawne
self.pokrycieTerminalne(x)
a = self.search(x,poprawnosc,poprawnosc)
tmp.append(a)
else:
tmp.append([-1])
else:
tmp.append(a)
#pokrycie startowe:
print "dlugosc="+str(len(slowo))+" poprawnosc="+str(poprawnosc) + "slowo " +str(slowo)
if (len(slowo)>= 1) and (poprawnosc== 1) and (len(slowo)<= 2):
print "pokrycie startowe"
if self.pokrycieStartowe(slowo) > 0:
#przerywamy dzialanie algorytmu, poniewaz dodano nowy klasyfikator, nalezy obsluzyc w metodzie nadrzednej
return 0
table_CYK.append(tmp)
#wywolanie pokrycia agresywnego
#if (poprawnosc ==1)and (random.random() > self.parametry.Pa):
#print "pokrycie agresywne"
#self.pokrycieAgresywne()
#wypelnianie dalszych poziomow:
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
K = self.szukajPar(wiersz,pozycja)
LL = self.szukajTerminal(K,table_CYK,poprawnosc, wiersz)
if LL == -10:
return -10
tmp.append(LL)
pozycja+=1
table_CYK.append(tmp)
wiersz+=1
pozycja = 0
for x in table_CYK[len(slowo)-1][0]:
print x
if x == 'S':
succes = 1
if succes == poprawnosc:
succes = 1
print "succes"
else:
succes = 0
self.countProfi(succes)
if succes != 1:
#tutaj albo robimy S-> w cos co juz jest w ostatniej komorce, lub trzeba ostatnia komorke wypelnic jeszcze raz i dodac jednego S
# moze miec postac tylko nie terminalna
#K = self.szukajPar(len(slowo),0)
#losujemy jedna z par i dodajemy
#x = random.randint(0,len(K))
#lewa = self.szukajTerminal(x,table_CYK,poprawnosc, wiersz)
#dodac i zreserowac
#return -1
pass
#obbliczenie funkcji przystosowania:
self.countFitness()
return table_CYK
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji'''
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK,poprawnosc, wiersz):
'''metoda zwraca liste pasujacych terminali'''
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
for b in table_CYK[x[1][0]][x[1][1]]:
wynik=self.search(str(a)+str(b),poprawnosc, wiersz)
if (wynik != -1) and (wynik != -10):
for y in wynik:
if y != -1:
if not y in tmp:
tmp.extend(y)
elif wynik == -10:
return -10
if len(tmp)<=0:
tmp = [-1]
return tmp
def countFitness(self):
#przeniesc to do implementacji klasyfikatora!!!
PD = self.getPD()
fc = ff = 0
for x in self.G:
for y in self.G[x]:
#liczenie ff:
if(PD[0]-PD[1]!=0.0):
ff = (y.p -y.d - PD[1])/(PD[0]-PD[1])
else:
ff = 0.0
#liczenie fc:
if((y.u[0]+y.u[1])==0):
fc = self.parametry.f0
else:
if (self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1]) != 0:
fc = (self.parametry.wp * y.u[1])/(self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1])
#liczenie przystosowania:
if (self.parametry.wc + self.parametry.wf) != 0:
y.fitness = (self.parametry.wc*fc + self.parametry.wf*ff)/(self.parametry.wc + self.parametry.wf)
def getPD(self):
'''metoda zwaraca krorke (max(p-d),min(p-d)) '''
minimum = 0.0
maximum = 0.0
for x in self.G:
for y in self.G[x]:
tmp = y.p - y.d
if tmp > minimum:
minimum = tmp
if tmp < maximum:
maximum = tmp
return (maximum,minimum)
def countProfi(self, rozbior):
if rozbior == 0:
for x in self.usedTerminals:
x[0].d += self.parametry.ba*pow(2,x[1])*self.parametry.raf
else:
for x in self.usedTerminals:
x[0].p += self.parametry.ba*pow(2,x[1])*self.parametry.raf
def universalCover(self):
'''tutaj nie rozumie do konca idei tego pokrycia'''
pass
def pokryciePelne(self):
'''tego tez nie dokonca czaje i trzeba sie zapyac'''
pass
def pokrycieTerminalne(self, term):
'''operacja pokrycia terminalnego, przyjmuje terminal do dodania'''
self.add(string.upper(term) , term)
def pokrycieStartowe(self, term):
'''dodanie pokrycia startowego dal zdan dlugosci 1'''
return self.add("S" , term)
def pokrycieAgresywne(self, name):
'''i tego tez nie rozumiem
zorbie tak: ze zbioru detektorow wybieram 3 i robie z nich klasyfikator'''
#print "pokrycie agresywne"
D = self.G.keys()
tmp = random.randint(0,len(D)-1)
self.add(D[tmp] ,name)
def krzyzowanie(self,A,B, classA, classB):
'''metoda krzyzowania klasyfikatoprow, jeszcze nie przetestowana
nie sprawdzone czy napewno dziala poprawnie!!!'''
'''tmp=0
for x in self.G[A]:
if x.name == classB:
tmp=1
if tmp==0:
self.G[A].append(classifier(classB))
tmp=0
for x in self.G[B]:
if x.name == classA:
tmp=1
if tmp==0:
self.G[B].append(classifier(classA))'''
self.add(A,classB)
self.add(B,classA)
def mutacja(self):
'''musze tutaj jeszcze przeimplemntowac inne elementy, dodac tablice terminali(G.keys()) i nieterminali
nie sprawdzone czy napewno dziala poprawnie!!!'''
def inwersja(self,A,classA):
''' genetyk inwersji
nie sprawdzone czy napewno dziala poprawnie!!!'''
for x in G[A]:
if x.name == classB.name:
tmp=1
if tmp==0:
slef.G[A].append(classifier(str(classA[1])+str(classA[0])))
def scisk_new(self, left, name):
'''metoda dodaje dany klasyfikator ze sciskiem left-->name'''
cs_table = []
cf_table = []
choose = 0
minmal = 100000
for y in range(0,self.parametry.cf):
for x in range(0,self.parametry.cs):
keys = self.G.keys()
while 1:
B = random.choice(keys)
if len(self.G[B])>1:
break
while 1:
K = self.G[B][random.randint(0,len(self.G[B])-1)]
if len(K.name) > 1:
break
if K.fitness <= minmal:
minmal = K.fitness
choose = K
cf_table.append(K)
#szukamy najbardziej podobnego:
podobienstwo_max = 0
for x in cf_table:
podobienstwo = 0
if len(name) == 0:
if x.left == left:
podobienstwo += 1
if x.name[0] == name[0]:
podobienstwo += 1
if x.name[1] == name[1]:
podobienstwo += 1
if podobienstwo > podobienstwo_max:
podobienstwo_max = podobienstwo
K = x
return self.rem(K.left,K.name)
#SEKCJA TESTOWA:
G = gramatyka()
print G.getGramarStr()
A = G.CYK("1aa")
while A == 0:
A = G.CYK("1aabb")
print A
for x in A:
print x
#A = G.CYK("1h")
#while A == 0:
#A = G.CYK("1h")
print G.getGramarStr()
print "scisk"
#print G.scisk_new()
#B = G.usedTerminals
#for x in B:
#print x[0].left + "-->"+x[0].name + " poziom: "+str(x[1])
#G.countFitness
#print G.scisk_new("A")
#print G.CYK("1a")
#print G.getGramarStr()
#M = G.scisk()
#print G.getGramarStr()
#print M
| Python |
import string, random
positions = [22.23423, 8.345345]
def updatePosition(positions):
positions[0]=positions[0]+random.uniform(-0.0123,0.0232)
positions[1]=positions[0]+random.uniform(-0.0123,0.0232)
tmp = "/web/main/updateLocation.html?longitude="+str(positions[0])+"&latitude="+str(positions[1])
return tmp
for x in range(100):
print updatePosition(positions)
x+=1
while k <100:
| Python |
##klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
#Gramatyka w postaci slownika
self.Gg = {"S":["AB","BC"],"A":["BA","a"],"B":["CC","b"],"C":["AB","a"]}
self.G = {"S":["AB","AC"],"C":["SB","a"],"B":["BB","b"],"A":["a"]}
def add(self, A, B):
'''doaje kolejne reguly do gramamtyki, jeszcze nie przetestowane czy poprawnie dziala'''
if self.G.has_key(A):
self.G[A].append(B)
else:
self.G[A] = [B]
def search(self,terminal):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, metoda rozszezona o symbol uniwersalny'''
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if ((T == terminal) or (T == '#')):
find = 1
self.result.append(x)
if find == 1:
return self.result
else:
return -1
def getGramarStr(self):
tmp = ""
for x in self.G:
tmp += str(x) + "-->" + str(self.G[x])+ "\n"
return tmp
def CYK(self, slowo):
tmp = []
table_CYK =[]
final = []
#peirwsza czesc odpowiadajaca za wypelnienie pierwszego wiersza w tabeli
for x in slowo:
a = self.search(x)
if a == -1:
tmp.append([-1])
else:
tmp.append(a)
table_CYK.append([])
table_CYK[0] = tmp[0:]
#tutaj jakas totalna masakra taka ze glowa mala:):
#table_CYK.append([])
poziom=1
while poziom < (len(table_CYK[0])):
table_CYK.append([])
#k jest iteratorem dla while, nic pozatym
k=0
while k < len(table_CYK[0])-poziom:
tmp=[]
##tutaj zakres nie jest obknuty do konca
##cos - poziom po ktorym aktualnie poszukujemy:
for cos in range(0,poziom):
if cos<=(poziom-1-cos):
for a in table_CYK[cos][k]:
if table_CYK[cos][k] == -1:
tmp=[]
else:
for b in table_CYK[poziom-1-cos][k+1+cos]:
#print "if: dla [%d;%d] [%d;%d] szukam %s%s"%(cos,k,poziom-1-cos,k+1+cos,str(a),str(b))
wynik = self.search(str(a)+str(b))
if wynik != -1:
#if (wynik in tmp) == False:
if not [elements in wynik for elements in tmp]:
tmp.extend(wynik)
#print "else: dla [%d;%d] [%d;%d] szukam %s%s"%(cos,k,poziom-1-cos,k+1,str(a),str(b))
else:
for b in table_CYK[cos][k]:
if table_CYK[cos][k] == -1:
tmp=[]
for a in table_CYK[poziom-1-cos][k+1+cos]:
#print "else: dla [%d;%d] [%d;%d] szukam %s%s"%(cos,k+1,poziom-1-cos,k+1+cos,str(b),str(a))
wynik = self.search(str(b)+str(a))
if wynik != -1:
if not [elements in wynik for elements in tmp]:
tmp.extend(wynik)
if len(tmp) <= 0:
tmp = [-1]
table_CYK[poziom].append(tmp)
k+=1
#print "ostatio wygenerowany poziom"
#print table_CYK[poziom]
poziom+=1
return table_CYK
##klasa bedzie udawac zachowanie multiplekasera, bede jej uzywac do testow
class classifier():
'''klasa bedzie representowac klasyfikator w systemie'''
def __init__(self,name):
self.name = name
def set(self,name):
self.name=name
def getName(slef):
return slef.name
G = gramatyka()
K = G.CYK("aabb")
#G = gramatyka()
#print G.getGramarStr()
#K = G.CYK("abaaaaabbaba")
print "final:"
for x in K:
print x
| Python |
import sys, string
from CYK import gramatyka
from properties import properties
from PyQt4 import QtCore, QtGui
from okno_new import Ui_GCS
class MyForm(QtGui.QMainWindow):
#definicja zmiennych :
testingWords = []
fileIndex = 0
word = "aabb"
G = gramatyka()
parametry = properties()
#G.setProperties(parametry)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_GCS()
self.ui.setupUi(self)
#self.ui.window_CYK.addTab(self.genTabCYK())
self.ui.window_grammar.setText(self.G.getGramarStr())
#ustawianie polaczen:
#wystartowanie algorytmu:
QtCore.QObject.connect(self.ui.start_GLBS, QtCore.SIGNAL("clicked()"),self.genTabCYK)
#otwieranie pliku
QtCore.QObject.connect(self.ui.menuOpcje, QtCore.SIGNAL("clicked()"),self.openFile)
#puusty przycis narazie
#QtCore.QObject.connect(self.ui.change_word,QtCore.SIGNAL("clicked()"),self.changeWord)
#otwieranie pliku:
QtCore.QObject.connect(self.ui.open_file, QtCore.SIGNAL("clicked()"),self.openFile)
#nastepny krok
QtCore.QObject.connect(self.ui.change_word,QtCore.SIGNAL("clicked()"),self.readLine)
#popranie danych z formularza zmiennych, jeszcze sa tam jakies braki!!
QtCore.QObject.connect(self.ui.propertiesAccept,QtCore.SIGNAL("clicked()"),self.getProperties)
#anulowanie wprowadzanych preferenci
QtCore.QObject.connect(self.ui.propertiesCancel,QtCore.SIGNAL("clicked()"),self.cancelProperties)
#QtCore.QObject.connect(self.ui.change_word,QtCore.SIGNAL("clicked()"),self.readLine)
self.cancelProperties()
def genTabCYK(self):
print "w GCS ie"
print self.word
table = self.G.CYK(str(self.word))
while table == 0:
table = self.G.CYK(str(self.word))
if table == -10:
print "sdffffffffffffffffffffffff"
return -10
tmp = ""
for x in table:
tmp += str(x)+"\n"
self.ui.window_cyk.setText(tmp)
self.ui.window_grammar.setText(self.G.getGramarStr())
def readLine(self):
if self.fileIndex == len(self.testingWords) -1:
self.fileIndex = 0
self.fileIndex += 1
self.word = self.testingWords[self.fileIndex]
self.ui.window_cyk.setText(self.testingWords[self.fileIndex])
self.genTabCYK()
def showDict(self):
self.ui.okno_gl.setText(str(self.G.G))
def changeWord(self):
pass
def openFile(self):
''' metoda otwiera wskazany plik, i wyswietla'''
#co dalej z tym tekstem dlaczego ich ....
tmp = ''
fd = QtGui.QFileDialog(self)
self.filename = fd.getOpenFileName()
from os.path import isfile
if isfile(self.filename):
for x in open(self.filename):
self.testingWords.append(x[:len(x)-1])
self.editFile()
for x in self.testingWords:
tmp+=x #+" len: " + str(len(x)) + "\n"
self.ui.window_file.setText(tmp)
def editFile(self):
for x in range(0,len(self.testingWords)):
#tmp = self.testingWords[x][0]
self.testingWords[x] =self.testingWords[x][0]+self.testingWords[x][self.testingWords[x][2:].find(" ")+3:]
while self.testingWords[x].find(" ") > 0:
k = self.testingWords[x].find(" ")
self.testingWords[x]=self.testingWords[x][:k]+self.testingWords[x][k+1:]
def getProperties(self):
'''metoda ma za zadanie zczytywanie zmiennych, ale nie wiem jak z qwidegta pobrac dane'''
self.G.parametry.ba = self.ui.ba.value()
self.G.parametry.cf = self.ui.cf.value()
self.G.parametry.cs = self.ui.cs.value()
self.G.parametry.nelit = self.ui.nelit.value()
self.G.parametry.nmax = self.ui.nmax.value()
self.G.parametry.nN = self.ui.nN.value()
self.G.parametry.np = self.ui.np.value()
self.G.parametry.nrun = self.ui.nrun.value()
self.G.parametry.nstart = self.ui.nstart.value()
self.G.parametry.nT = self.ui.nT.value()
self.G.parametry.Pa = self.ui.Pa.value()
self.G.parametry.Pi = self.ui.Pi.value()
self.G.parametry.Pk= self.ui.Pk.value()
self.G.parametry.Pm= self.ui.Pm.value()
self.G.parametry.raf= self.ui.raf.value()
self.G.parametry.ts= self.ui.ts.value()
self.G.parametry.wc= self.ui.wc.value()
self.G.parametry.wf= self.ui.wf.value()
self.G.parametry.wn= self.ui.wn.value()
self.G.parametry.wp= self.ui.wp.value()
self.G.parametry.f0= self.ui.f0.value()
#self.ui.okno_gl.setText(str(self.ui.ba))
#self.ui.window_cyk.setText(str(self.parametry.ba))
def cancelProperties(self):
'''metoda ma za zadanie przywrocenie starych danych do formularza w przypadku wcisniecia "anuluj"'''
self.ui.ba.setValue(self.G.parametry.ba)
self.ui.cf.setValue(self.G.parametry.cf)
self.ui.cs.setValue(self.G.parametry.cs)
self.ui.nelit.setValue(self.G.parametry.nelit)
self.ui.nmax.setValue(self.G.parametry.nmax)
self.ui.nN.setValue(self.G.parametry.nN)
self.ui.np.setValue(self.G.parametry.np)
self.ui.nrun.setValue(self.G.parametry.nrun)
self.ui.nstart.setValue(self.G.parametry.nstart)
self.ui.nT.setValue(self.G.parametry.nT)
self.ui.Pa.setValue(self.G.parametry.Pa)
self.ui.Pi.setValue(self.G.parametry.Pi)
self.ui.Pk.setValue(self.G.parametry.Pk)
self.ui.Pm.setValue(self.G.parametry.Pm)
self.ui.raf.setValue(self.G.parametry.raf)
self.ui.ts.setValue(self.G.parametry.ts)
self.ui.wc.setValue(self.G.parametry.wc)
self.ui.wf.setValue(self.G.parametry.wf)
self.ui.wn.setValue(self.G.parametry.wn)
self.ui.wp.setValue(self.G.parametry.wp)
self.ui.f0.setValue(self.G.parametry.f0)
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = MyForm()
myapp.show()
sys.exit(app.exec_())
| Python |
#-*- coding: utf-8 -*-
#klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
import string, random
from properties import properties
from classifier import classifier
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
#tworzenie instncji parametrow
self.parametry = properties()
self.usedTerminals =[]
#Gramatyka w postaci slownika
#self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"A":[classifier("BA","A"),classifier("a","A")],"B":[classifier("CC","B"),classifier("b","B")],"C":[classifier("AB","C"),classifier("a","C")]}
self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.classifierNum=0
for x in self.G:
for y in self.G[x]:
if len(y.right)>1:
self.classifierNum+=1
def CYK(self, slowo):
''' algorytm CYK '''
#Do poprawienia:
#1. ocenienie po zakonczeniu
#2. przerywanie algorytmu
#3. tablica cyk na obiektach
#4. uzycie pokrycia
#5. symbole uniwersalne
#6.
poprawnosc = int(slowo[0])
slowo = slowo[1:]
#tymczasowa tablica do klasyfikatorów:
tmp = []
table_CYK=[]
#uzupelnianie pierwszego wiersza:
for x in slowo:
a = self.search(x,poprawnosc, 0)
if a == -1:
if poprawnosc == 1:
#rezygnuje z wprowadzania pustych znakow na pierwszym poziomie o ile zdanie jest poprawne
self.pokrycieTerminalne(x)
a = self.search(x,poprawnosc,0)
tmp.append(a)
else:
tmp.append([-1])
else:
tmp.append(a)
table_CYK.append(tmp)
#wypelnianie dalszych poziomow:
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
pary = self.szukajPar(wiersz,pozycja)
LL = self.szukajTerminal(pary,table_CYK,poprawnosc, wiersz)
if LL == -10:
return -10
tmp.append(LL)
pozycja+=1
table_CYK.append(tmp)
wiersz+=1
pozycja = 0
return table_CYK
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji'''
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK,poprawnosc, wiersz):
'''metoda zwraca liste pasujacych terminali'''
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
if a == -1:
continue
for b in table_CYK[x[1][0]][x[1][1]]:
if b == -1:
continue
print "szukam dla:"
print str(a.left)+str(b.left)
wynik=self.search(str(a.left)+str(b.left),poprawnosc, wiersz)
print "znalazlem:"
print wynik
if (wynik != -1) and (wynik != -10):
for y in wynik:
if y != -1:
#if not y in tmp:
print "dodaje:"
print y.getClassifierStr()
tmp.append(y)
elif wynik == -10:
return -10
if len(tmp)<=0:
tmp = [-1]
return tmp
def search(self,terminal,poprawnosc, poziom):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, rozszerzona o symbol uniwersalny'''
find = 0
result = []
for x in self.G:
for T in range(0,len(self.G[x])):
if ((self.G[x][T].right == terminal) or (self.G[x][T].right == '#')):
self.usedTerminals.append((T,poziom))
find = 1
result.append(self.G[x][T])
else:
pass
#możliwość zastosowania logiki rozmytej
#uzycie pokrycia agresywnego i restart systemu:
#print "agresywne"
#if self.parametry.Pa < random.random():
#self.pokrycieAgresywne(terminal)
if find == 1:
return result
else:
return -1
#testy:
G = gramatyka()
tab = G.CYK('1aabb')
#clas = classifier('A','AC')
#tmp = []
#tmp.extend('aaa')
#tmp.extend(clas)
#print tmp
print tab
str = '['
for x in tab:
str += '['
for kol in x:
str += '['
for el in kol:
if el == -1:
str += '-1'
else:
str += el.getClassifierStr()
str += ']'
str += ']'+"\n"
str += ']'
print str
| Python |
##klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
#Gramatyka w postaci slownika
self.Gg = {"S":["AB","BC"],"A":["BA","a"],"B":["CC","b"],"C":["AB","a"]}
self.G = {"S":["AB","AC"],"C":["SB","a"],"B":["BB","b"],"A":["a"]}
def add(self, A, B):
'''doaje kolejne reguly do gramamtyki, jeszcze nie przetestowane czy poprawnie dziala'''
if self.G.has_key(A):
self.G[A].append(B)
else:
self.G[A] = [B]
def search(self,terminal):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, metoda rozszezona o symbol uniwersalny'''
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if ((T == terminal) or (T == '#')):
find = 1
self.result.append(x)
if find == 1:
return self.result
else:
return -1
def getGramarStr(self):
tmp = ""
for x in self.G:
tmp += str(x) + "-->" + str(self.G[x])+ "\n"
return tmp
def CYK(self, slowo):
table_CYK=[]
tmp = []
#wypelnianie pierwszego poziomu:
for x in slowo:
a = self.search(x)
if a == -1:
tmp.append([-1])
else:
tmp.append(a)
table_CYK.append(tmp)
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
print "aktualne pole: "+str(wiersz)+str(pozycja)
#tutaj teraz trzeba odpalic uzupelnianie tablicy:(zamiast print)
K = self.szukajPar(wiersz,pozycja)
print "wyszukiwane pary"+str(K)
tmp.append(self.szukajTerminal(K,table_CYK))
#print str(table_CYK[x[0][0]][x[0][1]]) + str(table_CYK[x[1][0]][x[1][1]])
#print "cala linia" + str(M)
pozycja+=1
table_CYK.append(tmp)
wiersz+=1
pozycja = 0
print("\n")
return table_CYK
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji'''
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK):
'''metoda zwraca liste pasujacych terminali'''
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
for b in table_CYK[x[1][0]][x[1][1]]:
wynik=self.search(str(a)+str(b))
print str(wynik)
if wynik != -1:
for y in wynik:
if y != -1:
if not y in tmp:
tmp.extend(y)
if len(tmp)<=0:
tmp = [-1]
return tmp
G = gramatyka()
K = G.szukajPar(2,0)
#G = gramatyka()
#print G.getGramarStr()
table_CYK = G.CYK("aabb")
print "final:"
for x in table_CYK:
print x
L = G.szukajPar(1,2)
M = G.szukajTerminal(L,table_CYK)
print str(M) | Python |
from distutils.core import setup
import py2exe
setup(console=['GUI.py'])
| Python |
class properties():
def __init__(self):
self.Pk=0.5
self.Pm=0.5
self.Pi=0.5
#pelne pokrycie:
self.Pa=0.78
self.cf=5
self.cs=5
self.ba=5
self.raf=5
self.ts=0
#rozmiar populacji:
self.np=10
self.nstart=0
self.nN=0
self.nT=0
self.nelit=0
self.nrun=0
self.nmax=0
self.wc=10
self.wf=15
self.wp=10
self.wn=20
self.f0 = 5.0
#mozna oposcic plodnosc, ff nie jest brana pod uwage. | Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'okno_new.ui'
#
# Created: Mon Sep 01 12:18:38 2008
# by: PyQt4 UI code generator 4.4.2
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_GCS(object):
def setupUi(self, GCS):
GCS.setObjectName("GCS")
GCS.resize(821,600)
self.centralwidget = QtGui.QWidget(GCS)
self.centralwidget.setGeometry(QtCore.QRect(0,33,821,548))
self.centralwidget.setObjectName("centralwidget")
self.window_CYK = QtGui.QTabWidget(self.centralwidget)
self.window_CYK.setGeometry(QtCore.QRect(150,20,631,491))
self.window_CYK.setObjectName("window_CYK")
self.tab = QtGui.QWidget()
self.tab.setGeometry(QtCore.QRect(0,0,625,464))
self.tab.setObjectName("tab")
self.window_cyk = QtGui.QTextBrowser(self.tab)
self.window_cyk.setGeometry(QtCore.QRect(0,0,631,471))
self.window_cyk.setObjectName("window_cyk")
self.window_CYK.addTab(self.tab,"")
self.tab_2 = QtGui.QWidget()
self.tab_2.setGeometry(QtCore.QRect(0,0,625,464))
self.tab_2.setObjectName("tab_2")
self.window_grammar = QtGui.QTextBrowser(self.tab_2)
self.window_grammar.setGeometry(QtCore.QRect(0,0,631,471))
self.window_grammar.setObjectName("window_grammar")
self.window_CYK.addTab(self.tab_2,"")
self.tab_3 = QtGui.QWidget()
self.tab_3.setGeometry(QtCore.QRect(0,0,625,464))
self.tab_3.setObjectName("tab_3")
self.window_file = QtGui.QTextBrowser(self.tab_3)
self.window_file.setGeometry(QtCore.QRect(0,0,631,471))
self.window_file.setObjectName("window_file")
self.window_CYK.addTab(self.tab_3,"")
self.tab_4 = QtGui.QWidget()
self.tab_4.setGeometry(QtCore.QRect(0,0,625,464))
self.tab_4.setObjectName("tab_4")
self.numberOfLoops = QtGui.QSpinBox(self.tab_4)
self.numberOfLoops.setGeometry(QtCore.QRect(70,30,42,22))
self.numberOfLoops.setMaximum(10000)
self.numberOfLoops.setProperty("value",QtCore.QVariant(1))
self.numberOfLoops.setObjectName("numberOfLoops")
self.label = QtGui.QLabel(self.tab_4)
self.label.setGeometry(QtCore.QRect(10,30,61,20))
self.label.setObjectName("label")
self.propertiesAccept = QtGui.QPushButton(self.tab_4)
self.propertiesAccept.setGeometry(QtCore.QRect(540,430,75,23))
self.propertiesAccept.setObjectName("propertiesAccept")
self.propertiesCancel = QtGui.QPushButton(self.tab_4)
self.propertiesCancel.setGeometry(QtCore.QRect(450,430,75,23))
self.propertiesCancel.setObjectName("propertiesCancel")
self.label_2 = QtGui.QLabel(self.tab_4)
self.label_2.setGeometry(QtCore.QRect(150,30,61,20))
self.label_2.setObjectName("label_2")
self.label_3 = QtGui.QLabel(self.tab_4)
self.label_3.setGeometry(QtCore.QRect(150,50,61,20))
self.label_3.setObjectName("label_3")
self.label_4 = QtGui.QLabel(self.tab_4)
self.label_4.setGeometry(QtCore.QRect(150,70,61,20))
self.label_4.setObjectName("label_4")
self.label_5 = QtGui.QLabel(self.tab_4)
self.label_5.setGeometry(QtCore.QRect(150,90,61,20))
self.label_5.setObjectName("label_5")
self.Pk = QtGui.QDoubleSpinBox(self.tab_4)
self.Pk.setGeometry(QtCore.QRect(180,30,62,22))
self.Pk.setDecimals(2)
self.Pk.setMaximum(1.0)
self.Pk.setSingleStep(0.01)
self.Pk.setProperty("value",QtCore.QVariant(0.0))
self.Pk.setObjectName("Pk")
self.Pm = QtGui.QDoubleSpinBox(self.tab_4)
self.Pm.setGeometry(QtCore.QRect(180,50,62,22))
self.Pm.setMaximum(1.0)
self.Pm.setSingleStep(0.01)
self.Pm.setObjectName("Pm")
self.Pi = QtGui.QDoubleSpinBox(self.tab_4)
self.Pi.setGeometry(QtCore.QRect(180,70,62,22))
self.Pi.setMaximum(1.0)
self.Pi.setSingleStep(0.01)
self.Pi.setObjectName("Pi")
self.Pa = QtGui.QDoubleSpinBox(self.tab_4)
self.Pa.setGeometry(QtCore.QRect(180,90,62,22))
self.Pa.setMaximum(1.0)
self.Pa.setSingleStep(0.01)
self.Pa.setObjectName("Pa")
self.label_6 = QtGui.QLabel(self.tab_4)
self.label_6.setGeometry(QtCore.QRect(10,10,61,20))
self.label_6.setObjectName("label_6")
self.label_7 = QtGui.QLabel(self.tab_4)
self.label_7.setGeometry(QtCore.QRect(130,10,111,20))
self.label_7.setObjectName("label_7")
self.label_8 = QtGui.QLabel(self.tab_4)
self.label_8.setGeometry(QtCore.QRect(270,10,111,20))
self.label_8.setObjectName("label_8")
self.label_9 = QtGui.QLabel(self.tab_4)
self.label_9.setGeometry(QtCore.QRect(270,30,61,20))
self.label_9.setObjectName("label_9")
self.label_10 = QtGui.QLabel(self.tab_4)
self.label_10.setGeometry(QtCore.QRect(270,50,61,20))
self.label_10.setObjectName("label_10")
self.label_11 = QtGui.QLabel(self.tab_4)
self.label_11.setGeometry(QtCore.QRect(270,70,61,20))
self.label_11.setObjectName("label_11")
self.label_12 = QtGui.QLabel(self.tab_4)
self.label_12.setGeometry(QtCore.QRect(270,90,61,20))
self.label_12.setObjectName("label_12")
self.cs = QtGui.QSpinBox(self.tab_4)
self.cs.setGeometry(QtCore.QRect(300,50,42,22))
self.cs.setMinimum(1)
self.cs.setMaximum(30)
self.cs.setObjectName("cs")
self.cf = QtGui.QSpinBox(self.tab_4)
self.cf.setGeometry(QtCore.QRect(300,30,42,22))
self.cf.setMinimum(1)
self.cf.setMaximum(30)
self.cf.setObjectName("cf")
self.ba = QtGui.QSpinBox(self.tab_4)
self.ba.setGeometry(QtCore.QRect(300,70,42,22))
self.ba.setMaximum(15)
self.ba.setObjectName("ba")
self.raf = QtGui.QSpinBox(self.tab_4)
self.raf.setGeometry(QtCore.QRect(300,90,42,22))
self.raf.setMaximum(15)
self.raf.setObjectName("raf")
self.label_13 = QtGui.QLabel(self.tab_4)
self.label_13.setGeometry(QtCore.QRect(10,150,61,20))
self.label_13.setObjectName("label_13")
self.label_14 = QtGui.QLabel(self.tab_4)
self.label_14.setGeometry(QtCore.QRect(10,170,61,20))
self.label_14.setObjectName("label_14")
self.label_15 = QtGui.QLabel(self.tab_4)
self.label_15.setGeometry(QtCore.QRect(10,190,61,20))
self.label_15.setObjectName("label_15")
self.label_16 = QtGui.QLabel(self.tab_4)
self.label_16.setGeometry(QtCore.QRect(10,210,61,20))
self.label_16.setObjectName("label_16")
self.label_17 = QtGui.QLabel(self.tab_4)
self.label_17.setGeometry(QtCore.QRect(10,230,61,20))
self.label_17.setObjectName("label_17")
self.label_18 = QtGui.QLabel(self.tab_4)
self.label_18.setGeometry(QtCore.QRect(10,250,61,20))
self.label_18.setObjectName("label_18")
self.label_19 = QtGui.QLabel(self.tab_4)
self.label_19.setGeometry(QtCore.QRect(10,290,61,20))
self.label_19.setObjectName("label_19")
self.label_20 = QtGui.QLabel(self.tab_4)
self.label_20.setGeometry(QtCore.QRect(10,270,61,20))
self.label_20.setObjectName("label_20")
self.label_21 = QtGui.QLabel(self.tab_4)
self.label_21.setGeometry(QtCore.QRect(10,310,61,20))
self.label_21.setObjectName("label_21")
self.ts = QtGui.QSpinBox(self.tab_4)
self.ts.setGeometry(QtCore.QRect(60,170,42,22))
self.ts.setMinimum(1)
self.ts.setMaximum(30)
self.ts.setObjectName("ts")
self.np = QtGui.QSpinBox(self.tab_4)
self.np.setGeometry(QtCore.QRect(60,190,42,22))
self.np.setMinimum(1)
self.np.setObjectName("np")
self.nstart = QtGui.QSpinBox(self.tab_4)
self.nstart.setGeometry(QtCore.QRect(60,210,42,22))
self.nstart.setMinimum(1)
self.nstart.setObjectName("nstart")
self.nN = QtGui.QSpinBox(self.tab_4)
self.nN.setGeometry(QtCore.QRect(60,230,42,22))
self.nN.setMinimum(1)
self.nN.setMaximum(30)
self.nN.setObjectName("nN")
self.nelit = QtGui.QSpinBox(self.tab_4)
self.nelit.setGeometry(QtCore.QRect(60,270,42,22))
self.nelit.setMinimum(1)
self.nelit.setObjectName("nelit")
self.nT = QtGui.QSpinBox(self.tab_4)
self.nT.setGeometry(QtCore.QRect(60,250,42,22))
self.nT.setMinimum(1)
self.nT.setObjectName("nT")
self.nrun = QtGui.QSpinBox(self.tab_4)
self.nrun.setGeometry(QtCore.QRect(60,290,42,22))
self.nrun.setMinimum(10)
self.nrun.setMaximum(50)
self.nrun.setObjectName("nrun")
self.nmax = QtGui.QSpinBox(self.tab_4)
self.nmax.setGeometry(QtCore.QRect(60,310,42,22))
self.nmax.setMinimum(1)
self.nmax.setMaximum(50000)
self.nmax.setObjectName("nmax")
self.label_22 = QtGui.QLabel(self.tab_4)
self.label_22.setGeometry(QtCore.QRect(160,170,61,20))
self.label_22.setObjectName("label_22")
self.label_23 = QtGui.QLabel(self.tab_4)
self.label_23.setGeometry(QtCore.QRect(160,190,61,20))
self.label_23.setObjectName("label_23")
self.label_24 = QtGui.QLabel(self.tab_4)
self.label_24.setGeometry(QtCore.QRect(160,210,61,20))
self.label_24.setObjectName("label_24")
self.label_25 = QtGui.QLabel(self.tab_4)
self.label_25.setGeometry(QtCore.QRect(160,230,61,20))
self.label_25.setObjectName("label_25")
self.label_26 = QtGui.QLabel(self.tab_4)
self.label_26.setGeometry(QtCore.QRect(160,250,61,20))
self.label_26.setObjectName("label_26")
self.wp = QtGui.QSpinBox(self.tab_4)
self.wp.setGeometry(QtCore.QRect(180,170,42,22))
self.wp.setMinimum(1)
self.wp.setMaximum(20)
self.wp.setObjectName("wp")
self.wn = QtGui.QSpinBox(self.tab_4)
self.wn.setGeometry(QtCore.QRect(180,190,42,22))
self.wn.setMinimum(1)
self.wn.setMaximum(20)
self.wn.setObjectName("wn")
self.wc = QtGui.QSpinBox(self.tab_4)
self.wc.setGeometry(QtCore.QRect(180,210,42,22))
self.wc.setMinimum(1)
self.wc.setMaximum(20)
self.wc.setObjectName("wc")
self.wf = QtGui.QSpinBox(self.tab_4)
self.wf.setGeometry(QtCore.QRect(180,230,42,22))
self.wf.setMinimum(1)
self.wf.setMaximum(15)
self.wf.setObjectName("wf")
self.f0 = QtGui.QSpinBox(self.tab_4)
self.f0.setGeometry(QtCore.QRect(180,250,42,22))
self.f0.setMaximum(10)
self.f0.setObjectName("f0")
self.window_CYK.addTab(self.tab_4,"")
self.start_GLBS = QtGui.QPushButton(self.centralwidget)
self.start_GLBS.setGeometry(QtCore.QRect(10,60,121,31))
self.start_GLBS.setObjectName("start_GLBS")
self.Pause = QtGui.QPushButton(self.centralwidget)
self.Pause.setGeometry(QtCore.QRect(10,100,121,31))
self.Pause.setObjectName("Pause")
self.params = QtGui.QPushButton(self.centralwidget)
self.params.setGeometry(QtCore.QRect(10,140,121,31))
self.params.setObjectName("params")
self.open_file = QtGui.QPushButton(self.centralwidget)
self.open_file.setGeometry(QtCore.QRect(10,20,121,31))
self.open_file.setObjectName("open_file")
self.Koniec = QtGui.QPushButton(self.centralwidget)
self.Koniec.setGeometry(QtCore.QRect(10,510,121,31))
self.Koniec.setObjectName("Koniec")
self.change_word = QtGui.QPushButton(self.centralwidget)
self.change_word.setGeometry(QtCore.QRect(10,180,121,31))
self.change_word.setObjectName("change_word")
GCS.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(GCS)
self.menubar.setGeometry(QtCore.QRect(0,0,821,21))
self.menubar.setObjectName("menubar")
self.menuOpcje = QtGui.QMenu(self.menubar)
self.menuOpcje.setObjectName("menuOpcje")
self.menuAbout = QtGui.QMenu(self.menubar)
self.menuAbout.setObjectName("menuAbout")
GCS.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(GCS)
self.statusbar.setGeometry(QtCore.QRect(0,581,821,19))
self.statusbar.setObjectName("statusbar")
GCS.setStatusBar(self.statusbar)
self.toolBar = QtGui.QToolBar(GCS)
self.toolBar.setGeometry(QtCore.QRect(0,21,12,12))
self.toolBar.setObjectName("toolBar")
GCS.addToolBar(QtCore.Qt.TopToolBarArea,self.toolBar)
self.toolBar_2 = QtGui.QToolBar(GCS)
self.toolBar_2.setGeometry(QtCore.QRect(12,21,809,12))
self.toolBar_2.setObjectName("toolBar_2")
GCS.addToolBar(QtCore.Qt.TopToolBarArea,self.toolBar_2)
self.actionWczytaj_Dane = QtGui.QAction(GCS)
self.actionWczytaj_Dane.setObjectName("actionWczytaj_Dane")
self.menuOpcje.addAction(self.actionWczytaj_Dane)
self.menubar.addAction(self.menuOpcje.menuAction())
self.menubar.addAction(self.menuAbout.menuAction())
self.retranslateUi(GCS)
self.window_CYK.setCurrentIndex(3)
QtCore.QObject.connect(self.Koniec,QtCore.SIGNAL("clicked()"),GCS.close)
QtCore.QMetaObject.connectSlotsByName(GCS)
def retranslateUi(self, GCS):
GCS.setWindowTitle(QtGui.QApplication.translate("GCS", "MainWindow", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab), QtGui.QApplication.translate("GCS", "Tab 1", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_2), QtGui.QApplication.translate("GCS", "Tab 2", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_3), QtGui.QApplication.translate("GCS", "Strona", None, QtGui.QApplication.UnicodeUTF8))
self.label.setText(QtGui.QApplication.translate("GCS", "Liczba pętli", None, QtGui.QApplication.UnicodeUTF8))
self.propertiesAccept.setText(QtGui.QApplication.translate("GCS", "Akceptuj", None, QtGui.QApplication.UnicodeUTF8))
self.propertiesCancel.setText(QtGui.QApplication.translate("GCS", "Anuluj", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate("GCS", "Pk", None, QtGui.QApplication.UnicodeUTF8))
self.label_3.setText(QtGui.QApplication.translate("GCS", "Pm", None, QtGui.QApplication.UnicodeUTF8))
self.label_4.setText(QtGui.QApplication.translate("GCS", "Pi", None, QtGui.QApplication.UnicodeUTF8))
self.label_5.setText(QtGui.QApplication.translate("GCS", "Pa", None, QtGui.QApplication.UnicodeUTF8))
self.label_6.setText(QtGui.QApplication.translate("GCS", "Ogólne:", None, QtGui.QApplication.UnicodeUTF8))
self.label_7.setText(QtGui.QApplication.translate("GCS", "Algorytm gentyczny:", None, QtGui.QApplication.UnicodeUTF8))
self.label_8.setText(QtGui.QApplication.translate("GCS", "Algorytm ścisku:", None, QtGui.QApplication.UnicodeUTF8))
self.label_9.setText(QtGui.QApplication.translate("GCS", "cf", None, QtGui.QApplication.UnicodeUTF8))
self.label_10.setText(QtGui.QApplication.translate("GCS", "cs", None, QtGui.QApplication.UnicodeUTF8))
self.label_11.setText(QtGui.QApplication.translate("GCS", "ba", None, QtGui.QApplication.UnicodeUTF8))
self.label_12.setText(QtGui.QApplication.translate("GCS", "raf", None, QtGui.QApplication.UnicodeUTF8))
self.label_13.setText(QtGui.QApplication.translate("GCS", "Pozostałe:", None, QtGui.QApplication.UnicodeUTF8))
self.label_14.setText(QtGui.QApplication.translate("GCS", "ts", None, QtGui.QApplication.UnicodeUTF8))
self.label_15.setText(QtGui.QApplication.translate("GCS", "np", None, QtGui.QApplication.UnicodeUTF8))
self.label_16.setText(QtGui.QApplication.translate("GCS", "nstart", None, QtGui.QApplication.UnicodeUTF8))
self.label_17.setText(QtGui.QApplication.translate("GCS", "nN", None, QtGui.QApplication.UnicodeUTF8))
self.label_18.setText(QtGui.QApplication.translate("GCS", "nT", None, QtGui.QApplication.UnicodeUTF8))
self.label_19.setText(QtGui.QApplication.translate("GCS", "nrun", None, QtGui.QApplication.UnicodeUTF8))
self.label_20.setText(QtGui.QApplication.translate("GCS", "nelit", None, QtGui.QApplication.UnicodeUTF8))
self.label_21.setText(QtGui.QApplication.translate("GCS", "nmax", None, QtGui.QApplication.UnicodeUTF8))
self.label_22.setText(QtGui.QApplication.translate("GCS", "wp", None, QtGui.QApplication.UnicodeUTF8))
self.label_23.setText(QtGui.QApplication.translate("GCS", "wn", None, QtGui.QApplication.UnicodeUTF8))
self.label_24.setText(QtGui.QApplication.translate("GCS", "wc", None, QtGui.QApplication.UnicodeUTF8))
self.label_25.setText(QtGui.QApplication.translate("GCS", "wf", None, QtGui.QApplication.UnicodeUTF8))
self.label_26.setText(QtGui.QApplication.translate("GCS", "f0", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_4), QtGui.QApplication.translate("GCS", "Strona", None, QtGui.QApplication.UnicodeUTF8))
self.start_GLBS.setText(QtGui.QApplication.translate("GCS", "Start", None, QtGui.QApplication.UnicodeUTF8))
self.Pause.setText(QtGui.QApplication.translate("GCS", "Pause", None, QtGui.QApplication.UnicodeUTF8))
self.params.setText(QtGui.QApplication.translate("GCS", "Zmień parametry", None, QtGui.QApplication.UnicodeUTF8))
self.open_file.setText(QtGui.QApplication.translate("GCS", "Wczytaj plik", None, QtGui.QApplication.UnicodeUTF8))
self.Koniec.setText(QtGui.QApplication.translate("GCS", "Koniec", None, QtGui.QApplication.UnicodeUTF8))
self.change_word.setText(QtGui.QApplication.translate("GCS", "Następny krok", None, QtGui.QApplication.UnicodeUTF8))
self.menuOpcje.setTitle(QtGui.QApplication.translate("GCS", "Opcje", None, QtGui.QApplication.UnicodeUTF8))
self.menuAbout.setTitle(QtGui.QApplication.translate("GCS", "About", None, QtGui.QApplication.UnicodeUTF8))
self.toolBar.setWindowTitle(QtGui.QApplication.translate("GCS", "toolBar", None, QtGui.QApplication.UnicodeUTF8))
self.toolBar_2.setWindowTitle(QtGui.QApplication.translate("GCS", "toolBar_2", None, QtGui.QApplication.UnicodeUTF8))
self.actionWczytaj_Dane.setText(QtGui.QApplication.translate("GCS", "Wczytaj Dane", None, QtGui.QApplication.UnicodeUTF8))
| Python |
import sys, string
from PyQt4 import QtCore, QtGui
from CYK import gramatyka
from okno import Ui_CYK
class MyForm(QtGui.QMainWindow):
#definicja zmiennych :
word = "aaaaabbbbsss"
G = gramatyka()
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_CYK()
self.ui.setupUi(self)
# definiuke wlasne polaczenie slotow:
#QtCore.QObject.connect(self.ui.button_open,QtCore.SIGNAL("clicked()"), self.file_dialog)
#dodanie slowa:
QtCore.QObject.connect(self.ui.dodaj_slowo,QtCore.SIGNAL("clicked()"),self.addWord)
#generacja tablicy CYK:
QtCore.QObject.connect(self.ui.generujTabCYK,QtCore.SIGNAL("clicked()"),self.genTabCYK)
#pokaz slownik:
QtCore.QObject.connect(self.ui.show_dict,QtCore.SIGNAL("clicked()"),self.showDict)
def addWord(self):
self.word=self.ui.slowo.toPlainText()
self.ui.okno_gl.setText(self.word)
def genTabCYK(self):
table = self.G.CYK(str(self.word))
tmp = "slowo: \t %s \n"%(self.word)
for x in table:
tmp += str(x)+"\n"
self.ui.okno_gl.setText(tmp)
def showDict(self):
self.ui.okno_gl.setText(str(self.G.G))
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = MyForm()
myapp.show()
sys.exit(app.exec_())
| Python |
##klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
import string, random
from properties import properties
from classifier import classifier
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
self.parametry = properties()
self.usedTerminals =[]
#Gramatyka w postaci slownika
#self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"A":[classifier("BA","A"),classifier("a","A")],"B":[classifier("CC","B"),classifier("b","B")],"C":[classifier("AB","C"),classifier("a","C")]}
self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.classifierNum=0
for x in self.G:
for y in self.G[x]:
if len(y.name)>1:
self.classifierNum+=1
def setProperties(self,p):
''' metoda uaktualnia parametry danego badania'''
self.parametry=p
def add(self, A, B):
'''dodaje kolejne reguly do gramamtyki A-->B'''
tmp=0
# sprawdzanie czy istnieje juz taki klasyfikator:
if self.G.has_key(A):
for x in self.G[A]:
if x.name==B:
tmp=1
if tmp == 0:
#scisk tutaj:
if(self.classifierNum >= self.parametry.np):
self.scisk_new(B,A)
#i dodajemy
self.G[A].append(classifier(B,A))
print "dodalem:" + A +"-->"+B
if len(B)>1:
self.classifierNum+=1
return 1
else:
#print "nie dodalem bo juz jest:)"
return -1
else:
if(self.classifierNum >= self.parametry.np):
self.scisk_new(B,A)
self.G[A] = [classifier(B,A)]
print "dodalem:" + A +"-->"+B
self.classifierNum+=1
return 1
def rem(self,A,B):
'''metoda usowa klasyfikator z gramatyki'''
tmp = 0
for x in self.G[A]:
if x.name == B:
del self.G[A][tmp]
self.classifierNum-=1
return 1
#print "usuwam"
tmp+=1
if len(self.G[A])==0:
del(self.G[A])
return 1
def search(self,terminal,poprawnosc, poziom):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, rozszerzona o symbol uniwersalny'''
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if ((T.name == terminal) or (T.name == '#')):
self.usedTerminals.append((T,poziom))
find = 1
self.result.append(x)
#Tutaj T dodajemy do listy uzytych podaczas parsowania
#przyznawanie punktow:
T.u[int(poprawnosc)]+=1
else:
#uzycie pokrycia agresywnego i restart systemu:
if self.parametry.Pa < random.random():
self.pokrycieAgresywne(terminal)
#info do systemu ze trzeba restart walnac
#return -10
#trzeba jeszcze tutaj przerwac
if find == 1:
return self.result
else:
return -1
def getGramarStr(self):
'''metoda zwraca liste klasyfikatorow wraz z ich parametrami w postaci stringa'''
tmp = ""
for x in self.G:
for y in self.G[x]:
tmp += str(x) + " -->" + y.name +"\t"+"un= "+str(y.u[0])+"\t"+"up="+str(y.u[1])+"\t fitnes"+str(y.fitness)+ " p i d "+"("+str(y.p)+","+str(y.d)+")"+"\n"
return tmp
def CYK(self, slowo):
''' algorytm CYK '''
succes = 0
poprawnosc = int(slowo[0])
slowo = slowo[1:]
table_CYK=[]
tmp = []
used_clas = []
#wypelnianie pierwszego poziomu:
for x in slowo:
a = self.search(x,poprawnosc, 0)
if a == -1:
if poprawnosc == 1:
#rezygnuje z wprowadzania pustych znakow na pierwszym poziomie o ile zdanie jest poprawne
self.pokrycieTerminalne(x)
a = self.search(x,poprawnosc,poprawnosc)
tmp.append(a)
else:
tmp.append([-1])
else:
tmp.append(a)
#pokrycie startowe:
print "dlugosc="+str(len(slowo))+" poprawnosc="+str(poprawnosc) + "slowo " +str(slowo)
if (len(slowo)>= 1) and (poprawnosc== 1) and (len(slowo)<= 2):
print "pokrycie startowe"
if self.pokrycieStartowe(slowo) > 0:
#przerywamy dzialanie algorytmu, poniewaz dodano nowy klasyfikator, nalezy obsluzyc w metodzie nadrzednej
return 0
table_CYK.append(tmp)
#wywolanie pokrycia agresywnego
#if (poprawnosc ==1)and (random.random() > self.parametry.Pa):
#print "pokrycie agresywne"
#self.pokrycieAgresywne()
#wypelnianie dalszych poziomow:
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
K = self.szukajPar(wiersz,pozycja)
LL = self.szukajTerminal(K,table_CYK,poprawnosc, wiersz)
if LL == -10:
return -10
tmp.append(LL)
pozycja+=1
table_CYK.append(tmp)
wiersz+=1
pozycja = 0
for x in table_CYK[len(slowo)-1][0]:
print x
if x == 'S':
succes = 1
if succes == poprawnosc:
succes = 1
print "succes"
else:
succes = 0
self.countProfi(succes)
if succes != 1:
#tutaj albo robimy S-> w cos co juz jest w ostatniej komorce, lub trzeba ostatnia komorke wypelnic jeszcze raz i dodac jednego S
# moze miec postac tylko nie terminalna
#K = self.szukajPar(len(slowo),0)
#losujemy jedna z par i dodajemy
#x = random.randint(0,len(K))
#lewa = self.szukajTerminal(x,table_CYK,poprawnosc, wiersz)
#dodac i zreserowac
#return -1
pass
#obbliczenie funkcji przystosowania:
self.countFitness()
return table_CYK
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji'''
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK,poprawnosc, wiersz):
'''metoda zwraca liste pasujacych terminali'''
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
for b in table_CYK[x[1][0]][x[1][1]]:
wynik=self.search(str(a)+str(b),poprawnosc, wiersz)
if (wynik != -1) and (wynik != -10):
for y in wynik:
if y != -1:
if not y in tmp:
tmp.extend(y)
elif wynik == -10:
return -10
if len(tmp)<=0:
tmp = [-1]
return tmp
def countFitness(self):
#przeniesc to do implementacji klasyfikatora!!!
PD = self.getPD()
fc = ff = 0
for x in self.G:
for y in self.G[x]:
#liczenie ff:
if(PD[0]-PD[1]!=0.0):
ff = (y.p -y.d - PD[1])/(PD[0]-PD[1])
else:
ff = 0.0
#liczenie fc:
if((y.u[0]+y.u[1])==0):
fc = self.parametry.f0
else:
if (self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1]) != 0:
fc = (self.parametry.wp * y.u[1])/(self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1])
#liczenie przystosowania:
if (self.parametry.wc + self.parametry.wf) != 0:
y.fitness = (self.parametry.wc*fc + self.parametry.wf*ff)/(self.parametry.wc + self.parametry.wf)
def getPD(self):
'''metoda zwaraca krorke (max(p-d),min(p-d)) '''
minimum = 0.0
maximum = 0.0
for x in self.G:
for y in self.G[x]:
tmp = y.p - y.d
if tmp > minimum:
minimum = tmp
if tmp < maximum:
maximum = tmp
return (maximum,minimum)
def countProfi(self, rozbior):
if rozbior == 0:
for x in self.usedTerminals:
x[0].d += self.parametry.ba*pow(2,x[1])*self.parametry.raf
else:
for x in self.usedTerminals:
x[0].p += self.parametry.ba*pow(2,x[1])*self.parametry.raf
def universalCover(self):
'''tutaj nie rozumie do konca idei tego pokrycia'''
pass
def pokryciePelne(self):
'''tego tez nie dokonca czaje i trzeba sie zapyac'''
pass
def pokrycieTerminalne(self, term):
'''operacja pokrycia terminalnego, przyjmuje terminal do dodania'''
self.add(string.upper(term) , term)
def pokrycieStartowe(self, term):
'''dodanie pokrycia startowego dal zdan dlugosci 1'''
return self.add("S" , term)
def pokrycieAgresywne(self, name):
'''i tego tez nie rozumiem
zorbie tak: ze zbioru detektorow wybieram 3 i robie z nich klasyfikator'''
#print "pokrycie agresywne"
D = self.G.keys()
tmp = random.randint(0,len(D)-1)
self.add(D[tmp] ,name)
def krzyzowanie(self,A,B, classA, classB):
'''metoda krzyzowania klasyfikatoprow, jeszcze nie przetestowana
nie sprawdzone czy napewno dziala poprawnie!!!'''
'''tmp=0
for x in self.G[A]:
if x.name == classB:
tmp=1
if tmp==0:
self.G[A].append(classifier(classB))
tmp=0
for x in self.G[B]:
if x.name == classA:
tmp=1
if tmp==0:
self.G[B].append(classifier(classA))'''
self.add(A,classB)
self.add(B,classA)
def mutacja(self):
'''musze tutaj jeszcze przeimplemntowac inne elementy, dodac tablice terminali(G.keys()) i nieterminali
nie sprawdzone czy napewno dziala poprawnie!!!'''
def inwersja(self,A,classA):
''' genetyk inwersji
nie sprawdzone czy napewno dziala poprawnie!!!'''
for x in G[A]:
if x.name == classB.name:
tmp=1
if tmp==0:
slef.G[A].append(classifier(str(classA[1])+str(classA[0])))
def scisk_new(self, left, name):
'''metoda dodaje dany klasyfikator ze sciskiem left-->name'''
cs_table = []
cf_table = []
choose = 0
minmal = 100000
for y in range(0,self.parametry.cf):
for x in range(0,self.parametry.cs):
keys = self.G.keys()
while 1:
B = random.choice(keys)
if len(self.G[B])>1:
break
while 1:
K = self.G[B][random.randint(0,len(self.G[B])-1)]
if len(K.name) > 1:
break
if K.fitness <= minmal:
minmal = K.fitness
choose = K
cf_table.append(K)
#szukamy najbardziej podobnego:
podobienstwo_max = 0
for x in cf_table:
podobienstwo = 0
if len(name) == 0:
if x.left == left:
podobienstwo += 1
if x.name[0] == name[0]:
podobienstwo += 1
if x.name[1] == name[1]:
podobienstwo += 1
if podobienstwo > podobienstwo_max:
podobienstwo_max = podobienstwo
K = x
return self.rem(K.left,K.name)
#SEKCJA TESTOWA:
G = gramatyka()
print G.getGramarStr()
A = G.CYK("1aa")
while A == 0:
A = G.CYK("1aabb")
print A
for x in A:
print x
#A = G.CYK("1h")
#while A == 0:
#A = G.CYK("1h")
print G.getGramarStr()
print "scisk"
#print G.scisk_new()
#B = G.usedTerminals
#for x in B:
#print x[0].left + "-->"+x[0].name + " poziom: "+str(x[1])
#G.countFitness
#print G.scisk_new("A")
#print G.CYK("1a")
#print G.getGramarStr()
#M = G.scisk()
#print G.getGramarStr()
#print M
| Python |
class classifier():
'''klasa bedzie representowac klasyfikator w systemie'''
def __init__(self,name, left):
#prawa strona kalsyfikatora
self.left = left;
self.right = name
'''ilosc uzyc jest realizowana za pomoca tablicy
u[0] -> ilosc uzyc klasyfikatora przy parsowaniu zdania niepoprawnego
u[1] -> ilosc uzyc klasyfikatora przy parsowaniu zdania poprawnego'''
#ilosc poprawnych uzyc
self.u = []
self.u.append(0.0)
#ilosc niepoprawnych uzyc
self.u.append(0.0)
#co to bylo ??;), czy mam to updejtowac dopiero po rozbiorze?
self.p = 0.0
self.d =0.0
self.fitness = 0.0
def setName(self,name):
self.right=name
def getRight(self):
return self.right
def addPoints(self, poprawnosc):
'''dodanie opdpowiednio punktow do odpowiednieo parametru u'''
self.u[poprawnosc] =self.u[poprawnosc]+1
def getClassifierStr(self):
return self.left + "--->" + self.right
| Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'properties_window.ui'
#
# Created: Tue Aug 26 11:08:30 2008
# by: PyQt4 UI code generator 4.4.2
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_Properties(object):
def setupUi(self, Properties):
Properties.setObjectName("Properties")
Properties.resize(829,601)
self.lineEdit = QtGui.QLineEdit(Properties)
self.lineEdit.setGeometry(QtCore.QRect(20,10,451,71))
self.lineEdit.setObjectName("lineEdit")
self.retranslateUi(Properties)
QtCore.QMetaObject.connectSlotsByName(Properties)
def retranslateUi(self, Properties):
Properties.setWindowTitle(QtGui.QApplication.translate("Properties", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
self.lineEdit.setText(QtGui.QApplication.translate("Properties", "hi hey hello", None, QtGui.QApplication.UnicodeUTF8))
| Python |
#-*- coding: utf-8 -*-
#klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
import string, random
from properties import properties
from classifier import classifier
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
self.permisionCover = 1
self.parametry = properties()
self.usedTerminals =[]
#Gramatyka w postaci slownika
#self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"A":[classifier("BA","A"),classifier("a","A")],"B":[classifier("CC","B"),classifier("b","B")],"C":[classifier("AB","C"),classifier("a","C")]}
self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.classifierNum=0
for x in self.G:
for y in self.G[x]:
if len(y.right)>1:
self.classifierNum+=1
def setProperties(self,p):
''' metoda uaktualnia parametry danego badania'''
self.parametry=p
def add(self, A, B):
'''dodaje kolejne reguly do gramamtyki A-->B'''
tmp=0
# sprawdzanie czy istnieje juz taki klasyfikator:
if self.G.has_key(A):
for x in self.G[A]:
if x.name==B:
tmp=1
if tmp == 0:
#scisk tutaj:
if(self.classifierNum >= self.parametry.np):
self.scisk_new(B,A)
#i dodajemy
self.G[A].append(classifier(B,A))
print "dodalem:" + A +"-->"+B
if len(B)>1:
self.classifierNum+=1
return 1
else:
#print "nie dodalem bo juz jest:)"
return -1
else:
if(self.classifierNum >= self.parametry.np):
self.scisk_new(B,A)
self.G[A] = [classifier(B,A)]
print "dodalem:" + A +"-->"+B
self.classifierNum+=1
return 1
def rem(self,A,B):
'''metoda usowa klasyfikator z gramatyki'''
tmp = 0
for x in self.G[A]:
if x.name == B:
del self.G[A][tmp]
self.classifierNum-=1
return 1
#print "usuwam"
tmp+=1
if len(self.G[A])==0:
del(self.G[A])
return 1
def search(self,terminal,poprawnosc, poziom):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, rozszerzona o symbol uniwersalny'''
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if ((T.name == terminal) or (T.name == '#')):
self.usedTerminals.append((T,poziom))
find = 1
self.result.append(x)
#Tutaj T dodajemy do listy uzytych podaczas parsowania
#przyznawanie punktow:
T.u[int(poprawnosc)]+=1
#else:
##uzycie pokrycia agresywnego i restart systemu:
#if (self.parametry.Pa < random.random()) and (self.permisionCover ==1):
#if self.pokrycieAgresywne(terminal) == 1:
##info do systemu ze trzeba restart walnac
#self.permisionCover = 0
#return -10
if find == 1:
return self.result
else:
if (self.parametry.Pa < random.random()) and (self.permisionCover ==1):
if self.pokrycieAgresywne(terminal) == 1:
#info do systemu ze trzeba restart walnac
self.permisionCover = 0
return -10
else:
return -1
def getGramarStr(self):
'''metoda zwraca liste klasyfikatorow wraz z ich parametrami w postaci stringa'''
tmp = ""
for x in self.G:
for y in self.G[x]:
tmp += str(x) + " -->" + y.right +"\t"+"un= "+str(y.u[0])+"\t"+"up="+str(y.u[1])+"\t fitnes"+str(y.fitness)+ " p i d "+"("+str(y.p)+","+str(y.d)+")"+"\n"
return tmp
def CYK(self, slowo):
''' algorytm CYK '''
succes = 0
poprawnosc = int(slowo[0])
slowo = slowo[1:]
table_CYK=[]
tmp = []
used_clas = []
#wypelnianie pierwszego poziomu:
for x in slowo:
a = self.search(x,poprawnosc, 0)
if(a == -10):
print "przerwalem!"
return -10
if a == -1:
if poprawnosc == 1:
#rezygnuje z wprowadzania pustych znakow na pierwszym poziomie o ile zdanie jest poprawne
self.pokrycieTerminalne(x)
a = self.search(x,poprawnosc,poprawnosc)
if a == -10:
print "restart systemu"
return -10
tmp.append(a)
print tmp
else:
tmp.append([-1])
else:
tmp.append(a)
#pokrycie startowe:
print "dlugosc="+str(len(slowo))+" poprawnosc= "+str(poprawnosc) + "slowo " +str(slowo)
if (len(slowo)>= 1) and (poprawnosc== 1) and (len(slowo)<= 2):
print "pokrycie startowe"
if self.pokrycieStartowe(slowo) > 0:
#przerywamy dzialanie algorytmu, poniewaz dodano nowy klasyfikator, nalezy obsluzyc w metodzie nadrzednej
return 0
print tmp
table_CYK.append(tmp)
print table_CYK
print "rozpoczynamy dodawanie na kolejnym poziomie"
#wypelnianie dalszych poziomow:
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
K = self.szukajPar(wiersz,pozycja)
LL = self.szukajTerminal(K,table_CYK,poprawnosc, wiersz)
if LL == -10:
return -10
tmp.append(LL)
pozycja+=1
table_CYK.append(tmp)
wiersz+=1
pozycja = 0
print "cyk sie skonczyl"
for x in table_CYK[len(slowo)-1][0]:
print x
if x == 'S':
succes = 1
if succes == poprawnosc:
succes = 1
print "succes"
else:
succes = 0
print "fuj"
self.countProfi(succes)
if succes != 1:
#tutaj albo robimy S-> w cos co juz jest w ostatniej komorce, lub trzeba ostatnia komorke wypelnic jeszcze raz i dodac jednego S
# moze miec postac tylko nie terminalna
#K = self.szukajPar(len(slowo),0)
#losujemy jedna z par i dodajemy
#x = random.randint(0,len(K))
#lewa = self.szukajTerminal(x,table_CYK,poprawnosc, wiersz)
#dodac i zreserowac
#return -1
pass
#obbliczenie funkcji przystosowania:
self.countFitness()
return table_CYK
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji'''
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK,poprawnosc, wiersz):
'''metoda zwraca liste pasujacych terminali'''
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
for b in table_CYK[x[1][0]][x[1][1]]:
wynik=self.search(str(a)+str(b),poprawnosc, wiersz)
if (wynik != -1) and (wynik != -10):
for y in wynik:
if y != -1:
if not y in tmp:
tmp.extend(y)
elif wynik == -10:
return -10
if len(tmp)<=0:
tmp = [-1]
return tmp
def countFitness(self):
#przeniesc to do implementacji klasyfikatora!!!
PD = self.getPD()
fc = ff = 0
for x in self.G:
for y in self.G[x]:
#liczenie ff:
if(PD[0]-PD[1]!=0.0):
ff = (y.p -y.d - PD[1])/(PD[0]-PD[1])
else:
ff = 0.0
#liczenie fc:
if((y.u[0]+y.u[1])==0):
fc = self.parametry.f0
else:
if (self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1]) != 0:
fc = (self.parametry.wp * y.u[1])/(self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1])
#liczenie przystosowania:
if (self.parametry.wc + self.parametry.wf) != 0:
y.fitness = (self.parametry.wc*fc + self.parametry.wf*ff)/(self.parametry.wc + self.parametry.wf)
def getPD(self):
'''metoda zwaraca krorke (max(p-d),min(p-d)) '''
minimum = 0.0
maximum = 0.0
for x in self.G:
for y in self.G[x]:
tmp = y.p - y.d
if tmp > minimum:
minimum = tmp
if tmp < maximum:
maximum = tmp
return (maximum,minimum)
def countProfi(self, rozbior):
if rozbior == 0:
for x in self.usedTerminals:
x[0].d += self.parametry.ba*pow(2,x[1])*self.parametry.raf
else:
for x in self.usedTerminals:
x[0].p += self.parametry.ba*pow(2,x[1])*self.parametry.raf
def randomSelction(self):
'''losowanie klasyfikatora '''
K = self.G.keys()
key = random.randint(0,len(K)-1)
tmp = self.G[K[key]]
prawa = random.randint(0,len(tmp)-1)
return (K[key],tmp[prawa].name)
def universalCover(self):
'''tutaj nie rozumie do konca idei tego pokrycia'''
pass
def pokryciePelne(self):
'''tego tez nie dokonca czaje i trzeba sie zapyac'''
pass
def pokrycieStartowe(self, term):
'''dodanie pokrycia startowego dal zdan dlugosci 1'''
return self.add("S" , term)
def pokrycieAgresywne(self, name):
'''i tego tez nie rozumiem
zorbie tak: ze zbioru detektorow wybieram 3 i robie z nich klasyfikator'''
print "pokrycie agresywne "+ name
if self.permisionCover == 0:
return 0
D = self.G.keys()
tmp = random.randint(0,len(D)-1)
return self.add(D[tmp],name) == 1
def krzyzowanie(self):
'''metoda krzyzowania klasyfikatoprow, jeszcze nie przetestowana
nie sprawdzone czy napewno dziala poprawnie!!!'''
A,ClassA = self.randomSelction()
while(len(ClassA)!=2):
A,ClassA = self.randomSelction()
B,ClassB = self.randomSelction()
while(len(ClassB)!=2):
B,ClassB = self.randomSelction()
self.add(A,ClassB)
self.add(B,ClassA)
def mutacja(self):
'''musze tutaj jeszcze przeimplemntowac inne elementy, dodac tablice terminali(G.keys()) i nieterminali
nie sprawdzone czy napewno dziala poprawnie!!!'''
def inwersja(self):
''' genetyk inwersji
nie sprawdzone czy napewno dziala poprawnie!!!'''
A,classA = self.randomSelction()
while(len(classA)!=2):
A,classA = self.randomSelction()
self.add(A,classA[1]+classA[0])
def alowCover(self):
self.permisionCover=1
return 1
def scisk_new(self, left, name):
'''metoda dodaje dany klasyfikator ze sciskiem left-->name'''
cs_table = []
cf_table = []
choose = 0
minmal = 100000
for y in range(0,self.parametry.cf):
for x in range(0,self.parametry.cs):
keys = self.G.keys()
while 1:
B = random.choice(keys)
if len(self.G[B])>1:
break
while 1:
K = self.G[B][random.randint(0,len(self.G[B])-1)]
if len(K.name) > 1:
break
if K.fitness <= minmal:
minmal = K.fitness
choose = K
cf_table.append(K)
#szukamy najbardziej podobnego:
podobienstwo_max = 0
for x in cf_table:
podobienstwo = 0
if len(name) == 0:
if x.left == left:
podobienstwo += 1
if x.name[0] == name[0]:
podobienstwo += 1
if x.name[1] == name[1]:
podobienstwo += 1
if podobienstwo > podobienstwo_max:
podobienstwo_max = podobienstwo
K = x
return self.rem(K.left,K.name)
#SEKCJA TESTOWA:
G = gramatyka()
print G.getGramarStr()
print G.randomSelction()
#A = G.CYK("1aa")
#while A == 0:
#A = G.CYK("1aabb")
#if A == -10:
#print "restart"
#print "koniec"
#print A
#if A !=-10:
#for x in A:
#print x
#A = G.CYK("1h")
#while A == 0:
#A = G.CYK("1h")
print "koniec"
| Python |
##klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
#Gramatyka w postaci slownika
self.Gg = {"S":["AB","BC"],"A":["BA","a"],"B":["CC","b"],"C":["AB","a"]}
self.G = {"S":["AB","AC"],"C":["SB","a"],"B":["BB","b"],"A":["a"]}
def add(self, A, B):
'''doaje kolejne reguly do gramamtyki, jeszcze nie przetestowane czy poprawnie dziala'''
if self.G.has_key(A):
self.G[A].append(B)
else:
self.G[A] = [B]
def search(self,terminal):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, metoda rozszezona o symbol uniwersalny'''
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if ((T == terminal) or (T == '#')):
find = 1
self.result.append(x)
if find == 1:
return self.result
else:
return -1
def getGramarStr(self):
tmp = ""
for x in self.G:
tmp += str(x) + "-->" + str(self.G[x])+ "\n"
return tmp
def CYK(self, slowo):
tmp = []
table_CYK =[]
final = []
#peirwsza czesc odpowiadajaca za wypelnienie pierwszego wiersza w tabeli
for x in slowo:
a = self.search(x)
if a == -1:
tmp.append([-1])
else:
tmp.append(a)
table_CYK.append([])
table_CYK[0] = tmp[0:]
#tutaj jakas totalna masakra taka ze glowa mala:):
#table_CYK.append([])
poziom=1
while poziom < (len(table_CYK[0])):
table_CYK.append([])
#k jest iteratorem dla while, nic pozatym
k=0
while k < len(table_CYK[0])-poziom:
tmp=[]
##tutaj zakres nie jest obknuty do konca
##cos - poziom po ktorym aktualnie poszukujemy:
for cos in range(0,poziom):
if cos<=(poziom-1-cos):
for a in table_CYK[cos][k]:
if table_CYK[cos][k] == -1:
tmp=[]
else:
for b in table_CYK[poziom-1-cos][k+1+cos]:
#print "if: dla [%d;%d] [%d;%d] szukam %s%s"%(cos,k,poziom-1-cos,k+1+cos,str(a),str(b))
wynik = self.search(str(a)+str(b))
if wynik != -1:
#if (wynik in tmp) == False:
if not [elements in wynik for elements in tmp]:
tmp.extend(wynik)
#print "else: dla [%d;%d] [%d;%d] szukam %s%s"%(cos,k,poziom-1-cos,k+1,str(a),str(b))
else:
for b in table_CYK[cos][k]:
if table_CYK[cos][k] == -1:
tmp=[]
for a in table_CYK[poziom-1-cos][k+1+cos]:
#print "else: dla [%d;%d] [%d;%d] szukam %s%s"%(cos,k+1,poziom-1-cos,k+1+cos,str(b),str(a))
wynik = self.search(str(b)+str(a))
if wynik != -1:
if not [elements in wynik for elements in tmp]:
tmp.extend(wynik)
if len(tmp) <= 0:
tmp = [-1]
table_CYK[poziom].append(tmp)
k+=1
#print "ostatio wygenerowany poziom"
#print table_CYK[poziom]
poziom+=1
return table_CYK
##klasa bedzie udawac zachowanie multiplekasera, bede jej uzywac do testow
class classifier():
'''klasa bedzie representowac klasyfikator w systemie'''
def __init__(self,name):
self.name = name
def set(self,name):
self.name=name
def getName(slef):
return slef.name
G = gramatyka()
K = G.CYK("aabb")
#G = gramatyka()
#print G.getGramarStr()
#K = G.CYK("abaaaaabbaba")
print "final:"
for x in K:
print x
| Python |
#-*- coding: utf-8 -*
import random
class membershipOperations():
''' klassa na podstawie gramatyki i aktualnego stanu srodowiska obliczac bedzie funkcje przynaleznosci dla danego klasyfikatora w danym momenci rozbiou zdania'''
def __init__(self, parent):
self.parent = parent
self.functionType = "random"
def fullRandom(self):
''' totalny random funkcji przynaleznosci'''
return random.random()
def zadehUnion(self, a, b):
return max(a,b)
def zadehConjunction(self, a, b):
return min(a,b)
def yagerUnion(self, a, b):
wu = self.parent.getParams().yagerWu
tmp = (a**wu +b**wu)**(1/wu)
return min(1.0,tmp)
def yagerConjunction(self, a, b):
wi = self.parent.getParams().yagerWi
return 1.0 - min(((1.0-a)**wi + (1.0-b)**wi)**(1.0/wi))
def duboisUnion(self, a, b):
alfaI = self.parent.getParams().duboisAlfai
alfaU = self.parent.getParams().duboisAlfau
return (a+b - a*b - min(a,b,1.0-alfaU))/max(1.0-a,1.0-b,alfaU)
def duboisConjunction(self, a, b):
alfaI = self.parent.getParams().duboisAlfai
alfaU = self.parent.getParams().duboisAlfau
return (a*b)/max(a,b,alfaI)
def hamacherUnion(self, a, b):
qu = self.parent.getParams().hamacherQu
return (a+b-(2.0 - qu)*a*b)/(1-(1-qu)*a*b)
def hamacherConjunction(self, a, b):
qi = self.parent.getParams().hamacherQi
return (a*b)/(qi + (1.0 - qi)(a+b+a*b))
def dombiUnion(self, a, b):
wu = self.parent.getParams().dombiWu
return 1.0/((1.0+((1/a)-1)**(-1.0*wu) + ((1.0/a)-1)**(-1.0*wu)))**(-1.0/wi)
def dombiConjunction(self, a, b):
wi = self.parent.getParams().dombiWi
return 1.0/((1.0+((1/a)-1)**(-1.0*wi) + ((1.0/a)-1)**(-1.0*wi)))**(-1.0/wi)
def countFuzzyUnion(self, a, b):
'''tutaj bedzie juz liczone unia w zaleznosci od wybranej metody'''
self.functionType = self.parent.getParams().fuzzyUnion
if self.functionType == "random" or self.functionType == "none":
return self.fullRandom()
elif self.functionType == "Yager":
return self.yagerUnion(a, b)
elif self.functionType == "Zedeh":
return self.zedehUnion(a, b)
elif self.functionType == "Dubois":
return self.duboisUnion(a,b)
elif self.functionType == "Hamcher":
return self.hamacherUnion(a,b)
elif self.functionType == "Dombi":
return self.dombirUnion(a,b)
else:
return -99
def countFuzzyConjunction(self, a, b):
'''tutaj bedzie juz liczone unia w zaleznosci od wybranej metody'''
if self.functionType == "random":
return self.fullRandom()
elif self.functionType == "Yager":
return self.yagerConjunction(a, b)
elif self.functionType == "Zedeh":
return self.zedehConjunction(a, b)
elif self.functionType == "Dubois":
return self.duboisConjunction(a,b)
elif self.function == "Hamcher":
return self.hamacherConjunction(a,b)
elif self.function == "Dombi":
return self.dombirConjunction(a,b)
else:
return -99
def setFunction(self,function):
self.functionType = function
class membershipFunctions():
''' klasa musi z parenta zczytac parametry przetwarzania i uruchomic odpowiednia funkcje przynaleznosci po kazdym zakonczonym rozkladzie zestawu uczacego'''
def __init__(self, parent):
self.parent = parent
self.getParams()
def getParams(self):
'''metoda pobiera parametry od rodzica i odpowiednio je ustwaia'''
parametry = self.parent.getParams()
self.memberShipType = str(parametry.memebershipFunction)
self.generalization = str(parametry.generalization)
def typeS(self):
'''funkcja ma za zadanie obliczenie funkcji przynaleznosci dla calej gramatyki'''
a=b=c=0.0
gramatyka = self.parent.getGrammar()
(c,a)=gramatyka.getPD()
#trzeba sie zastanowic nad zmiana definicji b
b=(c+a)/2
for x in gramatyka.G:
for y in gramatyka.G[x]:
n = y.p-y.d
if n <= a:
y.omega = 0
elif n > a and n <= b:
y.omega = 2*((n-a)/(c-a))
elif n>b and n<=c:
y.omega= 1-2*((n-a)/(c-a))
else:
y.omega = 1.0
def kwadrat(self):
gramatyka = self.parent.getGrammar()
for x in gramatyka.G:
for y in gramatyka.G[x]:
y.omega = y.omega*y.omega
def pierwiastek(self):
for x in gramatyka.G:
for y in gramatyka.G[x]:
y.omega = y.omega**0.5
def countMembership(self):
self.getParams()
print self.memberShipType
if self.memberShipType == 'Type S':
print "licze type S"
self.typeS()
else:
print 'nie wybrano nic'
if self.generalization == 'kwadrat':
self.kwadrat()
elif self.generalization == 'pierwiastek':
self.pierwiastek()
else:
print "brak generalizacji"
| Python |
#-*- coding: utf-8 -*-
#klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
import string, random
from properties import properties
from classifier import classifier
from genetyk import genetyk
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
#tworzenie instncji parametrow
self.parametry = properties()
self.allowFulCover = 1
#Gramatyka w postaci slownika
#self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"A":[classifier("BA","A"),classifier("a","A")],"B":[classifier("CC","B"),classifier("b","B")],"C":[classifier("AB","C"),classifier("a","C")]}
self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.G_backUp = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.classifierNum=0
self.allowCover = 1
for x in self.G:
for y in self.G[x]:
if len(y.right)>1:
self.classifierNum+=1
def makeBackUp(self):
self.G_backUp = self.G
def bringBackGrammar(self):
self.G = self.G_backUp
def CYK(self, slowo):
''' algorytm CYK '''
print "CYK"
#Do poprawienia:
#1. ocenienie po zakonczeniu -> done
#2. przerywanie algorytmu -> dotychczas done
#3. tablica cyk na obiektach -> done
#4. uzycie pokrycia -> done
#4.1 pokrycie agresywne -> done
#4.2 pokrycie pelne -> done
#4.3 pokrycie pokrycie universane
#5. symbole uniwersalne
#co trza sprawdzic:
#6. Nagradzanie (kiedy ?!)
#7. populacje turniejową
#8. przeanalizowac ktore usuwe klasyfikatory
#9, sprawdzic zaleznosc obiektow
#10 sprawdzic back tracjing
#11.kiedy rozbior zdania jest poprawny?!
#12.
# a zem wymyslil
# 1. S-> w cos w ostatniej komorce jezeli prowadzi do poprawnego rozwiazania a nie prowadzi do nie poprawnego trza wywalic z gramatyki
poprawnosc = int(slowo[0])
slowo = slowo[1:]
#tymczasowa tablica do klasyfikatorów:
tmp = []
self.table_CYK=[]
#uzupelnianie pierwszego wiersza:
for x in slowo:
a = self.search(x,poprawnosc, 0)
if a == -1:
if poprawnosc == 1:
#rezygnuje z wprowadzania pustych znakow na pierwszym poziomie o ile zdanie jest poprawne
self.pokrycieTerminalne(x)
a = self.search(x,poprawnosc,0)
tmp.append(a)
else:
tmp.append([-1])
else:
tmp.append(a)
self.table_CYK.append(tmp)
#zastosowanie pokrycia startowego przerwanie algorytmu
#musi nastąpić reset ustawień w metodzie nadrzędnej
if len(slowo) == 1:
if self.pokrycieStartowe(slowo[0]) == 1:
return -10
#wypelnianie dalszych poziomow:
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
pary = self.szukajPar(wiersz,pozycja)
LL = self.szukajTerminal(pary,self.table_CYK,poprawnosc, wiersz)
if LL == -10:
return -10
tmp.append(LL)
pozycja+=1
self.table_CYK.append(tmp)
wiersz+=1
pozycja = 0
#sprawdzenie poziomu sparsowania zdania:
#tutaj także bedzie można rozmytość zastosować
#sprawdzenie czy zdanie sie sparsowalo
result = 0
for y in self.table_CYK[len(slowo)-1]:
for x in y:
if x == -1:
result += 0
elif x.left == 'S':
result = 1
#pokrycie pelne zdanie poprawne i nie sparsowane:
if poprawnosc == 1 and result == 0 and self.allowFulCover==1:
if self.pokryciePelne(len(slowo)-1) == 0:
return -10
#sprawdzenie poprawnosci cyka
#if poprawnosc == result:
#return 1
#else:
#return 0
return result
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji
wiersz -> a
pozycja -> b
'''
#print "szukaj par"
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK,poprawnosc, wiersz):
'''metoda zwraca liste pasujacych terminali'''
#print "szukaj terminali"
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
if a == -1:
continue
for b in table_CYK[x[1][0]][x[1][1]]:
if b == -1:
continue
wynik=self.search(str(a.left)+str(b.left),poprawnosc, wiersz)
if (wynik != -1) and (wynik != -10):
for y in wynik:
if y != -1:
if not y in tmp:
tmp.append(y)
elif wynik == -10:
return -10
if len(tmp)<=0:
tmp = [-1]
return tmp
def search(self,terminal,poprawnosc, poziom):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, rozszerzona o symbol uniwersalny'''
#print "search"
find = 0
result = []
for x in self.G:
for T in range(0,len(self.G[x])):
if ((self.G[x][T].right == terminal) or (self.G[x][T].right == '#')):
find = 1
#rezygnujemy z przyznawania poniewaz bedziemy to robic po zakonczeniu rozbioru
#self.G[x][T].u[poprawnosc] += 1
result.append(self.G[x][T])
else:
pass
#możliwość zastosowania logiki rozmytej
#uzycie pokrycia agresywnego i restart systemu:
#print "agresywne"
#if self.parametry.Pa > random.random():
#self.pokrycieAgresywne(terminal)
if find == 1:
return result
else:
if (self.parametry.Pa > random.random()) and (poprawnosc == 1) and (poziom > 1):
if self.pokrycieAgresywne(terminal) == 1:
return -10
else:
print "no i nie weszlo w pokrycie agresywne"
return -1
def pokrycieTerminalne(self, term):
'''operacja pokrycia terminalnego, przyjmuje terminal do dodania'''
print "pokrycie terminalne"
return self.add(string.upper(term) , term)
def pokrycieStartowe(self, term):
'''pokrycie startowe'''
print "pokrycie startowe"
return self.add('S',term)
def pokryciePelne(self, poziom):
'''FullCover zwraca -1 gdy pokrycie nie jest mozliwe, lub 0 gdy doda terminal taki jak trza'''
print "pokrycie pelne"
tab_par=self.szukajPar(poziom,0)
for x in tab_par:
for a in self.table_CYK[x[0][0]][x[0][1]]:
if a == -1:
continue
for b in self.table_CYK[x[1][0]][x[1][1]]:
if b == -1:
continue
self.add('S',str(a.left)+str(b.left))
self.allowFulCover = 0
return 0
return -1
def pokrycieAgresywne(self, terminal):
'''i tego tez nie rozumiem
zorbie tak: ze zbioru detektorow wybieram 3 i robie z nich klasyfikator'''
print "pokrycie agresywne "+ terminal
#if self.permisionCover == 0:
#return 0
D = self.G.keys()
tmp = random.randint(0,len(D)-1)
return self.add(D[tmp],terminal)
def getGramarStr(self):
'''metoda zwraca liste klasyfikatorow wraz z ich parametrami w postaci stringa'''
tmp = ""
for x in self.G:
for y in self.G[x]:
tmp+=y.getClassifierStrExt()
return tmp
def getDictionaryStr(self):
pass
def add(self, A, B):
'''dodaje kolejne reguly do gramamtyki A-->B'''
print "add"
print self.classifierNum
tmp=0
# sprawdzanie czy istnieje juz taki klasyfikator:
if self.G.has_key(A):
for x in self.G[A]:
if x.right==B:
#znalazlem juz taki klasyfikator:
tmp=1
return -1
if tmp == 0:
#scisk tutaj:
if(self.classifierNum >= self.parametry.np):
self.scisk(A,B)
#i dodajemy
self.G[A].append(classifier(B,A))
if len(B)>1:
self.classifierNum+=1
print "dodalem"
print str(A) +'-->' +str(B)
return 1
else:
#print "nie dodalem bo juz jest:)"
return -1
else:
if(self.classifierNum >= self.parametry.np):
self.scisk(A,B)
self.G[A] = [classifier(B,A)]
print "dodalem"
print str(A) +'-->' +str(B)
self.classifierNum+=1
return 1
def rem(self,class_rem):
'''metoda usowa klasyfikator z gramatyki'''
print "rem"
i = 0
for x in self.G[class_rem.left]:
if x.compare(class_rem) == len(class_rem.right)+1:
print 'usuwam'
print self.G[class_rem.left][i]
self.classifierNum-=1
del self.G[class_rem.left][i]
if len(self.G[class_rem.left])==0:
del(self.G[class_rem.left])
print self.classifierNum
return 1
i += 1
print "zem nie usunal !!!!!!!!!!!!!!!!!!!!"
return 0
def scisk(self, left, name):
'''metoda dodaje dany klasyfikator ze sciskiem left-->name'''
print "scisk"
cs_table = []
cf_table = []
choose = 0
minmal = 100000
for y in range(0,self.parametry.cf):
for x in range(0,self.parametry.cs):
keys = self.G.keys()
while 1:
B = random.choice(keys)
#if len(self.G[B])>1:
#break
K = self.G[B][random.randint(0,len(self.G[B])-1)]
if len(K.getRight()) > 1:
break
if K.fitness <= minmal:
minmal = K.fitness
choose = K
cf_table.append(K)
#return cf_table
#szukamy najbardziej podobnego:
podobienstwo_max = -1
tmp_cla = classifier(name,left)
print tmp_cla
for x in cf_table:
podobienstwo = x.compare(tmp_cla)
if podobienstwo_max < podobienstwo:
choose = x
#usuwamy najbardziej podobny z klasyfikatorów:
#self.rem(choose.left, choose.right)
#dodaje nowy klasyfikator:
#self.add(left,name)
return self.rem(choose)
def countProfit(self, rozbior, word_len, poprawnosc):
'''metoda liczy profit uzyskany odczas rozbioru poprawnego/niepoprawnego'''
print "count profit"
#sprawdzamy czy rzobior byl napewno do konca zrobiony:
result = 0
for y in self.table_CYK[word_len]:
for x in y:
if x == -1:
pass
elif x.left == 'S':
result = 1
for x in range(0,word_len):
for y in self.table_CYK[x]:
for n in y:
if n != -1:
n.u[int(poprawnosc)] += 1
if result == 1:
if int(poprawnosc) == 1:
n.p += self.parametry.ba*pow(2,x)*self.parametry.raf
else:
n.d += self.parametry.ba*pow(2,x)*self.parametry.raf
#if rozbior == 0:
#for x in self.usedTerminals:
#x[0].d += self.parametry.ba*pow(2,x[1])*self.parametry.raf
#else:
#for x in self.usedTerminals:
#x[0].p += self.parametry.ba*pow(2,x[1])*self.parametry.ra
def countFitness(self):
#przeniesc to do implementacji klasyfikatora!!!
print "count fitness"
#Pd jest (maximum,minimum)
PD = self.getPD()
fc = ff = 0
for x in self.G:
for y in self.G[x]:
#liczenie ff:
if(PD[0]-PD[1]!=0.0):
ff = (y.p -y.d - PD[1])/(PD[0]-PD[1])
else:
ff = 0.0
#liczenie fc:
if((y.u[0]+y.u[1])==0):
fc = self.parametry.f0
else:
if (self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1]) != 0:
fc = (self.parametry.wp * y.u[1])/(self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1])
#liczenie przystosowania:
if (self.parametry.wc + self.parametry.wf) != 0:
y.fitness = (self.parametry.wc*fc + self.parametry.wf*ff)/(self.parametry.wc + self.parametry.wf)
def getPD(self):
'''metoda zwaraca krorke (max(p-d),min(p-d)) '''
print "get PD"
minimum = 0.0
maximum = 0.0
for x in self.G:
for y in self.G[x]:
tmp = y.p - y.d
if tmp < minimum:
minimum = tmp
if tmp > maximum:
maximum = tmp
return (maximum,minimum)
#testy:
G = gramatyka()
for x in G.G:
for y in G.G[x]:
print y.omega
| Python |
#-*- coding: utf-8 -*-
import datetime
import sys, os
from properties import properties
########################################################################
class testReporter:
"""Klasa ma za zadanie raportowanie wyników testow"""
#----------------------------------------------------------------------
def __init__(self, parent):
"""Constructor"""
os.chdir('testy')
self.parent = parent
try:
self.fileData = self.parent.getFileName()
except:
self.fileData = None
name = str(self.createFileName())
self.raport = open(name,'a+')
#self.createFileName()
#self.raport.write(self.makePropertiesHeader())
def createFileName(self):
data = str(datetime.datetime.now())
data = data[:19]+'.txt'
data = data.replace(' ','_')
data = data.replace('-','_')
data = data.replace(':','_')
return data
def makePropertiesHeader(self):
#self.parent.getParams().getAtributsString()
params = self.parent.getParams()
dict = params.__dict__
tmp = ""
self.addLine(str(self.fileData))
for x in dict:
tmp += str(x) +" = "+str(dict[x]) + "/n"
self.addLine(tmp)
def addLine(self, line):
self.raport.write(line)
def close(self):
self.raport.close()
if __name__ == "__main__":
#cos = testReporter("assa")
proper = properties()
print proper.__dict__
print open.__doc__
print 'done'
| Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'popup.ui'
#
# Created: Mon Sep 7 11:37:15 2009
# by: PyQt4 UI code generator 4.4.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_Dialog(object):
def setupUi(self, Dialog):
Dialog.setObjectName("Dialog")
Dialog.resize(480, 168)
self.komunikat = QtGui.QLabel(Dialog)
self.komunikat.setGeometry(QtCore.QRect(30, 30, 561, 71))
self.komunikat.setObjectName("komunikat")
self.buttonOK = QtGui.QPushButton(Dialog)
self.buttonOK.setGeometry(QtCore.QRect(190, 120, 80, 28))
self.buttonOK.setObjectName("buttonOK")
self.retranslateUi(Dialog)
QtCore.QMetaObject.connectSlotsByName(Dialog)
def retranslateUi(self, Dialog):
Dialog.setWindowTitle(QtGui.QApplication.translate("Dialog", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
self.komunikat.setText(QtGui.QApplication.translate("Dialog", "TextLabel", None, QtGui.QApplication.UnicodeUTF8))
self.buttonOK.setText(QtGui.QApplication.translate("Dialog", "OK", None, QtGui.QApplication.UnicodeUTF8))
| Python |
##klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
#Gramatyka w postaci slownika
self.Gg = {"S":["AB","BC"],"A":["BA","a"],"B":["CC","b"],"C":["AB","a"]}
self.G = {"S":["AB","AC"],"C":["SB","a"],"B":["BB","b"],"A":["a"]}
def add(self, A, B):
'''doaje kolejne reguly do gramamtyki, jeszcze nie przetestowane czy poprawnie dziala'''
if self.G.has_key(A):
self.G[A].append(B)
else:
self.G[A] = [B]
def search(self,terminal):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, metoda rozszezona o symbol uniwersalny'''
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if ((T == terminal) or (T == '#')):
find = 1
self.result.append(x)
if find == 1:
return self.result
else:
return -1
def getGramarStr(self):
tmp = ""
for x in self.G:
tmp += str(x) + "-->" + str(self.G[x])+ "\n"
return tmp
def CYK(self, slowo):
table_CYK=[]
tmp = []
#wypelnianie pierwszego poziomu:
for x in slowo:
a = self.search(x)
if a == -1:
tmp.append([-1])
else:
tmp.append(a)
table_CYK.append(tmp)
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
print "aktualne pole: "+str(wiersz)+str(pozycja)
#tutaj teraz trzeba odpalic uzupelnianie tablicy:(zamiast print)
K = self.szukajPar(wiersz,pozycja)
print "wyszukiwane pary"+str(K)
tmp.append(self.szukajTerminal(K,table_CYK))
#print str(table_CYK[x[0][0]][x[0][1]]) + str(table_CYK[x[1][0]][x[1][1]])
#print "cala linia" + str(M)
pozycja+=1
table_CYK.append(tmp)
wiersz+=1
pozycja = 0
print("\n")
return table_CYK
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji'''
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK):
'''metoda zwraca liste pasujacych terminali'''
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
for b in table_CYK[x[1][0]][x[1][1]]:
wynik=self.search(str(a)+str(b))
print str(wynik)
if wynik != -1:
for y in wynik:
if y != -1:
if not y in tmp:
tmp.extend(y)
if len(tmp)<=0:
tmp = [-1]
return tmp
G = gramatyka()
K = G.szukajPar(2,0)
#G = gramatyka()
#print G.getGramarStr()
table_CYK = G.CYK("aabb")
print "final:"
for x in table_CYK:
print x
L = G.szukajPar(1,2)
M = G.szukajTerminal(L,table_CYK)
print str(M) | Python |
#-*- coding: utf-8 -*-
import sys
import string
import re
from PyQt4 import QtCore, QtGui
from task_GUI import Ui_Tasks
from thread_flcs import funnction_FLSC
class tasks_generator(QtGui.QMainWindow):
def __init__(self, parent):
QtGui.QWidget.__init__(self, parent)
self.regular_expresion = '^(\D)(\^)(\d)((\*)(\D)(\^)(\d))*$'
self.ui = Ui_Tasks()
self.ui.setupUi(self)
#wzór do generowania zbiorów uczących
self.pattern = ""
self.max_len = 0
self.min_len = 0
self.collection_size = 0
#definiujemy 2 zdarzenia OK i Anuluj:
#QtCore.QObject.connect(self.ui.button_anuluj, QtCore.SIGNAL("clicked()"),self.close)
QtCore.QObject.connect(self.ui.button_anuluj, QtCore.SIGNAL("clicked()"),self.watek)
QtCore.QObject.connect(self.ui.button_ok, QtCore.SIGNAL("clicked()"),self.getContent)
def watek(self):
self.licz = funnction_FLSC(self,"licz")
self.licz.start()
pass
def getContent(self):
self.pattern = self.ui.patter.text()
re.search(self.regular_expresion,self.pattern)
if re.search(self.regular_expresion,self.pattern) == None:
self.ui.label_error.setText("zly format wzoru !!!")
else:
self.max_len = int(self.ui.max_lenght.text())
self.min_len = int(self.ui.min_lenght.text())
self.collection_size = int(self.ui.collection_size.text())
print self.max_len
print self.min_len
print self.collection_size
self.genTasks()
def genTasks(self):
self.doColections()
print self.nonterminals
print self.nonterminals_power
#trzeba obmyśleć jeszcze jakoś algorytm generowania tego parszywych zdan uczacych
def checkPattern(self):
''' trzeba tutaj wyrażenie regularne zastosowac, ale to w pracy bo chce soprano dzisiaj pogladac'''
pass
def doColections(self):
self.nonterminals = []
self.nonterminals_power = []
x =0
while 1:
if (x+2) > len(self.pattern):
break
else:
self.nonterminals.append(str(self.pattern[x]))
self.nonterminals_power.append(int(self.pattern[x+2]))
x+=4
pass
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = tasks_generator(None)
myapp.show()
sys.exit(app.exec_())
| Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'task_generate.ui'
#
# Created: Mon Jul 20 22:22:57 2009
# by: PyQt4 UI code generator 4.4.3
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_Tasks(object):
def setupUi(self, Anuluj):
Anuluj.setObjectName("Anuluj")
Anuluj.resize(352, 206)
self.button_ok = QtGui.QPushButton(Anuluj)
self.button_ok.setGeometry(QtCore.QRect(30, 170, 80, 27))
self.button_ok.setObjectName("button_ok")
self.button_anuluj = QtGui.QPushButton(Anuluj)
self.button_anuluj.setGeometry(QtCore.QRect(140, 170, 80, 27))
self.button_anuluj.setObjectName("button_anuluj")
self.patter = QtGui.QLineEdit(Anuluj)
self.patter.setGeometry(QtCore.QRect(20, 30, 271, 21))
self.patter.setObjectName("patter")
self.max_lenght = QtGui.QSpinBox(Anuluj)
self.max_lenght.setGeometry(QtCore.QRect(240, 90, 54, 21))
self.max_lenght.setObjectName("max_lenght")
self.min_lenght = QtGui.QSpinBox(Anuluj)
self.min_lenght.setGeometry(QtCore.QRect(240, 120, 54, 23))
self.min_lenght.setObjectName("min_lenght")
self.collection_size = QtGui.QSpinBox(Anuluj)
self.collection_size.setGeometry(QtCore.QRect(240, 150, 54, 23))
self.collection_size.setObjectName("collection_size")
self.label = QtGui.QLabel(Anuluj)
self.label.setGeometry(QtCore.QRect(20, 10, 281, 21))
self.label.setObjectName("label")
self.label_2 = QtGui.QLabel(Anuluj)
self.label_2.setGeometry(QtCore.QRect(20, 90, 181, 21))
self.label_2.setObjectName("label_2")
self.label_3 = QtGui.QLabel(Anuluj)
self.label_3.setGeometry(QtCore.QRect(20, 120, 181, 16))
self.label_3.setObjectName("label_3")
self.label_4 = QtGui.QLabel(Anuluj)
self.label_4.setGeometry(QtCore.QRect(20, 150, 181, 21))
self.label_4.setObjectName("label_4")
self.label_error = QtGui.QLabel(Anuluj)
self.label_error.setGeometry(QtCore.QRect(20, 60, 271, 16))
self.label_error.setObjectName("label_error")
self.retranslateUi(Anuluj)
QtCore.QMetaObject.connectSlotsByName(Anuluj)
def retranslateUi(self, Anuluj):
Anuluj.setWindowTitle(QtGui.QApplication.translate("Anuluj", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
self.button_ok.setText(QtGui.QApplication.translate("Anuluj", "OK", None, QtGui.QApplication.UnicodeUTF8))
self.button_anuluj.setText(QtGui.QApplication.translate("Anuluj", "Anuluj", None, QtGui.QApplication.UnicodeUTF8))
self.label.setText(QtGui.QApplication.translate("Anuluj", "Podaj wzór gramatyki w formacie a^n*b^n:", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate("Anuluj", "maksymalna dlugosc zdania:", None, QtGui.QApplication.UnicodeUTF8))
self.label_3.setText(QtGui.QApplication.translate("Anuluj", "minimalna dlugosc zdania:", None, QtGui.QApplication.UnicodeUTF8))
self.label_4.setText(QtGui.QApplication.translate("Anuluj", "ilosc zdan uczacych:", None, QtGui.QApplication.UnicodeUTF8))
| Python |
#-*- coding: utf-8 -*-
class properties():
def __init__(self):
#krzyzowanie
self.Pk=0.2
#mutacja
self.Pm=0.8
#inwersja
self.Pi=0.0
#pelne pokrycie:
self.Pa=0.0
self.cf=18
self.cs=3
self.ba=1
self.raf=0.5
self.ts=0
#rozmiar populacji:
self.np=40
self.nstart=0
self.nN=0
self.nT=0
self.nelit=0
self.nrun=0
self.nmax=0
self.wc=1
self.wf=0
self.wp=1
self.wn=2
self.f0 = 0.5
#zmienne do gui
self.memebershipFunction = 'none'
self.fuzzyUnion = 'none'
self.generalization = 'none'
#zmienne do fuzzy union i conjunction:
# Yager (0,infinity):
self.yagerWi = 1.0
self.yagerWu = 1.0
#Dubois (0,1):
self.duboisAlfai = 0.1
self.duboisAlfau = 0.3
#Hamacher (0,infinity):
self.hamacherQi = 1.0
self.hamacherQu = 1.0
#Dombi (0, infinity)
self.dombiWu = 1.0
self.dombiWi = 1.0
def getAtributsString(self):
tmp = ""
#krzyzowanie
tmp += "Pk: " +str(self.Pk) + "\n"
tmp += "Pm: " +str(self.Pm) + "\n"
tmp += "Pi: " +str(self.Pi) + "\n"
tmp += "Pa: " +str(self.Pa) + "\n"
tmp += "cf: " +str(self.cf) + "\n"
tmp += "cs: " +str(self.cs) + "\n"
tmp += "ba: " +str(self.ba) + "\n"
tmp += "raf: " +str(self.raf) + "\n"
tmp += "ts: " +str(self.ts) + "\n"
tmp += "np: " +str(self.np) + "\n"
tmp += "nstart: " +str(self.nstart) + "\n"
tmp += "nN: " +str(self.nN) + "\n"
tmp += "nT : " +str(self.nT) + "\n"
tmp += "nstart : " +str(self.nstart) + "\n"
tmp += "nelit : " +str(self.nelit) + "\n"
tmp += "nrun: " +str(self.nrun) + "\n"
tmp += "nmax: " +str(self.nmax) + "\n"
tmp += "wc: " +str(self.wc) + "\n"
tmp += "wf: " +str(self.wf) + "\n"
tmp += "wp: " +str(self.wp) + "\n"
tmp += "wn: " +str(self.wn) + "\n"
tmp += "f0: " +str(self.f0) + "\n"
return tmp
#mozna oposcic plodnosc, ff nie jest brana pod uwage. | Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'okno_new.ui'
#
# Created: Tue Sep 8 23:53:05 2009
# by: PyQt4 UI code generator 4.4.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_GCS(object):
def setupUi(self, GCS):
GCS.setObjectName("GCS")
GCS.resize(821, 646)
self.centralwidget = QtGui.QWidget(GCS)
self.centralwidget.setObjectName("centralwidget")
self.window_CYK = QtGui.QTabWidget(self.centralwidget)
self.window_CYK.setGeometry(QtCore.QRect(150, 20, 631, 491))
self.window_CYK.setObjectName("window_CYK")
self.tab = QtGui.QWidget()
self.tab.setObjectName("tab")
self.window_cyk = QtGui.QTextBrowser(self.tab)
self.window_cyk.setGeometry(QtCore.QRect(0, 0, 631, 471))
self.window_cyk.setObjectName("window_cyk")
self.window_CYK.addTab(self.tab, "")
self.tab_2 = QtGui.QWidget()
self.tab_2.setObjectName("tab_2")
self.window_grammar = QtGui.QTextBrowser(self.tab_2)
self.window_grammar.setGeometry(QtCore.QRect(0, 0, 631, 471))
self.window_grammar.setObjectName("window_grammar")
self.window_CYK.addTab(self.tab_2, "")
self.tab_3 = QtGui.QWidget()
self.tab_3.setObjectName("tab_3")
self.window_file = QtGui.QTextBrowser(self.tab_3)
self.window_file.setGeometry(QtCore.QRect(0, 0, 631, 471))
self.window_file.setObjectName("window_file")
self.window_CYK.addTab(self.tab_3, "")
self.tab_4 = QtGui.QWidget()
self.tab_4.setObjectName("tab_4")
self.numberOfLoops = QtGui.QSpinBox(self.tab_4)
self.numberOfLoops.setGeometry(QtCore.QRect(70, 30, 42, 22))
self.numberOfLoops.setMaximum(10000)
self.numberOfLoops.setProperty("value", QtCore.QVariant(1))
self.numberOfLoops.setObjectName("numberOfLoops")
self.label = QtGui.QLabel(self.tab_4)
self.label.setGeometry(QtCore.QRect(10, 30, 61, 20))
self.label.setObjectName("label")
self.propertiesAccept = QtGui.QPushButton(self.tab_4)
self.propertiesAccept.setGeometry(QtCore.QRect(540, 430, 75, 23))
self.propertiesAccept.setObjectName("propertiesAccept")
self.propertiesCancel = QtGui.QPushButton(self.tab_4)
self.propertiesCancel.setGeometry(QtCore.QRect(450, 430, 75, 23))
self.propertiesCancel.setObjectName("propertiesCancel")
self.label_2 = QtGui.QLabel(self.tab_4)
self.label_2.setGeometry(QtCore.QRect(150, 30, 61, 20))
self.label_2.setObjectName("label_2")
self.label_3 = QtGui.QLabel(self.tab_4)
self.label_3.setGeometry(QtCore.QRect(150, 50, 61, 20))
self.label_3.setObjectName("label_3")
self.label_4 = QtGui.QLabel(self.tab_4)
self.label_4.setGeometry(QtCore.QRect(150, 70, 61, 20))
self.label_4.setObjectName("label_4")
self.label_5 = QtGui.QLabel(self.tab_4)
self.label_5.setGeometry(QtCore.QRect(150, 90, 61, 20))
self.label_5.setObjectName("label_5")
self.Pk = QtGui.QDoubleSpinBox(self.tab_4)
self.Pk.setGeometry(QtCore.QRect(180, 30, 62, 22))
self.Pk.setDecimals(2)
self.Pk.setMaximum(1.0)
self.Pk.setSingleStep(0.01)
self.Pk.setProperty("value", QtCore.QVariant(0.0))
self.Pk.setObjectName("Pk")
self.Pm = QtGui.QDoubleSpinBox(self.tab_4)
self.Pm.setGeometry(QtCore.QRect(180, 50, 62, 22))
self.Pm.setMaximum(1.0)
self.Pm.setSingleStep(0.01)
self.Pm.setObjectName("Pm")
self.Pi = QtGui.QDoubleSpinBox(self.tab_4)
self.Pi.setGeometry(QtCore.QRect(180, 70, 62, 22))
self.Pi.setMaximum(1.0)
self.Pi.setSingleStep(0.01)
self.Pi.setObjectName("Pi")
self.Pa = QtGui.QDoubleSpinBox(self.tab_4)
self.Pa.setGeometry(QtCore.QRect(180, 90, 62, 22))
self.Pa.setMaximum(1.0)
self.Pa.setSingleStep(0.01)
self.Pa.setObjectName("Pa")
self.label_6 = QtGui.QLabel(self.tab_4)
self.label_6.setGeometry(QtCore.QRect(10, 10, 61, 20))
self.label_6.setObjectName("label_6")
self.label_7 = QtGui.QLabel(self.tab_4)
self.label_7.setGeometry(QtCore.QRect(130, 10, 111, 20))
self.label_7.setObjectName("label_7")
self.label_8 = QtGui.QLabel(self.tab_4)
self.label_8.setGeometry(QtCore.QRect(270, 10, 111, 20))
self.label_8.setObjectName("label_8")
self.label_9 = QtGui.QLabel(self.tab_4)
self.label_9.setGeometry(QtCore.QRect(270, 30, 61, 20))
self.label_9.setObjectName("label_9")
self.label_10 = QtGui.QLabel(self.tab_4)
self.label_10.setGeometry(QtCore.QRect(270, 50, 61, 20))
self.label_10.setObjectName("label_10")
self.label_11 = QtGui.QLabel(self.tab_4)
self.label_11.setGeometry(QtCore.QRect(270, 70, 61, 20))
self.label_11.setObjectName("label_11")
self.label_12 = QtGui.QLabel(self.tab_4)
self.label_12.setGeometry(QtCore.QRect(270, 90, 61, 20))
self.label_12.setObjectName("label_12")
self.cs = QtGui.QSpinBox(self.tab_4)
self.cs.setGeometry(QtCore.QRect(300, 50, 42, 22))
self.cs.setMinimum(1)
self.cs.setMaximum(30)
self.cs.setObjectName("cs")
self.cf = QtGui.QSpinBox(self.tab_4)
self.cf.setGeometry(QtCore.QRect(300, 30, 42, 22))
self.cf.setMinimum(1)
self.cf.setMaximum(30)
self.cf.setObjectName("cf")
self.ba = QtGui.QSpinBox(self.tab_4)
self.ba.setGeometry(QtCore.QRect(300, 70, 42, 22))
self.ba.setMaximum(15)
self.ba.setObjectName("ba")
self.raf = QtGui.QSpinBox(self.tab_4)
self.raf.setGeometry(QtCore.QRect(300, 90, 42, 22))
self.raf.setMaximum(15)
self.raf.setObjectName("raf")
self.label_13 = QtGui.QLabel(self.tab_4)
self.label_13.setGeometry(QtCore.QRect(10, 150, 61, 20))
self.label_13.setObjectName("label_13")
self.label_14 = QtGui.QLabel(self.tab_4)
self.label_14.setGeometry(QtCore.QRect(10, 170, 61, 20))
self.label_14.setObjectName("label_14")
self.label_15 = QtGui.QLabel(self.tab_4)
self.label_15.setGeometry(QtCore.QRect(10, 190, 61, 20))
self.label_15.setObjectName("label_15")
self.label_16 = QtGui.QLabel(self.tab_4)
self.label_16.setGeometry(QtCore.QRect(10, 210, 61, 20))
self.label_16.setObjectName("label_16")
self.label_17 = QtGui.QLabel(self.tab_4)
self.label_17.setGeometry(QtCore.QRect(10, 230, 61, 20))
self.label_17.setObjectName("label_17")
self.label_18 = QtGui.QLabel(self.tab_4)
self.label_18.setGeometry(QtCore.QRect(10, 250, 61, 20))
self.label_18.setObjectName("label_18")
self.label_19 = QtGui.QLabel(self.tab_4)
self.label_19.setGeometry(QtCore.QRect(10, 290, 61, 20))
self.label_19.setObjectName("label_19")
self.label_20 = QtGui.QLabel(self.tab_4)
self.label_20.setGeometry(QtCore.QRect(10, 270, 61, 20))
self.label_20.setObjectName("label_20")
self.label_21 = QtGui.QLabel(self.tab_4)
self.label_21.setGeometry(QtCore.QRect(10, 310, 61, 20))
self.label_21.setObjectName("label_21")
self.ts = QtGui.QSpinBox(self.tab_4)
self.ts.setGeometry(QtCore.QRect(60, 170, 42, 22))
self.ts.setMinimum(1)
self.ts.setMaximum(30)
self.ts.setObjectName("ts")
self.np = QtGui.QSpinBox(self.tab_4)
self.np.setGeometry(QtCore.QRect(60, 190, 42, 22))
self.np.setMinimum(1)
self.np.setObjectName("np")
self.nstart = QtGui.QSpinBox(self.tab_4)
self.nstart.setGeometry(QtCore.QRect(60, 210, 42, 22))
self.nstart.setMinimum(1)
self.nstart.setObjectName("nstart")
self.nN = QtGui.QSpinBox(self.tab_4)
self.nN.setGeometry(QtCore.QRect(60, 230, 42, 22))
self.nN.setMinimum(1)
self.nN.setMaximum(30)
self.nN.setObjectName("nN")
self.nelit = QtGui.QSpinBox(self.tab_4)
self.nelit.setGeometry(QtCore.QRect(60, 270, 42, 22))
self.nelit.setMinimum(1)
self.nelit.setObjectName("nelit")
self.nT = QtGui.QSpinBox(self.tab_4)
self.nT.setGeometry(QtCore.QRect(60, 250, 42, 22))
self.nT.setMinimum(1)
self.nT.setObjectName("nT")
self.nrun = QtGui.QSpinBox(self.tab_4)
self.nrun.setGeometry(QtCore.QRect(60, 290, 42, 22))
self.nrun.setMinimum(10)
self.nrun.setMaximum(50)
self.nrun.setObjectName("nrun")
self.nmax = QtGui.QSpinBox(self.tab_4)
self.nmax.setGeometry(QtCore.QRect(60, 310, 42, 22))
self.nmax.setMinimum(1)
self.nmax.setMaximum(50000)
self.nmax.setObjectName("nmax")
self.label_22 = QtGui.QLabel(self.tab_4)
self.label_22.setGeometry(QtCore.QRect(160, 170, 61, 20))
self.label_22.setObjectName("label_22")
self.label_23 = QtGui.QLabel(self.tab_4)
self.label_23.setGeometry(QtCore.QRect(160, 190, 61, 20))
self.label_23.setObjectName("label_23")
self.label_24 = QtGui.QLabel(self.tab_4)
self.label_24.setGeometry(QtCore.QRect(160, 210, 61, 20))
self.label_24.setObjectName("label_24")
self.label_25 = QtGui.QLabel(self.tab_4)
self.label_25.setGeometry(QtCore.QRect(160, 230, 61, 20))
self.label_25.setObjectName("label_25")
self.label_26 = QtGui.QLabel(self.tab_4)
self.label_26.setGeometry(QtCore.QRect(160, 250, 61, 20))
self.label_26.setObjectName("label_26")
self.wp = QtGui.QSpinBox(self.tab_4)
self.wp.setGeometry(QtCore.QRect(180, 170, 42, 22))
self.wp.setMinimum(1)
self.wp.setMaximum(20)
self.wp.setObjectName("wp")
self.wn = QtGui.QSpinBox(self.tab_4)
self.wn.setGeometry(QtCore.QRect(180, 190, 42, 22))
self.wn.setMinimum(1)
self.wn.setMaximum(20)
self.wn.setObjectName("wn")
self.wc = QtGui.QSpinBox(self.tab_4)
self.wc.setGeometry(QtCore.QRect(180, 210, 42, 22))
self.wc.setMinimum(1)
self.wc.setMaximum(20)
self.wc.setObjectName("wc")
self.wf = QtGui.QSpinBox(self.tab_4)
self.wf.setGeometry(QtCore.QRect(180, 230, 42, 22))
self.wf.setMinimum(1)
self.wf.setMaximum(15)
self.wf.setObjectName("wf")
self.f0 = QtGui.QSpinBox(self.tab_4)
self.f0.setGeometry(QtCore.QRect(180, 250, 42, 22))
self.f0.setMaximum(10)
self.f0.setObjectName("f0")
self.label_28 = QtGui.QLabel(self.tab_4)
self.label_28.setGeometry(QtCore.QRect(300, 150, 54, 18))
self.label_28.setObjectName("label_28")
self.comboBoxMembership = QtGui.QComboBox(self.tab_4)
self.comboBoxMembership.setGeometry(QtCore.QRect(460, 176, 131, 27))
self.comboBoxMembership.setObjectName("comboBoxMembership")
self.comboBoxMembership.addItem(QtCore.QString())
self.comboBoxMembership.addItem(QtCore.QString())
self.label_29 = QtGui.QLabel(self.tab_4)
self.label_29.setGeometry(QtCore.QRect(300, 180, 131, 18))
self.label_29.setObjectName("label_29")
self.label_30 = QtGui.QLabel(self.tab_4)
self.label_30.setGeometry(QtCore.QRect(300, 214, 131, 18))
self.label_30.setObjectName("label_30")
self.comboBoxUnion = QtGui.QComboBox(self.tab_4)
self.comboBoxUnion.setGeometry(QtCore.QRect(460, 210, 131, 27))
self.comboBoxUnion.setObjectName("comboBoxUnion")
self.comboBoxUnion.addItem(QtCore.QString())
self.label_31 = QtGui.QLabel(self.tab_4)
self.label_31.setGeometry(QtCore.QRect(300, 250, 131, 18))
self.label_31.setObjectName("label_31")
self.comboBoxUnion_2 = QtGui.QComboBox(self.tab_4)
self.comboBoxUnion_2.setGeometry(QtCore.QRect(461, 246, 131, 27))
self.comboBoxUnion_2.setObjectName("comboBoxUnion_2")
self.comboBoxUnion_2.addItem(QtCore.QString())
self.comboBoxUnion_2.addItem(QtCore.QString())
self.comboBoxUnion_2.addItem(QtCore.QString())
self.window_CYK.addTab(self.tab_4, "")
self.start_GLBS = QtGui.QPushButton(self.centralwidget)
self.start_GLBS.setGeometry(QtCore.QRect(10, 60, 121, 31))
self.start_GLBS.setObjectName("start_GLBS")
self.Pause = QtGui.QPushButton(self.centralwidget)
self.Pause.setGeometry(QtCore.QRect(10, 100, 121, 31))
self.Pause.setObjectName("Pause")
self.params = QtGui.QPushButton(self.centralwidget)
self.params.setGeometry(QtCore.QRect(10, 140, 121, 31))
self.params.setObjectName("params")
self.open_file = QtGui.QPushButton(self.centralwidget)
self.open_file.setGeometry(QtCore.QRect(10, 20, 121, 31))
self.open_file.setObjectName("open_file")
self.Koniec = QtGui.QPushButton(self.centralwidget)
self.Koniec.setGeometry(QtCore.QRect(20, 530, 121, 31))
self.Koniec.setObjectName("Koniec")
self.change_word = QtGui.QPushButton(self.centralwidget)
self.change_word.setGeometry(QtCore.QRect(10, 180, 121, 31))
self.change_word.setObjectName("change_word")
self.create_test = QtGui.QPushButton(self.centralwidget)
self.create_test.setGeometry(QtCore.QRect(10, 220, 121, 31))
self.create_test.setObjectName("create_test")
self.progressBar = QtGui.QProgressBar(self.centralwidget)
self.progressBar.setGeometry(QtCore.QRect(150, 530, 661, 23))
self.progressBar.setProperty("value", QtCore.QVariant(0))
self.progressBar.setObjectName("progressBar")
self.label_27 = QtGui.QLabel(self.centralwidget)
self.label_27.setGeometry(QtCore.QRect(160, 510, 181, 18))
self.label_27.setObjectName("label_27")
GCS.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(GCS)
self.menubar.setGeometry(QtCore.QRect(0, 0, 821, 26))
self.menubar.setObjectName("menubar")
self.menuOpcje = QtGui.QMenu(self.menubar)
self.menuOpcje.setObjectName("menuOpcje")
self.menuAbout = QtGui.QMenu(self.menubar)
self.menuAbout.setObjectName("menuAbout")
GCS.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(GCS)
self.statusbar.setObjectName("statusbar")
GCS.setStatusBar(self.statusbar)
self.toolBar = QtGui.QToolBar(GCS)
self.toolBar.setObjectName("toolBar")
GCS.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.toolBar_2 = QtGui.QToolBar(GCS)
self.toolBar_2.setObjectName("toolBar_2")
GCS.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar_2)
self.actionWczytaj_Dane = QtGui.QAction(GCS)
self.actionWczytaj_Dane.setObjectName("actionWczytaj_Dane")
self.menuOpcje.addAction(self.actionWczytaj_Dane)
self.menubar.addAction(self.menuOpcje.menuAction())
self.menubar.addAction(self.menuAbout.menuAction())
self.retranslateUi(GCS)
self.window_CYK.setCurrentIndex(3)
QtCore.QObject.connect(self.Koniec, QtCore.SIGNAL("clicked()"), GCS.close)
QtCore.QMetaObject.connectSlotsByName(GCS)
def retranslateUi(self, GCS):
GCS.setWindowTitle(QtGui.QApplication.translate("GCS", "MainWindow", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab), QtGui.QApplication.translate("GCS", "Tab 1", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_2), QtGui.QApplication.translate("GCS", "Tab 2", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_3), QtGui.QApplication.translate("GCS", "Strona", None, QtGui.QApplication.UnicodeUTF8))
self.label.setText(QtGui.QApplication.translate("GCS", "Liczba pętli", None, QtGui.QApplication.UnicodeUTF8))
self.propertiesAccept.setText(QtGui.QApplication.translate("GCS", "Akceptuj", None, QtGui.QApplication.UnicodeUTF8))
self.propertiesCancel.setText(QtGui.QApplication.translate("GCS", "Anuluj", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate("GCS", "Pk", None, QtGui.QApplication.UnicodeUTF8))
self.label_3.setText(QtGui.QApplication.translate("GCS", "Pm", None, QtGui.QApplication.UnicodeUTF8))
self.label_4.setText(QtGui.QApplication.translate("GCS", "Pi", None, QtGui.QApplication.UnicodeUTF8))
self.label_5.setText(QtGui.QApplication.translate("GCS", "Pa", None, QtGui.QApplication.UnicodeUTF8))
self.label_6.setText(QtGui.QApplication.translate("GCS", "Ogólne:", None, QtGui.QApplication.UnicodeUTF8))
self.label_7.setText(QtGui.QApplication.translate("GCS", "Algorytm gentyczny:", None, QtGui.QApplication.UnicodeUTF8))
self.label_8.setText(QtGui.QApplication.translate("GCS", "Algorytm ścisku:", None, QtGui.QApplication.UnicodeUTF8))
self.label_9.setText(QtGui.QApplication.translate("GCS", "cf", None, QtGui.QApplication.UnicodeUTF8))
self.label_10.setText(QtGui.QApplication.translate("GCS", "cs", None, QtGui.QApplication.UnicodeUTF8))
self.label_11.setText(QtGui.QApplication.translate("GCS", "ba", None, QtGui.QApplication.UnicodeUTF8))
self.label_12.setText(QtGui.QApplication.translate("GCS", "raf", None, QtGui.QApplication.UnicodeUTF8))
self.label_13.setText(QtGui.QApplication.translate("GCS", "Pozostałe:", None, QtGui.QApplication.UnicodeUTF8))
self.label_14.setText(QtGui.QApplication.translate("GCS", "ts", None, QtGui.QApplication.UnicodeUTF8))
self.label_15.setText(QtGui.QApplication.translate("GCS", "np", None, QtGui.QApplication.UnicodeUTF8))
self.label_16.setText(QtGui.QApplication.translate("GCS", "nstart", None, QtGui.QApplication.UnicodeUTF8))
self.label_17.setText(QtGui.QApplication.translate("GCS", "nN", None, QtGui.QApplication.UnicodeUTF8))
self.label_18.setText(QtGui.QApplication.translate("GCS", "nT", None, QtGui.QApplication.UnicodeUTF8))
self.label_19.setText(QtGui.QApplication.translate("GCS", "nrun", None, QtGui.QApplication.UnicodeUTF8))
self.label_20.setText(QtGui.QApplication.translate("GCS", "nelit", None, QtGui.QApplication.UnicodeUTF8))
self.label_21.setText(QtGui.QApplication.translate("GCS", "nmax", None, QtGui.QApplication.UnicodeUTF8))
self.label_22.setText(QtGui.QApplication.translate("GCS", "wp", None, QtGui.QApplication.UnicodeUTF8))
self.label_23.setText(QtGui.QApplication.translate("GCS", "wn", None, QtGui.QApplication.UnicodeUTF8))
self.label_24.setText(QtGui.QApplication.translate("GCS", "wc", None, QtGui.QApplication.UnicodeUTF8))
self.label_25.setText(QtGui.QApplication.translate("GCS", "wf", None, QtGui.QApplication.UnicodeUTF8))
self.label_26.setText(QtGui.QApplication.translate("GCS", "f0", None, QtGui.QApplication.UnicodeUTF8))
self.label_28.setText(QtGui.QApplication.translate("GCS", "Fuzzy:", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxMembership.setItemText(0, QtGui.QApplication.translate("GCS", "Type S", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxMembership.setItemText(1, QtGui.QApplication.translate("GCS", "brak", None, QtGui.QApplication.UnicodeUTF8))
self.label_29.setText(QtGui.QApplication.translate("GCS", "funkcja przynależności:", None, QtGui.QApplication.UnicodeUTF8))
self.label_30.setText(QtGui.QApplication.translate("GCS", "iloczyn rozmyty:", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxUnion.setItemText(0, QtGui.QApplication.translate("GCS", "klasyczny", None, QtGui.QApplication.UnicodeUTF8))
self.label_31.setText(QtGui.QApplication.translate("GCS", "uogulnienie:", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxUnion_2.setItemText(0, QtGui.QApplication.translate("GCS", "kwadrat", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxUnion_2.setItemText(1, QtGui.QApplication.translate("GCS", "pierwiastek", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxUnion_2.setItemText(2, QtGui.QApplication.translate("GCS", "brak", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_4), QtGui.QApplication.translate("GCS", "Strona", None, QtGui.QApplication.UnicodeUTF8))
self.start_GLBS.setText(QtGui.QApplication.translate("GCS", "Start", None, QtGui.QApplication.UnicodeUTF8))
self.Pause.setText(QtGui.QApplication.translate("GCS", "Pause", None, QtGui.QApplication.UnicodeUTF8))
self.params.setText(QtGui.QApplication.translate("GCS", "Zmień parametry", None, QtGui.QApplication.UnicodeUTF8))
self.open_file.setText(QtGui.QApplication.translate("GCS", "Wczytaj plik", None, QtGui.QApplication.UnicodeUTF8))
self.Koniec.setText(QtGui.QApplication.translate("GCS", "Koniec", None, QtGui.QApplication.UnicodeUTF8))
self.change_word.setText(QtGui.QApplication.translate("GCS", "Następny krok", None, QtGui.QApplication.UnicodeUTF8))
self.create_test.setText(QtGui.QApplication.translate("GCS", "Generuj zdania", None, QtGui.QApplication.UnicodeUTF8))
self.label_27.setText(QtGui.QApplication.translate("GCS", "Process progress:", None, QtGui.QApplication.UnicodeUTF8))
self.menuOpcje.setTitle(QtGui.QApplication.translate("GCS", "Opcje", None, QtGui.QApplication.UnicodeUTF8))
self.menuAbout.setTitle(QtGui.QApplication.translate("GCS", "About", None, QtGui.QApplication.UnicodeUTF8))
self.toolBar.setWindowTitle(QtGui.QApplication.translate("GCS", "toolBar", None, QtGui.QApplication.UnicodeUTF8))
self.toolBar_2.setWindowTitle(QtGui.QApplication.translate("GCS", "toolBar_2", None, QtGui.QApplication.UnicodeUTF8))
self.actionWczytaj_Dane.setText(QtGui.QApplication.translate("GCS", "Wczytaj Dane", None, QtGui.QApplication.UnicodeUTF8))
| Python |
#-*- coding: utf-8 -*-
import sys, string, random
from CYK_new import gramatyka
from properties import properties
from PyQt4 import QtCore, QtGui
from okno_new import Ui_GCS
from gen_learning import tasks_generator
from genetyk import genetyk
from thread_flcs import funnction_FLSC
from popUps import popUp
class MyForm(QtGui.QMainWindow):
#definicja zmiennych :
word = "1aabb"
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.dialogTasks = tasks_generator(self)
self.ui = Ui_GCS()
self.parametry = properties()
self.testingWords = []
self.ui.setupUi(self)
self.FLCS = funnction_FLSC(self)
#definiuje obiekt obsługujący popUp'y:
self.popUp = popUp(self)
self.genetyk = genetyk(self.FLCS.getGrammar(),self.parametry)
self.fileIndex = 0
#self.ui.window_CYK.addTab(self.genTabCYK())
#print "tutaj gramtyka na okno idzie:"
self.ui.window_grammar.setText(self.FLCS.getGrammar().getGramarStr())
#dodawanie dotatkowych combosow w oknie:
self.addMembershipFunctionBox()
self.addFuzzyFunctionBox()
#ustawianie polaczen:
#wystartowanie algorytmu:
QtCore.QObject.connect(self.ui.start_GLBS, QtCore.SIGNAL("clicked()"),self.genTabCYK)
#otwieranie pliku
QtCore.QObject.connect(self.ui.menuOpcje, QtCore.SIGNAL("clicked()"),self.openFile)
#przycisk do testow (nastepny krok)
QtCore.QObject.connect(self.ui.change_word,QtCore.SIGNAL("clicked()"),self.testy)
#nastepny krok
#QtCore.QObject.connect(self.ui.change_word,QtCore.SIGNAL("clicked()"),self.readLine)
#pobranie danych z formularza zmiennych
QtCore.QObject.connect(self.ui.propertiesAccept,QtCore.SIGNAL("clicked()"),self.getProperties)
#generowanie zdan uczacych button:
QtCore.QObject.connect(self.ui.create_test,QtCore.SIGNAL("clicked()"),self.generate_tasks)
#anulowanie wprowadzanych preferenci
QtCore.QObject.connect(self.ui.propertiesCancel,QtCore.SIGNAL("clicked()"),self.cancelProperties)
#QtCore.QObject.connect(self.ui.change_word,QtCore.SIGNAL("clicked()"),self.readLine)
self.cancelProperties()
self.getProperties()
#otwieranie pliku:
QtCore.QObject.connect(self.ui.open_file, QtCore.SIGNAL("clicked()"),self.openFile)
def checkData(self):
'''funkcja bedzie sprwdzac czy dane do testow zostaly wczytane'''
if len(self.testingWords) < 5:
return 0
else:
return 1
def genTabCYK(self):
''' metoda bedzie odpowiadac za petle główna porgramu'''
print "w GCS ie"
if self.checkData():
self.ui.progressBar.setValue(0)
#odświerzenie widoku gramatyki:
self.FLCS.setFunction("parseKit")
self.FLCS.start()
QtCore.QObject.connect(self.FLCS,QtCore.SIGNAL("textOnConsole(PyQt_PyObject)"), self.textOnConsole)
QtCore.QObject.connect(self.FLCS,QtCore.SIGNAL("progresBarUpdate(PyQt_PyObject)"), self.progresBarUpdate)
QtCore.QObject.connect(self.FLCS,QtCore.SIGNAL("finished()"), self.po_wykonaniu_watku)
else:
print "dane testowe nie prawidlowe"
self.popUp.setText("Dane nie zostały wczytane")
self.popUp.show()
def progresBarUpdate(self, progess):
self.ui.progressBar.setValue(progess)
def textOnConsole(self, napis):
''' wyświetla przekazany text na konsole glowna aplikacji'''
self.ui.window_cyk.setText(napis)
def po_wykonaniu_watku(self):
print "selekcja ruletkowa:"
self.genetyk.makeGen()
self.ui.window_grammar.setText(self.FLCS.getGrammar().getGramarStr())
print "koniec done!"
def readLine(self):
if self.fileIndex == len(self.testingWords) -1:
self.fileIndex = 0
self.FLCS.getGrammar().countFitness()
self.fileIndex += 1
x=self.fileIndex
self.word = self.testingWords[self.fileIndex]
self.ui.window_cyk.setText(self.testingWords[self.fileIndex])
result = self.FLCS.getGrammar().CYK(self.testingWords[self.fileIndex])
if result is int:
return 0
self.FLCS.getGrammar().countProfit(result,len(self.testingWords[x])-1,self.testingWords[x][0])
self.ui.window_grammar.setText(self.FLCS.getGrammar().getGramarStr())
def showDict(self):
self.ui.okno_gl.setText(str(self.FLCS.getGrammar().G))
def changeWord(self):
pass
def openFile(self):
''' metoda otwiera wskazany plik, i wyswietla'''
print "jezdem"
tmp = ''
fd = QtGui.QFileDialog(self)
self.filename = fd.getOpenFileName()
from os.path import isfile
if isfile(self.filename):
for x in open(self.filename):
self.testingWords.append(x[:len(x)-1])
self.editFile()
self.FLCS.setTestingWords(self.testingWords)
for x in self.testingWords:
tmp+=x + "\n" #+" len: " + str(len(x)) + "\n"
self.ui.window_file.setText(tmp)
def editFile(self):
for x in range(0,len(self.testingWords)):
#tmp = self.testingWords[x][0]
self.testingWords[x] = self.testingWords[x][0]+self.testingWords[x][self.testingWords[x][2:].find(" ")+3:]
#usuwanie spacji:
while self.testingWords[x].find(" ") > 0:
k = self.testingWords[x].find(" ")
self.testingWords[x]=self.testingWords[x][:k]+self.testingWords[x][k+1:]
self.testingWords[x]=self.testingWords[x].rstrip()
def getProperties(self):
'''metoda ma za zadanie zczytywanie zmiennych, ale nie wiem jak z qwidegta pobrac dane'''
self.FLCS.getParams().ba = self.ui.ba.value()
self.FLCS.getParams().cf = self.ui.cf.value()
self.FLCS.getParams().cs = self.ui.cs.value()
self.FLCS.getParams().nelit = self.ui.nelit.value()
self.FLCS.getParams().nmax = self.ui.nmax.value()
self.FLCS.getParams().nN = self.ui.nN.value()
self.FLCS.getParams().np = self.ui.np.value()
self.FLCS.getParams().nrun = self.ui.nrun.value()
self.FLCS.getParams().nstart = self.ui.nstart.value()
self.FLCS.getParams().nT = self.ui.nT.value()
self.FLCS.getParams().Pa = self.ui.Pa.value()
self.FLCS.getParams().Pi = self.ui.Pi.value()
self.FLCS.getParams().Pk= self.ui.Pk.value()
self.FLCS.getParams().Pm= self.ui.Pm.value()
self.FLCS.getParams().raf= self.ui.raf.value()
self.FLCS.getParams().ts= self.ui.ts.value()
self.FLCS.getParams().wc= self.ui.wc.value()
self.FLCS.getParams().wf= self.ui.wf.value()
self.FLCS.getParams().wn= self.ui.wn.value()
self.FLCS.getParams().wp= self.ui.wp.value()
self.FLCS.getParams().f0= self.ui.f0.value()
#pobieranie danych do rozmycia
self.FLCS.getGrammar().parametry.fuzzyUnion = str(self.ui.comboBoxUnion.currentText())
self.FLCS.getGrammar().parametry.memebershipFunction = str(self.ui.comboBoxMembership.currentText())
#tutaj tak durnie sie nazywa bo tak moze kiedys zmienie
self.FLCS.getGrammar().parametry.generalization = self.ui.comboBoxUnion_2.currentText()
print self.FLCS.getGrammar().parametry.__dict__
print str(self.FLCS.getGrammar().parametry.__dict__['generalization']) == 'kwadrat'
print str(self.FLCS.getGrammar().parametry.__dict__['memebershipFunction']) == 'Type S'
#self.genetyk.updateProperies(self.FLCS.progressgetGrammar().parametry)
#self.ui.okno_gl.setText(str(self.ui.ba))
#self.ui.window_cyk.setText(str(self.parametry.ba))
def cancelProperties(self):
'''metoda ma za zadanie przywrocenie starych danych do formularza w przypadku wcisniecia "anuluj"'''
self.ui.ba.setValue(self.FLCS.getParams().ba)
self.ui.cf.setValue(self.FLCS.getParams().cf)
self.ui.cs.setValue(self.FLCS.getParams().cs)
self.ui.nelit.setValue(self.FLCS.getParams().nelit)
self.ui.nmax.setValue(self.FLCS.getParams().nmax)
self.ui.nN.setValue(self.FLCS.getParams().nN)
self.ui.np.setValue(self.FLCS.getParams().np)
self.ui.nrun.setValue(self.FLCS.getParams().nrun)
self.ui.nstart.setValue(self.FLCS.getParams().nstart)
self.ui.nT.setValue(self.FLCS.getParams().nT)
self.ui.Pa.setValue(self.FLCS.getParams().Pa)
self.ui.Pi.setValue(self.FLCS.getParams().Pi)
self.ui.Pk.setValue(self.FLCS.getParams().Pk)
self.ui.Pm.setValue(self.FLCS.getParams().Pm)
self.ui.raf.setValue(self.FLCS.getParams().raf)
self.ui.ts.setValue(self.FLCS.getParams().ts)
self.ui.wc.setValue(self.FLCS.getParams().wc)
self.ui.wf.setValue(self.FLCS.getParams().wf)
self.ui.wn.setValue(self.FLCS.getParams().wn)
self.ui.wp.setValue(self.FLCS.getParams().wp)
self.ui.f0.setValue(self.FLCS.getParams().f0)
def generate_tasks(self):
print "a se kliklem se"
self.dialogTasks.show()
def testy(self):
self.FLCS.setFunction("test")
self.FLCS.start()
def getFileName(self):
return self.filename
def getParams(self):
return self.FLCS.getGrammar().parametry
def getGrammar(self):
return self.FLCS.getGrammar()
def addMembershipFunctionBox(self):
''' funkcja bedzie dodawac dodatkowe nazwy funckji przynaleznosci do wyboru'''
#self.ui.comboBoxMembership.addItem(QtCore.QString("sraka"))
pass
def addFuzzyFunctionBox(self):
''' funkcja bedzie dodawac dodatkowe nazwy operacji rozmytych do wyboru'''
self.ui.comboBoxUnion.addItem(QtCore.QString("Zedeh"))
self.ui.comboBoxUnion.addItem(QtCore.QString("Yager"))
self.ui.comboBoxUnion.addItem(QtCore.QString("Dubois"))
self.ui.comboBoxUnion.addItem(QtCore.QString("Hamacher"))
self.ui.comboBoxUnion.addItem(QtCore.QString("Dombi"))
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = MyForm()
myapp.show()
sys.exit(app.exec_())
| Python |
import sys, string
from PyQt4 import QtCore, QtGui
from CYK import gramatyka
from okno import Ui_CYK
class MyForm(QtGui.QMainWindow):
#definicja zmiennych :
word = "aaaaabbbbsss"
G = gramatyka()
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_CYK()
self.ui.setupUi(self)
# definiuke wlasne polaczenie slotow:
#QtCore.QObject.connect(self.ui.button_open,QtCore.SIGNAL("clicked()"), self.file_dialog)
#dodanie slowa:
QtCore.QObject.connect(self.ui.dodaj_slowo,QtCore.SIGNAL("clicked()"),self.addWord)
#generacja tablicy CYK:
QtCore.QObject.connect(self.ui.generujTabCYK,QtCore.SIGNAL("clicked()"),self.genTabCYK)
#pokaz slownik:
QtCore.QObject.connect(self.ui.show_dict,QtCore.SIGNAL("clicked()"),self.showDict)
def addWord(self):
self.word=self.ui.slowo.toPlainText()
self.ui.okno_gl.setText(self.word)
def genTabCYK(self):
table = self.G.CYK(str(self.word))
tmp = "slowo: \t %s \n"%(self.word)
for x in table:
tmp += str(x)+"\n"
self.ui.okno_gl.setText(tmp)
def showDict(self):
self.ui.okno_gl.setText(str(self.G.G))
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = MyForm()
myapp.show()
sys.exit(app.exec_())
| Python |
#-*- coding: utf-8 -*-
from PyQt4 import QtCore
from flcs import gramatyka
from testReporter import testReporter
from membership_Funkctions import membershipFunctions
import time
import sys
class funnction_FLSC(QtCore.QThread):
def __init__(self, parent):
super(funnction_FLSC, self).__init__(parent)
self.ui = parent.ui
self.function = "licz"
self.testingWords = []
self.parent = parent
self.grammar = gramatyka()
self.raport = testReporter(self)
self.membership = membershipFunctions(self)
def setFunction(self, function):
self.function = function
def getFuncton(self):
return self.function
def getGrammar(self):
return self.grammar
def getParams(self):
return self.grammar.parametry
def setTestingWords(self, words):
self.testingWords = words
def getTestingWords(self):
return self.testingWords
def run(self):
if self.function == "licz":
for x in range(0,5):
print "licze..."
time.sleep(1)
elif self.function == "parseKit":
#self.raport.makePropertiesHeader()
self.parseKit()
#self.raport.close()
elif self.function == "test":
self.test()
else:
print "funkcja w obłudze FLCS jest nie znana"
return -1
def parseKit(self):
'''metoda bedzie parsowac jeden zestaw uczący'''
#robimy kopie zapasową gramatyki:
good = 0
bad = 0
poprawnie = 0
nie = 0
self.grammar.makeBackUp()
self.grammar.allowCover = 1
#parsowanie zdań:
self.grammar.allowFulCover = 1
x =1
while 1:
print "liczymy dla:" + self.testingWords[x]
#tutaj robimy CYK
result = self.grammar.CYK(self.testingWords[x])
if result == -10:
#przerwanie, reset z powodu zastosowania pokrycia:
print "reset"
x = 1
good = 0
bad = 0
poprawnie = 0
nie = 0
continue
#jak się skończy to liczymy p i d jeszcze czyba u by trzeba bylo:
self.grammar.countProfit(result,len(self.testingWords[x])-2,self.testingWords[x][0])
if result == 1:
good += 1
else:
bad += 1
if result == int(self.testingWords[x][0]):
poprawnie += 1
else:
nie += 1
x+=1
#self.ui.window_cyk.setText("sparsowane %d, nie sparsowane %d, poprawnie %d nie poprawnie %d wspony"%(good,bad,poprawnie,nie))
#self.ui.window_cyk.setText("robie se "+str(x))
self.emit(QtCore.SIGNAL('textOnConsole(PyQt_PyObject)'),"sparsowane %d, nie sparsowane %d, poprawnie %d nie poprawnie %d wspony"%(good,bad,poprawnie,nie))
self.emit(QtCore.SIGNAL('progresBarUpdate(PyQt_PyObject)'),int(100*x/len(self.testingWords)))
if x >= len(self.testingWords):
break
#time.sleep(0.2)
#self.ui.window_cyk.setText("sparsowane %d, nie sparsowane %d, poprawnie %d nie poprawnie %d wspony"%(good,bad,poprawnie,nie))
self.grammar.countFitness()
print "licze membership"
self.membership.countMembership()
return 0
def test(self):
print self.parent.filename
def getFileName(self):
return self.getFileName()
def getParams(self):
return self.grammar.parametry
| Python |
#-*- coding: utf-8 -*-
from popupWindow import Ui_Dialog
from PyQt4 import QtCore, QtGui
class popUp(QtGui.QMainWindow):
def __init__(self,parent):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
QtCore.QObject.connect(self.ui.buttonOK, QtCore.SIGNAL("clicked()"), self.close)
def setText(self,text):
self.ui.komunikat.setText(QtGui.QApplication.translate("Dialog", text, None, QtGui.QApplication.UnicodeUTF8)) | Python |
#-*- coding: utf-8 -*-
class classifier():
'''klasa bedzie representowac klasyfikator w systemie'''
def __init__(self,name, left):
#prawa strona kalsyfikatora
self.left = left;
self.right = name
'''ilosc uzyc jest realizowana za pomoca tablicy
u[0] -> ilosc uzyc klasyfikatora przy parsowaniu zdania niepoprawnego
u[1] -> ilosc uzyc klasyfikatora przy parsowaniu zdania poprawnego'''
#ilosc poprawnych uzyc
self.u = []
self.u.append(0.0)
#ilosc niepoprawnych uzyc
self.u.append(0.0)
#co to bylo ??;), czy mam to updejtowac dopiero po rozbiorze?
self.p = 0.0
self.d =0.0
self.r1 = 0.0
self.r2 = 0.0
self.fitness = 0.0
self.omega = 1.0
def __len__(self):
return len(self.right)
def __repr__(self):
return self.left +"-->" + self.right
def compare(self,other):
''' metoda porównuje dwa klasyfikaotry jak u GCS'''
result = 0
if self.left == other.left:
result += 1
for x in range(0,len(self.right)):
try:
if self.right[x] == other.right[x]:
result += 1
except:
pass
return result
def resetParams(self):
''' resetuje paramtery classyfikatora'''
self.u[0] = 0
self.u[1] = 0
#co to bylo ??;), czy mam to updejtowac dopiero po rozbiorze?
self.p = 0.0
self.d =0.0
self.fitness = 0.0
#def __cmp__(self,other):
#result = 0
#if self.left == other.left:
#result += 1
#for x in range(0,len(self.right)-1):
#if self.rigt[x] == other.right[x]:
#result += 1
#return result
def setName(self,name):
self.right=name
def setLeft(self,left):
self.left=left
def getRight(self):
return self.right
def addPoints(self, poprawnosc):
'''dodanie opdpowiednio punktow do odpowiednieo parametru u'''
self.u[poprawnosc] =self.u[poprawnosc]+1
def getClassifierStrExt(self):
return self.left + "--->" + self.right +"\t"+"un= "+str(self.u[0])+"\t"+"up="+str(self.u[1])+"\t fitnes"+str(self.fitness)+ " p i d "+"("+str(self.p)+","+str(self.d)+")"+ " " + str(self.omega)+'\n'
#" r1 "+str( self.r1)+" r2 "+str(self.r2)+"\n"
def getClassifierStr(self):
return self.left + "--->" + self.right | Python |
#-*- coding: utf-8 -*-
import random
from classifier import classifier
class genetyk():
def __init__(self,grammar,properites):
self.grammar = grammar
self.properties = properites
def ruletSelection(self):
suma = 0.0
for x in self.grammar.G:
for y in self.grammar.G[x]:
if len(y.right) == 2:
y.r1 = suma
suma += y.fitness
y.r2 = suma
print "suma:"
print suma
print "losowa"
losowa = random.uniform(0,suma)
print losowa
for x in self.grammar.G:
for y in self.grammar.G[x]:
if y.r1< losowa < y.r2:
A = classifier(y.right,y.left)
losowa = random.uniform(0,suma)
print losowa
while 1:
#print "while"
for x in self.grammar.G:
for y in self.grammar.G[x]:
if y.r1< losowa < y.r2:
if y.compare(A)!=3:
B = classifier(y.right,y.left)
print "znalazlem"
return (A,B)
else:
losowa = random.uniform(0,suma)
return (A,B)
def randomSelection(self):
pass
def elitSelection(self):
pass
def mutation(self, A):
#tutaj cos glupiego trzeba wymyslic
print "mutacja"
#mutacja lewej strony
if random.random()<self.properties.Pm:
D = self.grammar.G.keys()
tmp = random.randint(0,len(D)-1)
A.left = D[tmp]
#mutacja prawej strony
#1
if random.random()<self.properties.Pm:
print "!!!!!!!!!!!!!!!!!!!!!!!"
print A
D = self.grammar.G.keys()
tmp = random.randint(0,len(D)-1)
A.right = D[tmp] + A.right[1:]
print A
#2
if random.random()<self.properties.Pm:
print "!!!!!!!!!!!!!!!!!!!!!!!"
print A
D = self.grammar.G.keys()
tmp = random.randint(0,len(D)-1)
A.right = A.right[:1] +D[tmp]
print A
def crossing(self,A,B):
tmp = A.right
A.right = B.right
B.right = tmp
return A, B
def inversion(self,A):
A.right = A.right[::-1]
return A
def updateGrammar(self):
pass
def updateProperies(self):
pass
def makeGen(self):
''' tutaj bedzie cala akcja wraz z uaktualnieniem gramatyki'''
#selekcja dwoch klasyfikatorów za pomocą ruletki (kopie juz)
A,B = self.ruletSelection()
if random.random()< self.properties.Pk:
print A
print B
self.crossing(A,B)
#tutaj mutajca na A
self.mutation(A)
#tutaj mutajca na B
self.mutation(B)
if random.random()< self.properties.Pi:
self.inversion(A)
if random.random()< self.properties.Pi:
self.inversion(B)
print "dodaje:"
print A
print B
self.grammar.add(A.left,A.right)
self.grammar.add(B.left,B.right)
| Python |
#-*- coding: utf-8 -*-
#klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
import string, random
from properties import properties
from classifier import classifier
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
self.permisionCover = 1
self.parametry = properties()
self.usedTerminals =[]
#Gramatyka w postaci slownika
#self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"A":[classifier("BA","A"),classifier("a","A")],"B":[classifier("CC","B"),classifier("b","B")],"C":[classifier("AB","C"),classifier("a","C")]}
self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.classifierNum=0
for x in self.G:
for y in self.G[x]:
if len(y.right)>1:
self.classifierNum+=1
def setProperties(self,p):
''' metoda uaktualnia parametry danego badania'''
self.parametry=p
def add(self, A, B):
'''dodaje kolejne reguly do gramamtyki A-->B'''
tmp=0
# sprawdzanie czy istnieje juz taki klasyfikator:
if self.G.has_key(A):
for x in self.G[A]:
if x.name==B:
tmp=1
if tmp == 0:
#scisk tutaj:
if(self.classifierNum >= self.parametry.np):
self.scisk_new(B,A)
#i dodajemy
self.G[A].append(classifier(B,A))
print "dodalem:" + A +"-->"+B
if len(B)>1:
self.classifierNum+=1
return 1
else:
#print "nie dodalem bo juz jest:)"
return -1
else:
if(self.classifierNum >= self.parametry.np):
self.scisk_new(B,A)
self.G[A] = [classifier(B,A)]
print "dodalem:" + A +"-->"+B
self.classifierNum+=1
return 1
def rem(self,A,B):
'''metoda usowa klasyfikator z gramatyki'''
tmp = 0
for x in self.G[A]:
if x.name == B:
del self.G[A][tmp]
self.classifierNum-=1
return 1
#print "usuwam"
tmp+=1
if len(self.G[A])==0:
del(self.G[A])
return 1
def search(self,terminal,poprawnosc, poziom):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, rozszerzona o symbol uniwersalny'''
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if ((T.name == terminal) or (T.name == '#')):
self.usedTerminals.append((T,poziom))
find = 1
self.result.append(x)
#Tutaj T dodajemy do listy uzytych podaczas parsowania
#przyznawanie punktow:
T.u[int(poprawnosc)]+=1
#else:
##uzycie pokrycia agresywnego i restart systemu:
#if (self.parametry.Pa < random.random()) and (self.permisionCover ==1):
#if self.pokrycieAgresywne(terminal) == 1:
##info do systemu ze trzeba restart walnac
#self.permisionCover = 0
#return -10
if find == 1:
return self.result
else:
if (self.parametry.Pa < random.random()) and (self.permisionCover ==1):
if self.pokrycieAgresywne(terminal) == 1:
#info do systemu ze trzeba restart walnac
self.permisionCover = 0
return -10
else:
return -1
def getGramarStr(self):
'''metoda zwraca liste klasyfikatorow wraz z ich parametrami w postaci stringa'''
tmp = ""
for x in self.G:
for y in self.G[x]:
tmp += str(x) + " -->" + y.right +"\t"+"un= "+str(y.u[0])+"\t"+"up="+str(y.u[1])+"\t fitnes"+str(y.fitness)+ " p i d "+"("+str(y.p)+","+str(y.d)+")"+"\n"
return tmp
def CYK(self, slowo):
''' algorytm CYK '''
succes = 0
poprawnosc = int(slowo[0])
slowo = slowo[1:]
table_CYK=[]
tmp = []
used_clas = []
#wypelnianie pierwszego poziomu:
for x in slowo:
a = self.search(x,poprawnosc, 0)
if(a == -10):
print "przerwalem!"
return -10
if a == -1:
if poprawnosc == 1:
#rezygnuje z wprowadzania pustych znakow na pierwszym poziomie o ile zdanie jest poprawne
self.pokrycieTerminalne(x)
a = self.search(x,poprawnosc,poprawnosc)
if a == -10:
print "restart systemu"
return -10
tmp.append(a)
print tmp
else:
tmp.append([-1])
else:
tmp.append(a)
#pokrycie startowe:
print "dlugosc="+str(len(slowo))+" poprawnosc= "+str(poprawnosc) + "slowo " +str(slowo)
if (len(slowo)>= 1) and (poprawnosc== 1) and (len(slowo)<= 2):
print "pokrycie startowe"
if self.pokrycieStartowe(slowo) > 0:
#przerywamy dzialanie algorytmu, poniewaz dodano nowy klasyfikator, nalezy obsluzyc w metodzie nadrzednej
return 0
print tmp
table_CYK.append(tmp)
print table_CYK
print "rozpoczynamy dodawanie na kolejnym poziomie"
#wypelnianie dalszych poziomow:
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
K = self.szukajPar(wiersz,pozycja)
LL = self.szukajTerminal(K,table_CYK,poprawnosc, wiersz)
if LL == -10:
return -10
tmp.append(LL)
pozycja+=1
table_CYK.append(tmp)
wiersz+=1
pozycja = 0
print "cyk sie skonczyl"
for x in table_CYK[len(slowo)-1][0]:
print x
if x == 'S':
succes = 1
if succes == poprawnosc:
succes = 1
print "succes"
else:
succes = 0
print "fuj"
self.countProfi(succes)
if succes != 1:
#tutaj albo robimy S-> w cos co juz jest w ostatniej komorce, lub trzeba ostatnia komorke wypelnic jeszcze raz i dodac jednego S
# moze miec postac tylko nie terminalna
#K = self.szukajPar(len(slowo),0)
#losujemy jedna z par i dodajemy
#x = random.randint(0,len(K))
#lewa = self.szukajTerminal(x,table_CYK,poprawnosc, wiersz)
#dodac i zreserowac
#return -1
pass
#obbliczenie funkcji przystosowania:
self.countFitness()
return table_CYK
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji'''
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK,poprawnosc, wiersz):
'''metoda zwraca liste pasujacych terminali'''
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
for b in table_CYK[x[1][0]][x[1][1]]:
wynik=self.search(str(a)+str(b),poprawnosc, wiersz)
if (wynik != -1) and (wynik != -10):
for y in wynik:
if y != -1:
if not y in tmp:
tmp.extend(y)
elif wynik == -10:
return -10
if len(tmp)<=0:
tmp = [-1]
return tmp
def countFitness(self):
#przeniesc to do implementacji klasyfikatora!!!
PD = self.getPD()
fc = ff = 0
for x in self.G:
for y in self.G[x]:
#liczenie ff:
if(PD[0]-PD[1]!=0.0):
ff = (y.p -y.d - PD[1])/(PD[0]-PD[1])
else:
ff = 0.0
#liczenie fc:
if((y.u[0]+y.u[1])==0):
fc = self.parametry.f0
else:
if (self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1]) != 0:
fc = (self.parametry.wp * y.u[1])/(self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1])
#liczenie przystosowania:
if (self.parametry.wc + self.parametry.wf) != 0:
y.fitness = (self.parametry.wc*fc + self.parametry.wf*ff)/(self.parametry.wc + self.parametry.wf)
def getPD(self):
'''metoda zwaraca krorke (max(p-d),min(p-d)) '''
minimum = 0.0
maximum = 0.0
for x in self.G:
for y in self.G[x]:
tmp = y.p - y.d
if tmp > minimum:
minimum = tmp
if tmp < maximum:
maximum = tmp
return (maximum,minimum)
def countProfi(self, rozbior):
if rozbior == 0:
for x in self.usedTerminals:
x[0].d += self.parametry.ba*pow(2,x[1])*self.parametry.raf
else:
for x in self.usedTerminals:
x[0].p += self.parametry.ba*pow(2,x[1])*self.parametry.raf
def randomSelction(self):
'''losowanie klasyfikatora '''
K = self.G.keys()
key = random.randint(0,len(K)-1)
tmp = self.G[K[key]]
prawa = random.randint(0,len(tmp)-1)
return (K[key],tmp[prawa].name)
def universalCover(self):
'''tutaj nie rozumie do konca idei tego pokrycia'''
pass
def pokryciePelne(self):
'''tego tez nie dokonca czaje i trzeba sie zapyac'''
pass
def pokrycieStartowe(self, term):
'''dodanie pokrycia startowego dal zdan dlugosci 1'''
return self.add("S" , term)
def pokrycieAgresywne(self, name):
'''i tego tez nie rozumiem
zorbie tak: ze zbioru detektorow wybieram 3 i robie z nich klasyfikator'''
print "pokrycie agresywne "+ name
if self.permisionCover == 0:
return 0
D = self.G.keys()
tmp = random.randint(0,len(D)-1)
return self.add(D[tmp],name) == 1
def krzyzowanie(self):
'''metoda krzyzowania klasyfikatoprow, jeszcze nie przetestowana
nie sprawdzone czy napewno dziala poprawnie!!!'''
A,ClassA = self.randomSelction()
while(len(ClassA)!=2):
A,ClassA = self.randomSelction()
B,ClassB = self.randomSelction()
while(len(ClassB)!=2):
B,ClassB = self.randomSelction()
self.add(A,ClassB)
self.add(B,ClassA)
def mutacja(self):
'''musze tutaj jeszcze przeimplemntowac inne elementy, dodac tablice terminali(G.keys()) i nieterminali
nie sprawdzone czy napewno dziala poprawnie!!!'''
def inwersja(self):
''' genetyk inwersji
nie sprawdzone czy napewno dziala poprawnie!!!'''
A,classA = self.randomSelction()
while(len(classA)!=2):
A,classA = self.randomSelction()
self.add(A,classA[1]+classA[0])
def alowCover(self):
self.permisionCover=1
return 1
def scisk_new(self, left, name):
'''metoda dodaje dany klasyfikator ze sciskiem left-->name'''
cs_table = []
cf_table = []
choose = 0
minmal = 100000
for y in range(0,self.parametry.cf):
for x in range(0,self.parametry.cs):
keys = self.G.keys()
while 1:
B = random.choice(keys)
if len(self.G[B])>1:
break
while 1:
K = self.G[B][random.randint(0,len(self.G[B])-1)]
if len(K.name) > 1:
break
if K.fitness <= minmal:
minmal = K.fitness
choose = K
cf_table.append(K)
#szukamy najbardziej podobnego:
podobienstwo_max = 0
for x in cf_table:
podobienstwo = 0
if len(name) == 0:
if x.left == left:
podobienstwo += 1
if x.name[0] == name[0]:
podobienstwo += 1
if x.name[1] == name[1]:
podobienstwo += 1
if podobienstwo > podobienstwo_max:
podobienstwo_max = podobienstwo
K = x
return self.rem(K.left,K.name)
#SEKCJA TESTOWA:
G = gramatyka()
print G.getGramarStr()
print G.randomSelction()
#A = G.CYK("1aa")
#while A == 0:
#A = G.CYK("1aabb")
#if A == -10:
#print "restart"
#print "koniec"
#print A
#if A !=-10:
#for x in A:
#print x
#A = G.CYK("1h")
#while A == 0:
#A = G.CYK("1h")
print "koniec"
| Python |
##klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
#Gramatyka w postaci slownika
self.Gg = {"S":["AB","BC"],"A":["BA","a"],"B":["CC","b"],"C":["AB","a"]}
self.G = {"S":["AB","AC"],"C":["SB","a"],"B":["BB","b"],"A":["a"]}
def add(self, A, B):
'''doaje kolejne reguly do gramamtyki, jeszcze nie przetestowane czy poprawnie dziala'''
if self.G.has_key(A):
self.G[A].append(B)
else:
self.G[A] = [B]
def search(self,terminal):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, metoda rozszezona o symbol uniwersalny'''
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if ((T == terminal) or (T == '#')):
find = 1
self.result.append(x)
if find == 1:
return self.result
else:
return -1
def getGramarStr(self):
tmp = ""
for x in self.G:
tmp += str(x) + "-->" + str(self.G[x])+ "\n"
return tmp
def CYK(self, slowo):
tmp = []
table_CYK =[]
final = []
#peirwsza czesc odpowiadajaca za wypelnienie pierwszego wiersza w tabeli
for x in slowo:
a = self.search(x)
if a == -1:
tmp.append([-1])
else:
tmp.append(a)
table_CYK.append([])
table_CYK[0] = tmp[0:]
#tutaj jakas totalna masakra taka ze glowa mala:):
#table_CYK.append([])
poziom=1
while poziom < (len(table_CYK[0])):
table_CYK.append([])
#k jest iteratorem dla while, nic pozatym
k=0
while k < len(table_CYK[0])-poziom:
tmp=[]
##tutaj zakres nie jest obknuty do konca
##cos - poziom po ktorym aktualnie poszukujemy:
for cos in range(0,poziom):
if cos<=(poziom-1-cos):
for a in table_CYK[cos][k]:
if table_CYK[cos][k] == -1:
tmp=[]
else:
for b in table_CYK[poziom-1-cos][k+1+cos]:
#print "if: dla [%d;%d] [%d;%d] szukam %s%s"%(cos,k,poziom-1-cos,k+1+cos,str(a),str(b))
wynik = self.search(str(a)+str(b))
if wynik != -1:
#if (wynik in tmp) == False:
if not [elements in wynik for elements in tmp]:
tmp.extend(wynik)
#print "else: dla [%d;%d] [%d;%d] szukam %s%s"%(cos,k,poziom-1-cos,k+1,str(a),str(b))
else:
for b in table_CYK[cos][k]:
if table_CYK[cos][k] == -1:
tmp=[]
for a in table_CYK[poziom-1-cos][k+1+cos]:
#print "else: dla [%d;%d] [%d;%d] szukam %s%s"%(cos,k+1,poziom-1-cos,k+1+cos,str(b),str(a))
wynik = self.search(str(b)+str(a))
if wynik != -1:
if not [elements in wynik for elements in tmp]:
tmp.extend(wynik)
if len(tmp) <= 0:
tmp = [-1]
table_CYK[poziom].append(tmp)
k+=1
#print "ostatio wygenerowany poziom"
#print table_CYK[poziom]
poziom+=1
return table_CYK
##klasa bedzie udawac zachowanie multiplekasera, bede jej uzywac do testow
class classifier():
'''klasa bedzie representowac klasyfikator w systemie'''
def __init__(self,name):
self.name = name
def set(self,name):
self.name=name
def getName(slef):
return slef.name
G = gramatyka()
K = G.CYK("aabb")
#G = gramatyka()
#print G.getGramarStr()
#K = G.CYK("abaaaaabbaba")
print "final:"
for x in K:
print x
| Python |
#-*- coding: utf-8 -*-
#klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
import string, random
from properties import properties
from classifier import classifier
from genetyk import genetyk
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
#tworzenie instncji parametrow
self.parametry = properties()
self.allowFulCover = 1
#Gramatyka w postaci slownika
#self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"A":[classifier("BA","A"),classifier("a","A")],"B":[classifier("CC","B"),classifier("b","B")],"C":[classifier("AB","C"),classifier("a","C")]}
self.G = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.G_backUp = {"S":[classifier("AB","S"),classifier("AC","S")],"C":[classifier("SB","C"),classifier("a","C")],"B":[classifier("BB","B"),classifier("b","B")],"A":[classifier("a","A")]}
self.classifierNum=0
self.allowCover = 1
for x in self.G:
for y in self.G[x]:
if len(y.right)>1:
self.classifierNum+=1
def makeBackUp(self):
self.G_backUp = self.G
def bringBackGrammar(self):
self.G = self.G_backUp
def CYK(self, slowo):
''' algorytm CYK '''
print "CYK"
#Do poprawienia:
#1. ocenienie po zakonczeniu -> done
#2. przerywanie algorytmu -> dotychczas done
#3. tablica cyk na obiektach -> done
#4. uzycie pokrycia -> done
#4.1 pokrycie agresywne -> done
#4.2 pokrycie pelne -> done
#4.3 pokrycie pokrycie universane
#5. symbole uniwersalne
#co trza sprawdzic:
#6. Nagradzanie (kiedy ?!)
#7. populacje turniejową
#8. przeanalizowac ktore usuwe klasyfikatory
#9, sprawdzic zaleznosc obiektow
#10 sprawdzic back tracjing
#11.kiedy rozbior zdania jest poprawny?!
#12.
# a zem wymyslil
# 1. S-> w cos w ostatniej komorce jezeli prowadzi do poprawnego rozwiazania a nie prowadzi do nie poprawnego trza wywalic z gramatyki
poprawnosc = int(slowo[0])
slowo = slowo[1:]
#tymczasowa tablica do klasyfikatorów:
tmp = []
self.table_CYK=[]
#uzupelnianie pierwszego wiersza:
for x in slowo:
a = self.search(x,poprawnosc, 0)
if a == -1:
if poprawnosc == 1:
#rezygnuje z wprowadzania pustych znakow na pierwszym poziomie o ile zdanie jest poprawne
self.pokrycieTerminalne(x)
a = self.search(x,poprawnosc,0)
tmp.append(a)
else:
tmp.append([-1])
else:
tmp.append(a)
self.table_CYK.append(tmp)
#zastosowanie pokrycia startowego przerwanie algorytmu
#musi nastąpić reset ustawień w metodzie nadrzędnej
if len(slowo) == 1:
if self.pokrycieStartowe(slowo[0]) == 1:
return -10
#wypelnianie dalszych poziomow:
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
pary = self.szukajPar(wiersz,pozycja)
LL = self.szukajTerminal(pary,self.table_CYK,poprawnosc, wiersz)
if LL == -10:
return -10
tmp.append(LL)
pozycja+=1
self.table_CYK.append(tmp)
wiersz+=1
pozycja = 0
#sprawdzenie poziomu sparsowania zdania:
#tutaj także bedzie można rozmytość zastosować
#sprawdzenie czy zdanie sie sparsowalo
result = 0
for y in self.table_CYK[len(slowo)-1]:
for x in y:
if x == -1:
result += 0
elif x.left == 'S':
result = 1
#pokrycie pelne zdanie poprawne i nie sparsowane:
if poprawnosc == 1 and result == 0 and self.allowFulCover==1:
if self.pokryciePelne(len(slowo)-1) == 0:
return -10
#sprawdzenie poprawnosci cyka
#if poprawnosc == result:
#return 1
#else:
#return 0
return result
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji
wiersz -> a
pozycja -> b
'''
#print "szukaj par"
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK,poprawnosc, wiersz):
'''metoda zwraca liste pasujacych terminali'''
#print "szukaj terminali"
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
if a == -1:
continue
for b in table_CYK[x[1][0]][x[1][1]]:
if b == -1:
continue
wynik=self.search(str(a.left)+str(b.left),poprawnosc, wiersz)
if (wynik != -1) and (wynik != -10):
for y in wynik:
if y != -1:
if not y in tmp:
tmp.append(y)
elif wynik == -10:
return -10
if len(tmp)<=0:
tmp = [-1]
return tmp
def search(self,terminal,poprawnosc, poziom):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, rozszerzona o symbol uniwersalny'''
#print "search"
find = 0
result = []
for x in self.G:
for T in range(0,len(self.G[x])):
if ((self.G[x][T].right == terminal) or (self.G[x][T].right == '#')):
find = 1
#rezygnujemy z przyznawania poniewaz bedziemy to robic po zakonczeniu rozbioru
#self.G[x][T].u[poprawnosc] += 1
result.append(self.G[x][T])
else:
pass
#możliwość zastosowania logiki rozmytej
#uzycie pokrycia agresywnego i restart systemu:
#print "agresywne"
#if self.parametry.Pa > random.random():
#self.pokrycieAgresywne(terminal)
if find == 1:
return result
else:
if (self.parametry.Pa > random.random()) and (poprawnosc == 1) and (poziom > 1):
if self.pokrycieAgresywne(terminal) == 1:
return -10
else:
print "no i nie weszlo w pokrycie agresywne"
return -1
def pokrycieTerminalne(self, term):
'''operacja pokrycia terminalnego, przyjmuje terminal do dodania'''
print "pokrycie terminalne"
return self.add(string.upper(term) , term)
def pokrycieStartowe(self, term):
'''pokrycie startowe'''
print "pokrycie startowe"
return self.add('S',term)
def pokryciePelne(self, poziom):
'''FullCover zwraca -1 gdy pokrycie nie jest mozliwe, lub 0 gdy doda terminal taki jak trza'''
print "pokrycie pelne"
tab_par=self.szukajPar(poziom,0)
for x in tab_par:
for a in self.table_CYK[x[0][0]][x[0][1]]:
if a == -1:
continue
for b in self.table_CYK[x[1][0]][x[1][1]]:
if b == -1:
continue
self.add('S',str(a.left)+str(b.left))
self.allowFulCover = 0
return 0
return -1
def pokrycieAgresywne(self, terminal):
'''i tego tez nie rozumiem
zorbie tak: ze zbioru detektorow wybieram 3 i robie z nich klasyfikator'''
print "pokrycie agresywne "+ terminal
#if self.permisionCover == 0:
#return 0
D = self.G.keys()
tmp = random.randint(0,len(D)-1)
return self.add(D[tmp],terminal)
def getGramarStr(self):
'''metoda zwraca liste klasyfikatorow wraz z ich parametrami w postaci stringa'''
tmp = ""
for x in self.G:
for y in self.G[x]:
tmp+=y.getClassifierStrExt()
return tmp
def getDictionaryStr(self):
pass
def add(self, A, B):
'''dodaje kolejne reguly do gramamtyki A-->B'''
print "add"
print self.classifierNum
tmp=0
# sprawdzanie czy istnieje juz taki klasyfikator:
if self.G.has_key(A):
for x in self.G[A]:
if x.right==B:
#znalazlem juz taki klasyfikator:
tmp=1
return -1
if tmp == 0:
#scisk tutaj:
if(self.classifierNum >= self.parametry.np):
self.scisk(A,B)
#i dodajemy
self.G[A].append(classifier(B,A))
if len(B)>1:
self.classifierNum+=1
print "dodalem"
print str(A) +'-->' +str(B)
return 1
else:
#print "nie dodalem bo juz jest:)"
return -1
else:
if(self.classifierNum >= self.parametry.np):
self.scisk(A,B)
self.G[A] = [classifier(B,A)]
print "dodalem"
print str(A) +'-->' +str(B)
self.classifierNum+=1
return 1
def rem(self,class_rem):
'''metoda usowa klasyfikator z gramatyki'''
print "rem"
i = 0
for x in self.G[class_rem.left]:
if x.compare(class_rem) == len(class_rem.right)+1:
print 'usuwam'
print self.G[class_rem.left][i]
self.classifierNum-=1
del self.G[class_rem.left][i]
if len(self.G[class_rem.left])==0:
del(self.G[class_rem.left])
print self.classifierNum
return 1
i += 1
print "zem nie usunal !!!!!!!!!!!!!!!!!!!!"
return 0
def scisk(self, left, name):
'''metoda dodaje dany klasyfikator ze sciskiem left-->name'''
print "scisk"
cs_table = []
cf_table = []
choose = 0
minmal = 100000
for y in range(0,self.parametry.cf):
for x in range(0,self.parametry.cs):
keys = self.G.keys()
while 1:
B = random.choice(keys)
#if len(self.G[B])>1:
#break
K = self.G[B][random.randint(0,len(self.G[B])-1)]
if len(K.getRight()) > 1:
break
if K.fitness <= minmal:
minmal = K.fitness
choose = K
cf_table.append(K)
#return cf_table
#szukamy najbardziej podobnego:
podobienstwo_max = -1
tmp_cla = classifier(name,left)
print tmp_cla
for x in cf_table:
podobienstwo = x.compare(tmp_cla)
if podobienstwo_max < podobienstwo:
choose = x
#usuwamy najbardziej podobny z klasyfikatorów:
#self.rem(choose.left, choose.right)
#dodaje nowy klasyfikator:
#self.add(left,name)
return self.rem(choose)
def countProfit(self, rozbior, word_len, poprawnosc):
'''metoda liczy profit uzyskany odczas rozbioru poprawnego/niepoprawnego'''
print "count profit"
#sprawdzamy czy rzobior byl napewno do konca zrobiony:
result = 0
for y in self.table_CYK[word_len]:
for x in y:
if x == -1:
pass
elif x.left == 'S':
result = 1
for x in range(0,word_len):
for y in self.table_CYK[x]:
for n in y:
if n != -1:
n.u[int(poprawnosc)] += 1
if result == 1:
if int(poprawnosc) == 1:
n.p += self.parametry.ba*pow(2,x)*self.parametry.raf
else:
n.d += self.parametry.ba*pow(2,x)*self.parametry.raf
#if rozbior == 0:
#for x in self.usedTerminals:
#x[0].d += self.parametry.ba*pow(2,x[1])*self.parametry.raf
#else:
#for x in self.usedTerminals:
#x[0].p += self.parametry.ba*pow(2,x[1])*self.parametry.ra
def countFitness(self):
#przeniesc to do implementacji klasyfikatora!!!
print "count fitness"
#Pd jest (maximum,minimum)
PD = self.getPD()
fc = ff = 0
for x in self.G:
for y in self.G[x]:
#liczenie ff:
if(PD[0]-PD[1]!=0.0):
ff = (y.p -y.d - PD[1])/(PD[0]-PD[1])
else:
ff = 0.0
#liczenie fc:
if((y.u[0]+y.u[1])==0):
fc = self.parametry.f0
else:
if (self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1]) != 0:
fc = (self.parametry.wp * y.u[1])/(self.parametry.wn*y.u[0]+self.parametry.wp*y.u[1])
#liczenie przystosowania:
if (self.parametry.wc + self.parametry.wf) != 0:
y.fitness = (self.parametry.wc*fc + self.parametry.wf*ff)/(self.parametry.wc + self.parametry.wf)
def getPD(self):
'''metoda zwaraca krorke (max(p-d),min(p-d)) '''
print "get PD"
minimum = 0.0
maximum = 0.0
for x in self.G:
for y in self.G[x]:
tmp = y.p - y.d
if tmp < minimum:
minimum = tmp
if tmp > maximum:
maximum = tmp
return (maximum,minimum)
#testy:
G = gramatyka()
gen = genetyk(G,G.parametry)
result = -10
while result == -10:
result = G.CYK('1abba')
tab = G.table_CYK
print "wynik cyka " + str(result)
for x in tab:
print x
G.countProfit(result,len('1abba')-2,1)
G.countFitness()
print G.getGramarStr()
print "genetyczny przedsawiamy:"
gen.makeGen()
#tmp.right = "dupa"
print G.getGramarStr()
print G.getPD()
#A = classifier('AB','C')
#print gen.inversion(A)
| Python |
##klasa ta reperezentowac bedzie gramatyke
# trzeba zamontowac tutaj funkcje umozliwiajace edycje gramtyki
# narazie bedzie to jedynie statyczna klasa posiadajaca jedna gramtyke na sztywno
class gramatyka():
'''klasa zaiwera gramatyke wraz z operacja,i na niej dostepnymi'''
def __init__(self):
#Gramatyka w postaci slownika
self.Gg = {"S":["AB","BC"],"A":["BA","a"],"B":["CC","b"],"C":["AB","a"]}
self.G = {"S":["AB","AC"],"C":["SB","a"],"B":["BB","b"],"A":["a"]}
def add(self, A, B):
'''doaje kolejne reguly do gramamtyki, jeszcze nie przetestowane czy poprawnie dziala'''
if self.G.has_key(A):
self.G[A].append(B)
else:
self.G[A] = [B]
def search(self,terminal):
'''metoda wyszukuje caly slownik w poszukiwaniu klasyfikatorow pasujacych do przekazanego terminalu, metoda rozszezona o symbol uniwersalny'''
find = 0
self.result = []
for x in self.G:
for T in self.G[x]:
if ((T == terminal) or (T == '#')):
find = 1
self.result.append(x)
if find == 1:
return self.result
else:
return -1
def getGramarStr(self):
tmp = ""
for x in self.G:
tmp += str(x) + "-->" + str(self.G[x])+ "\n"
return tmp
def CYK(self, slowo):
table_CYK=[]
tmp = []
#wypelnianie pierwszego poziomu:
for x in slowo:
a = self.search(x)
if a == -1:
tmp.append([-1])
else:
tmp.append(a)
table_CYK.append(tmp)
wiersz = 1
pozycja = 0
while wiersz < len(slowo):
tmp = []
while pozycja < (len(slowo)-wiersz):
print "aktualne pole: "+str(wiersz)+str(pozycja)
#tutaj teraz trzeba odpalic uzupelnianie tablicy:(zamiast print)
K = self.szukajPar(wiersz,pozycja)
print "wyszukiwane pary"+str(K)
tmp.append(self.szukajTerminal(K,table_CYK))
#print str(table_CYK[x[0][0]][x[0][1]]) + str(table_CYK[x[1][0]][x[1][1]])
#print "cala linia" + str(M)
pozycja+=1
table_CYK.append(tmp)
wiersz+=1
pozycja = 0
print("\n")
return table_CYK
def szukajPar(self,a,b):
'''metoda ta zwraca pary par generujace zdanie dla odpowiedniej pozcycji'''
tablica = []
a=a+1
b=b+1
for x in range(1,a):
tablica.append([[x-1,b-1],[a-x-1,b+x-1]])
return tablica
def szukajTerminal(self,K,table_CYK):
'''metoda zwraca liste pasujacych terminali'''
tmp = []
for x in K:
for a in table_CYK[x[0][0]][x[0][1]]:
for b in table_CYK[x[1][0]][x[1][1]]:
wynik=self.search(str(a)+str(b))
print str(wynik)
if wynik != -1:
for y in wynik:
if y != -1:
if not y in tmp:
tmp.extend(y)
if len(tmp)<=0:
tmp = [-1]
return tmp
G = gramatyka()
K = G.szukajPar(2,0)
#G = gramatyka()
#print G.getGramarStr()
table_CYK = G.CYK("aabb")
print "final:"
for x in table_CYK:
print x
L = G.szukajPar(1,2)
M = G.szukajTerminal(L,table_CYK)
print str(M) | Python |
#-*- coding: utf-8 -*-
import sys
import string
from PyQt4 import QtCore, QtGui
from task_GUI import Ui_Tasks
class tasks_generator(QtGui.QMainWindow):
def __init__(self, parent):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_Tasks()
self.ui.setupUi(self)
#wzór do generowania zbiorów uczących
self.pattern = ""
self.max_len = 0
self.min_len = 0
self.collection_size = 0
#definiujemy 2 zdarzenia OK i Anuluj:
QtCore.QObject.connect(self.ui.button_anuluj, QtCore.SIGNAL("clicked()"),self.close)
QtCore.QObject.connect(self.ui.button_ok, QtCore.SIGNAL("clicked()"),self.getContent)
def getContent(self):
self.pattern = self.ui.patter.text()
if len(self.pattern) <=1:
self.ui.label_error.setText("zly format wzoru !!!")
else:
self.max_len = int(self.ui.max_lenght.text())
self.min_len = int(self.ui.min_lenght.text())
self.collection_size = int(self.ui.collection_size.text())
print self.max_len
print self.min_len
print self.collection_size
self.genTasks()
def genTasks(self):
self.doColections()
print self.nonterminals
print self.nonterminals_power
#trzeba obmyśleć jeszcze jakoś algorytm generowania tego parszywych zdan uczacych
def checkPattern(self):
''' trzeba tutaj wyrażenie regularne zastosowac, ale to w pracy bo chce soprano dzisiaj pogladac'''
pass
def doColections(self):
self.nonterminals = []
self.nonterminals_power = []
x =0
while 1:
if (x+2) > len(self.pattern):
break
else:
self.nonterminals.append(str(self.pattern[x]))
self.nonterminals_power.append(int(self.pattern[x+2]))
x+=4
pass
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = tasks_generator(None)
myapp.show()
sys.exit(app.exec_())
| Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'task_generate.ui'
#
# Created: Mon Jul 20 22:22:57 2009
# by: PyQt4 UI code generator 4.4.3
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_Tasks(object):
def setupUi(self, Anuluj):
Anuluj.setObjectName("Anuluj")
Anuluj.resize(352, 206)
self.button_ok = QtGui.QPushButton(Anuluj)
self.button_ok.setGeometry(QtCore.QRect(30, 170, 80, 27))
self.button_ok.setObjectName("button_ok")
self.button_anuluj = QtGui.QPushButton(Anuluj)
self.button_anuluj.setGeometry(QtCore.QRect(140, 170, 80, 27))
self.button_anuluj.setObjectName("button_anuluj")
self.patter = QtGui.QLineEdit(Anuluj)
self.patter.setGeometry(QtCore.QRect(20, 30, 271, 21))
self.patter.setObjectName("patter")
self.max_lenght = QtGui.QSpinBox(Anuluj)
self.max_lenght.setGeometry(QtCore.QRect(240, 90, 54, 21))
self.max_lenght.setObjectName("max_lenght")
self.min_lenght = QtGui.QSpinBox(Anuluj)
self.min_lenght.setGeometry(QtCore.QRect(240, 120, 54, 23))
self.min_lenght.setObjectName("min_lenght")
self.collection_size = QtGui.QSpinBox(Anuluj)
self.collection_size.setGeometry(QtCore.QRect(240, 150, 54, 23))
self.collection_size.setObjectName("collection_size")
self.label = QtGui.QLabel(Anuluj)
self.label.setGeometry(QtCore.QRect(20, 10, 281, 21))
self.label.setObjectName("label")
self.label_2 = QtGui.QLabel(Anuluj)
self.label_2.setGeometry(QtCore.QRect(20, 90, 181, 21))
self.label_2.setObjectName("label_2")
self.label_3 = QtGui.QLabel(Anuluj)
self.label_3.setGeometry(QtCore.QRect(20, 120, 181, 16))
self.label_3.setObjectName("label_3")
self.label_4 = QtGui.QLabel(Anuluj)
self.label_4.setGeometry(QtCore.QRect(20, 150, 181, 21))
self.label_4.setObjectName("label_4")
self.label_error = QtGui.QLabel(Anuluj)
self.label_error.setGeometry(QtCore.QRect(20, 60, 271, 16))
self.label_error.setObjectName("label_error")
self.retranslateUi(Anuluj)
QtCore.QMetaObject.connectSlotsByName(Anuluj)
def retranslateUi(self, Anuluj):
Anuluj.setWindowTitle(QtGui.QApplication.translate("Anuluj", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
self.button_ok.setText(QtGui.QApplication.translate("Anuluj", "OK", None, QtGui.QApplication.UnicodeUTF8))
self.button_anuluj.setText(QtGui.QApplication.translate("Anuluj", "Anuluj", None, QtGui.QApplication.UnicodeUTF8))
self.label.setText(QtGui.QApplication.translate("Anuluj", "Podaj wzór gramatyki w formacie a^n*b^n:", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate("Anuluj", "maksymalna dlugosc zdania:", None, QtGui.QApplication.UnicodeUTF8))
self.label_3.setText(QtGui.QApplication.translate("Anuluj", "minimalna dlugosc zdania:", None, QtGui.QApplication.UnicodeUTF8))
self.label_4.setText(QtGui.QApplication.translate("Anuluj", "ilosc zdan uczacych:", None, QtGui.QApplication.UnicodeUTF8))
| Python |
#-*- coding: utf-8 -*-
class properties():
def __init__(self):
#krzyzowanie
self.Pk=0.2
#mutacja
self.Pm=0.8
#inwersja
self.Pi=0.0
#pelne pokrycie:
self.Pa=0.0
self.cf=18
self.cs=3
self.ba=1
self.raf=0.5
self.ts=0
#rozmiar populacji:
self.np=40
self.nstart=0
self.nN=0
self.nT=0
self.nelit=0
self.nrun=0
self.nmax=0
self.wc=1
self.wf=0
self.wp=1
self.wn=2
self.f0 = 0.5
#mozna oposcic plodnosc, ff nie jest brana pod uwage. | Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'okno_new.ui'
#
# Created: Sun Jul 19 23:20:59 2009
# by: PyQt4 UI code generator 4.4.3
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_GCS(object):
def setupUi(self, GCS):
GCS.setObjectName("GCS")
GCS.resize(821, 600)
self.centralwidget = QtGui.QWidget(GCS)
self.centralwidget.setObjectName("centralwidget")
self.window_CYK = QtGui.QTabWidget(self.centralwidget)
self.window_CYK.setGeometry(QtCore.QRect(150, 10, 631, 491))
self.window_CYK.setObjectName("window_CYK")
self.tab = QtGui.QWidget()
self.tab.setObjectName("tab")
self.window_cyk = QtGui.QTextBrowser(self.tab)
self.window_cyk.setGeometry(QtCore.QRect(0, 0, 631, 471))
self.window_cyk.setObjectName("window_cyk")
self.window_CYK.addTab(self.tab, "")
self.tab_2 = QtGui.QWidget()
self.tab_2.setObjectName("tab_2")
self.window_grammar = QtGui.QTextBrowser(self.tab_2)
self.window_grammar.setGeometry(QtCore.QRect(0, 0, 631, 471))
self.window_grammar.setObjectName("window_grammar")
self.window_CYK.addTab(self.tab_2, "")
self.tab_3 = QtGui.QWidget()
self.tab_3.setObjectName("tab_3")
self.window_file = QtGui.QTextBrowser(self.tab_3)
self.window_file.setGeometry(QtCore.QRect(0, 0, 631, 471))
self.window_file.setObjectName("window_file")
self.window_CYK.addTab(self.tab_3, "")
self.tab_4 = QtGui.QWidget()
self.tab_4.setObjectName("tab_4")
self.numberOfLoops = QtGui.QSpinBox(self.tab_4)
self.numberOfLoops.setGeometry(QtCore.QRect(70, 30, 42, 22))
self.numberOfLoops.setMaximum(10000)
self.numberOfLoops.setProperty("value", QtCore.QVariant(1))
self.numberOfLoops.setObjectName("numberOfLoops")
self.label = QtGui.QLabel(self.tab_4)
self.label.setGeometry(QtCore.QRect(10, 30, 61, 20))
self.label.setObjectName("label")
self.propertiesAccept = QtGui.QPushButton(self.tab_4)
self.propertiesAccept.setGeometry(QtCore.QRect(540, 430, 75, 23))
self.propertiesAccept.setObjectName("propertiesAccept")
self.propertiesCancel = QtGui.QPushButton(self.tab_4)
self.propertiesCancel.setGeometry(QtCore.QRect(450, 430, 75, 23))
self.propertiesCancel.setObjectName("propertiesCancel")
self.label_2 = QtGui.QLabel(self.tab_4)
self.label_2.setGeometry(QtCore.QRect(150, 30, 61, 20))
self.label_2.setObjectName("label_2")
self.label_3 = QtGui.QLabel(self.tab_4)
self.label_3.setGeometry(QtCore.QRect(150, 50, 61, 20))
self.label_3.setObjectName("label_3")
self.label_4 = QtGui.QLabel(self.tab_4)
self.label_4.setGeometry(QtCore.QRect(150, 70, 61, 20))
self.label_4.setObjectName("label_4")
self.label_5 = QtGui.QLabel(self.tab_4)
self.label_5.setGeometry(QtCore.QRect(150, 90, 61, 20))
self.label_5.setObjectName("label_5")
self.Pk = QtGui.QDoubleSpinBox(self.tab_4)
self.Pk.setGeometry(QtCore.QRect(180, 30, 62, 22))
self.Pk.setDecimals(2)
self.Pk.setMaximum(1.0)
self.Pk.setSingleStep(0.01)
self.Pk.setProperty("value", QtCore.QVariant(0.0))
self.Pk.setObjectName("Pk")
self.Pm = QtGui.QDoubleSpinBox(self.tab_4)
self.Pm.setGeometry(QtCore.QRect(180, 50, 62, 22))
self.Pm.setMaximum(1.0)
self.Pm.setSingleStep(0.01)
self.Pm.setObjectName("Pm")
self.Pi = QtGui.QDoubleSpinBox(self.tab_4)
self.Pi.setGeometry(QtCore.QRect(180, 70, 62, 22))
self.Pi.setMaximum(1.0)
self.Pi.setSingleStep(0.01)
self.Pi.setObjectName("Pi")
self.Pa = QtGui.QDoubleSpinBox(self.tab_4)
self.Pa.setGeometry(QtCore.QRect(180, 90, 62, 22))
self.Pa.setMaximum(1.0)
self.Pa.setSingleStep(0.01)
self.Pa.setObjectName("Pa")
self.label_6 = QtGui.QLabel(self.tab_4)
self.label_6.setGeometry(QtCore.QRect(10, 10, 61, 20))
self.label_6.setObjectName("label_6")
self.label_7 = QtGui.QLabel(self.tab_4)
self.label_7.setGeometry(QtCore.QRect(130, 10, 111, 20))
self.label_7.setObjectName("label_7")
self.label_8 = QtGui.QLabel(self.tab_4)
self.label_8.setGeometry(QtCore.QRect(270, 10, 111, 20))
self.label_8.setObjectName("label_8")
self.label_9 = QtGui.QLabel(self.tab_4)
self.label_9.setGeometry(QtCore.QRect(270, 30, 61, 20))
self.label_9.setObjectName("label_9")
self.label_10 = QtGui.QLabel(self.tab_4)
self.label_10.setGeometry(QtCore.QRect(270, 50, 61, 20))
self.label_10.setObjectName("label_10")
self.label_11 = QtGui.QLabel(self.tab_4)
self.label_11.setGeometry(QtCore.QRect(270, 70, 61, 20))
self.label_11.setObjectName("label_11")
self.label_12 = QtGui.QLabel(self.tab_4)
self.label_12.setGeometry(QtCore.QRect(270, 90, 61, 20))
self.label_12.setObjectName("label_12")
self.cs = QtGui.QSpinBox(self.tab_4)
self.cs.setGeometry(QtCore.QRect(300, 50, 42, 22))
self.cs.setMinimum(1)
self.cs.setMaximum(30)
self.cs.setObjectName("cs")
self.cf = QtGui.QSpinBox(self.tab_4)
self.cf.setGeometry(QtCore.QRect(300, 30, 42, 22))
self.cf.setMinimum(1)
self.cf.setMaximum(30)
self.cf.setObjectName("cf")
self.ba = QtGui.QSpinBox(self.tab_4)
self.ba.setGeometry(QtCore.QRect(300, 70, 42, 22))
self.ba.setMaximum(15)
self.ba.setObjectName("ba")
self.raf = QtGui.QSpinBox(self.tab_4)
self.raf.setGeometry(QtCore.QRect(300, 90, 42, 22))
self.raf.setMaximum(15)
self.raf.setObjectName("raf")
self.label_13 = QtGui.QLabel(self.tab_4)
self.label_13.setGeometry(QtCore.QRect(10, 150, 61, 20))
self.label_13.setObjectName("label_13")
self.label_14 = QtGui.QLabel(self.tab_4)
self.label_14.setGeometry(QtCore.QRect(10, 170, 61, 20))
self.label_14.setObjectName("label_14")
self.label_15 = QtGui.QLabel(self.tab_4)
self.label_15.setGeometry(QtCore.QRect(10, 190, 61, 20))
self.label_15.setObjectName("label_15")
self.label_16 = QtGui.QLabel(self.tab_4)
self.label_16.setGeometry(QtCore.QRect(10, 210, 61, 20))
self.label_16.setObjectName("label_16")
self.label_17 = QtGui.QLabel(self.tab_4)
self.label_17.setGeometry(QtCore.QRect(10, 230, 61, 20))
self.label_17.setObjectName("label_17")
self.label_18 = QtGui.QLabel(self.tab_4)
self.label_18.setGeometry(QtCore.QRect(10, 250, 61, 20))
self.label_18.setObjectName("label_18")
self.label_19 = QtGui.QLabel(self.tab_4)
self.label_19.setGeometry(QtCore.QRect(10, 290, 61, 20))
self.label_19.setObjectName("label_19")
self.label_20 = QtGui.QLabel(self.tab_4)
self.label_20.setGeometry(QtCore.QRect(10, 270, 61, 20))
self.label_20.setObjectName("label_20")
self.label_21 = QtGui.QLabel(self.tab_4)
self.label_21.setGeometry(QtCore.QRect(10, 310, 61, 20))
self.label_21.setObjectName("label_21")
self.ts = QtGui.QSpinBox(self.tab_4)
self.ts.setGeometry(QtCore.QRect(60, 170, 42, 22))
self.ts.setMinimum(1)
self.ts.setMaximum(30)
self.ts.setObjectName("ts")
self.np = QtGui.QSpinBox(self.tab_4)
self.np.setGeometry(QtCore.QRect(60, 190, 42, 22))
self.np.setMinimum(1)
self.np.setObjectName("np")
self.nstart = QtGui.QSpinBox(self.tab_4)
self.nstart.setGeometry(QtCore.QRect(60, 210, 42, 22))
self.nstart.setMinimum(1)
self.nstart.setObjectName("nstart")
self.nN = QtGui.QSpinBox(self.tab_4)
self.nN.setGeometry(QtCore.QRect(60, 230, 42, 22))
self.nN.setMinimum(1)
self.nN.setMaximum(30)
self.nN.setObjectName("nN")
self.nelit = QtGui.QSpinBox(self.tab_4)
self.nelit.setGeometry(QtCore.QRect(60, 270, 42, 22))
self.nelit.setMinimum(1)
self.nelit.setObjectName("nelit")
self.nT = QtGui.QSpinBox(self.tab_4)
self.nT.setGeometry(QtCore.QRect(60, 250, 42, 22))
self.nT.setMinimum(1)
self.nT.setObjectName("nT")
self.nrun = QtGui.QSpinBox(self.tab_4)
self.nrun.setGeometry(QtCore.QRect(60, 290, 42, 22))
self.nrun.setMinimum(10)
self.nrun.setMaximum(50)
self.nrun.setObjectName("nrun")
self.nmax = QtGui.QSpinBox(self.tab_4)
self.nmax.setGeometry(QtCore.QRect(60, 310, 42, 22))
self.nmax.setMinimum(1)
self.nmax.setMaximum(50000)
self.nmax.setObjectName("nmax")
self.label_22 = QtGui.QLabel(self.tab_4)
self.label_22.setGeometry(QtCore.QRect(160, 170, 61, 20))
self.label_22.setObjectName("label_22")
self.label_23 = QtGui.QLabel(self.tab_4)
self.label_23.setGeometry(QtCore.QRect(160, 190, 61, 20))
self.label_23.setObjectName("label_23")
self.label_24 = QtGui.QLabel(self.tab_4)
self.label_24.setGeometry(QtCore.QRect(160, 210, 61, 20))
self.label_24.setObjectName("label_24")
self.label_25 = QtGui.QLabel(self.tab_4)
self.label_25.setGeometry(QtCore.QRect(160, 230, 61, 20))
self.label_25.setObjectName("label_25")
self.label_26 = QtGui.QLabel(self.tab_4)
self.label_26.setGeometry(QtCore.QRect(160, 250, 61, 20))
self.label_26.setObjectName("label_26")
self.wp = QtGui.QSpinBox(self.tab_4)
self.wp.setGeometry(QtCore.QRect(180, 170, 42, 22))
self.wp.setMinimum(1)
self.wp.setMaximum(20)
self.wp.setObjectName("wp")
self.wn = QtGui.QSpinBox(self.tab_4)
self.wn.setGeometry(QtCore.QRect(180, 190, 42, 22))
self.wn.setMinimum(1)
self.wn.setMaximum(20)
self.wn.setObjectName("wn")
self.wc = QtGui.QSpinBox(self.tab_4)
self.wc.setGeometry(QtCore.QRect(180, 210, 42, 22))
self.wc.setMinimum(1)
self.wc.setMaximum(20)
self.wc.setObjectName("wc")
self.wf = QtGui.QSpinBox(self.tab_4)
self.wf.setGeometry(QtCore.QRect(180, 230, 42, 22))
self.wf.setMinimum(1)
self.wf.setMaximum(15)
self.wf.setObjectName("wf")
self.f0 = QtGui.QSpinBox(self.tab_4)
self.f0.setGeometry(QtCore.QRect(180, 250, 42, 22))
self.f0.setMaximum(10)
self.f0.setObjectName("f0")
self.window_CYK.addTab(self.tab_4, "")
self.tab_5 = QtGui.QWidget()
self.tab_5.setObjectName("tab_5")
self.label_27 = QtGui.QLabel(self.tab_5)
self.label_27.setGeometry(QtCore.QRect(110, 60, 281, 21))
self.label_27.setObjectName("label_27")
self.label_28 = QtGui.QLabel(self.tab_5)
self.label_28.setGeometry(QtCore.QRect(110, 140, 181, 16))
self.label_28.setObjectName("label_28")
self.button_ok = QtGui.QPushButton(self.tab_5)
self.button_ok.setGeometry(QtCore.QRect(120, 220, 80, 27))
self.button_ok.setObjectName("button_ok")
self.label_29 = QtGui.QLabel(self.tab_5)
self.label_29.setGeometry(QtCore.QRect(110, 170, 181, 21))
self.label_29.setObjectName("label_29")
self.button_anuluj = QtGui.QPushButton(self.tab_5)
self.button_anuluj.setGeometry(QtCore.QRect(230, 220, 80, 27))
self.button_anuluj.setObjectName("button_anuluj")
self.patter = QtGui.QLineEdit(self.tab_5)
self.patter.setGeometry(QtCore.QRect(110, 80, 271, 21))
self.patter.setObjectName("patter")
self.min_lenght = QtGui.QSpinBox(self.tab_5)
self.min_lenght.setGeometry(QtCore.QRect(330, 140, 54, 23))
self.min_lenght.setObjectName("min_lenght")
self.max_lenght = QtGui.QSpinBox(self.tab_5)
self.max_lenght.setGeometry(QtCore.QRect(330, 110, 54, 21))
self.max_lenght.setObjectName("max_lenght")
self.collection_size = QtGui.QSpinBox(self.tab_5)
self.collection_size.setGeometry(QtCore.QRect(330, 170, 54, 23))
self.collection_size.setObjectName("collection_size")
self.label_30 = QtGui.QLabel(self.tab_5)
self.label_30.setGeometry(QtCore.QRect(110, 110, 181, 21))
self.label_30.setObjectName("label_30")
self.window_CYK.addTab(self.tab_5, "")
self.start_GLBS = QtGui.QPushButton(self.centralwidget)
self.start_GLBS.setGeometry(QtCore.QRect(10, 60, 121, 31))
self.start_GLBS.setObjectName("start_GLBS")
self.Pause = QtGui.QPushButton(self.centralwidget)
self.Pause.setGeometry(QtCore.QRect(10, 100, 121, 31))
self.Pause.setObjectName("Pause")
self.params = QtGui.QPushButton(self.centralwidget)
self.params.setGeometry(QtCore.QRect(10, 140, 121, 31))
self.params.setObjectName("params")
self.open_file = QtGui.QPushButton(self.centralwidget)
self.open_file.setGeometry(QtCore.QRect(10, 20, 121, 31))
self.open_file.setObjectName("open_file")
self.Koniec = QtGui.QPushButton(self.centralwidget)
self.Koniec.setGeometry(QtCore.QRect(10, 510, 121, 31))
self.Koniec.setObjectName("Koniec")
self.change_word = QtGui.QPushButton(self.centralwidget)
self.change_word.setGeometry(QtCore.QRect(10, 180, 121, 31))
self.change_word.setObjectName("change_word")
self.create_test = QtGui.QPushButton(self.centralwidget)
self.create_test.setGeometry(QtCore.QRect(10, 220, 121, 31))
self.create_test.setObjectName("create_test")
GCS.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(GCS)
self.menubar.setGeometry(QtCore.QRect(0, 0, 821, 22))
self.menubar.setObjectName("menubar")
self.menuOpcje = QtGui.QMenu(self.menubar)
self.menuOpcje.setObjectName("menuOpcje")
self.menuAbout = QtGui.QMenu(self.menubar)
self.menuAbout.setObjectName("menuAbout")
GCS.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(GCS)
self.statusbar.setObjectName("statusbar")
GCS.setStatusBar(self.statusbar)
self.toolBar = QtGui.QToolBar(GCS)
self.toolBar.setObjectName("toolBar")
GCS.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.toolBar_2 = QtGui.QToolBar(GCS)
self.toolBar_2.setObjectName("toolBar_2")
GCS.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar_2)
self.actionWczytaj_Dane = QtGui.QAction(GCS)
self.actionWczytaj_Dane.setObjectName("actionWczytaj_Dane")
self.menuOpcje.addAction(self.actionWczytaj_Dane)
self.menubar.addAction(self.menuOpcje.menuAction())
self.menubar.addAction(self.menuAbout.menuAction())
self.retranslateUi(GCS)
self.window_CYK.setCurrentIndex(4)
QtCore.QObject.connect(self.Koniec, QtCore.SIGNAL("clicked()"), GCS.close)
QtCore.QMetaObject.connectSlotsByName(GCS)
def retranslateUi(self, GCS):
GCS.setWindowTitle(QtGui.QApplication.translate("GCS", "MainWindow", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab), QtGui.QApplication.translate("GCS", "Tab 1", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_2), QtGui.QApplication.translate("GCS", "Tab 2", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_3), QtGui.QApplication.translate("GCS", "Strona", None, QtGui.QApplication.UnicodeUTF8))
self.label.setText(QtGui.QApplication.translate("GCS", "Liczba pętli", None, QtGui.QApplication.UnicodeUTF8))
self.propertiesAccept.setText(QtGui.QApplication.translate("GCS", "Akceptuj", None, QtGui.QApplication.UnicodeUTF8))
self.propertiesCancel.setText(QtGui.QApplication.translate("GCS", "Anuluj", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate("GCS", "Pk", None, QtGui.QApplication.UnicodeUTF8))
self.label_3.setText(QtGui.QApplication.translate("GCS", "Pm", None, QtGui.QApplication.UnicodeUTF8))
self.label_4.setText(QtGui.QApplication.translate("GCS", "Pi", None, QtGui.QApplication.UnicodeUTF8))
self.label_5.setText(QtGui.QApplication.translate("GCS", "Pa", None, QtGui.QApplication.UnicodeUTF8))
self.label_6.setText(QtGui.QApplication.translate("GCS", "Ogólne:", None, QtGui.QApplication.UnicodeUTF8))
self.label_7.setText(QtGui.QApplication.translate("GCS", "Algorytm gentyczny:", None, QtGui.QApplication.UnicodeUTF8))
self.label_8.setText(QtGui.QApplication.translate("GCS", "Algorytm ścisku:", None, QtGui.QApplication.UnicodeUTF8))
self.label_9.setText(QtGui.QApplication.translate("GCS", "cf", None, QtGui.QApplication.UnicodeUTF8))
self.label_10.setText(QtGui.QApplication.translate("GCS", "cs", None, QtGui.QApplication.UnicodeUTF8))
self.label_11.setText(QtGui.QApplication.translate("GCS", "ba", None, QtGui.QApplication.UnicodeUTF8))
self.label_12.setText(QtGui.QApplication.translate("GCS", "raf", None, QtGui.QApplication.UnicodeUTF8))
self.label_13.setText(QtGui.QApplication.translate("GCS", "Pozostałe:", None, QtGui.QApplication.UnicodeUTF8))
self.label_14.setText(QtGui.QApplication.translate("GCS", "ts", None, QtGui.QApplication.UnicodeUTF8))
self.label_15.setText(QtGui.QApplication.translate("GCS", "np", None, QtGui.QApplication.UnicodeUTF8))
self.label_16.setText(QtGui.QApplication.translate("GCS", "nstart", None, QtGui.QApplication.UnicodeUTF8))
self.label_17.setText(QtGui.QApplication.translate("GCS", "nN", None, QtGui.QApplication.UnicodeUTF8))
self.label_18.setText(QtGui.QApplication.translate("GCS", "nT", None, QtGui.QApplication.UnicodeUTF8))
self.label_19.setText(QtGui.QApplication.translate("GCS", "nrun", None, QtGui.QApplication.UnicodeUTF8))
self.label_20.setText(QtGui.QApplication.translate("GCS", "nelit", None, QtGui.QApplication.UnicodeUTF8))
self.label_21.setText(QtGui.QApplication.translate("GCS", "nmax", None, QtGui.QApplication.UnicodeUTF8))
self.label_22.setText(QtGui.QApplication.translate("GCS", "wp", None, QtGui.QApplication.UnicodeUTF8))
self.label_23.setText(QtGui.QApplication.translate("GCS", "wn", None, QtGui.QApplication.UnicodeUTF8))
self.label_24.setText(QtGui.QApplication.translate("GCS", "wc", None, QtGui.QApplication.UnicodeUTF8))
self.label_25.setText(QtGui.QApplication.translate("GCS", "wf", None, QtGui.QApplication.UnicodeUTF8))
self.label_26.setText(QtGui.QApplication.translate("GCS", "f0", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_4), QtGui.QApplication.translate("GCS", "Strona", None, QtGui.QApplication.UnicodeUTF8))
self.label_27.setText(QtGui.QApplication.translate("GCS", "Podaj wzór gramatyki w formacie a^n*b^n:", None, QtGui.QApplication.UnicodeUTF8))
self.label_28.setText(QtGui.QApplication.translate("GCS", "minimalna dlugosc zdania:", None, QtGui.QApplication.UnicodeUTF8))
self.button_ok.setText(QtGui.QApplication.translate("GCS", "OK", None, QtGui.QApplication.UnicodeUTF8))
self.label_29.setText(QtGui.QApplication.translate("GCS", "ilosc zdan uczacych:", None, QtGui.QApplication.UnicodeUTF8))
self.button_anuluj.setText(QtGui.QApplication.translate("GCS", "Anuluj", None, QtGui.QApplication.UnicodeUTF8))
self.label_30.setText(QtGui.QApplication.translate("GCS", "maksymalna dlugosc zdania:", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_5), QtGui.QApplication.translate("GCS", "Strona", None, QtGui.QApplication.UnicodeUTF8))
self.start_GLBS.setText(QtGui.QApplication.translate("GCS", "Start", None, QtGui.QApplication.UnicodeUTF8))
self.Pause.setText(QtGui.QApplication.translate("GCS", "Pause", None, QtGui.QApplication.UnicodeUTF8))
self.params.setText(QtGui.QApplication.translate("GCS", "Zmień parametry", None, QtGui.QApplication.UnicodeUTF8))
self.open_file.setText(QtGui.QApplication.translate("GCS", "Wczytaj plik", None, QtGui.QApplication.UnicodeUTF8))
self.Koniec.setText(QtGui.QApplication.translate("GCS", "Koniec", None, QtGui.QApplication.UnicodeUTF8))
self.change_word.setText(QtGui.QApplication.translate("GCS", "Następny krok", None, QtGui.QApplication.UnicodeUTF8))
self.create_test.setText(QtGui.QApplication.translate("GCS", "Generuj zdania", None, QtGui.QApplication.UnicodeUTF8))
self.menuOpcje.setTitle(QtGui.QApplication.translate("GCS", "Opcje", None, QtGui.QApplication.UnicodeUTF8))
self.menuAbout.setTitle(QtGui.QApplication.translate("GCS", "About", None, QtGui.QApplication.UnicodeUTF8))
self.toolBar.setWindowTitle(QtGui.QApplication.translate("GCS", "toolBar", None, QtGui.QApplication.UnicodeUTF8))
self.toolBar_2.setWindowTitle(QtGui.QApplication.translate("GCS", "toolBar_2", None, QtGui.QApplication.UnicodeUTF8))
self.actionWczytaj_Dane.setText(QtGui.QApplication.translate("GCS", "Wczytaj Dane", None, QtGui.QApplication.UnicodeUTF8))
| Python |
#-*- coding: utf-8 -*-
import sys, string, random
from CYK_new import gramatyka
from properties import properties
from PyQt4 import QtCore, QtGui
from okno_new import Ui_GCS
from gen_learning import tasks_generator
from genetyk import genetyk
class MyForm(QtGui.QMainWindow):
#definicja zmiennych :
word = "1aabb"
#G.setProperties(parametry)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.dialogTasks = tasks_generator(self)
self.ui = Ui_GCS()
self.parametry = properties()
self.testingWords = []
self.ui.setupUi(self)
self.G = gramatyka()
self.genetyk = genetyk(self.G,self.parametry)
self.fileIndex = 0
#self.ui.window_CYK.addTab(self.genTabCYK())
print "tutaj gramtyka na okno idzie:"
self.ui.window_grammar.setText(self.G.getGramarStr())
#ustawianie polaczen:
#wystartowanie algorytmu:
QtCore.QObject.connect(self.ui.start_GLBS, QtCore.SIGNAL("clicked()"),self.genTabCYK)
#otwieranie pliku
QtCore.QObject.connect(self.ui.menuOpcje, QtCore.SIGNAL("clicked()"),self.openFile)
#puusty przycis narazie
#QtCore.QObject.connect(self.ui.change_word,QtCore.SIGNAL("clicked()"),self.changeWord)
#otwieranie pliku:
QtCore.QObject.connect(self.ui.open_file, QtCore.SIGNAL("clicked()"),self.openFile)
#nastepny krok
QtCore.QObject.connect(self.ui.change_word,QtCore.SIGNAL("clicked()"),self.readLine)
#popranie danych z formularza zmiennych, jeszcze sa tam jakies braki!!
QtCore.QObject.connect(self.ui.propertiesAccept,QtCore.SIGNAL("clicked()"),self.getProperties)
#generowanie zdan uczacych button:
QtCore.QObject.connect(self.ui.create_test,QtCore.SIGNAL("clicked()"),self.generate_tasks)
#anulowanie wprowadzanych preferenci
QtCore.QObject.connect(self.ui.propertiesCancel,QtCore.SIGNAL("clicked()"),self.cancelProperties)
#QtCore.QObject.connect(self.ui.change_word,QtCore.SIGNAL("clicked()"),self.readLine)
self.cancelProperties()
def genTabCYK(self):
''' metoda bedzie odpowiadac za petle główna porgramu'''
print "w GCS ie"
#odświerzenie widoku gramatyki:
self.parsKit()
print "selekcja ruletkowa:"
self.genetyk.makeGen()
self.ui.window_grammar.setText(self.G.getGramarStr())
print "koniec done!"
def readLine(self):
if self.fileIndex == len(self.testingWords) -1:
self.fileIndex = 0
self.G.countFitness()
self.fileIndex += 1
x=self.fileIndex
self.word = self.testingWords[self.fileIndex]
self.ui.window_cyk.setText(self.testingWords[self.fileIndex])
result = self.G.CYK(self.testingWords[self.fileIndex])
if result is int:
return 0
self.G.countProfit(result,len(self.testingWords[x])-1,self.testingWords[x][0])
self.ui.window_grammar.setText(self.G.getGramarStr())
def parsKit(self):
'''metoda bedzie parsowac jeden zestaw uczący'''
#robimy kopie zapasową gramatyki:
good = 0
bad = 0
poprawnie = 0
nie = 0
self.G.makeBackUp()
self.G.allowCover = 1
#parsowanie zdań:
self.G.allowFulCover = 1
x =1
while 1:
print "liczymy dla:" + self.testingWords[x]
#tutaj robimy CYK
result = self.G.CYK(self.testingWords[x])
if result == -10:
#przerwanie, reset z powodu zastosowania pokrycia:
print "reset"
x = 1
good = 0
bad = 0
poprawnie = 0
nie = 0
continue
#jak się skończy to liczymy p i d jeszcze czyba u by trzeba bylo:
self.G.countProfit(result,len(self.testingWords[x])-2,self.testingWords[x][0])
if result == 1:
good += 1
else:
bad += 1
if result == int(self.testingWords[x][0]):
poprawnie += 1
else:
nie += 1
x+=1
if x >= len(self.testingWords):
break
self.ui.window_cyk.setText("sparsowane %d, nie sparsowane %d, poprawnie %d nie poprawnie %d wspony"%(good,bad,poprawnie,nie))
self.G.countFitness()
return 0
def showDict(self):
self.ui.okno_gl.setText(str(self.G.G))
def changeWord(self):
pass
def openFile(self):
''' metoda otwiera wskazany plik, i wyswietla'''
tmp = ''
fd = QtGui.QFileDialog(self)
self.filename = fd.getOpenFileName()
from os.path import isfile
if isfile(self.filename):
for x in open(self.filename):
self.testingWords.append(x[:len(x)-1])
self.editFile()
for x in self.testingWords:
tmp+=x + "\n" #+" len: " + str(len(x)) + "\n"
self.ui.window_file.setText(tmp)
def editFile(self):
for x in range(0,len(self.testingWords)):
#tmp = self.testingWords[x][0]
self.testingWords[x] = self.testingWords[x][0]+self.testingWords[x][self.testingWords[x][2:].find(" ")+3:]
#usuwanie spacji:
while self.testingWords[x].find(" ") > 0:
k = self.testingWords[x].find(" ")
self.testingWords[x]=self.testingWords[x][:k]+self.testingWords[x][k+1:]
self.testingWords[x]=self.testingWords[x].rstrip()
def getProperties(self):
'''metoda ma za zadanie zczytywanie zmiennych, ale nie wiem jak z qwidegta pobrac dane'''
self.G.parametry.ba = self.ui.ba.value()
self.G.parametry.cf = self.ui.cf.value()
self.G.parametry.cs = self.ui.cs.value()
self.G.parametry.nelit = self.ui.nelit.value()
self.G.parametry.nmax = self.ui.nmax.value()
self.G.parametry.nN = self.ui.nN.value()
self.G.parametry.np = self.ui.np.value()
self.G.parametry.nrun = self.ui.nrun.value()
self.G.parametry.nstart = self.ui.nstart.value()
self.G.parametry.nT = self.ui.nT.value()
self.G.parametry.Pa = self.ui.Pa.value()
self.G.parametry.Pi = self.ui.Pi.value()
self.G.parametry.Pk= self.ui.Pk.value()
self.G.parametry.Pm= self.ui.Pm.value()
self.G.parametry.raf= self.ui.raf.value()
self.G.parametry.ts= self.ui.ts.value()
self.G.parametry.wc= self.ui.wc.value()
self.G.parametry.wf= self.ui.wf.value()
self.G.parametry.wn= self.ui.wn.value()
self.G.parametry.wp= self.ui.wp.value()
self.G.parametry.f0= self.ui.f0.value()
self.genetyk.updateProperies(self.G.parametry)
#self.ui.okno_gl.setText(str(self.ui.ba))
#self.ui.window_cyk.setText(str(self.parametry.ba))
def cancelProperties(self):
'''metoda ma za zadanie przywrocenie starych danych do formularza w przypadku wcisniecia "anuluj"'''
self.ui.ba.setValue(self.G.parametry.ba)
self.ui.cf.setValue(self.G.parametry.cf)
self.ui.cs.setValue(self.G.parametry.cs)
self.ui.nelit.setValue(self.G.parametry.nelit)
self.ui.nmax.setValue(self.G.parametry.nmax)
self.ui.nN.setValue(self.G.parametry.nN)
self.ui.np.setValue(self.G.parametry.np)
self.ui.nrun.setValue(self.G.parametry.nrun)
self.ui.nstart.setValue(self.G.parametry.nstart)
self.ui.nT.setValue(self.G.parametry.nT)
self.ui.Pa.setValue(self.G.parametry.Pa)
self.ui.Pi.setValue(self.G.parametry.Pi)
self.ui.Pk.setValue(self.G.parametry.Pk)
self.ui.Pm.setValue(self.G.parametry.Pm)
self.ui.raf.setValue(self.G.parametry.raf)
self.ui.ts.setValue(self.G.parametry.ts)
self.ui.wc.setValue(self.G.parametry.wc)
self.ui.wf.setValue(self.G.parametry.wf)
self.ui.wn.setValue(self.G.parametry.wn)
self.ui.wp.setValue(self.G.parametry.wp)
self.ui.f0.setValue(self.G.parametry.f0)
def generate_tasks(self):
print "a se kliklem se"
self.dialogTasks.show()
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = MyForm()
myapp.show()
sys.exit(app.exec_())
| Python |
import sys, string
from PyQt4 import QtCore, QtGui
from CYK import gramatyka
from okno import Ui_CYK
class MyForm(QtGui.QMainWindow):
#definicja zmiennych :
word = "aaaaabbbbsss"
G = gramatyka()
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_CYK()
self.ui.setupUi(self)
# definiuke wlasne polaczenie slotow:
#QtCore.QObject.connect(self.ui.button_open,QtCore.SIGNAL("clicked()"), self.file_dialog)
#dodanie slowa:
QtCore.QObject.connect(self.ui.dodaj_slowo,QtCore.SIGNAL("clicked()"),self.addWord)
#generacja tablicy CYK:
QtCore.QObject.connect(self.ui.generujTabCYK,QtCore.SIGNAL("clicked()"),self.genTabCYK)
#pokaz slownik:
QtCore.QObject.connect(self.ui.show_dict,QtCore.SIGNAL("clicked()"),self.showDict)
def addWord(self):
self.word=self.ui.slowo.toPlainText()
self.ui.okno_gl.setText(self.word)
def genTabCYK(self):
table = self.G.CYK(str(self.word))
tmp = "slowo: \t %s \n"%(self.word)
for x in table:
tmp += str(x)+"\n"
self.ui.okno_gl.setText(tmp)
def showDict(self):
self.ui.okno_gl.setText(str(self.G.G))
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = MyForm()
myapp.show()
sys.exit(app.exec_())
| Python |
#-*- coding: utf-8 -*-
class classifier():
'''klasa bedzie representowac klasyfikator w systemie'''
def __init__(self,name, left):
#prawa strona kalsyfikatora
self.left = left;
self.right = name
'''ilosc uzyc jest realizowana za pomoca tablicy
u[0] -> ilosc uzyc klasyfikatora przy parsowaniu zdania niepoprawnego
u[1] -> ilosc uzyc klasyfikatora przy parsowaniu zdania poprawnego'''
#ilosc poprawnych uzyc
self.u = []
self.u.append(0.0)
#ilosc niepoprawnych uzyc
self.u.append(0.0)
#co to bylo ??;), czy mam to updejtowac dopiero po rozbiorze?
self.p = 0.0
self.d =0.0
self.r1 = 0.0
self.r2 = 0.0
self.fitness = 0.0
def __len__(self):
return len(self.right)
def __repr__(self):
return self.left +"-->" + self.right
def compare(self,other):
''' metoda porównuje dwa klasyfikaotry jak u GCS'''
result = 0
if self.left == other.left:
result += 1
for x in range(0,len(self.right)):
try:
if self.right[x] == other.right[x]:
result += 1
except:
pass
return result
def resetParams(self):
''' resetuje paramtery classyfikatora'''
self.u[0] = 0
self.u[1] = 0
#co to bylo ??;), czy mam to updejtowac dopiero po rozbiorze?
self.p = 0.0
self.d =0.0
self.fitness = 0.0
#def __cmp__(self,other):
#result = 0
#if self.left == other.left:
#result += 1
#for x in range(0,len(self.right)-1):
#if self.rigt[x] == other.right[x]:
#result += 1
#return result
def setName(self,name):
self.right=name
def setLeft(self,left):
self.left=left
def getRight(self):
return self.right
def addPoints(self, poprawnosc):
'''dodanie opdpowiednio punktow do odpowiednieo parametru u'''
self.u[poprawnosc] =self.u[poprawnosc]+1
def getClassifierStrExt(self):
return self.left + "--->" + self.right +"\t"+"un= "+str(self.u[0])+"\t"+"up="+str(self.u[1])+"\t fitnes"+str(self.fitness)+ " p i d "+"("+str(self.p)+","+str(self.d)+")"+ '\n'
#" r1 "+str( self.r1)+" r2 "+str(self.r2)+"\n"
def getClassifierStr(self):
return self.left + "--->" + self.right | Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'popup.ui'
#
# Created: Mon Sep 7 11:37:15 2009
# by: PyQt4 UI code generator 4.4.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_Dialog(object):
def setupUi(self, Dialog):
Dialog.setObjectName("Dialog")
Dialog.resize(480, 168)
self.komunikat = QtGui.QLabel(Dialog)
self.komunikat.setGeometry(QtCore.QRect(30, 30, 561, 71))
self.komunikat.setObjectName("komunikat")
self.buttonOK = QtGui.QPushButton(Dialog)
self.buttonOK.setGeometry(QtCore.QRect(190, 120, 80, 28))
self.buttonOK.setObjectName("buttonOK")
self.retranslateUi(Dialog)
QtCore.QMetaObject.connectSlotsByName(Dialog)
def retranslateUi(self, Dialog):
Dialog.setWindowTitle(QtGui.QApplication.translate("Dialog", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
self.komunikat.setText(QtGui.QApplication.translate("Dialog", "TextLabel", None, QtGui.QApplication.UnicodeUTF8))
self.buttonOK.setText(QtGui.QApplication.translate("Dialog", "OK", None, QtGui.QApplication.UnicodeUTF8))
| Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'task_generate.ui'
#
# Created: Mon Jul 20 22:22:57 2009
# by: PyQt4 UI code generator 4.4.3
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_Anuluj(object):
def setupUi(self, Anuluj):
Anuluj.setObjectName("Anuluj")
Anuluj.resize(352, 206)
self.button_ok = QtGui.QPushButton(Anuluj)
self.button_ok.setGeometry(QtCore.QRect(30, 170, 80, 27))
self.button_ok.setObjectName("button_ok")
self.button_anuluj = QtGui.QPushButton(Anuluj)
self.button_anuluj.setGeometry(QtCore.QRect(140, 170, 80, 27))
self.button_anuluj.setObjectName("button_anuluj")
self.patter = QtGui.QLineEdit(Anuluj)
self.patter.setGeometry(QtCore.QRect(20, 30, 271, 21))
self.patter.setObjectName("patter")
self.max_lenght = QtGui.QSpinBox(Anuluj)
self.max_lenght.setGeometry(QtCore.QRect(240, 90, 54, 21))
self.max_lenght.setObjectName("max_lenght")
self.min_lenght = QtGui.QSpinBox(Anuluj)
self.min_lenght.setGeometry(QtCore.QRect(240, 120, 54, 23))
self.min_lenght.setObjectName("min_lenght")
self.collection_size = QtGui.QSpinBox(Anuluj)
self.collection_size.setGeometry(QtCore.QRect(240, 150, 54, 23))
self.collection_size.setObjectName("collection_size")
self.label = QtGui.QLabel(Anuluj)
self.label.setGeometry(QtCore.QRect(20, 10, 281, 21))
self.label.setObjectName("label")
self.label_2 = QtGui.QLabel(Anuluj)
self.label_2.setGeometry(QtCore.QRect(20, 90, 181, 21))
self.label_2.setObjectName("label_2")
self.label_3 = QtGui.QLabel(Anuluj)
self.label_3.setGeometry(QtCore.QRect(20, 120, 181, 16))
self.label_3.setObjectName("label_3")
self.label_4 = QtGui.QLabel(Anuluj)
self.label_4.setGeometry(QtCore.QRect(20, 150, 181, 21))
self.label_4.setObjectName("label_4")
self.label_error = QtGui.QLabel(Anuluj)
self.label_error.setGeometry(QtCore.QRect(20, 60, 271, 16))
self.label_error.setObjectName("label_error")
self.retranslateUi(Anuluj)
QtCore.QMetaObject.connectSlotsByName(Anuluj)
def retranslateUi(self, Anuluj):
Anuluj.setWindowTitle(QtGui.QApplication.translate("Anuluj", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
self.button_ok.setText(QtGui.QApplication.translate("Anuluj", "OK", None, QtGui.QApplication.UnicodeUTF8))
self.button_anuluj.setText(QtGui.QApplication.translate("Anuluj", "Anuluj", None, QtGui.QApplication.UnicodeUTF8))
self.label.setText(QtGui.QApplication.translate("Anuluj", "Podaj wzór gramatyki w formacie a^n*b^n:", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate("Anuluj", "maksymalna dlugosc zdania:", None, QtGui.QApplication.UnicodeUTF8))
self.label_3.setText(QtGui.QApplication.translate("Anuluj", "minimalna dlugosc zdania:", None, QtGui.QApplication.UnicodeUTF8))
self.label_4.setText(QtGui.QApplication.translate("Anuluj", "ilosc zdan uczacych:", None, QtGui.QApplication.UnicodeUTF8))
| Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'okno_new.ui'
#
# Created: Tue Sep 8 23:53:05 2009
# by: PyQt4 UI code generator 4.4.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_GCS(object):
def setupUi(self, GCS):
GCS.setObjectName("GCS")
GCS.resize(821, 646)
self.centralwidget = QtGui.QWidget(GCS)
self.centralwidget.setObjectName("centralwidget")
self.window_CYK = QtGui.QTabWidget(self.centralwidget)
self.window_CYK.setGeometry(QtCore.QRect(150, 20, 631, 491))
self.window_CYK.setObjectName("window_CYK")
self.tab = QtGui.QWidget()
self.tab.setObjectName("tab")
self.window_cyk = QtGui.QTextBrowser(self.tab)
self.window_cyk.setGeometry(QtCore.QRect(0, 0, 631, 471))
self.window_cyk.setObjectName("window_cyk")
self.window_CYK.addTab(self.tab, "")
self.tab_2 = QtGui.QWidget()
self.tab_2.setObjectName("tab_2")
self.window_grammar = QtGui.QTextBrowser(self.tab_2)
self.window_grammar.setGeometry(QtCore.QRect(0, 0, 631, 471))
self.window_grammar.setObjectName("window_grammar")
self.window_CYK.addTab(self.tab_2, "")
self.tab_3 = QtGui.QWidget()
self.tab_3.setObjectName("tab_3")
self.window_file = QtGui.QTextBrowser(self.tab_3)
self.window_file.setGeometry(QtCore.QRect(0, 0, 631, 471))
self.window_file.setObjectName("window_file")
self.window_CYK.addTab(self.tab_3, "")
self.tab_4 = QtGui.QWidget()
self.tab_4.setObjectName("tab_4")
self.numberOfLoops = QtGui.QSpinBox(self.tab_4)
self.numberOfLoops.setGeometry(QtCore.QRect(70, 30, 42, 22))
self.numberOfLoops.setMaximum(10000)
self.numberOfLoops.setProperty("value", QtCore.QVariant(1))
self.numberOfLoops.setObjectName("numberOfLoops")
self.label = QtGui.QLabel(self.tab_4)
self.label.setGeometry(QtCore.QRect(10, 30, 61, 20))
self.label.setObjectName("label")
self.propertiesAccept = QtGui.QPushButton(self.tab_4)
self.propertiesAccept.setGeometry(QtCore.QRect(540, 430, 75, 23))
self.propertiesAccept.setObjectName("propertiesAccept")
self.propertiesCancel = QtGui.QPushButton(self.tab_4)
self.propertiesCancel.setGeometry(QtCore.QRect(450, 430, 75, 23))
self.propertiesCancel.setObjectName("propertiesCancel")
self.label_2 = QtGui.QLabel(self.tab_4)
self.label_2.setGeometry(QtCore.QRect(150, 30, 61, 20))
self.label_2.setObjectName("label_2")
self.label_3 = QtGui.QLabel(self.tab_4)
self.label_3.setGeometry(QtCore.QRect(150, 50, 61, 20))
self.label_3.setObjectName("label_3")
self.label_4 = QtGui.QLabel(self.tab_4)
self.label_4.setGeometry(QtCore.QRect(150, 70, 61, 20))
self.label_4.setObjectName("label_4")
self.label_5 = QtGui.QLabel(self.tab_4)
self.label_5.setGeometry(QtCore.QRect(150, 90, 61, 20))
self.label_5.setObjectName("label_5")
self.Pk = QtGui.QDoubleSpinBox(self.tab_4)
self.Pk.setGeometry(QtCore.QRect(180, 30, 62, 22))
self.Pk.setDecimals(2)
self.Pk.setMaximum(1.0)
self.Pk.setSingleStep(0.01)
self.Pk.setProperty("value", QtCore.QVariant(0.0))
self.Pk.setObjectName("Pk")
self.Pm = QtGui.QDoubleSpinBox(self.tab_4)
self.Pm.setGeometry(QtCore.QRect(180, 50, 62, 22))
self.Pm.setMaximum(1.0)
self.Pm.setSingleStep(0.01)
self.Pm.setObjectName("Pm")
self.Pi = QtGui.QDoubleSpinBox(self.tab_4)
self.Pi.setGeometry(QtCore.QRect(180, 70, 62, 22))
self.Pi.setMaximum(1.0)
self.Pi.setSingleStep(0.01)
self.Pi.setObjectName("Pi")
self.Pa = QtGui.QDoubleSpinBox(self.tab_4)
self.Pa.setGeometry(QtCore.QRect(180, 90, 62, 22))
self.Pa.setMaximum(1.0)
self.Pa.setSingleStep(0.01)
self.Pa.setObjectName("Pa")
self.label_6 = QtGui.QLabel(self.tab_4)
self.label_6.setGeometry(QtCore.QRect(10, 10, 61, 20))
self.label_6.setObjectName("label_6")
self.label_7 = QtGui.QLabel(self.tab_4)
self.label_7.setGeometry(QtCore.QRect(130, 10, 111, 20))
self.label_7.setObjectName("label_7")
self.label_8 = QtGui.QLabel(self.tab_4)
self.label_8.setGeometry(QtCore.QRect(270, 10, 111, 20))
self.label_8.setObjectName("label_8")
self.label_9 = QtGui.QLabel(self.tab_4)
self.label_9.setGeometry(QtCore.QRect(270, 30, 61, 20))
self.label_9.setObjectName("label_9")
self.label_10 = QtGui.QLabel(self.tab_4)
self.label_10.setGeometry(QtCore.QRect(270, 50, 61, 20))
self.label_10.setObjectName("label_10")
self.label_11 = QtGui.QLabel(self.tab_4)
self.label_11.setGeometry(QtCore.QRect(270, 70, 61, 20))
self.label_11.setObjectName("label_11")
self.label_12 = QtGui.QLabel(self.tab_4)
self.label_12.setGeometry(QtCore.QRect(270, 90, 61, 20))
self.label_12.setObjectName("label_12")
self.cs = QtGui.QSpinBox(self.tab_4)
self.cs.setGeometry(QtCore.QRect(300, 50, 42, 22))
self.cs.setMinimum(1)
self.cs.setMaximum(30)
self.cs.setObjectName("cs")
self.cf = QtGui.QSpinBox(self.tab_4)
self.cf.setGeometry(QtCore.QRect(300, 30, 42, 22))
self.cf.setMinimum(1)
self.cf.setMaximum(30)
self.cf.setObjectName("cf")
self.ba = QtGui.QSpinBox(self.tab_4)
self.ba.setGeometry(QtCore.QRect(300, 70, 42, 22))
self.ba.setMaximum(15)
self.ba.setObjectName("ba")
self.raf = QtGui.QSpinBox(self.tab_4)
self.raf.setGeometry(QtCore.QRect(300, 90, 42, 22))
self.raf.setMaximum(15)
self.raf.setObjectName("raf")
self.label_13 = QtGui.QLabel(self.tab_4)
self.label_13.setGeometry(QtCore.QRect(10, 150, 61, 20))
self.label_13.setObjectName("label_13")
self.label_14 = QtGui.QLabel(self.tab_4)
self.label_14.setGeometry(QtCore.QRect(10, 170, 61, 20))
self.label_14.setObjectName("label_14")
self.label_15 = QtGui.QLabel(self.tab_4)
self.label_15.setGeometry(QtCore.QRect(10, 190, 61, 20))
self.label_15.setObjectName("label_15")
self.label_16 = QtGui.QLabel(self.tab_4)
self.label_16.setGeometry(QtCore.QRect(10, 210, 61, 20))
self.label_16.setObjectName("label_16")
self.label_17 = QtGui.QLabel(self.tab_4)
self.label_17.setGeometry(QtCore.QRect(10, 230, 61, 20))
self.label_17.setObjectName("label_17")
self.label_18 = QtGui.QLabel(self.tab_4)
self.label_18.setGeometry(QtCore.QRect(10, 250, 61, 20))
self.label_18.setObjectName("label_18")
self.label_19 = QtGui.QLabel(self.tab_4)
self.label_19.setGeometry(QtCore.QRect(10, 290, 61, 20))
self.label_19.setObjectName("label_19")
self.label_20 = QtGui.QLabel(self.tab_4)
self.label_20.setGeometry(QtCore.QRect(10, 270, 61, 20))
self.label_20.setObjectName("label_20")
self.label_21 = QtGui.QLabel(self.tab_4)
self.label_21.setGeometry(QtCore.QRect(10, 310, 61, 20))
self.label_21.setObjectName("label_21")
self.ts = QtGui.QSpinBox(self.tab_4)
self.ts.setGeometry(QtCore.QRect(60, 170, 42, 22))
self.ts.setMinimum(1)
self.ts.setMaximum(30)
self.ts.setObjectName("ts")
self.np = QtGui.QSpinBox(self.tab_4)
self.np.setGeometry(QtCore.QRect(60, 190, 42, 22))
self.np.setMinimum(1)
self.np.setObjectName("np")
self.nstart = QtGui.QSpinBox(self.tab_4)
self.nstart.setGeometry(QtCore.QRect(60, 210, 42, 22))
self.nstart.setMinimum(1)
self.nstart.setObjectName("nstart")
self.nN = QtGui.QSpinBox(self.tab_4)
self.nN.setGeometry(QtCore.QRect(60, 230, 42, 22))
self.nN.setMinimum(1)
self.nN.setMaximum(30)
self.nN.setObjectName("nN")
self.nelit = QtGui.QSpinBox(self.tab_4)
self.nelit.setGeometry(QtCore.QRect(60, 270, 42, 22))
self.nelit.setMinimum(1)
self.nelit.setObjectName("nelit")
self.nT = QtGui.QSpinBox(self.tab_4)
self.nT.setGeometry(QtCore.QRect(60, 250, 42, 22))
self.nT.setMinimum(1)
self.nT.setObjectName("nT")
self.nrun = QtGui.QSpinBox(self.tab_4)
self.nrun.setGeometry(QtCore.QRect(60, 290, 42, 22))
self.nrun.setMinimum(10)
self.nrun.setMaximum(50)
self.nrun.setObjectName("nrun")
self.nmax = QtGui.QSpinBox(self.tab_4)
self.nmax.setGeometry(QtCore.QRect(60, 310, 42, 22))
self.nmax.setMinimum(1)
self.nmax.setMaximum(50000)
self.nmax.setObjectName("nmax")
self.label_22 = QtGui.QLabel(self.tab_4)
self.label_22.setGeometry(QtCore.QRect(160, 170, 61, 20))
self.label_22.setObjectName("label_22")
self.label_23 = QtGui.QLabel(self.tab_4)
self.label_23.setGeometry(QtCore.QRect(160, 190, 61, 20))
self.label_23.setObjectName("label_23")
self.label_24 = QtGui.QLabel(self.tab_4)
self.label_24.setGeometry(QtCore.QRect(160, 210, 61, 20))
self.label_24.setObjectName("label_24")
self.label_25 = QtGui.QLabel(self.tab_4)
self.label_25.setGeometry(QtCore.QRect(160, 230, 61, 20))
self.label_25.setObjectName("label_25")
self.label_26 = QtGui.QLabel(self.tab_4)
self.label_26.setGeometry(QtCore.QRect(160, 250, 61, 20))
self.label_26.setObjectName("label_26")
self.wp = QtGui.QSpinBox(self.tab_4)
self.wp.setGeometry(QtCore.QRect(180, 170, 42, 22))
self.wp.setMinimum(1)
self.wp.setMaximum(20)
self.wp.setObjectName("wp")
self.wn = QtGui.QSpinBox(self.tab_4)
self.wn.setGeometry(QtCore.QRect(180, 190, 42, 22))
self.wn.setMinimum(1)
self.wn.setMaximum(20)
self.wn.setObjectName("wn")
self.wc = QtGui.QSpinBox(self.tab_4)
self.wc.setGeometry(QtCore.QRect(180, 210, 42, 22))
self.wc.setMinimum(1)
self.wc.setMaximum(20)
self.wc.setObjectName("wc")
self.wf = QtGui.QSpinBox(self.tab_4)
self.wf.setGeometry(QtCore.QRect(180, 230, 42, 22))
self.wf.setMinimum(1)
self.wf.setMaximum(15)
self.wf.setObjectName("wf")
self.f0 = QtGui.QSpinBox(self.tab_4)
self.f0.setGeometry(QtCore.QRect(180, 250, 42, 22))
self.f0.setMaximum(10)
self.f0.setObjectName("f0")
self.label_28 = QtGui.QLabel(self.tab_4)
self.label_28.setGeometry(QtCore.QRect(300, 150, 54, 18))
self.label_28.setObjectName("label_28")
self.comboBoxMembership = QtGui.QComboBox(self.tab_4)
self.comboBoxMembership.setGeometry(QtCore.QRect(460, 176, 131, 27))
self.comboBoxMembership.setObjectName("comboBoxMembership")
self.comboBoxMembership.addItem(QtCore.QString())
self.comboBoxMembership.addItem(QtCore.QString())
self.label_29 = QtGui.QLabel(self.tab_4)
self.label_29.setGeometry(QtCore.QRect(300, 180, 131, 18))
self.label_29.setObjectName("label_29")
self.label_30 = QtGui.QLabel(self.tab_4)
self.label_30.setGeometry(QtCore.QRect(300, 214, 131, 18))
self.label_30.setObjectName("label_30")
self.comboBoxUnion = QtGui.QComboBox(self.tab_4)
self.comboBoxUnion.setGeometry(QtCore.QRect(460, 210, 131, 27))
self.comboBoxUnion.setObjectName("comboBoxUnion")
self.comboBoxUnion.addItem(QtCore.QString())
self.label_31 = QtGui.QLabel(self.tab_4)
self.label_31.setGeometry(QtCore.QRect(300, 250, 131, 18))
self.label_31.setObjectName("label_31")
self.comboBoxUnion_2 = QtGui.QComboBox(self.tab_4)
self.comboBoxUnion_2.setGeometry(QtCore.QRect(461, 246, 131, 27))
self.comboBoxUnion_2.setObjectName("comboBoxUnion_2")
self.comboBoxUnion_2.addItem(QtCore.QString())
self.comboBoxUnion_2.addItem(QtCore.QString())
self.comboBoxUnion_2.addItem(QtCore.QString())
self.window_CYK.addTab(self.tab_4, "")
self.start_GLBS = QtGui.QPushButton(self.centralwidget)
self.start_GLBS.setGeometry(QtCore.QRect(10, 60, 121, 31))
self.start_GLBS.setObjectName("start_GLBS")
self.Pause = QtGui.QPushButton(self.centralwidget)
self.Pause.setGeometry(QtCore.QRect(10, 100, 121, 31))
self.Pause.setObjectName("Pause")
self.params = QtGui.QPushButton(self.centralwidget)
self.params.setGeometry(QtCore.QRect(10, 140, 121, 31))
self.params.setObjectName("params")
self.open_file = QtGui.QPushButton(self.centralwidget)
self.open_file.setGeometry(QtCore.QRect(10, 20, 121, 31))
self.open_file.setObjectName("open_file")
self.Koniec = QtGui.QPushButton(self.centralwidget)
self.Koniec.setGeometry(QtCore.QRect(20, 530, 121, 31))
self.Koniec.setObjectName("Koniec")
self.change_word = QtGui.QPushButton(self.centralwidget)
self.change_word.setGeometry(QtCore.QRect(10, 180, 121, 31))
self.change_word.setObjectName("change_word")
self.create_test = QtGui.QPushButton(self.centralwidget)
self.create_test.setGeometry(QtCore.QRect(10, 220, 121, 31))
self.create_test.setObjectName("create_test")
self.progressBar = QtGui.QProgressBar(self.centralwidget)
self.progressBar.setGeometry(QtCore.QRect(150, 530, 661, 23))
self.progressBar.setProperty("value", QtCore.QVariant(0))
self.progressBar.setObjectName("progressBar")
self.label_27 = QtGui.QLabel(self.centralwidget)
self.label_27.setGeometry(QtCore.QRect(160, 510, 181, 18))
self.label_27.setObjectName("label_27")
GCS.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(GCS)
self.menubar.setGeometry(QtCore.QRect(0, 0, 821, 26))
self.menubar.setObjectName("menubar")
self.menuOpcje = QtGui.QMenu(self.menubar)
self.menuOpcje.setObjectName("menuOpcje")
self.menuAbout = QtGui.QMenu(self.menubar)
self.menuAbout.setObjectName("menuAbout")
GCS.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(GCS)
self.statusbar.setObjectName("statusbar")
GCS.setStatusBar(self.statusbar)
self.toolBar = QtGui.QToolBar(GCS)
self.toolBar.setObjectName("toolBar")
GCS.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.toolBar_2 = QtGui.QToolBar(GCS)
self.toolBar_2.setObjectName("toolBar_2")
GCS.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar_2)
self.actionWczytaj_Dane = QtGui.QAction(GCS)
self.actionWczytaj_Dane.setObjectName("actionWczytaj_Dane")
self.menuOpcje.addAction(self.actionWczytaj_Dane)
self.menubar.addAction(self.menuOpcje.menuAction())
self.menubar.addAction(self.menuAbout.menuAction())
self.retranslateUi(GCS)
self.window_CYK.setCurrentIndex(3)
QtCore.QObject.connect(self.Koniec, QtCore.SIGNAL("clicked()"), GCS.close)
QtCore.QMetaObject.connectSlotsByName(GCS)
def retranslateUi(self, GCS):
GCS.setWindowTitle(QtGui.QApplication.translate("GCS", "MainWindow", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab), QtGui.QApplication.translate("GCS", "Tab 1", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_2), QtGui.QApplication.translate("GCS", "Tab 2", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_3), QtGui.QApplication.translate("GCS", "Strona", None, QtGui.QApplication.UnicodeUTF8))
self.label.setText(QtGui.QApplication.translate("GCS", "Liczba pętli", None, QtGui.QApplication.UnicodeUTF8))
self.propertiesAccept.setText(QtGui.QApplication.translate("GCS", "Akceptuj", None, QtGui.QApplication.UnicodeUTF8))
self.propertiesCancel.setText(QtGui.QApplication.translate("GCS", "Anuluj", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate("GCS", "Pk", None, QtGui.QApplication.UnicodeUTF8))
self.label_3.setText(QtGui.QApplication.translate("GCS", "Pm", None, QtGui.QApplication.UnicodeUTF8))
self.label_4.setText(QtGui.QApplication.translate("GCS", "Pi", None, QtGui.QApplication.UnicodeUTF8))
self.label_5.setText(QtGui.QApplication.translate("GCS", "Pa", None, QtGui.QApplication.UnicodeUTF8))
self.label_6.setText(QtGui.QApplication.translate("GCS", "Ogólne:", None, QtGui.QApplication.UnicodeUTF8))
self.label_7.setText(QtGui.QApplication.translate("GCS", "Algorytm gentyczny:", None, QtGui.QApplication.UnicodeUTF8))
self.label_8.setText(QtGui.QApplication.translate("GCS", "Algorytm ścisku:", None, QtGui.QApplication.UnicodeUTF8))
self.label_9.setText(QtGui.QApplication.translate("GCS", "cf", None, QtGui.QApplication.UnicodeUTF8))
self.label_10.setText(QtGui.QApplication.translate("GCS", "cs", None, QtGui.QApplication.UnicodeUTF8))
self.label_11.setText(QtGui.QApplication.translate("GCS", "ba", None, QtGui.QApplication.UnicodeUTF8))
self.label_12.setText(QtGui.QApplication.translate("GCS", "raf", None, QtGui.QApplication.UnicodeUTF8))
self.label_13.setText(QtGui.QApplication.translate("GCS", "Pozostałe:", None, QtGui.QApplication.UnicodeUTF8))
self.label_14.setText(QtGui.QApplication.translate("GCS", "ts", None, QtGui.QApplication.UnicodeUTF8))
self.label_15.setText(QtGui.QApplication.translate("GCS", "np", None, QtGui.QApplication.UnicodeUTF8))
self.label_16.setText(QtGui.QApplication.translate("GCS", "nstart", None, QtGui.QApplication.UnicodeUTF8))
self.label_17.setText(QtGui.QApplication.translate("GCS", "nN", None, QtGui.QApplication.UnicodeUTF8))
self.label_18.setText(QtGui.QApplication.translate("GCS", "nT", None, QtGui.QApplication.UnicodeUTF8))
self.label_19.setText(QtGui.QApplication.translate("GCS", "nrun", None, QtGui.QApplication.UnicodeUTF8))
self.label_20.setText(QtGui.QApplication.translate("GCS", "nelit", None, QtGui.QApplication.UnicodeUTF8))
self.label_21.setText(QtGui.QApplication.translate("GCS", "nmax", None, QtGui.QApplication.UnicodeUTF8))
self.label_22.setText(QtGui.QApplication.translate("GCS", "wp", None, QtGui.QApplication.UnicodeUTF8))
self.label_23.setText(QtGui.QApplication.translate("GCS", "wn", None, QtGui.QApplication.UnicodeUTF8))
self.label_24.setText(QtGui.QApplication.translate("GCS", "wc", None, QtGui.QApplication.UnicodeUTF8))
self.label_25.setText(QtGui.QApplication.translate("GCS", "wf", None, QtGui.QApplication.UnicodeUTF8))
self.label_26.setText(QtGui.QApplication.translate("GCS", "f0", None, QtGui.QApplication.UnicodeUTF8))
self.label_28.setText(QtGui.QApplication.translate("GCS", "Fuzzy:", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxMembership.setItemText(0, QtGui.QApplication.translate("GCS", "Type S", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxMembership.setItemText(1, QtGui.QApplication.translate("GCS", "brak", None, QtGui.QApplication.UnicodeUTF8))
self.label_29.setText(QtGui.QApplication.translate("GCS", "funkcja przynależności:", None, QtGui.QApplication.UnicodeUTF8))
self.label_30.setText(QtGui.QApplication.translate("GCS", "iloczyn rozmyty:", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxUnion.setItemText(0, QtGui.QApplication.translate("GCS", "klasyczny", None, QtGui.QApplication.UnicodeUTF8))
self.label_31.setText(QtGui.QApplication.translate("GCS", "uogulnienie:", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxUnion_2.setItemText(0, QtGui.QApplication.translate("GCS", "kwadrat", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxUnion_2.setItemText(1, QtGui.QApplication.translate("GCS", "pierwiastek", None, QtGui.QApplication.UnicodeUTF8))
self.comboBoxUnion_2.setItemText(2, QtGui.QApplication.translate("GCS", "brak", None, QtGui.QApplication.UnicodeUTF8))
self.window_CYK.setTabText(self.window_CYK.indexOf(self.tab_4), QtGui.QApplication.translate("GCS", "Strona", None, QtGui.QApplication.UnicodeUTF8))
self.start_GLBS.setText(QtGui.QApplication.translate("GCS", "Start", None, QtGui.QApplication.UnicodeUTF8))
self.Pause.setText(QtGui.QApplication.translate("GCS", "Pause", None, QtGui.QApplication.UnicodeUTF8))
self.params.setText(QtGui.QApplication.translate("GCS", "Zmień parametry", None, QtGui.QApplication.UnicodeUTF8))
self.open_file.setText(QtGui.QApplication.translate("GCS", "Wczytaj plik", None, QtGui.QApplication.UnicodeUTF8))
self.Koniec.setText(QtGui.QApplication.translate("GCS", "Koniec", None, QtGui.QApplication.UnicodeUTF8))
self.change_word.setText(QtGui.QApplication.translate("GCS", "Następny krok", None, QtGui.QApplication.UnicodeUTF8))
self.create_test.setText(QtGui.QApplication.translate("GCS", "Generuj zdania", None, QtGui.QApplication.UnicodeUTF8))
self.label_27.setText(QtGui.QApplication.translate("GCS", "Process progress:", None, QtGui.QApplication.UnicodeUTF8))
self.menuOpcje.setTitle(QtGui.QApplication.translate("GCS", "Opcje", None, QtGui.QApplication.UnicodeUTF8))
self.menuAbout.setTitle(QtGui.QApplication.translate("GCS", "About", None, QtGui.QApplication.UnicodeUTF8))
self.toolBar.setWindowTitle(QtGui.QApplication.translate("GCS", "toolBar", None, QtGui.QApplication.UnicodeUTF8))
self.toolBar_2.setWindowTitle(QtGui.QApplication.translate("GCS", "toolBar_2", None, QtGui.QApplication.UnicodeUTF8))
self.actionWczytaj_Dane.setText(QtGui.QApplication.translate("GCS", "Wczytaj Dane", None, QtGui.QApplication.UnicodeUTF8))
| Python |
from google.appengine.ext import db
from datetime import datetime
class Flea_Server(db.Model):
owner = db.UserProperty( required = True )
server_name = db.StringProperty()
ip_address = db.StringProperty()
last_active_time = db.DateTimeProperty()
uuid = db.StringProperty( required = True )
visible = db.StringProperty( required = True, choices=set(["Public", "Private"])) | Python |
from google.appengine.ext import webapp
from google.appengine.api import users
class BaseAction(webapp.RequestHandler):
dict_data = None
def __init__(self):
self.dict_data = {
"user_status" : user_wrapper(),
}
def viewdata(self, key, value):
self.dict_data[key] = value
def get_viewdata(self):
#self.viewdata( "user_status", user_wrapper() )
return self.dict_data
class user_wrapper(object):
user_name = None
entrance_status = None
entrance_url = None
def __init__( self ):
user = users.get_current_user()
if user:
self.user_name = str( user )
self.entrance_status = "Logout"
self.entrance_url = users.create_logout_url( "/" )
else:
self.user_name = 'Guest'
self.entrance_status = 'Login'
self.entrance_url = users.create_login_url( "/" ) | Python |
from google.appengine.ext import webapp
from actions import *
from google.appengine.ext.webapp import template
application = webapp.WSGIApplication([
('/', Home),
('/Export', Export),
('/Add',Add),
('/Link',Link),
('/PublicServer',PublicServer),
('/Delete',Delete),
], debug=True)
def main():
template.register_template_library('filters.relative_time')
wsgiref.handlers.CGIHandler().run(application)
if __name__ == '__main__':
main()
| Python |
import urllib
import time
def send_request( url, server_name ):
url_address = "http://" + url
counter = 1
print url_address
while 1:
urllib.urlopen( url_address,None )
time.sleep( 60 )
counter += 1
if __name__ == '__main__':
host = 'localhost:9999'
path = '/Link'
uuid = '47b244ab-85ab-4263-a3da-c39a14c58aa4z'
send_request( host + path + "?uuid=" + uuid ,'') | Python |
import cgi
import datetime
import wsgiref.handlers
from google.appengine.api import users
from google.appengine.ext import webapp
from models import *
import os
from google.appengine.ext.webapp import template
import uuid
from base_action import BaseAction
def getTemplatePath(template_name):
path = os.path.join( os.path.dirname(__file__), template_name )
return path
class Home(BaseAction):
def get(self):
flea_servers = None
user = users.get_current_user()
if self.request.get( "p" ) == '':
page_index = 0
else:
page_index = int( self.request.get( "p" ) )
page_size = int( "10" )
page_offset = int( page_index * page_size )
if user:
flea_servers = Flea_Server.gql("WHERE owner = :1", user).fetch( page_size, page_offset )
else:
flea_servers = Flea_Server.all().fetch( page_size, page_offset )
self.viewdata( 'flea_servers', flea_servers )
self.response.out.write( template.render( getTemplatePath( 'template/home.html' ), self.get_viewdata() ))
class PublicServer(BaseAction):
def get( self ):
public_visible = 'Public'
flea_servers = Flea_Server.gql( "WHERE visible = :1", public_visible )
self.viewdata( 'flea_servers', flea_servers )
self.response.out.write( template.render( getTemplatePath( 'template/public_server.html' ), self.get_viewdata() ) )
class Add(BaseAction):
def get(self):
self.response.out.write( template.render( getTemplatePath( 'template/add.html' ), self.get_viewdata() ))
def post(self):
user = users.get_current_user()
if user:
_server_name = self.request.get( "server_name" )
_visible = None
if self.request.get( "visible" ):
_visible = 'Public'
else:
_visible = 'Private'
uuid_value = str( uuid.uuid4() )
flea_server = Flea_Server( owner = users.get_current_user(), server_name = _server_name, uuid = uuid_value, visible = _visible )
flea_server.put()
self.redirect( "/" )
else:
self.redirect( users.create_login_url("/") )
class Link(webapp.RequestHandler):
def get(self):
ip_address = self.request.remote_addr
uuid = self.request.get( "uuid" )
matched_flea_server = Flea_Server.gql( "where uuid = :1", uuid ).get()
if matched_flea_server is not None:
from datetime import datetime
matched_flea_server.last_active_time = datetime.now()
matched_flea_server.ip_address = ip_address
matched_flea_server.put()
self.response.out.write( matched_flea_server )
else:
self.response.out.write( "No server mantched" )
class Export(webapp.RequestHandler):
def get(self):
uuid = self.request.get( 'uuid' )
flea_server = Flea_Server.gql( "WHERE uuid = :1", uuid )
file_name = 'test'
self.response.headers['Content-Type'] = 'application/octet-stream'
self.response.headers['content-disposition'] = 'attachment; filename=' + file_name + '.py'
template_values = {
'uuid' : uuid,
}
path = os.path.join( os.path.dirname(__file__), 'template/script_template.txt' )
self.response.out.write( template.render( path, template_values ) )
class Delete( webapp.RequestHandler ):
def get(self):
uuid = self.request.get( 'uuid' )
flea_server = Flea_Server.gql( "WHERE uuid = :1", uuid ).get()
flea_server.delete()
self.redirect("/")
| Python |
class UserStatus(object):
pass | Python |
#from actions import *
import unittest
class test_add_server(unittest.TestCase):
def test_action_should_handle_the_parameters_from_request(self):
#addServerAction = AddServer()
#assert addServerAction != None, "AddServer class is not existed"
mockClient = self.client
if __name__ == '__main__':
unittest.main() | Python |
from google.appengine.ext import webapp
from datetime import datetime
register = webapp.template.create_template_register()
@register.filter
def relative_time(value):
if value is None:
return "N/A"
passed_time = datetime.now() - value
if passed_time.days > 0:
return str( passed_time.days )+ " day ago"
if passed_time.seconds / 3600 > 0:
return str(passed_time.seconds / 3600) + " hour ago"
if passed_time.seconds / 60 > 0:
return str(passed_time.seconds / 60 ) + " minute ago"
else:
return "few seconds ago"
| Python |
# -*- coding: utf-8 -*-
__author__ = 'gongqf'
from ctms import app
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5840, debug=True)
| Python |
# -*- coding: utf-8 -*-
__author__ = 'gongqf'
import os
DEBUG = False
CSRF_ENABLED = False
SECRET_KEY = 'jmN]X R8/X0XHZyj~,?!93LWRT/ArH'
BASE_PATH = os.path.abspath(os.path.dirname(__file__))
APP_FOLDER = 'ctms'
CTMS_DATABASE = 'ctms.db3'
DATABASE = os.path.join(BASE_PATH, APP_FOLDER, CTMS_DATABASE)
SQLALCHEMY_DATABASE_URI = 'sqlite:///' + DATABASE
print DATABASE, SQLALCHEMY_DATABASE_URI
# email server
MAIL_SERVER = 'your.mailserver.com'
MAIL_PORT = 25
MAIL_USE_TLS = False
MAIL_USE_SSL = False
MAIL_USERNAME = 'you'
MAIL_PASSWORD = 'your-password'
# administrator list
ADMINS = ['you@example.com']
# pagination
POSTS_PER_PAGE = 3
MAX_SEARCH_RESULTS = 50
| Python |
# -*- coding: utf-8 -*-
__author__ = 'gongqf'
from ctms import sa
class User(sa.Model):
__tablename__ = 't_user'
u_id = sa.Column(sa.Integer, primary_key=True)
u_user = sa.Column(sa.String(64), unique=True, nullable=False)
u_name = sa.Column(sa.String(32), nullable=False)
u_pass = sa.Column(sa.String(32), nullable=False)
u_email = sa.Column(sa.String(120), index=True, unique=True)
u_lastlogin = sa.Column(sa.DateTime)
u_active = sa.Column(sa.Boolean, default=1)
u_auth = sa.Column(sa.Boolean, default=1)
# role = sa.Column(sa.SmallInteger, default = ROLE_USER)
# posts = sa.relationship('Post', backref = 'author', lazy = 'dynamic')
# about_me = sa.Column(sa.String(140))
# followed = sa.relationship('User',
# secondary = followers,
# primaryjoin = (followers.c.follower_id == id),
# secondaryjoin = (followers.c.followed_id == id),
# backref = sa.backref('followers', lazy = 'dynamic'),
# lazy = 'dynamic')
# @staticmethod
# def make_unique_nickname(nickname):
# if User.query.filter_by(nickname = nickname).first() == None:
# return nickname
# version = 2
# while True:
# new_nickname = nickname + str(version)
# if User.query.filter_by(nickname = new_nickname).first() == None:
# break
# version += 1
# return new_nickname
def is_authenticated(self):
return unicode(self.u_auth)
def is_active(self):
return unicode(self.u_active)
def is_anonymous(self):
return False
def get_uid(self):
return unicode(self.uid)
# def avatar(self, size):
# return 'http://www.gravatar.com/avatar/' + md5(self.email).hexdigest() + '?d=mm&s=' + str(size)
#
# def follow(self, user):
# if not self.is_following(user):
# self.followed.append(user)
# return self
#
# def unfollow(self, user):
# if self.is_following(user):
# self.followed.remove(user)
# return self
#
# def is_following(self, user):
# return self.followed.filter(followers.c.followed_id == user.id).count() > 0
#
# def followed_posts(self):
# return Post.query.join(followers, (followers.c.followed_id == Post.user_id)).filter(followers.c.follower_id == self.id).order_by(Post.timestamp.desc())
def __repr__(self):
return '<User %r>' % self.u_user | Python |
# -*- coding: utf-8 -*-
import StringIO
__author__ = 'ggcall'
import requests
import sqlite3
import re
import os
from PIL import Image
def randcode(pic):
# pic_name="old.jpg"
# f = open(pic_name, 'wb')
# f.write(pic)
# f.close
# time.sleep(5)
# box=(0,0,60,20)
im=StringIO.StringIO(pic)
# im.save(pic_name)
im=Image.open(im)
# im=im.crop(box)
# im=im.filter(ImageFilter.MedianFilter())
# enhancer = ImageEnhance.Contrast(im)
# im = enhancer.enhance(1)
# im = im.convert('L')
# im.show()
im.save("code.jpg")
os.popen('tesseract.exe code.jpg code digits')
with open('code.txt') as file:
t=file.read()
print 'txt:',t
t=re.findall('\d',t)
if(len(t)==4):
return ''.join(t)
else:
return ''
pic_url ='http://www.npedi.com/edi/ediweb/image.jsp'
login_url='http://www.npedi.com/edi/webLoginAction.do'
post_data=dict()
post_data['usercode']='GUEST'
post_data['password']='guest'
post_data['randcode']=''
login_pattern='<font color="#FF3300" >GUEST</font>'
# 登录的地址
def getpic(url):
r=requests.get(url)
code=randcode(r.content)
return code,r.cookies
def checkpic(url,code):
while not re.match('\d{4}',code):
print 'pic check fail'
code,cookies=getpic(url)
# code='1'
print 'pic check ok'
return code,cookies
def gethtml(url,params,cookies):
# post_data['randcode']=''
login_html=requests.get(url,params=params,cookies=cookies).text
return login_html
def checkhtml(url,params,cookies,html):
while not re.search(login_pattern,html):
print 'login fail'
html=gethtml(url,params,cookies)
# html=''
print 'success'
return True
html=''
post_data['randcode'],cookies=checkpic(pic_url,post_data['randcode'])
checkhtml(login_url,post_data,cookies,html)
dbpath=os.path.join(os.path.dirname(__file__),os.path.pardir,'ctms.db3')
print dbpath
con=sqlite3.connect(dbpath)
cur=con.execute('select * from t_ct')
rv = [dict((cur.description[idx][0], value) for idx, value in enumerate(row)) for row in cur.fetchall()]
# cookie=requests.get('http://122.227.172.219:50004/get_npedi_auth').json()['cookie']
cookie=cookies['JSESSIONID']
print cookie
url='http://www.npedi.com/edi/voyageInfoAction.do'
cookies=dict(JSESSIONID=cookie)
rv=[{'ct_code':'BLCT'}]
for r in rv:
print r['ct_code']
for i in range(1,2):
print i,r['ct_code']
params={'pageIndex':i,'ename':'','voyage':'','cpcode':r['ct_code']}
res=requests.get(url,params=params,cookies=cookies).text
print res
| Python |
# -*- coding: utf-8 -*-
__author__ = 'gongqf'
import sqlite3
import re
from datetime import datetime
from ctms import app, sa
from contextlib import closing
from flask import request, render_template, jsonify, redirect, url_for, Response, send_file, g, session
from config import DATABASE
from models import User
def init_db():
with closing(connect_db()) as db:
with app.open_resource('schema.sql') as f:
db.cursor().executescript(f.read())
db.commit()
def query_db(query, args=(), one=False):
# print query
cur = g.db.execute(query, args)
rv = [dict((cur.description[idx][0], value) for idx, value in enumerate(row)) for row in cur.fetchall()]
return (rv[0] if rv else None) if one else rv
def close_db():
if hasattr(g, 'db'):
g.db.close()
def connect_db():
return sqlite3.connect(DATABASE)
def request_wants_json():
best = request.accept_mimetypes.best_match(['application/json', 'text/html'])
return best == 'application/json' and request.accept_mimetypes[best] > request.accept_mimetypes['text/html']
def del_none_value(d):
for k in d.keys():
if d[k] is None:
d.pop(k)
return d
def db_insert(tbname, kv):
def exe_sql(d):
d = del_none_value(d)
cols = ','.join(d.keys())
vals = ','.join(['\'%s\'' % v.replace("'", "''") for v in d.values()])
sql = 'insert into %s (%s) values(%s)' % (tbname, cols, vals)
# print sql
query_db(sql)
if type(kv) is list:
for x in kv:
if type(x) is dict:
exe_sql(x)
elif type(kv) is dict:
exe_sql(kv)
def db_update(tbname, kv, cd):
def exe_sql(d):
d = del_none_value(d)
cols = ['%s=' % k for k in d.keys()]
vals = ['\'%s\'' % v for v in d.values()]
cv = []
for x in xrange(len(d)):
cv.append('%s%s' % (cols[x], vals[x]))
setval = ','.join(cv)
query_db('update %s set %s where %s =\'%s\'' % (tbname, setval, cd[0], cd[1]))
if type(kv) is list:
for x in kv:
if type(x) is dict:
exe_sql(x)
elif type(kv) is dict:
exe_sql(kv)
def sarow_to_dict(rows):
if type(rows) is tuple or type(rows) is list:
l = []
for row in rows:
d = {}
for column in row.__table__.columns:
d[column.name] = getattr(row, column.name)
l.append(d)
return l
else:
return rows
def to_dict(items, use_none=True, del_key=None):
'''
items: 是把request.form获得的immutablemultidict对象用iteritems取得
use_none:是否把空值('')转换为None返回,默认转换为None
del_key: 是否删除指定的key,比如多余获取的input值,传入值可以是tuple或list,默认不删除
'''
d = {}
for k, v in items:
if v:
d[k] = v
elif use_none:
d[k] = None
if del_key:
if type(del_key) is tuple or type(del_key) is list:
for key in del_key:
d.pop(key, None)
else:
d.pop(del_key, None)
return d
def clean_html(html):
pattern = '\s+|( )+'
# pattern='\s+'
# html = re.sub(pattern, ' ', html)
# 去掉html标记间的空格
# pattern='> <'
# html=re.sub(pattern,'><',html)
return re.sub(pattern, ' ', html).replace('> <', '><')
def clean_row(row):
for k in row.keys():
if row[k] is '':
row[k] = None
return row
@app.before_request
def before_request():
g.db = connect_db()
g.db.execute("PRAGMA foreign_keys=on")
@app.teardown_request
def teardown_request(exption):
close_db()
@app.errorhandler(404)
def internal_error(error):
return render_template('404.html'), 404
@app.errorhandler(500)
def internal_error(error):
sa.session.rollback()
return render_template('500.html'), 500
@app.route('/')
def index():
# session.clear()
return render_template('index.html')
@app.route('/logout')
def logout():
session.clear()
return redirect(url_for('index'))
@app.route('/login', methods=['POST'])
def login():
if request.method == 'POST':
uuser = request.form['uuser']
upass = request.form['upass']
sql = 'select * from t_user where u_user=? and u_pass=?'
print sql
login_user = query_db(sql, (uuser, upass), one=True)
if login_user:
session['uid'] = login_user['u_id']
session['name'] = login_user['u_name']
session['user'] = login_user['u_user']
return jsonify({"bSuccess": True, "iErr": 0})
else:
sql = 'select * from t_user where u_user=?'
error_user = query_db(sql, (uuser,), one=True)
if error_user:
return jsonify({"bSuccess": False, "iErr": 300, "sMsg": u"密码错误"})
else:
return jsonify({"bSuccess": False, "iErr": 400, "sMsg": u"未找到用户"})
@app.route('/changepassword', methods=['POST'])
def changepassword():
if request.method == 'POST':
uid = session['uid']
uopass = request.form['uopass']
unpass = request.form['unpass']
uqpass = request.form['uqpass']
if unpass != uqpass:
return jsonify({"bSuccess": False, "iErr": 301, "sMsg": u"密码不匹配"})
sql = 'select * from t_user where u_id=?'
exits_user = query_db(sql, (uid,), one=True)
if exits_user:
sql = 'select * from t_user where u_id=? and u_pass=?'
ok_user = query_db(sql, (uid, uopass), one=True)
if ok_user:
sql = 'update t_user set u_pass=? where u_id=?'
query_db(sql, (unpass, uid))
g.db.commit()
return jsonify({"bSuccess": True, "iErr": 0, "sMsg": u"密码修改成功"})
else:
return jsonify({"bSuccess": False, "iErr": 302, "sMsg": u"原密码错误"})
else:
return jsonify({"bSuccess": False, "iErr": 400, "sMsg": u"未找到用户"})
@app.route('/sysUser', methods=['GET', 'POST'])
def sysUser():
sql='select * from t_user'
users=query_db(sql)
return render_template('sysUer.html', users=users)
# return render_template('sysUser-i.html', users=users)
def execute_sql(tbl, cols='*', w=(), page=1, rows=10, sort=None, order=None):
# sql_table = tbl
# where_list = []
where_expr = ''
if type(cols) is list or type(cols) is tuple:
cols = ','.join(cols)
if w:
where_expr = 'where %s' % ' and '.join(w)
raw_sql = 'select %s from %s %s' % (cols, tbl, where_expr)
print 'raw_sql: %s' % raw_sql
count_sql = 'select count(*) as total from (%s)' % raw_sql
print 'count_sql: %s' % count_sql
if sort and order:
rows_sql = '%s order by %s %s' % (raw_sql, sort, order)
if page and rows:
offset = (page-1)*rows
rows_sql = '%s limit %d offset %d' % (rows_sql, rows, offset)
print 'rows_sql: %s' % rows_sql
rows = query_db(rows_sql)
total = query_db(count_sql, one=True)['total']
return total, rows
def safe_request(s, d=''):
return request.args.get(s, d).replace("'", "''")
@app.route('/sysUser.json', methods=['GET', 'POST'])
def sysUser_json():
# if request.method == 'GET':
page = request.args.get('page', 1, type=int)
rows = request.args.get('rows', 10, type=int)
sort = safe_request('sort', 'u_id')
order = safe_request('order', 'desc')
u_id = request.args.get('u_id', 0, type=int)
u_user = safe_request('u_user', '')
u_name = safe_request('u_name', '')
w = []
w.append('u_id=%s' % u_id) if u_id else None
w.append('u_user=\'%s\'' % u_user) if u_user else None
w.append('u_name=\'%s\'' % u_name) if u_name else None
total, rows = execute_sql(tbl='t_user', w=tuple(w), page=page, rows=rows, sort=sort, order=order)
return jsonify(total=total, rows=rows)
# return render_template('sysUser-i.html', users=users) | Python |
# -*- coding: utf-8 -*-
__author__ = 'gongqf'
import os
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask.ext.mail import Mail
from config import BASE_PATH, MAIL_PASSWORD, MAIL_PORT, MAIL_SERVER, MAIL_USERNAME, ADMINS
app = Flask(__name__)
app.config.from_object('config')
sa = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
mail = Mail(app)
if not app.debug:
import logging
from logging.handlers import SMTPHandler
credentials = None
if MAIL_USERNAME or MAIL_PASSWORD:
credentials = (MAIL_USERNAME, MAIL_PASSWORD)
mail_handler = SMTPHandler((MAIL_SERVER, MAIL_PORT), 'no-reply@' + MAIL_SERVER, ADMINS, 'microblog failure',
credentials)
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler(os.path.join(BASE_PATH, 'tmp', os.sep, 'debug.log'), 'a', 1 * 1024 * 1024, 10)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
app.logger.info('debug startup')
from ctms import views, models | Python |
# -*- coding: utf-8 -*-
__author__ = 'gongqf'
from gis import app
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5002, debug=True)
| Python |
# -*- coding: utf-8 -*-
import cx_Oracle
con = cx_Oracle.connect('gis/ndtvgis@192.168.20.79/GIS')
# print con.version
cur = con.cursor()
odf表 teodf
光交接表 tegjjx
光终端盒表 tegzdh
光分路器表 teobd
olt表 teolt
odf模块表 teodm
光设备模块表 tegldzb
光设备端子表 tegjsbdz
光设备跳纤表 tegjsbjmp
光缆表 tegl
光缆段表 tegld
光缆段纤芯表 tegldqx
光设备关联表 tegjsbgl
光纤熔接表 tegqrj
光缆接头表 tegljt
光缆预留表 teglyl
光缆盘留表 teglpl
光缆节连接点表 tegljljd
光缆节表 teglj
光路表 tegr
# tegjsbdz 面板端子
# teqy 区域 type=2
# tejz 分前端 zqybm=teqy.bm
# tejf 机房 jflx=1,jzbm=tejz.bm
# tegjjx 光交 jzbm=tejz.bm
# teodf ODF sysm=0,jfbm=tejf.bm 不确定 或者 sysm=0,jzbm=tejz.bm
# teodm odf和olt的机框号在这里
# ODF和机房的关系
# tepnt 的type=87是odf，ztid=tejf.id0
# tegjsbdz 端子跳接关系表
# SELECT * FROM tegjsbjmp where (rdevid=14812 or cdevid=14812) and (rdz=217 or cdz=217);
tegldzb 光设备模块表 关联了下面这些设备类型的数据
30
6
11
2
21
20
26
17
27
18
10
19
9
# select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.bz,jmp.id0,jmp.rdz,jmp.cdz,jmp.rdevid,jmp.cdevid from tegjsbdz dz left join (select * from tegjsbjmp jmp where jmp.rdevid=14812 or jmp.cdevid=14812) jmp on jmp.rdz=dz.dz or jmp.cdz=dz.dz where (dz.devid='14812' and dz.mkcol=1) order by dz.mkrow,dz.dzcol;
# tegjsbgl 端子成端关系表 devtype=2 是gj devtype=1 是ODF kh 是框号，只有odf有框 kh，gj没有框号 kh
# tegjsbjmp rdevlx 1是odf ，2 是gj，9是OBD，11是OLT
# SELECT cd.*,gld.mc FROM tegjsbgl cd left join tegld gld on cd.gldid=gld.id0 where cd.devid=14812;
# SELECT * FROM tegjsbgl cd where cd.devid=14812;
# SELECT * FROM tegld where id0=3084;
'''
SELECT * FROM tegjsbjmp where (rdevid=14789 or cdevid= 14789 ) and (rdevlx=1 and cdevlx=1) -- ODF的跳接关系
union
SELECT * FROM tegjsbjmp where rdevid=14789 and rdevlx=1 and cdevlx=9 --ODF跳接到OBD的关系
union
SELECT * FROM tegjsbjmp where rdevid=14789 and rdevlx=1 and cdevlx=11 --ODF跳接到OLT的关系
union
SELECT * FROM tegjsbjmp where cdevid=14789 and cdevlx=1 and rdevlx=9 --OBD跳接到ODF的关系
union
SELECT * FROM tegjsbjmp where cdevid=14789 and cdevlx=1 and rdevlx=11 --OLT跳接到ODF的关系
'''
SELECT dz.id0 id0 ,obd.bm||' '||dz.dz pw FROM tegjsbdz dz,teobd obd where dz.devid=20052 and dz.devid=obd.id0 --obd的端子id和pw
SELECT * FROM tegjsbjmp jmp where jmp.rdevid=16232 and jmp.cdevid=16232 --gj内部的跳接关系
union all
SELECT * FROM tegjsbjmp jmp where jmp.rdevid=16232 and jmp.cdevlx=9 --从gj跳到obd的关系
union all
SELECT * FROM tegjsbjmp jmp where jmp.cdevid=16232 and jmp.rdevlx=9 --从obd跳到光交的关系
光交上有跳接关系的所有端子 和 没有跳接关系的端子 按框分开来的合集
select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.zt,dz.bz,'' pw,jmp.jmp from tegjsbdz dz left join
(
select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.zt,dz.bz,'' pw,jmp.cdz jmp from tegjsbdz dz ,tegjsbjmp jmp
where dz.devid = 16232 and dz.mkcol=1 and jmp.rdevid=16232 and jmp.cdevid=16232 and jmp.rdz=dz.dz
union all
select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.zt,dz.bz,'' pw,jmp.rdz jmp from tegjsbdz dz ,tegjsbjmp jmp
where dz.devid = 16232 and dz.mkcol=1 and jmp.rdevid=16232 and jmp.cdevid=16232 and jmp.cdz=dz.dz
union all
select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.zt,dz.bz,'' pw,jmp.cdz jmp from tegjsbdz dz ,tegjsbjmp jmp
where dz.devid = 16232 and dz.mkcol=1 and jmp.rdevid=16232 and jmp.cdevlx=9 and jmp.rdz=dz.dz
union all
select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.zt,dz.bz,'' pw,jmp.rdz jmp from tegjsbdz dz ,tegjsbjmp jmp
where dz.devid = 16232 and dz.mkcol=1 and jmp.cdevid=16232 and jmp.rdevlx=9 and jmp.cdz=dz.dz
) jmp on dz.id0=jmp.id0 where dz.devid = 16232 and dz.mkcol=1
union all
select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.zt,dz.bz,'' pw,jmp.jmp from tegjsbdz dz left join
(
select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.zt,dz.bz,'' pw,jmp.cdz jmp from tegjsbdz dz ,tegjsbjmp jmp
where dz.devid = 16232 and dz.mkcol=2 and jmp.rdevid=16232 and jmp.cdevid=16232 and jmp.rdz=dz.dz
union all
select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.zt,dz.bz,'' pw,jmp.rdz jmp from tegjsbdz dz ,tegjsbjmp jmp
where dz.devid = 16232 and dz.mkcol=2 and jmp.rdevid=16232 and jmp.cdevid=16232 and jmp.cdz=dz.dz
union all
select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.zt,dz.bz,'' pw,jmp.cdz jmp from tegjsbdz dz ,tegjsbjmp jmp
where dz.devid = 16232 and dz.mkcol=2 and jmp.rdevid=16232 and jmp.cdevlx=9 and jmp.rdz=dz.dz
union all
select dz.id0,dz.devid,dz.mkrow,dz.mkcol,dz.dzrow,dz.dzcol,dz.dz,dz.zt,dz.bz,'' pw,jmp.rdz jmp from tegjsbdz dz ,tegjsbjmp jmp
where dz.devid = 16232 and dz.mkcol=2 and jmp.cdevid=16232 and jmp.rdevlx=9 and jmp.cdz=dz.dz
) jmp on dz.id0=jmp.id0 where dz.devid = 16232 and dz.mkcol=2
select * from tegjsbdz dz left join () jmp on where dz.devid = 16232 and dz.mkcol=1
--------------------------
得到r有跳接的端子
SELECT * FROM tegjsbjmp jmp left join
tegjsbdz dz on dz.devid=jmp.rdevid and dz.devtype=jmp.rdevlx and dz.dz=jmp.rdz
where jmp.rdevid=16232 and jmp.rdevlx=2
组合
union all
得到c有跳接的端子
SELECT * FROM tegjsbjmp jmp left join
tegjsbdz dz on dz.devid=jmp.cdevid and dz.devtype=jmp.cdevlx and dz.dz=jmp.cdz
where jmp.cdevid=16232 and jmp.cdevlx=2
--------------------------------
得到r端子id0和r端子跳接的对端c端子的id0,devid,devtype
SELECT rjmp.id0 adz,
cdz.devid bdevid,
cdz.devtype bdevtype,
cdz.id0 bdz
FROM (SELECT rdz.id0,
jmp.rdz,
jmp.rdevlx,
jmp.rdevid,
jmp.cdz,
jmp.cdevlx,
jmp.cdevid
FROM tegjsbjmp jmp
left join tegjsbdz rdz
ON rdz.devid = jmp.rdevid
AND rdz.devtype = jmp.rdevlx
AND rdz.dz = jmp.rdz
WHERE jmp.rdevid = 16232 and jmp.rdevlx=2) rjmp
left join tegjsbdz cdz
ON cdz.devid = rjmp.cdevid
AND cdz.devtype = rjmp.cdevlx
AND cdz.dz = rjmp.cdz
组合起来
union all
得到c端子id0和c端子跳接的对端r端子的id0,devid,devtype
SELECT cjmp.id0 adz,
rdz.devid bdevid,
rdz.devtype bdevtype,
rdz.id0 bdz
FROM (SELECT cdz.id0,
jmp.cdz,
jmp.cdevlx,
jmp.cdevid,
jmp.rdz,
jmp.rdevlx,
jmp.rdevid
FROM tegjsbjmp jmp
left join tegjsbdz cdz
ON cdz.devid = jmp.cdevid
AND cdz.devtype = jmp.cdevlx
AND cdz.dz = jmp.cdz
WHERE jmp.cdevid = 16232 and jmp.cdevlx=2) cjmp
left join tegjsbdz rdz
ON rdz.devid = cjmp.rdevid
AND rdz.devtype = cjmp.rdevlx
AND rdz.dz = cjmp.rdz
--------------------------------------------
老的
得到b端所有非当前设备的devtype和devid
a端为当前设备，例子里为gj
SELECT bdevtype,bdevid FROM (
SELECT rjmp.id0 adz,
cdz.devid bdevid,
cdz.devtype bdevtype,
cdz.id0 bdz
FROM (SELECT rdz.id0,
jmp.rdz,
jmp.rdevlx,
jmp.rdevid,
jmp.cdz,
jmp.cdevlx,
jmp.cdevid
FROM tegjsbjmp jmp
left join tegjsbdz rdz
ON rdz.devid = jmp.rdevid
AND rdz.devtype = jmp.rdevlx
AND rdz.dz = jmp.rdz
WHERE jmp.rdevid = 16232 and jmp.rdevlx=2) rjmp
left join tegjsbdz cdz
ON cdz.devid = rjmp.cdevid
AND cdz.devtype = rjmp.cdevlx
AND cdz.dz = rjmp.cdz
union all
SELECT cjmp.id0 adz,
rdz.devid bdevid,
rdz.devtype bdevtype,
rdz.id0 bdz
FROM (SELECT cdz.id0,
jmp.cdz,
jmp.cdevlx,
jmp.cdevid,
jmp.rdz,
jmp.rdevlx,
jmp.rdevid
FROM tegjsbjmp jmp
left join tegjsbdz cdz
ON cdz.devid = jmp.cdevid
AND cdz.devtype = jmp.cdevlx
AND cdz.dz = jmp.cdz
WHERE jmp.cdevid = 16232 and jmp.cdevlx=2) cjmp
left join tegjsbdz rdz
ON rdz.devid = cjmp.rdevid
AND rdz.devtype = cjmp.rdevlx
AND rdz.dz = cjmp.rdz
) b where bdevid<>16232 and bdevtype<>2
group by bdevtype,bdevid
----------------------
新的
得到b端所有非当前设备的devtype和devid
a端为当前设备，例子里为gj
SELECT bdevlx,
bdevid
FROM (SELECT cdevlx bdevlx,
cdevid bdevid
FROM tegjsbjmp rjmp
WHERE rdevid = 16232
AND rdevlx = 2
UNION ALL
SELECT rdevlx bdevlx,
rdevid bdevid
FROM tegjsbjmp cjmp
WHERE cdevid = 16232
AND cdevlx = 2)
WHERE bdevlx <> 2
AND bdevid <> 16232
GROUP BY bdevlx,
bdevid
----------------------------
需要测试的情况
gj 16236 百丈东路-海晏南路光交 B面中间空盘
gj 16232 河清北路-惊驾东路光交 A面有跳接obd
gj 14844 义路（维科集团）光交 A\B面上面有空盘
gj 14795 翠柏路-后河巷光交 A面有27盘，B面26盘
-----------------------------
for 面板 in 光交:
print 面板号（转义）
print table
for 盘 in 光交.面板:
print tr
print td,盘号（转义）
if 盘.端子==空：
print td,colspan=当前面板每盘最大端子数
else:
for 端子 in 光交.面板.盘
print td,端子信息
----------------------------
需要测试的情况
odf 14765 传输中心南ODF10号柜 8框
odf 14766 传输中心中机房中ODF1号柜 5框12盘4端子
odf 14784 竹福园机房ODF01 跳接到其他odf和obd
odf 14789 科技园区机房ODF02 有跳到OLT
odf 14737 广电大厦8楼机房ODF01 4盘12端子
-----------------------------
cur.execute("select * from tegjjx gj,tegjsbdz dz where gj.id0='14795' and gj.id0=dz.devid order by dz.mkcol,dz.mkrow,dz.dzcol")
rows=cur.fetchall()
print len(rows)
# for row in rows:
# print row
cur.close()
con.close() | Python |
# -*- coding: utf-8 -*-
import cx_Oracle
con = cx_Oracle.connect('gis/ndtvgis@192.168.20.79/GIS')
print con.version
cursor = con.cursor()
cursor.execute("select * from tegjd where bm=:bm",{'bm':'HS.ZFY/SQY/GJD01'})
rows=cursor.fetchall()
for row in rows:
print row
cursor.execute("select * from tegjd where bm like :bm",{'bm':'HS.ZFY/SQY/GJD%'})
for result in cursor:
print result[0],result[1],result[2]
cursor.close()
con.close() | Python |
# -*- coding: utf-8 -*-
from sqlalchemy import *
from sqlalchemy.sql import select
from sqlalchemy.schema import *
# create the engine for oracle db
# we need to install cx_Oracle and sqlalchemy in advance.
db_engine=create_engine('oracle://gis:ndtvgis@192.168.20.79:1521/GIS', echo=True)
# test the ddl to db
# this is tested in VM and works fine.
# db_engine.execute("create table zy_user(name varchar2(10), address varchar2(50))")
# reflect the table into sqlalchemy
# we should use the meta to do the reflect in version 0.9
meta=MetaData()
t=Table('tegjd',meta,autoload=True,autoload_with=db_engine)
# autoload the keys
# print t.c.keys()
# create the insert script
# ins=t.insert()
# print str(ins)
# check all the column names and do a select to fetch the data directly from table
conn=db_engine.connect()
s=select([t]).where(t.c.bm=='HS.ZFY/SQY/GJD01') # 提供查询条件
result=conn.execute(s)
for row in result:
print row[t.c.id0],row[t.c.mc] # 看这里，直接用t.c.name就可以调用name列的值了，c代表column。不用做映射，不用配置文件，简单到无语吧？...
print row
# remember to close the cursor
result.close() | Python |
# -*- coding: utf-8 -*-
__author__ = 'gongqf'
import os
DEBUG = False
CSRF_ENABLED = False
SECRET_KEY = 'jmN]X R8/X0XHZyj~,?!93LWRT/ArH'
BASE_PATH = os.path.abspath(os.path.dirname(__file__))
APP_FOLDER = 'gis'
DATABASE = 'gis/ndtvgis@192.168.20.79/GIS'
print DATABASE
# email server
MAIL_SERVER = 'your.mailserver.com'
MAIL_PORT = 25
MAIL_USE_TLS = False
MAIL_USE_SSL = False
MAIL_USERNAME = 'you'
MAIL_PASSWORD = 'your-password'
# administrator list
ADMINS = ['you@example.com']
# pagination
POSTS_PER_PAGE = 3
MAX_SEARCH_RESULTS = 50
| Python |
# -*- coding: utf-8 -*-
__author__ = 'gongqf'
| Python |
# -*- coding: utf-8 -*-
import StringIO
__author__ = 'ggcall'
import requests
import sqlite3
import re
import os
from PIL import Image
def randcode(pic):
# pic_name="old.jpg"
# f = open(pic_name, 'wb')
# f.write(pic)
# f.close
# time.sleep(5)
# box=(0,0,60,20)
im=StringIO.StringIO(pic)
# im.save(pic_name)
im=Image.open(im)
# im=im.crop(box)
# im=im.filter(ImageFilter.MedianFilter())
# enhancer = ImageEnhance.Contrast(im)
# im = enhancer.enhance(1)
# im = im.convert('L')
# im.show()
im.save("code.jpg")
os.popen('tesseract.exe code.jpg code digits')
with open('code.txt') as file:
t=file.read()
print 'txt:',t
t=re.findall('\d',t)
if(len(t)==4):
return ''.join(t)
else:
return ''
pic_url ='http://www.npedi.com/edi/ediweb/image.jsp'
login_url='http://www.npedi.com/edi/webLoginAction.do'
post_data=dict()
post_data['usercode']='GUEST'
post_data['password']='guest'
post_data['randcode']=''
login_pattern='<font color="#FF3300" >GUEST</font>'
# 登录的地址
def getpic(url):
r=requests.get(url)
code=randcode(r.content)
return code,r.cookies
def checkpic(url,code):
while not re.match('\d{4}',code):
print 'pic check fail'
code,cookies=getpic(url)
# code='1'
print 'pic check ok'
return code,cookies
def gethtml(url,params,cookies):
# post_data['randcode']=''
login_html=requests.get(url,params=params,cookies=cookies).text
return login_html
def checkhtml(url,params,cookies,html):
while not re.search(login_pattern,html):
print 'login fail'
html=gethtml(url,params,cookies)
# html=''
print 'success'
return True
html=''
post_data['randcode'],cookies=checkpic(pic_url,post_data['randcode'])
checkhtml(login_url,post_data,cookies,html)
dbpath=os.path.join(os.path.dirname(__file__),os.path.pardir,'ctms.db3')
print dbpath
con=sqlite3.connect(dbpath)
cur=con.execute('select * from t_ct')
rv = [dict((cur.description[idx][0], value) for idx, value in enumerate(row)) for row in cur.fetchall()]
# cookie=requests.get('http://122.227.172.219:50004/get_npedi_auth').json()['cookie']
cookie=cookies['JSESSIONID']
print cookie
url='http://www.npedi.com/edi/voyageInfoAction.do'
cookies=dict(JSESSIONID=cookie)
rv=[{'ct_code':'BLCT'}]
for r in rv:
print r['ct_code']
for i in range(1,2):
print i,r['ct_code']
params={'pageIndex':i,'ename':'','voyage':'','cpcode':r['ct_code']}
res=requests.get(url,params=params,cookies=cookies).text
print res
| Python |
# -*- coding: utf-8 -*-
__author__ = 'gongqf'
import sqlite3
import re
import json
import time
from datetime import datetime
from gis import app
from contextlib import closing
from flask import request, render_template, jsonify, redirect, url_for, Response, send_file, g, session, make_response
from config import DATABASE
from urllib import quote
@app.template_filter('is_list')
def is_list(value):
return isinstance(value, list)
def query_db(query, args=(), one=False):
# print query
cur = g.db.execute(query, args)
rv = [dict((cur.description[idx][0], value) for idx, value in enumerate(row)) for row in cur.fetchall()]
return (rv[0] if rv else None) if one else rv
def request_wants_json():
best = request.accept_mimetypes.best_match(['application/json', 'text/html'])
return best == 'application/json' and request.accept_mimetypes[best] > request.accept_mimetypes['text/html']
def del_none_value(d):
for k in d.keys():
if d[k] is None:
d.pop(k)
return d
def db_insert(tbname, kv):
def exe_sql(d):
d = del_none_value(d)
cols = ','.join(d.keys())
vals = ','.join(['\'%s\'' % v.replace("'", "''") for v in d.values()])
sql = 'insert into %s (%s) values(%s)' % (tbname, cols, vals)
# print sql
query_db(sql)
if type(kv) is list:
for x in kv:
if type(x) is dict:
exe_sql(x)
elif type(kv) is dict:
exe_sql(kv)
def db_update(tbname, kv, cd):
def exe_sql(d):
d = del_none_value(d)
cols = ['%s=' % k for k in d.keys()]
vals = ['\'%s\'' % v for v in d.values()]
cv = []
for x in xrange(len(d)):
cv.append('%s%s' % (cols[x], vals[x]))
setval = ','.join(cv)
query_db('update %s set %s where %s =\'%s\'' % (tbname, setval, cd[0], cd[1]))
if type(kv) is list:
for x in kv:
if type(x) is dict:
exe_sql(x)
elif type(kv) is dict:
exe_sql(kv)
def sarow_to_dict(rows):
if type(rows) is tuple or type(rows) is list:
l = []
for row in rows:
d = {}
for column in row.__table__.columns:
d[column.name] = getattr(row, column.name)
l.append(d)
return l
else:
return rows
def to_dict(items, use_none=True, del_key=None):
'''
items: 是把request.form获得的immutablemultidict对象用iteritems取得
use_none:是否把空值('')转换为None返回,默认转换为None
del_key: 是否删除指定的key,比如多余获取的input值,传入值可以是tuple或list,默认不删除
'''
d = {}
for k, v in items:
if v:
d[k] = v
elif use_none:
d[k] = None
if del_key:
if type(del_key) is tuple or type(del_key) is list:
for key in del_key:
d.pop(key, None)
else:
d.pop(del_key, None)
return d
def clean_html(html):
pattern = '\s+|( )+'
# pattern='\s+'
# html = re.sub(pattern, ' ', html)
# 去掉html标记间的空格
# pattern='> <'
# html=re.sub(pattern,'><',html)
return re.sub(pattern, ' ', html).replace('> <', '><')
def clean_row(row):
for k in row.keys():
if row[k] is '':
row[k] = None
return row
@app.errorhandler(404)
def internal_error(error):
return render_template('404.html'), 404
@app.errorhandler(500)
def internal_error(error):
return render_template('500.html'), 500
@app.route('/')
def index():
return render_template('index.html')
@app.route('/logout')
def logout():
return redirect(url_for('index'))
@app.route('/login', methods=['POST'])
def login():
if request.method == 'POST':
uuser = request.form['uuser']
upass = request.form['upass']
sql = 'select * from t_user where u_user=? and u_pass=?'
print sql
login_user = query_db(sql, (uuser, upass), one=True)
if login_user:
session['uid'] = login_user['u_id']
session['name'] = login_user['u_name']
session['user'] = login_user['u_user']
return jsonify({"bSuccess": True, "iErr": 0})
else:
sql = 'select * from t_user where u_user=?'
error_user = query_db(sql, (uuser,), one=True)
if error_user:
return jsonify({"bSuccess": False, "iErr": 300, "sMsg": u"密码错误"})
else:
return jsonify({"bSuccess": False, "iErr": 400, "sMsg": u"未找到用户"})
@app.route('/changepassword', methods=['POST'])
def changepassword():
if request.method == 'POST':
uid = session['uid']
uopass = request.form['uopass']
unpass = request.form['unpass']
uqpass = request.form['uqpass']
if unpass != uqpass:
return jsonify({"bSuccess": False, "iErr": 301, "sMsg": u"密码不匹配"})
sql = 'select * from t_user where u_id=?'
exits_user = query_db(sql, (uid,), one=True)
if exits_user:
sql = 'select * from t_user where u_id=? and u_pass=?'
ok_user = query_db(sql, (uid, uopass), one=True)
if ok_user:
sql = 'update t_user set u_pass=? where u_id=?'
query_db(sql, (unpass, uid))
g.db.commit()
return jsonify({"bSuccess": True, "iErr": 0, "sMsg": u"密码修改成功"})
else:
return jsonify({"bSuccess": False, "iErr": 302, "sMsg": u"原密码错误"})
else:
return jsonify({"bSuccess": False, "iErr": 400, "sMsg": u"未找到用户"})
@app.route('/sysUser', methods=['GET', 'POST'])
def sysUser():
sql = 'select * from t_user'
users = query_db(sql)
return render_template('sysUer.html', users=users)
# return render_template('sysUser-i.html', users=users)
def execute_sql(tbl, cols='*', w=(), page=1, rows=10, sort=None, order=None):
# sql_table = tbl
# where_list = []
where_expr = ''
if type(cols) is list or type(cols) is tuple:
cols = ','.join(cols)
if w:
where_expr = 'where %s' % ' and '.join(w)
raw_sql = 'select %s from %s %s' % (cols, tbl, where_expr)
print 'raw_sql: %s' % raw_sql
count_sql = 'select count(*) as total from (%s)' % raw_sql
print 'count_sql: %s' % count_sql
if sort and order:
rows_sql = '%s order by %s %s' % (raw_sql, sort, order)
if page and rows:
offset = (page - 1) * rows
rows_sql = '%s limit %d offset %d' % (rows_sql, rows, offset)
print 'rows_sql: %s' % rows_sql
rows = query_db(rows_sql)
total = query_db(count_sql, one=True)['total']
return total, rows
def execute_sql_simple(tbl, cols='*', w=()):
# sql_table = tbl
# where_list = []
where_expr = ''
if type(cols) is list or type(cols) is tuple:
cols = ','.join(cols)
if w:
where_expr = 'where %s' % ' and '.join(w)
raw_sql = 'select %s from %s %s' % (cols, tbl, where_expr)
print 'raw_sql: %s' % raw_sql
# if sort and order:
rows_sql = '%s order by %s %s' % (raw_sql, 'bm', 'asc')
print 'rows_sql: %s' % rows_sql
rows = g.db.execute(rows_sql).fetchall()
return rows
def safe_request(s, d=''):
return request.args.get(s, d).replace("'", "''")
@app.route('/sysUser.json', methods=['GET', 'POST'])
def sysUser_json():
# if request.method == 'GET':
page = request.args.get('page', 1, type=int)
rows = request.args.get('rows', 10, type=int)
sort = safe_request('sort', 'u_id')
order = safe_request('order', 'desc')
u_id = request.args.get('u_id', 0, type=int)
u_user = safe_request('u_user', '')
u_name = safe_request('u_name', '')
w = []
w.append('u_id=%s' % u_id) if u_id else None
w.append('u_user=\'%s\'' % u_user) if u_user else None
w.append('u_name=\'%s\'' % u_name) if u_name else None
total, rows = execute_sql(tbl='t_user', w=tuple(w), page=page, rows=rows, sort=sort, order=order)
return jsonify(total=total, rows=rows)
# return render_template('sysUser-i.html', users=users)
@app.route('/gl_tree')
def gl_tree():
tree = list()
qys = g.db.execute("select id0,bm,mc from teqy where bm in('HS','JD','JB')").fetchall()
for qy in qys:
qy_dict = dict()
qy_dict['id'] = qy[0]
qy_dict['text'] = qy[2].decode('gbk')
qy_dict['state'] = 'open'
qy_dict['children'] = list()
jzs = g.db.execute("select id0,bm,mc from tejz where zqybm=:qy", {'qy': qy[1]}).fetchall()
for jz in jzs:
jz_dict = dict()
jz_dict['id'] = jz[0]
jz_dict['text'] = jz[2].decode('gbk')
jz_dict['state'] = 'closed'
jz_dict['children'] = list()
gggls = g.db.execute(u"select id0,bm,mc from tegl where jzbm=:jz and jb='骨干光缆' order by bm",
{'jz': jz[1]}).fetchall()
if gggls:
gggl_dict = dict()
gggl_dict['text'] = u'骨干光缆'
gggl_dict['state'] = 'closed'
gggl_dict['children'] = list()
for gggl in gggls:
gl_dict = dict()
gl_dict['text'] = gggl[2].decode('gbk')
# gl_dict['text'] += '('+gggl[1]+')'
gl_dict['state'] = 'open'
gl_dict['attributes'] = dict(url='/gl/%s' % gggl[0])
# gl_dict['children'] = list()
gggl_dict['children'].append(gl_dict)
jz_dict['children'].append(gggl_dict)
hjgls = g.db.execute(u"select id0,bm,mc from tegl where jzbm=:jz and jb='汇聚光缆' order by bm",
{'jz': jz[1]}).fetchall()
if hjgls:
hjgl_dict = dict()
hjgl_dict['text'] = u'汇聚光缆'
hjgl_dict['state'] = 'closed'
hjgl_dict['children'] = list()
for hjgl in hjgls:
gl_dict = dict()
gl_dict['text'] = hjgl[2].decode('gbk')
# gl_dict['text'] += '('+hjgl[1]+')'
gl_dict['state'] = 'open'
gl_dict['attributes'] = dict(url='/gl/%s' % hjgl[0])
# gl_dict['children'] = list()
hjgl_dict['children'].append(gl_dict)
jz_dict['children'].append(hjgl_dict)
jrgls = g.db.execute(u"select id0,bm,mc from tegl where jzbm=:jz and jb='接入光缆' order by bm",
{'jz': jz[1]}).fetchall()
if jrgls:
jrgl_dict = dict()
jrgl_dict['text'] = u'接入光缆'
jrgl_dict['state'] = 'closed'
jrgl_dict['children'] = list()
for jrgl in jrgls:
gl_dict = dict()
gl_dict['text'] = jrgl[2].decode('gbk')
# gl_dict['text'] += '('+jrgl[1]+')'
gl_dict['state'] = 'open'
gl_dict['attributes'] = dict(url='/gl/%s' % jrgl[0])
# gl_dict['children'] = list()
jrgl_dict['children'].append(gl_dict)
jz_dict['children'].append(jrgl_dict)
qy_dict['children'].append(jz_dict)
tree.append(qy_dict)
return Response(json.dumps(tree), mimetype='application/javascript')
@app.route('/dz_tree')
def dz_tree():
tree = list()
qys = g.db.execute("select id0,bm,mc from teqy where bm in('HS','JD','JB')").fetchall()
for qy in qys:
qy_dict = dict()
qy_dict['id'] = qy[0]
qy_dict['text'] = qy[2].decode('gbk')
qy_dict['state'] = 'open'
qy_dict['children'] = list()
jzs = g.db.execute("select id0,bm,mc from tejz where zqybm=:qy", {'qy': qy[1]}).fetchall()
for jz in jzs:
jz_dict = dict()
jz_dict['id'] = jz[0]
jz_dict['text'] = jz[2].decode('gbk')
jz_dict['state'] = 'closed'
jz_dict['children'] = list()
gjs = g.db.execute("select id0,bm,mc from tegjjx where jzbm=:jz order by bm", {'jz': jz[1]}).fetchall()
for gj in gjs:
gj_dict = dict()
gj_dict['text'] = gj[2].decode('gbk')
gj_dict['state'] = 'open'
gj_dict['attributes'] = dict(url='/gj/%s' % gj[0])
jz_dict['children'].append(gj_dict)
gj_obds = g.db.execute("select id0,bm,mc from teobd where ztbm=:gj order by bm",
{'gj': gj[1]}).fetchall()
if gj_obds:
gj_obd_dict = dict()
gj_obd_dict['text'] = 'OBD'
gj_obd_dict['state'] = 'closed'
gj_obd_dict['children'] = list()
for obd in gj_obds:
obd_dict = dict()
obd_dict['text'] = obd[2].decode('gbk')
obd_dict['state'] = 'open'
obd_dict['attributes'] = dict(url='/obd/%s' % obd[0])
# obd_dict['children'] = list()
gj_obd_dict['children'].append(obd_dict)
gj_dict['children'] = list()
gj_dict['children'].append(gj_obd_dict)
jfs = g.db.execute("select id0,bm,mc from tejf where jzbm=:jz and jflx=1 order by bm",
{'jz': jz[1]}).fetchall()
for jf in jfs:
jf_dict = dict()
jf_dict['id'] = jf[0]
jf_dict['text'] = jf[2].decode('gbk')
jf_dict['state'] = 'open'
jf_dict['children'] = list()
odfs = g.db.execute("select id0,bm,mc from teodf where sysm=0 and jfbm=:jf order by bm",
{'jf': jf[1]}).fetchall()
if odfs:
jf_odf_dict = dict()
jf_odf_dict['text'] = 'ODF'
jf_odf_dict['state'] = 'open'
jf_odf_dict['children'] = list()
for odf in odfs:
odf_dict = dict()
odf_dict['text'] = odf[2].decode('gbk')
odf_dict['state'] = 'open'
odf_dict['attributes'] = dict(url='/odf/%s' % odf[0])
# odf_dict['children'] = list()
jf_odf_dict['children'].append(odf_dict)
jf_dict['children'].append(jf_odf_dict)
jf_obds = g.db.execute("select id0,bm,mc from teobd where ztbm=:jf order by bm",
{'jf': jf[1]}).fetchall()
if jf_obds:
jf_obd_dict = dict()
jf_obd_dict['text'] = 'OBD'
jf_obd_dict['state'] = 'closed'
jf_obd_dict['children'] = list()
for obd in jf_obds:
obd_dict = dict()
obd_dict['text'] = obd[2].decode('gbk')
obd_dict['state'] = 'open'
obd_dict['attributes'] = dict(url='/obd/%s' % obd[0])
# obd_dict['children'] = list()
jf_obd_dict['children'].append(obd_dict)
jf_dict['children'].append(jf_obd_dict)
jf_olts = g.db.execute("select id0,bm,mc from teolt where jfbm=:jf order by bm",
{'jf': jf[1]}).fetchall()
if jf_olts:
jf_olt_dict = dict()
jf_olt_dict['text'] = 'OLT'
jf_olt_dict['state'] = 'closed'
jf_olt_dict['children'] = list()
for olt in jf_olts:
olt_dict = dict()
olt_dict['text'] = olt[2].decode('gbk')
olt_dict['state'] = 'open'
olt_dict['attributes'] = dict(url='/olt/%s' % olt[0])
# olt_dict['children'] = list()
jf_olt_dict['children'].append(olt_dict)
jf_dict['children'].append(jf_olt_dict)
jz_dict['children'].append(jf_dict)
qy_dict['children'].append(jz_dict)
tree.append(qy_dict)
return Response(json.dumps(tree), mimetype='application/javascript')
def gbk_to_utf8(rs):
if type(rs) == list or type(rs) == tuple:
rows = list()
for r in rs:
if type(r) == list or type(r) == tuple:
row = list(r)
for i, e in enumerate(r):
if type(r[i]) == str:
row[i] = r[i].decode('gbk')
if re.search(u',|，', row[i]):
bz = row[i]
row[i] = re.split(u',|，', bz)
# print rv[head[idx]]
elif type(r) == str:
row = r.decode('gbk')
else:
row = r
rows.append(row)
return rows
def combin_dict(head, values):
# return dict(zip(head, values.decode('gbk') if type(values) == str else values))
if type(values) == tuple:
rv = dict()
for x in range(len(head)):
if type(values[x]) == str:
rv[head[x]] = values[x].decode('gbk')
else:
rv[head[x]] = values[x]
return rv
elif type(values) == list:
rvs = list()
for value in values:
rv = dict()
for idx in range(len(value)):
if type(value[idx]) == str:
v = value[idx].decode('gbk')
if re.search(u',|，', v):
# print value[idx].decode('gbk')
rv[head[idx]] = re.split(u',|，', v)
# print rv[head[idx]]
else:
rv[head[idx]] = v
# print rv[head[idx]]
else:
rv[head[idx]] = value[idx]
rvs.append(rv)
return rvs
def get_dev_table_name(devtype):
return {'1': 'teodf', '2': 'tegjjx', '9': 'teobd', '11': 'teolt'}[str(devtype)]
def get_gj_symbol(idx):
return (
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Y', 'Z', 'AA')[int(idx) - 1]
def get_odf_jh(bm):
odf = re.search('ODF.+', bm).group()
return str(int(''.join(re.findall('\d', odf))))
# return str(int(re.search('\d.+',odf_bm).group()))
def get_olt_jh(bm):
olt = re.search('OLT.+', bm).group()
return str(int(''.join(re.findall('\d', olt))))
# return str(int(re.search('\d.+',odf_bm).group()))
def dz_tj_info(devtype, dzs):
pass
def get_dz_pw(devtype, devid):
# 所有a端端子盘位
adz_pw = get_dev_pw(devtype=devtype, devid=devid, out=False)
# print adz_pw
bdev_sql = 'SELECT bdevlx, bdevid FROM (SELECT cdevlx bdevlx, cdevid bdevid FROM tegjsbjmp rjmp WHERE rdevid = :devid AND rdevlx = :devtype UNION ALL SELECT rdevlx bdevlx, rdevid bdevid FROM tegjsbjmp cjmp WHERE cdevid = :devid AND cdevlx = :devtype) WHERE (bdevlx <> :devtype AND bdevid <> :devid) or (bdevlx = :devtype AND bdevid <> :devid) GROUP BY bdevlx, bdevid'
bdevs = g.db.execute(bdev_sql, {'devtype': devtype, 'devid': devid}).fetchall()
# print bdevs
bdz_pw = dict()
for bdev in bdevs:
bdz_pw = dict(bdz_pw, **get_dev_pw(*bdev, out=False))
# print bdz_pw
dz_pw = dict(adz_pw, **(bdz_pw))
return dz_pw
@app.route('/get_dev_pw/<int:devtype>/<int:devid>', methods=['GET'])
def get_dev_pw(devtype, devid, out=True):
if devtype == 11:
return get_olt_pw(devid, out)
if devtype == 9:
return get_obd_pw(devid, out)
if devtype == 2:
return get_gj_pw(devid, out)
if devtype == 1:
return get_odf_pw(devid, out)
@app.route('/get_gj_pw/<int:devid>', methods=['GET'])
def get_gj_pw(devid=None, out=False):
s_time = time.time()
# head = ['id0', 'devid', 'mkrow', 'mkcol', 'dzrow', 'dzcol', 'dz', 'zt', 'bz']
# sql = 'select %s from tegjsbdz dz where dz.devid = :devid order by dz.mkcol, dz.mkrow, dz.dzcol' % ','.join(head)
# dzs = combin_dict(head, g.db.execute(sql, {'devid': devid}).fetchall())
# rows = g.db.execute('select mkcol,max(mkrow) from tegjsbdz dz where devid = :devid group by mkcol ', {'devid': devid}).fetchall()
# print rows
# mks = dict((row[0], row[1]) for row in rows)
# print mks
# for dz in dzs:
# dz['pw']='%s-%s-%s'%(get_gj_symbol(dz['mkcol']), get_gj_symbol(mks[dz['mkcol']]-dz['mkrow']+1) ,dz['dzcol'])
head = ['id0', 'mkrow', 'mkcol', 'dzcol']
sql = 'select %s from tegjsbdz dz where dz.devid = :devid and devtype=2 order by dz.mkcol, dz.mkrow, dz.dzcol' % ','.join(
head)
dzs = g.db.execute(sql, {'devid': devid}).fetchall()
rows = g.db.execute('select mkcol,max(mkrow) from tegjsbdz dz where devid = :devid and devtype=2 group by mkcol ',
{'devid': devid}).fetchall()
print rows
mks = dict((row[0], row[1]) for row in rows)
print mks
dz_pw = dict()
for dz in dzs:
dz_pw[dz[0]] = '%s-%s-%s' % (get_gj_symbol(dz[2]), get_gj_symbol(mks[dz[2]] - dz[1] + 1), dz[3])
print time.time() - s_time
if out:
return jsonify(dz_pw=dz_pw)
else:
return dz_pw
@app.route('/get_obd_pw/<int:devid>', methods=['GET'])
def get_obd_pw(devid=None, out=False):
s_time = time.time()
# 用编码显示
sql = "SELECT dz.id0 id0 ,substr(obd.bm,instr(obd.bm,'OBD')+3,LENGTH(obd.bm)-instr(obd.bm,'OBD')-3+1)||'/'||dz.dz pw FROM tegjsbdz dz,teobd obd where dz.devid=:devid and dz.devid=obd.id0"
# 用名称显示
sql = u"SELECT dz.id0 id0 ,substr(obd.mc,instr(obd.mc,'分光器')+3,LENGTH(obd.mc)-instr(obd.mc,'分光器')-3+1)||'/'||dz.dz pw FROM tegjsbdz dz,teobd obd where dz.devid=:devid and dz.devid=obd.id0"
rows = g.db.execute(sql, {'devid': devid}).fetchall()
dz_pw = dict((row[0], row[1]) for row in rows)
print time.time() - s_time
if out:
return jsonify(dz_pw=dz_pw)
else:
return dz_pw
@app.route('/get_odf_pw/<int:devid>', methods=['GET'])
def get_odf_pw(devid=None, out=False):
s_time = time.time()
sql = 'select bm from teodf where id0=:devid'
jh = get_odf_jh(g.db.execute(sql, {'devid': devid}).fetchone()[0])
head = ['id0', 'mkrow', 'dzrow', 'dzcol']
# select dz.id0 id0, kh, dzrow, dzcol from tegjsbdz dz left join teodm odm on dz.mkrow=odm.wlkh and dz.devid=odm.devid and dz.devtype=odm.devtype where dz.devid = 17413 and dz.devtype=1 order by dz.mkrow, dz.dzrow, dz.dzcol
sql = 'select dz.id0 id0, kh, dzrow, dzcol from tegjsbdz dz left join teodm odm on dz.mkrow=odm.wlkh and dz.devid=odm.devid and dz.devtype=odm.devtype where dz.devid = :devid and dz.devtype=1 order by dz.mkrow, dz.dzrow, dz.dzcol'
dzs = g.db.execute(sql, {'devid': devid}).fetchall()
dz_pw = dict()
for dz in dzs:
dz_pw[dz[0]] = '%s-%s-%s-%s' % (jh, dz[1], dz[2], dz[3])
print time.time() - s_time
if out:
return jsonify(dz_pw=dz_pw)
else:
return dz_pw
@app.route('/get_olt_pw/<int:devid>', methods=['GET'])
def get_olt_pw(devid=None, out=False):
# 未完成
s_time = time.time()
sql = 'select bm from teolt where id0=:devid'
jh = get_olt_jh(g.db.execute(sql, {'devid': devid}).fetchone()[0])
sql = "SELECT dz.id0,kh,dzb.bm,dz.bm FROM tegjsbdz dz left join tegldzb dzb on dz.devtype=dzb.devtype and dz.devid=dzb.devid and dz.mkrow=dzb.mkhh and dz.mkcol=dzb.mklh and dz.ssjk=dzb.ssjk left join teodm odm on dzb.devtype=odm.devtype and dzb.devid=odm.devid and dzb.ssjk=odm.id0 where dz.devid=:devid and dz.devtype=11 order by mkrow,mkcol,dzrow,dzcol"
dzs = g.db.execute(sql, {'devid': devid}).fetchall()
dz_pw = dict()
for dz in dzs:
dz_pw[dz[0]] = '%s-%s/%s/%s' % (jh, dz[1], dz[2], dz[3])
print time.time() - s_time
if out:
return jsonify(dz_pw=dz_pw)
else:
return dz_pw
@app.route('/gj/<int:id0>', methods=['GET'])
def gj(id0=None):
export = request.args.get('export')
dz_pw = get_dz_pw(devtype=2, devid=id0)
dzs_sql = 'select id0,devid,mkrow,mkcol,dzrow,dzcol,dz,zt,bz,bdevtype,bdevid,bdz from tegjsbdz dz left join (SELECT rjmp.id0 adz, cdz.devid bdevid, cdz.devtype bdevtype, cdz.id0 bdz FROM (SELECT rdz.id0, jmp.rdz, jmp.rdevlx, jmp.rdevid, jmp.cdz, jmp.cdevlx, jmp.cdevid FROM tegjsbjmp jmp left join tegjsbdz rdz ON rdz.devid = jmp.rdevid AND rdz.devtype = jmp.rdevlx AND rdz.dz = jmp.rdz WHERE jmp.rdevid = :id0 AND jmp.rdevlx = 2) rjmp left join tegjsbdz cdz ON cdz.devid = rjmp.cdevid AND cdz.devtype = rjmp.cdevlx AND cdz.dz = rjmp.cdz UNION ALL SELECT cjmp.id0 adz, rdz.devid bdevid, rdz.devtype bdevtype, rdz.id0 bdz FROM ( SELECT cdz.id0, jmp.cdz, jmp.cdevlx, jmp.cdevid, jmp.rdz, jmp.rdevlx, jmp.rdevid FROM tegjsbjmp jmp left join tegjsbdz cdz ON cdz.devid = jmp.cdevid AND cdz .devtype = jmp.cdevlx AND cdz.dz = jmp.cdz WHERE jmp.cdevid = :id0 AND jmp.cdevlx = 2) cjmp left join tegjsbdz rdz ON rdz.devid = cjmp.rdevid AND rdz.devtype = cjmp.rdevlx AND rdz.dz = cjmp.rdz) b on dz.id0=b.adz where devtype=2 and devid=:id0 order by mkcol,mkrow,dzcol'
dzs = gbk_to_utf8(g.db.execute(dzs_sql, {'id0': id0}).fetchall())
# print dzs
mbs_sql = 'SELECT mkcol,max(mkrow),max(dzcol) FROM tegjsbdz where devid=:id0 and devtype=2 group by mkcol order by mkcol'
mbs = g.db.execute(mbs_sql, {'id0': id0}).fetchall()
tables = list()
for mb in mbs:
table = dict()
table['table'] = mb[0]
table['max_row'] = mb[1]
table['max_col'] = mb[2]
trs = list()
for row in range(1, mb[1] + 1):
tr = dict()
tr['tr'] = row
tds = list()
for col in range(1, mb[2] + 1):
for dz in dzs:
if dz[3] == mb[0] and dz[2] == row and dz[5] == col:
tds.append(dz)
tr['tds'] = tds
trs.append(tr)
table['trs'] = trs
tables.append(table)
gl_cds = g.db.execute(
"select dz, mc||'/'||qx qx, gl.jb from tegjsbgl cd left join tegld gld on cd.gldid=gld.id0 left join tegl gl on gld.glid=gl.id0 where cd.devid=:id0 and cd.devtype=2",
{'id0': id0}).fetchall()
# print gl_cds[0]
# print 'gl_cds:',time.time()-s_time
gljb = {u'接入光缆': 'gl-jb-jr', u'汇聚光缆': 'gl-jb-hj', u'骨干光缆': 'gl-jb-gg'}
gl_cd = dict((x[0], x[1].decode('gbk')) for x in gl_cds)
gl_jb = dict((x[0], gljb[x[2].decode('gbk')]) for x in gl_cds)
# return jsonify(tables=tables)
if export:
gjmc = g.db.execute('select mc from tegjjx where id0=:id0', {'id0': id0}).fetchone()[0].decode('gbk').encode(
'utf-8')
resp = make_response(render_template('gj.html', tables=tables, dz_pw=dz_pw, gl_jb=gl_jb, gl_cd=gl_cd))
resp.headers['Content-Disposition'] = "attachment; filename='%s.%s'" % (quote(gjmc), export)
resp.headers['Content-Type'] = "application/octet-stream"
return resp
else:
return render_template('gj.html', tables=tables, dz_pw=dz_pw, gl_jb=gl_jb, gl_cd=gl_cd)
@app.route('/olt/<int:id0>', methods=['GET'])
def olt(id0=None):
s_time = time.time()
export = request.args.get('export')
dz_pw = get_dz_pw(devtype=11, devid=id0)
tables = list()
print time.time() - s_time
# return jsonify(tables=tables)
if export:
oltmc = g.db.execute('SELECT mc FROM teolt where id0=:id0', {'id0': id0}).fetchone()[0].decode('gbk').encode(
'utf-8')
resp = make_response(render_template('olt.html', tables=tables, dz_pw=dz_pw))
resp.headers['Content-Disposition'] = "attachment; filename='%s.%s'" % (quote(oltmc), export)
resp.headers['Content-Type'] = "application/octet-stream"
return resp
else:
return render_template('olt.html', tables=tables, dz_pw=dz_pw)
@app.route('/odf/<int:id0>', methods=['GET'])
def odf(id0=None):
s_time = time.time()
export = request.args.get('export')
dz_pw = get_dz_pw(devtype=1, devid=id0)
dzs_sql = 'SELECT id0,devid,mkrow,mkcol,dzrow,dzcol,dz,zt,bz,bdevtype,bdevid,bdz FROM tegjsbdz dz left join (SELECT rjmp.id0 adz,cdz.devid bdevid,cdz.devtype bdevtype,cdz.id0 bdz FROM (SELECT rdz.id0,jmp.rdz,jmp.rdevlx,jmp.rdevid,jmp.cdz,jmp.cdevlx,jmp.cdevid,jmp.ckh FROM tegjsbjmp jmp left join tegjsbdz rdz ON rdz.devid = jmp.rdevid AND rdz.devtype = jmp.rdevlx AND rdz.dz = jmp.rdz AND (SELECT kh FROM teodm WHERE devid = :id0 AND devtype = 1 AND wlkh = rdz.mkrow) = jmp.rkh WHERE jmp.rdevid = :id0 AND jmp.rdevlx = 1 AND jmp.cdevlx = 1) rjmp left join tegjsbdz cdz ON cdz.devid = rjmp.cdevid AND cdz.devtype = rjmp.cdevlx AND cdz.dz = rjmp.cdz AND (SELECT kh FROM teodm WHERE devid = rjmp.cdevid AND devtype = 1 AND wlkh = cdz.mkrow) = rjmp.ckh UNION ALL SELECT rjmp.id0 adz,cdz.devid bdevid,cdz.devtype bdevtype,cdz.id0 bdz FROM (SELECT rdz.id0,jmp.rdz,jmp.rdevlx,jmp.rdevid,jmp.cdz,jmp.cdevlx,jmp.cdevid,jmp.ckh FROM tegjsbjmp jmp left join tegjsbdz rdz ON rdz.devid = jmp.rdevid AND rdz.devtype = jmp.rdevlx AND rdz.dz = jmp.rdz AND (SELECT kh FROM teodm WHERE devid = :id0 AND devtype = 1 AND wlkh = rdz.mkrow) = jmp.rkh WHERE jmp.rdevid = :id0 AND jmp.rdevlx = 1 AND jmp.cdevlx <> 1) rjmp left join tegjsbdz cdz ON cdz.devid = rjmp.cdevid AND cdz.devtype = rjmp.cdevlx AND cdz.dz = rjmp.cdz UNION ALL SELECT cjmp.id0 adz,rdz.devid bdevid,rdz.devtype bdevtype,rdz.id0 bdz FROM (SELECT cdz.id0,jmp.cdz,jmp.cdevlx,jmp.cdevid,jmp.rdz,jmp.rdevlx,jmp.rdevid,jmp.rkh FROM tegjsbjmp jmp left join tegjsbdz cdz ON cdz.devid = jmp.cdevid AND cdz .devtype = jmp.cdevlx AND cdz.dz = jmp.cdz AND (SELECT kh FROM teodm WHERE devid = :id0 AND devtype = 1 AND wlkh = cdz.mkrow) = jmp.ckh WHERE jmp.cdevid = :id0 AND jmp.cdevlx = 1 AND jmp.rdevlx = 1) cjmp left join tegjsbdz rdz ON rdz.devid = cjmp.rdevid AND rdz.devtype = cjmp.rdevlx AND rdz.dz = cjmp.rdz AND (SELECT kh FROM teodm WHERE devid = cjmp.rdevid AND devtype = 1 AND wlkh = rdz.mkrow) = cjmp.rkh UNION ALL SELECT cjmp.id0 adz,rdz.devid bdevid,rdz.devtype bdevtype,rdz.id0 bdz FROM (SELECT cdz.id0,jmp.cdz,jmp.cdevlx,jmp.cdevid,jmp.rdz,jmp.rdevlx,jmp.rdevid,jmp.rkh FROM tegjsbjmp jmp left join tegjsbdz cdz ON cdz.devid = jmp.cdevid AND cdz .devtype = jmp.cdevlx AND cdz.dz = jmp.cdz AND (SELECT kh FROM teodm WHERE devid = :id0 AND devtype = 1 AND wlkh = cdz.mkrow) = jmp.ckh WHERE jmp.cdevid = :id0 AND jmp.cdevlx = 1 AND jmp.rdevlx <> 1) cjmp left join tegjsbdz rdz ON rdz.devid = cjmp.rdevid AND rdz.devtype = cjmp.rdevlx AND rdz.dz = cjmp.rdz) b ON dz.id0 = b.adz WHERE devtype = 1 AND devid = :id0 ORDER BY mkcol,mkrow,dzrow,dzcol '
dzs = gbk_to_utf8(g.db.execute(dzs_sql, {'id0': id0}).fetchall())
# print dzs
# kh，wlkh的引用会不错换错？看结果是对的，修改gis里的框号，修改的是kh这个字段。
mbs_sql = 'SELECT kh,wlkh,kdys,dybs,bdzs FROM teodm where devtype=1 and devid=:id0 order by wlkh'
mbs = g.db.execute(mbs_sql, {'id0': id0}).fetchall()
tables = list()
for mb in mbs:
table = dict()
table['table'] = mb[0]
table['max_row'] = mb[3]
table['max_col'] = mb[4]
trs = list()
for row in range(1, mb[3] + 1):
tr = dict()
tr['tr'] = row
tds = list()
for col in range(1, mb[4] + 1):
for dz in dzs:
if dz[2] == mb[1] and dz[4] == row and dz[5] == col:
tds.append(dz)
tr['tds'] = tds
trs.append(tr)
table['trs'] = trs
tables.append(table)
gl_cds = g.db.execute(
"select wlkh, dz, mc||'/'||qx qx, gl.jb from tegjsbgl cd left join teodm odm on cd.kh=odm.kh and cd.devid=odm.devid and cd.devtype=odm.devtype left join tegld gld on cd.gldid=gld.id0 left join tegl gl on gld.glid=gl.id0 where cd.devid=:id0 and cd.devtype=1",
{'id0': id0}).fetchall()
# print gl_cds[0]
gljb = {u'接入光缆': 'gl-jb-jr', u'汇聚光缆': 'gl-jb-hj', u'骨干光缆': 'gl-jb-gg'}
gl_jb = dict(('%s-%s' % (x[0], x[1].decode('gbk')), gljb[x[3].decode('gbk')]) for x in gl_cds)
gl_cd = dict(('%s-%s' % (x[0], x[1].decode('gbk')), x[2].decode('gbk')) for x in gl_cds)
print time.time() - s_time
# return jsonify(tables=tables)
if export:
odfmc = g.db.execute('SELECT mc FROM teodf where id0=:id0', {'id0': id0}).fetchone()[0].decode('gbk').encode(
'utf-8')
resp = make_response(render_template('odf.html', tables=tables, dz_pw=dz_pw, gl_jb=gl_jb, gl_cd=gl_cd))
resp.headers['Content-Disposition'] = "attachment; filename='%s.%s'" % (quote(odfmc), export)
resp.headers['Content-Type'] = "application/octet-stream"
return resp
else:
return render_template('odf.html', tables=tables, dz_pw=dz_pw, gl_jb=gl_jb, gl_cd=gl_cd)
@app.route('/obd/<int:id0>', methods=['GET'])
def obd(id0=None):
export = request.args.get('export')
obd_head = ('bm', 'mc')
obd_dev = combin_dict(list(obd_head), g.db.execute('select %s from teobd where id0 = :id0' % ','.join(obd_head),
{'id0': id0}).fetchone())
dz_head = ('dz.id0', 'dz.devid', 'dz.mkrow', 'dz.mkcol', 'dz.dzrow', 'dz.dzcol', 'dz.dz', 'dz.zt', 'dz.bz')
max_mkrow, max_dzcol = g.db.execute(
'select max(mkrow),max(dzcol) from tegjsbdz dz where devid = :id0 and devtype=9', {'id0': id0}).fetchone()
print max_mkrow, max_dzcol
mbs = list()
# dzs = list()
for mkrow in range(1, max_mkrow + 1):
mb = dict()
mb['mk_row'] = mkrow
mb['mk'] = combin_dict(list(dz_head), g.db.execute(
'select %s from tegjsbdz dz where dz.devid = :id0 and devtype=9 and dz.mkrow=:mkrow order by dz.dzcol' % (
','.join(dz_head)),
{'id0': id0, 'mkrow': mkrow}).fetchall())
print mb
mbs.append(mb)
if export:
resp = make_response(render_template('obd.html', devid=id0, mbs=mbs, obd_dev=obd_dev))
resp.headers['Content-Disposition'] = 'attachment; filename=obd.%s' % export
resp.headers['Content-Type'] = "application/octet-stream"
return resp
else:
return render_template('obd.html', devid=id0, mbs=mbs, obd_dev=obd_dev)
@app.route('/gl/<int:id0>', methods=['GET'])
def gl(id0=None):
export = request.args.get('export')
gl_head = ('bm', 'mc', 'jzbm', 'jb', 'cd', 'bz')
gl = combin_dict(list(gl_head),
g.db.execute('select %s from tegl where id0=:id0' % ','.join(gl_head), {'id0': id0}).fetchone())
gld_head = ('id0', 'bm', 'mc', 'gldxxs', 'qslx', 'qsbm', 'zzlx', 'zzbm', 'glcd')
glds = combin_dict(list(gld_head),
g.db.execute('select %s from tegld where glid=:id0 order by bm' % ','.join(gld_head),
{'id0': id0}).fetchall())
if export:
resp = make_response(render_template('gl.html', glid=id0, gl=gl, glds=glds))
resp.headers['Content-Disposition'] = 'attachment; filename=gl.%s' % export
resp.headers['Content-Type'] = "application/octet-stream"
return resp
else:
return render_template('gl.html', glid=id0, gl=gl, glds=glds)
@app.route('/gld.json', methods=['GET'])
def gld_json():
glid = request.args.get('glid', 0, type=int)
w = []
w.append('glid=%s' % glid) if glid else None
rows = execute_sql_simple(tbl='tegld', cols=('id0', 'bm', 'glcd'), w=tuple(w))
return jsonify(rows=rows)
| Python |
# -*- coding: utf-8 -*-
__author__ = 'gongqf'
import cx_Oracle
from flask import Flask, g
from config import DATABASE
# import os
# os.environ["NLS_LANG"] = "SIMPLIFIED CHINESE.ZHS16GBK"
app = Flask(__name__)
app.config.from_object('config')
def CloseDB():
if hasattr(g, 'db'):
g.db.close()
g.con.close()
def connect_db():
con = cx_Oracle.connect(DATABASE)
cur = con.cursor()
return cur, con
@app.before_request
def before_request():
g.db, g.con = connect_db()
# g.db.execute("PRAGMA foreign_keys=ON")
@app.teardown_request
def teardown_request(exception):
CloseDB()
from gis import views, models | Python |
# -*- coding: utf-8 -*-
import cx_Oracle
con = cx_Oracle.connect('gis/ndtvgis@192.168.20.79/GIS')
# print con.version
cursor = con.cursor()
cursor.execute("select sum(gdcd) from tegdd t")
for result in cursor:
print u'统计管道段长度:',result[0]
cursor.execute("select count(*) from tersj")
for result in cursor:
print u'统计人手井数量:',result[0]
cursor.execute("select count(*) from tegjd")
for result in cursor:
print u'统计光节点数量:',result[0]
cursor.execute("SELECT count(*) FROM tegld where id0 in (SELECT glid FROM tegljg group by glid having count(*)>4)")
for result in cursor:
print u'查询有光缆路由的光缆段数量(>4):',result[0]
cursor.close()
con.close() | Python |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# This script will try to create the minig indexes for all the users
# with active mail_perms in the OBM database.
#
# Depends: python-psycopg2 for postgresql or python-mysqldb for mysql.
import ConfigParser;
import os;
import sys;
import httplib;
import urllib;
# Read /etc/obm/obm_conf.ini & fetches login, domain & passwords from
# the P_UserObm table.
def fetch_user_passwords():
print "INFO: Reading /etc/obm/obm_conf.ini..."
config = ConfigParser.ConfigParser();
config.readfp(open("/etc/obm/obm_conf.ini"));
dbtype = config.get("global", "dbtype").strip();
host = config.get("global", "host").strip();
db = config.get("global", "db").strip();
user = config.get("global", "user").strip();
password = config.get("global", "password").strip(" \"");
print "INFO: type: '"+dbtype+"' host: '"+host+"' db: '"+db+"' user: '"+user+"' password: '"+password+"'";
ds = None;
if dbtype == "PGSQL":
import psycopg2 as dbapi2;
print "INFO: psycopg2 drived loaded."
ds = dbapi2.connect(host=host, database=db, user=user, password=password);
elif dbtype == 'MYSQL':
import MySQLdb as dbapi2;
print "INFO: MySQLdb driver loaded."
ds = dbapi2.connect(host=host, db=db, user=user, passwd=password);
else:
print "ERROR: Unrecognised dbtype: "+dbtype;
exit(1);
cur = ds.cursor();
cur.execute("""
SELECT userobm_login, domain_name, userobm_password
FROM P_UserObm
INNER JOIN P_Domain ON userobm_domain_id=domain_id
WHERE
userobm_password_type='PLAIN' AND
userobm_mail_perms=1 AND
userobm_archive=0 AND
NOT domain_global
ORDER BY domain_name, userobm_login
""");
rows = cur.fetchall();
cur.close();
return rows;
# login on the minig backend using the given tuple with login, domain
# & password
def init_minig_index(host, port, row):
print "INFO: init index for "+row[0]+"@"+row[1]+" on "+host+":"+str(port);
params = urllib.urlencode({ "login": row[0], "domain": row[1], "password": row[2] });
headers = { "Content-type": "application/x-www-form-urlencoded" };
con = httplib.HTTPConnection(host, port);
try:
con.request("POST", "/firstIndexing.do", params, headers);
response = con.getresponse();
print "INFO:", response.status, response.reason
data = response.read();
except Exception, e:
print "ERROR:", e
con.close();
def usage():
print """usage: ./minig_init_index.py <backend_host> <backend_port>
example: ./minig_init_index.py localhost 8081""";
if __name__ == "__main__":
if len(sys.argv) != 3:
usage();
exit(1);
rows = fetch_user_passwords();
for i in range (len(rows)):
init_minig_index(sys.argv[1], int(sys.argv[2]), rows[i]);
print "INFO: progress: "+str(i+1)+"/"+str(len(rows));
| Python |
#!/usr/bin/python2.6
# -*- coding: utf-8 -*-
import xml.etree.ElementTree as etree
import sys
tree = None
root = None
def loadFile(url):
global tree
tree = etree.parse(url)
global root
root = tree.getroot()
for e in root:
if e.tag.lower() == "modules":
root = e
break
def printXML():
print "----------------------------------------------------------"
for c in root:
print c.attrib["destPath"]
print "----------------------------------------------------------"
def fastSort(mi, mx):
global root
start = mi
end = mx
#print "start: %d, end: %d, mi: %d, mx: %d" % (start, end, mi, mx)
if mi >= mx:
pass
else:
flag = 0
#print "..........................................................."
while mi < mx:
doex = "Fasle"
if flag == 0:
if root[mi].attrib["destPath"] > root[mx].attrib["destPath"]:
root[mi], root[mx] = root[mx], root[mi]
flag = 1
doex = "True"
else:
mx = mx - 1
else:
if root[mi].attrib["destPath"] > root[mx].attrib["destPath"]:
root[mi], root[mx] = root[mx], root[mi]
flag = 0
doex = "True"
else:
mi = mi + 1
#print "min: %d, max: %d, doExchange: %s" %(mi, mx, doex)
#print "..........................................................."
fastSort(start, mi - 1)
fastSort(mx + 1, end)
if __name__ == "__main__":
#input args processor
args = sys.argv
inputurl = None
outputurl = None
if (args[1] != "-i") or (args[3] != "-i"):
inputurl = args[1] == "-i" and args[2] or args[4]
else:
print "need -i"
exit()
if (args[1] != "-o") or (args[3] != "-o"):
outputurl = args[1] == "-o" and args[2] or args[4]
else:
print "need -o"
exit()
print "InputURL: %s,\tOutputURL: %s" % (inputurl, outputurl)
print "load xml file ......"
loadFile(inputurl)
print "success ! get root length is %d" % len(root)
#print "primary elements sequence like this:"
#printXML()
print "start clean ......"
fastSort(0, len(root) - 1)
#print "sorted elements sequence like this:"
#printXML()
tree.write(outputurl)
print "clean up !"
| Python |
#!/usr/bin/python2.6
# -*- coding: utf-8 -*-
import xml.etree.ElementTree as etree
import sys
tree = None
root = None
def loadFile(url):
global tree
tree = etree.parse(url)
global root
root = tree.getroot()
for e in root:
if e.tag.lower() == "modules":
root = e
break
def printXML():
print "----------------------------------------------------------"
for c in root:
print c.attrib["destPath"]
print "----------------------------------------------------------"
def fastSort(mi, mx):
global root
start = mi
end = mx
#print "start: %d, end: %d, mi: %d, mx: %d" % (start, end, mi, mx)
if mi >= mx:
pass
else:
flag = 0
#print "..........................................................."
while mi < mx:
doex = "Fasle"
if flag == 0:
if root[mi].attrib["destPath"] > root[mx].attrib["destPath"]:
root[mi], root[mx] = root[mx], root[mi]
flag = 1
doex = "True"
else:
mx = mx - 1
else:
if root[mi].attrib["destPath"] > root[mx].attrib["destPath"]:
root[mi], root[mx] = root[mx], root[mi]
flag = 0
doex = "True"
else:
mi = mi + 1
#print "min: %d, max: %d, doExchange: %s" %(mi, mx, doex)
#print "..........................................................."
fastSort(start, mi - 1)
fastSort(mx + 1, end)
if __name__ == "__main__":
#input args processor
args = sys.argv
inputurl = None
outputurl = None
if (args[1] != "-i") or (args[3] != "-i"):
inputurl = args[1] == "-i" and args[2] or args[4]
else:
print "need -i"
exit()
if (args[1] != "-o") or (args[3] != "-o"):
outputurl = args[1] == "-o" and args[2] or args[4]
else:
print "need -o"
exit()
print "InputURL: %s,\tOutputURL: %s" % (inputurl, outputurl)
print "load xml file ......"
loadFile(inputurl)
print "success ! get root length is %d" % len(root)
#print "primary elements sequence like this:"
#printXML()
print "start clean ......"
fastSort(0, len(root) - 1)
#print "sorted elements sequence like this:"
#printXML()
tree.write(outputurl)
print "clean up !"
| Python |
#====================================================================
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# ====================================================================
#
# This software consists of voluntary contributions made by many
# individuals on behalf of the Apache Software Foundation. For more
# information on the Apache Software Foundation, please see
# <http://www.apache.org/>.
#
import os
import re
import tempfile
import shutil
ignore_pattern = re.compile('^(.svn|target|bin|classes)')
java_pattern = re.compile('^.*\.java')
annot_pattern = re.compile('import org\.apache\.http\.annotation\.')
def process_dir(dir):
files = os.listdir(dir)
for file in files:
f = os.path.join(dir, file)
if os.path.isdir(f):
if not ignore_pattern.match(file):
process_dir(f)
else:
if java_pattern.match(file):
process_source(f)
def process_source(filename):
tmp = tempfile.mkstemp()
tmpfd = tmp[0]
tmpfile = tmp[1]
try:
changed = False
dst = os.fdopen(tmpfd, 'w')
try:
src = open(filename)
try:
for line in src:
if annot_pattern.match(line):
changed = True
line = line.replace('import org.apache.http.annotation.', 'import net.jcip.annotations.')
dst.write(line)
finally:
src.close()
finally:
dst.close();
if changed:
shutil.move(tmpfile, filename)
else:
os.remove(tmpfile)
except:
os.remove(tmpfile)
process_dir('.')
| Python |
from google.appengine.api import users
from google.appengine.ext import webapp
from google.appengine.ext.webapp import template
from google.appengine.ext.webapp.util import run_wsgi_app
from blog.views import FlexView
import os
class MainPage(webapp.RequestHandler):
def get(self):
self.redirect('/blog')
class Blog(webapp.RequestHandler):
def get(self):
blog = FlexView('flex-pyamf-blog','blog','runtime/settings_blog.xml')
self.response.out.write(template.render(blog.path(), blog.template_values()))
class Admin(webapp.RequestHandler):
def get(self):
admin = FlexView('flex-pyamf-blog: admin', 'admin', 'runtime/settings_admin.xml')
self.response.out.write(template.render(admin.path(), admin.template_values()))
application = webapp.WSGIApplication(
[
('/', MainPage),
('/blog', Blog),
('/admin', Admin)
], debug=True)
def main():
run_wsgi_app(application)
if __name__ == "__main__":
main()
| Python |
"""
Model classes for the flex-pyamf-blog
"""
from google.appengine.ext.db import Model
from google.appengine.ext import db
class MiniPost(Model):
body = db.TextProperty()
category = db.CategoryProperty()
date = db.DateTimeProperty(auto_now_add=True)
title = db.StringProperty()
class StaticPage(Model):
body = db.TextProperty()
title = db.StringProperty()
class Project(Model):
date = db.DateTimeProperty(auto_now_add=True)
imageFilename = db.StringProperty()
imageUri = db.StringProperty()
thumbnailFilename = db.StringProperty()
thumbnailUri = db.StringProperty()
title = db.StringProperty()
class FileInfo(object):
filename = str()
uri = str()
class ResultSet:
def __init__(self):
self.currentPage = -1
self.firstPage = -1
self.hasNextPage = False
self.hasPreviousPage = False
self.itemCountPerPage = -1
self.items = []
self.lastPage = -1
self.nextPage = -1
self.pageCount = -1
self.previousPage = -1
self.totalItemCount = -1
| Python |
#!/usr/bin/env python
#
import os
import urllib
from google.appengine.ext import blobstore
from google.appengine.ext import webapp
from google.appengine.ext.webapp import blobstore_handlers
from google.appengine.ext.webapp import template
from google.appengine.ext.webapp.util import run_wsgi_app
class MainHandler(webapp.RequestHandler):
def get(self):
upload_url = blobstore.create_upload_url('/upload')
self.response.out.write('<html><body>')
self.response.out.write('<form action="%s" method="POST" enctype="multipart/form-data">' % upload_url)
self.response.out.write("""Upload File: <input type="file" name="file"><br> <input type="submit"
name="submit" value="Submit"> </form></body></html>""")
class UploadHandler(blobstore_handlers.BlobstoreUploadHandler):
def post(self):
upload_files = self.get_uploads('file') # 'file' is file upload field in the form
blob_info = upload_files[0]
self.redirect('/upload_success')
class UploadSuccessHandler(webapp.RequestHandler):
def get(self):
self.response.out.write('<p>asset uploaded!</p>')
self.response.out.write('<p><a href="/upload_form">upload another asset</a></p>')
class ServeHandler(blobstore_handlers.BlobstoreDownloadHandler):
def get(self, resource):
resource = str(urllib.unquote(resource))
blob_info = blobstore.BlobInfo.get(resource)
self.send_blob(blob_info)
def main():
application = webapp.WSGIApplication(
[('/upload_form', MainHandler),
('/upload', UploadHandler),
('/assets/([^/]+)?', ServeHandler),
('/upload_success', UploadSuccessHandler),
], debug=True)
run_wsgi_app(application)
if __name__ == '__main__':
main() | Python |
#!/usr/bin/env python
#
import os
import urllib
from google.appengine.ext import blobstore
from google.appengine.ext import webapp
from google.appengine.ext.webapp import blobstore_handlers
from google.appengine.ext.webapp import template
from google.appengine.ext.webapp.util import run_wsgi_app
class MainHandler(webapp.RequestHandler):
def get(self):
upload_url = blobstore.create_upload_url('/upload')
self.response.out.write('<html><body>')
self.response.out.write('<form action="%s" method="POST" enctype="multipart/form-data">' % upload_url)
self.response.out.write("""Upload File: <input type="file" name="file"><br> <input type="submit"
name="submit" value="Submit"> </form></body></html>""")
class UploadHandler(blobstore_handlers.BlobstoreUploadHandler):
def post(self):
upload_files = self.get_uploads('file') # 'file' is file upload field in the form
blob_info = upload_files[0]
self.redirect('/upload_success')
class UploadSuccessHandler(webapp.RequestHandler):
def get(self):
self.response.out.write('<p>asset uploaded!</p>')
self.response.out.write('<p><a href="/upload_form">upload another asset</a></p>')
class ServeHandler(blobstore_handlers.BlobstoreDownloadHandler):
def get(self, resource):
resource = str(urllib.unquote(resource))
blob_info = blobstore.BlobInfo.get(resource)
self.send_blob(blob_info)
def main():
application = webapp.WSGIApplication(
[('/upload_form', MainHandler),
('/upload', UploadHandler),
('/assets/([^/]+)?', ServeHandler),
('/upload_success', UploadSuccessHandler),
], debug=True)
run_wsgi_app(application)
if __name__ == '__main__':
main() | Python |
Subsets and Splits
SQL Console for ajibawa-2023/Python-Code-Large
Provides a useful breakdown of language distribution in the training data, showing which languages have the most samples and helping identify potential imbalances across different language groups.