def _cfn_param_updater(self, param, comparison_parameters,
stage_parameters):
"""
Generic CFN Updater method
"""
resolver = Resolver(self.parameter_store, stage_parameters,
comparison_parameters)
for key, value in comparison_parameters[param].items():
if str(value).startswith('resolve:'):
if resolver.fetch_parameter_store_value(value, key, param):
continue
if str(value).startswith('import:'):
if resolver.fetch_stack_output(value, key, param):
continue
resolver.update_cfn(key, param)
for key, value in stage_parameters[param].items():
if str(value).startswith('resolve:'):
if resolver.fetch_parameter_store_value(value, key, param):
continue
if str(value).startswith('import:'):
if resolver.fetch_stack_output(value, key, param):
continue
return resolver.__dict__.get('stage_parameters')
def __init__(self, url, uid, storage):
"""
@param url: monitored URL
@type url: basestring (str or unicode)
@param uid: user identifier. This ID has to be unique for each one,
who is using changemonitor.
@type uid: str
@param storage: storage of monitored-resource data
@type storage: model.Storage
"""
# resource data
self.url = url
self.uid = uid
# models
self.storage = storage
self.headers = storage._headermeta
# resolver
self.resolver = Resolver(storage)
# file
try:
self.file = self.storage.get(url)
except DocumentNotAvailable:
# if the file is not in the storage, resolver has to check
# the url and load actual data into the storage
self.resolver.resolve(url)
try:
self.file = self.storage.get(url)
except DocumentNotAvailable:
raise DocumentNotAvailable("Resource '%s' is not available." % url)
def _sc_param_updater(self, comparison_parameters, stage_parameters):
"""
Compares parameter files used for the Service Catalog deployment type
"""
resolver = Resolver(self.parameter_store, stage_parameters,
comparison_parameters)
for key, value in comparison_parameters.items():
if str(value).startswith('resolve:'):
if resolver.fetch_parameter_store_value(value, key):
continue
if str(value).startswith('import:'):
if resolver.fetch_stack_output(value, key):
continue
resolver.update_sc(key)
for key, value in stage_parameters.items():
if str(value).startswith('resolve:'):
if resolver.fetch_parameter_store_value(value, key):
continue
if str(value).startswith('import:'):
if resolver.fetch_stack_output(value, key):
continue
return resolver.__dict__.get('stage_parameters')
def run(line: str):
scanner: Scanner = Scanner(line, error_scan)
tokens: List[Token] = scanner.scanTokens()
parser: Parser = Parser(tokens, error_parse)
statements: List[stmt.Stmt] = parser.parse()
# // Stop if there was a syntax error.
if hadError:
return
interpreter: Interpreter = Interpreter(runtimeError)
resolver: Resolver = Resolver(interpreter, error_scan)
resolver.resolve(statements)
# // Stop if there was a resolution error.
if hadError:
return
if os.environ.get("DEBUG"):
print("**TOKENS**")
for t in tokens:
print(t)
print("**STATEMENTS**")
for s in statements:
print(s)
ipdb.set_trace()
interpreter.interpret(statements)
def test_finds_source_from_js_component_folder(self):
file = "/test/js/components/FileRenamePrompt-test.js"
r = Resolver().get_source(file, spec_folder="test")
self.assertEqual(len(r), 2)
self.assertEqual(r[0],
"/app/javascript/components/FileRenamePrompt.vue")
self.assertEqual(r[1], "/javascript/components/FileRenamePrompt.vue")
def test_finds_source_from_erb(self):
file = "/spec/views/namespace/users/_something.html.erb_spec.rb"
r = Resolver().get_source(file)
self.assertEqual(len(r), 2)
self.assertEqual(r[0],
"/app/views/namespace/users/_something.html.erb")
self.assertEqual(r[1], "/views/namespace/users/_something.html.erb")
def __init__(self,
conf=Config.default,
user=None,
host=None,
reactor=reactor):
"""Construct a new client context
Prepare a new context with the given config.
If user and host are None then they are collected
from the environment.
"""
self.conf, self.reactor = conf, reactor
self.circuits = CACircuitFactory(self)
self.resolv = Resolver(self.circuits, conf)
self._onClose = DeferredManager()
if host is None:
from socket import gethostname
host = gethostname()
self.host = host
if user is None:
from getpass import getuser
user = getuser()
self.user = user
reactor.addSystemEventTrigger("before", "shutdown", self.close)
def run(self):
""" Run the handler thread """
recv_header = self.received_message.header
try:
questions = self.received_message.questions[0]
qd_count = len(questions)
except IndexError:
return
# if recv_header.rd:
try:
resolver = Resolver(True)
answer_sname, addresses, aliasses = resolver.gethostbyname(questions[0].rdata.data)
except ResolverException as e:
print e
return
answers = list()
for address in addresses:
answer = message.Section(answer_sname, Type.A, Class.IN, 86400, len(address), address)
answers.append(answer)
send_header = message.Header(recv_header.ident, 0, qd_count, len(addresses), 0, 0)
send_header.qr = 1
send_header.opcode = 0
send_header.rd = recv_header.rd
response_message = message.Message(send_header, questions, answers)
response_bytes = response_message.to_bytes()
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(3)
sock.send(response_bytes, (self.ip_address, 53))
def _param_updater(self, comparison_parameters, stage_parameters):
"""
Generic Parameter Updater method
"""
resolver = Resolver(self.parameter_store, stage_parameters, comparison_parameters)
self._determine_parameter_structure(comparison_parameters, resolver)
self._determine_parameter_structure(stage_parameters, resolver)
return resolver.__dict__.get('stage_parameters')
def main():
parser = create_parser()
parsed_args = parser.parse_args(sys.argv[1:])
dns_addr = parsed_args.start_server
resolver = Resolver(dns_addr)
try:
resolver.start_listening()
except socket.error:
sys.exit()
def run_server(ip='0.0.0.0'):
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind((ip, 53))
except socket.error as e:
logging.error(e)
return
while True:
data, addr = s.recvfrom(1024)
ret = Resolver(data).do()
s.sendto(ret, addr)
def test_resolver(self):
from resolver import Resolver
import pytis.presentation
r = Resolver(search=('pytis', 'pytis.defs.profiles'))
view = r.get('cms.Languages', 'view_spec')
self.assertIsInstance(view, pytis.presentation.ViewSpec)
spec = r.specification('cms.Languages')
self.assertIsInstance(spec, pytis.presentation.Specification)
# Test top level specification name (from pytis.defs.profiles).
spec2 = r.specification('FormProfiles')
self.assertIsInstance(spec2, pytis.presentation.Specification)
specifications = [spec for name, spec in r.walk()]
from pytis.cms import Languages
self.assertIn(Languages, specifications)
def run(self, source):
scanner = Scanner(source, self)
tokens = scanner.scan_tokens()
parser = Parser(self, tokens)
statements = parser.parse()
if self.hadError:
return
if self.had_runtime_error:
return
resolver = Resolver(self.interpreter, self)
resolver.resolve(statements)
if self.hadError:
return
self.interpreter.interpret(statements)
def __init__(self, handlers=None):
if not handlers:
handlers = []
AsyncHTTPClient.configure(
"tornado.curl_httpclient.CurlAsyncHTTPClient",
max_clients=CURL['MAX_CLIENTS'],
)
self.cache = RedisCache(**REDIS['CLIENT'])
self.cache.initialize(**REDIS['TORNADO_CLIENT'])
tornado.ioloop.IOLoop.instance().add_future(
self.cache.run(), lambda future: future.result())
Api = get_db_api(is_cached=True)
self.db_api = Api(
DB_API['HOST'],
DB_API['PORT'],
http_client=AsyncHTTPClient(),
resolver=Resolver(ttl=DNS_RECORD_TTL),
cache=self.cache,
cache_key_ttl=DB_API['CACHE_KEY_TTL'],
connect_timeout=CURL['CONNECT_TIMEOUT'],
request_timeout=CURL['REQUEST_TIMEOUT'],
)
self.jinja = Environment(loader=FileSystemLoader(
JINJA['TEMPLATE_ROOT']),
**JINJA['SETTINGS'])
handlers += [
(r'/db/(?P<api_path>.*)', DBApiRequestHandler),
]
if DEBUG:
handlers += [
(r'/test/', TestView),
]
config = dict(debug=DEBUG, )
tornado.web.Application.__init__(self, handlers, **config)
def resolve_file(filename):
parser = Parser()
try:
with open(filename, 'r') as file:
for line in file:
line = re.sub('\s', '', line)
line_is_ignored = ignored_line.match(line)
if line_is_ignored is not None:
continue
try:
parser.handle_line(line)
except ParseError as exception:
print(
colored(
'Parse error of type : {} detected on line\n\t --> {}'
.format(exception.exception_type, line), 'red'))
raise FileError()
if not parser.queries:
print(colored('No queries furnished', 'red'))
raise FileError
if args.verbose:
print(parser)
resolver = Resolver(parser.facts, parser.rules, args.verbose)
for query in parser.queries:
try:
if args.verbose:
print(
colored('Query to solve : {}'.format(query), 'yellow'))
response = resolver.resolve_query(query)
print(
colored(
'query {} has been resolved to : {}'.format(
query, response), 'green'))
except ContradictionError as exception:
print(
colored(
'Contradiction detected on {0} that is {1} while his opposite is also {1}'
.format(exception.name, exception.value), 'red'))
except (FileNotFoundError, NameError, PermissionError, IsADirectoryError,
UnicodeDecodeError) as error:
print(colored(error, 'red'))
raise FileError()
def cli():
path = input("Введите путь до изображения:\n")
image_analyzer = ImageAnalyzer()
image_analyzer.read_image(path)
print("{} прочитано".format(path))
image_analyzer.process_xo()
main_map = image_analyzer.get_map()
print("Расчет анализатора:\n {}".format(main_map))
print("0 - пустота, 1 - Х, 2 - О")
resolver = Resolver(main_map)
res_points = resolver.resolve()
print("Ответ алгоритма: {}".format(res_points))
if image_analyzer.process_output(res_points):
print("Результат в файле output.pnt")
print("Done")
def run(self, source: str):
scanner = Scanner(self, source)
tokens = scanner.scan_tokens()
if DEBUG:
print(tokens)
parser = Parser(self, tokens)
statements = parser.parse()
if self.had_error:
return
resolver = Resolver(self, self.interpreter)
resolver.resolve_statements(statements)
if self.had_error:
return
self.interpreter.interpret(statements)
def __init__(self):
self.resolver = Resolver()
def play(url):
from resolver import Resolver
r = Resolver(url)
items.play_item(r.resolved_url, r.startpercent)
def test_finds_source_for_noncomponent(self):
file = "/test/js/utils/string-utils-test.js"
r = Resolver().get_source(file, spec_folder="test")
self.assertEqual(len(r), 2)
self.assertEqual(r[0], "/app/javascript/utils/string-utils.js")
def test_finds_source_from_py(self):
file = "/tests/something/foo_test.py"
r = Resolver().get_source(file, spec_folder="tests")
self.assertEqual(len(r), 2)
self.assertEqual(r[0], "/app/something/foo.py")
self.assertEqual(r[1], "/something/foo.py")
def step_three(self, ast):
resolver = Resolver(ast)
resolver.traverse()
from resolver import Resolver
from timeit import timeit
resolve = Resolver()
time_elapsed = timeit(setup='from __main__ import resolve ',
stmt='resolve("google.com")',
number=1)
print("Time elapsed for google.com:{0:f}".format(time_elapsed))
time_elapsed = timeit(setup='from __main__ import resolve ',
stmt='resolve("google.com")',
number=1)
print("Time elapsed for google.com:{0:f}".format(time_elapsed))
print("Is microsoft.com present in resolve cache:{0}".format(
resolve.has_host("microsoft.com")))
resolve("microsoft.com")
print("Is microsoft.com present in resolve cache:{0}".format(
resolve.has_host("microsoft.com")))
resolve.clear()
print("Is microsoft.com present in resolve cache:{0}".format(
resolve.has_host("microsoft.com")))
def __init__(self,
base="http://repo1.maven.org/maven2",
username=None,
password=None):
self.requestor = Requestor(username, password)
self.resolver = Resolver(base, self.requestor)
from resolver import Resolver r = Resolver() r.import_file() print(r.df.info()) print(r.build())
import json
import flask
from resolver import Resolver
app = flask.Flask(__name__)
app.resolver = Resolver()
@app.route('/')
def resolve_refstring():
"""
A very simple wrapper around our Resolver class to serve an API with the
desired functionality.
"""
refstring = flask.request.values.get('refstring', '')
return flask.jsonify({
'refstring': refstring,
'bibcode': app.resolver.make_bibcode(refstring)
})
def run():
app.run()
def play(url):
from resolver import Resolver
r = Resolver(url)
items.play_item(r.resolved_url)
if r.seektime:
items.seek_item(r.seektime)
def setUp(self):
self.resolver = Resolver()
with open('refsample.json') as f:
self.refmap = json.loads(f.read())
def __init__(self):
self.resolver = Resolver()
self.thread = Thread(target=self.run, args=()).start()
def process(opts):
print('start with files', opts.filename)
project = Project()
project.loadLib()
project.opts = opts
codeunits = []
gmlparser = codeparser
print('opts.gmllib', opts.gmllib)
typeMatcher = TypeMatcher()
astInterpreter = Interpreter()
astInterpreter.project = project
visitors = []
visitors.append(OwnerInitializer())
visitors.append(PreExpander())
visitors += [NameCacher(), NameResolver(), ScriptProcessor(), Resolver()]
for filename in opts.filename:
print('try parse file', filename)
codeunit = Table()
codeunits.append(codeunit)
codeunit.filename = filename
codeunit.parser = gmlparser
print('codeunit parse', filename, codeunit.filename)
ast = codeunit.parser.parse(open(filename).read(), filename)
print('codeunit parse ok', filename, ast)
ast.pkg = project.getPackage(ast.packageDef.path)
ast.lib = None
ast.project = project
ast.basename = os.path.splitext(os.path.basename(filename))[0]
ast.filename = filename
ast.name = ast.basename
assert ast.name, filename
codeunit.name = ast.basename
codeunit.ast = ast
setattr(codeunit.ast, typeMatcher.name, typeMatcher)
codeunit.ast.visitors = []
astDir = os.path.join(
opts.outputdir, *
ast.packageDef.path) if ast.packageDef.path else opts.outputdir
codeunit.ast.package_directory = astDir
codeunit.ast.package_path = '/'.join(codeunit.ast.packageDef.path)
# print('codeunit astDir=%s' % astDir, ast.pkg.path, ast.name)
if not os.path.exists(astDir):
os.makedirs(astDir)
codeunit.ast.setOwner(codeunit.ast.pkg)
for unit in project.libUnits:
unit.project = project
unit.pkg = project.getPackage(unit.packageDef.path)
unit.setOwner(unit.pkg)
project.visitorStack[0] = []
i = 0
analyzeStartTime = time.time()
for i in range(len(visitors)):
visitor = visitors[i]
j = 0
visitor.project = project
for unit in project.libUnits:
startTime = time.time()
visitor.visit(unit)
usedTime = time.time() - startTime
print('visit lib unit ok', unit.name, usedTime, unit)
for codeunit in codeunits:
j += 1
# print('visit ast', visitor.name, codeunit.ast.name, codeunit.ast.filename, i, j, codeunit.name)
assert (codeunit.ast.filename == codeunit.filename)
assert (codeunit.ast.name == codeunit.name)
startTime = time.time()
visitor.visit(codeunit.ast)
usedTime = time.time() - startTime
print('visit code unit ok', codeunit.ast.name, usedTime,
codeunit.ast)
# print('visit ast ok.', codeunit.ast.name, codeunit.ast.filename, visitor, codeunit, i, j, codeunit.name, codeunit, codeunit.ast)
assert (codeunit.ast.filename == codeunit.filename)
assert (codeunit.ast.name == codeunit.name)
astfilename = os.path.join(
codeunit.ast.package_directory,
'%s.%s.txt' % (codeunit.ast.name, visitor.opname))
# print('open file astfilename', astfilename, codeunit.ast.package_directory, codeunit.ast.name)
if visitor.opname == 'cacheName':
project.initPrelude()
project.loadPrelude()
project.visitorStack[0].append(visitor)
print('analyze ok', time.time() - analyzeStartTime)
if opts.interpreter:
evalStartTime = time.time()
astInterpreter.evaluateGlobalVar(codeunits)
ret = astInterpreter.execute('gml.runMain'.split('.'), sys.argv[:])
print('evaluate ok', time.time() - evalStartTime)
return ret
return True
