def optionalFileTypes(self, list_from_query):
mime_types = []
for element in list_from_query:
ext = re.search(r"\.([A-Za-z0-9-_]+)$", element[0])
if not ext:
continue
ext = ext.group(0)
mime = types_map.get(ext)
if mime:
mime_types.append(types_map.get(ext).split("/")[0])
x = ()
for y in Counter(mime_types).most_common(3):
x += y
x = [str(y) for y in x]
return ','.join(x)
def fileTypes(self, filelist):
mime_types = []
for path_str in filelist:
ext = re.search(r"\.([A-Za-z0-9-_]+)$", path_str)
if not ext:
continue
ext = ext.group(0)
mime = types_map.get(ext)
if mime:
mime_types.append(types_map.get(ext).split("/")[0])
x = ()
for y in Counter(mime_types).most_common(3):
x += y
x = [str(y) for y in x]
return ','.join(x)
def is_image(filename: str, /) -> bool:
"""Returns ``True`` if the filename refers to an image.
:param filename: String representing a path to a file.
:return: ``True`` if the `filename` is a path to an image file, otherwise ``False``.
"""
return types_map.get(path.splitext(filename)[-1], '').startswith('image/')
def _get_name_and_mime(self, doc, frmt, thumbnail, page_num ):
ext = "." + frmt
mimetype = types_map.get(ext, 'application/' + frmt)
if frmt in ('png', 'jpg'):
suffix = '_small.%s' % frmt if thumbnail else '.%s' % frmt
name = "%s_%s%s" % (doc.id,page_num, suffix)
else :
name = get_readable_name(doc) + ext
return name, mimetype
def get(self, request):
# Reboot server
if request == 'reboot':
# Set the mime type
mime = types_map.get(self.REBOOT_TYPE)
# Save the given time
time = self.get_int_query(*self.TIME)
# Load images for the next step
result = self._exp.add_step(time)
# Get a tile
else:
# Set the mime type
mime = types_map.get(self.IMAGE_TYPE)
# Give the requested tile
result = self.parse_tile()
# Set mime type
self.set_header("Content-Type", mime)
# Write result
self.write(result)
def upload_file(self, filename, content):
_, ext = splitext(filename)
content_type = types_map.get(ext)
r = post('%s%s' % (self.FILES_URL, filename), **self._request_kwargs(content_type=content_type, payload=content))
result = loads(r.text)
if 'error' in result:
raise ParseSyncException('Error trying to upload file to Parse.com: %s (%i)' % (result['error'], result['code']))
return result
def get(self, request):
# Reboot server
if request == 'reboot':
# Set the mime type
mime = types_map.get(self.REBOOT_TYPE)
# Save the given time
time = self.get_int_query(*self.TIME)
# Load images for the next step
result = self._exp.add_step(time)
# Get a tile
else:
# Set the mime type
mime = types_map.get(self.IMAGE_TYPE)
# Give the requested tile
result = self.parse_tile()
# Set mime type
self.set_header("Content-Type", mime)
# Write result
self.write(result)
def do_GET(self):
fname, ext = os.path.splitext(self.path)
context = zmq.Context()
socket = context.socket(zmq.PAIR)
socket.bind("tcp://*:5556")
socket.send(self.path.strip('/'))
file = socket.recv_pyobj()
socket.close()
self.send_response(file["status"])
self.send_header('Content-type', types_map.get(ext, "application/octet-stream"))
self.end_headers()
self.wfile.write(file["content"])
def handle_static(self, filepath):
""" Serves a path in the `./bfly/static` directory
Arguments
----------
path: str
the actual path to a file on the server
"""
extension = os.path.splitext(filepath)[1]
# Get the mimetype from the requested extension
mime_type = types_map.get(extension, self._basic_mime)
self.set_header("Content-Type", mime_type)
data = resource_string(self._root, filepath)
self.write(data)
def handle(self, filepath):
""" Serves a path in the `./bfly/static` directory
Arguments
----------
path: str
the actual path to a file on the server
"""
extension = os.path.splitext(filepath)[1]
# Get the mimetype from the requested extension
mime_type = types_map.get(extension, self._basic_mime)
self.set_header("Content-Type", mime_type)
data = resource_string(self._root, filepath)
self.write(data)
def upload_list(self, local_list):
""" upload list of files """
for local_name in local_list:
k = self.bucket.get_key(local_name)
if not k:
k = self.bucket.new_key(local_name)
local_file_path = os.path.join(self.dir, local_name)
if os.path.isfile(local_file_path):
lf = open(local_file_path, "r")
(base_name, ext) = os.path.splitext(local_file_path)
local_hash_tuple = k.compute_md5(lf)
k.set_contents_from_file(lf, md5=local_hash_tuple)
k.set_metadata("Content-Type", types_map.get(ext, "application/octet-stream"))
k.set_metadata("md5-hex", local_hash_tuple[0])
k.set_acl("public-read")
lf.close()
def mime_type(self):
""" Gets the mime type for the file_type
The mime type is from :data:`INPUT.IMAGE` \
if :meth:`is_data`, or :data:`INPUT.INFO` \
otherwise.
Returns
--------
str
The mime type from ``mimetypes.types_map``
"""
info_type = self.INPUT.INFO.FORMAT.VALUE
image_type = self.INPUT.IMAGE.FORMAT.VALUE
# Use image type for data and info type for info
file_type = image_type if self.is_data else info_type
# Get the right mime type or use default for this class
_basic_mime = self._basic_mime.format(file_type)
return types_map.get('.' + file_type, _basic_mime)
def doFlatfile(self, req, name):
'''
return flat file
BEWARE: assumes that the file won't change for a week
'''
try:
kind = name.rsplit('.', 1)[1].lower()
mime = (kind == 'ico') and 'image/x-icon' or types_map.get('.'+kind) \
or 'text/plain' # don't know why '.ico' is missing from types-map...
data = open(name, 'rb').read()
req.request.setHeader('content-type', mime)
# prevent browser from asking for image every page request
# assumes won't change for a week!
req.request.setHeader('expires', httpDate(time.time()+(3600*24*7)))
return data
except:
req.request.setResponseCode(404, "file not found")
# we generally don't want a fancy rendered error page here
return "file not found"
def doFlatfile(self, req, name):
'''
return flat file
BEWARE: assumes that the file won't change for a week
'''
# print ("flat file name >>>>>:", name)
try:
kind = name.rsplit('.', 1)[1].lower()
mime = (kind == 'ico') and 'image/x-icon' or types_map.get('.'+kind) \
or 'text/plain' # don't know why '.ico' is missing from types-map...
data = open(name, 'rb').read()
req.request.setHeader('content-type', mime)
# prevent browser from asking for image every page request
# assumes won't change for a week!
req.request.setHeader('expires',
httpDate(time.time() + (3600 * 24 * 7)))
return data
except:
raise
req.request.setResponseCode(404, b"file not found")
# we generally don't want a fancy rendered error page here
return "file not found"
def choose_content_type(self, extension):
return (types_map.get(extension, None) or
types_map.get(extension.lower(), None) or
"text/plain")
def get_mime(self, extname):
return MIME_TYPE.get(extname, "binary")
def define_mimetype(self):
filename = self.environ["PATH_INFO"]
self.headers["Content-type"] = MIMETYPES.get(path.splitext(filename)[1],
"unknown")
if self.headers["Content-type"] == "unknown":
del self.headers["Content-type"]
def set_content_type(self, path, request):
ext = get_extension(path).lower()
request.response['Content-Type'] = types_map.get(
"." + ext, 'application/octet-stream')
def encode_directory(directory):
u'''
Преобразование содержимого папки и её структуры в вид, пригодный для присоединения
к СМЭВ-сообщению согласно МР 2.4.4-2.5.6.
Результатом выполнения будет кортеж с уникальным GUID кодом (поле заголовка RequestCode)
и закодированный в base64 ZIP-архив с манифестом, файлами директории и соответствующими
файлами подписей.
ZIP-архив формируется в памяти.
:param unicode directory: Путь к папке, содержимое которой необходимо прикрепить.
:return: GUID и закодированный в base64 ZIP-архив.
:rtype: (unicode, unicode)
'''
# Генерируем код запроса
request_code = str(uuid.uuid4())
i = 1
in_memory_file = StringIO()
zip_arc = ZipFile(in_memory_file, 'w')
applied_documents_node = make_node('AppliedDocuments')
for (path, subdirs, files) in os.walk(directory):
for fn in files:
path_to_file = os.path.join(path,
fn).replace('\\',
'/').replace('\\\\', '/')
relative_path = path_to_file[len(directory):].lstrip('/')
dgst = get_file_digest(path_to_file)
dot_pos = fn.find('.')
applied_documents = [
{
'URL':
relative_path,
'Name':
fn,
'DigestValue':
dgst,
# Пытаемся определить MIME-тип файла, но если нет - бинарный файл.
'Type':
mime_types_map.get(fn[dot_pos:],
'application/octet-stream'),
# TODO: выяснить правила генерации кода документа
'CodeDocument':
u'0000',
'Number':
i,
},
# Файл с подписью по PKCS/7
{
'URL': u'%s%s' % (relative_path, '.sig'),
'Name': u'%s.sig' % fn,
'DigestValue': get_text_digest(dgst),
'Type': 'application/x-pkcs7-signature',
'CodeDocument': u'0000',
'Number': i + 1,
}
]
i += 2
for doc in applied_documents:
app_doc_node = make_node('AppliedDocument')
dict_to_xmldoc(app_doc_node, doc)
applied_documents_node.append(app_doc_node)
# Добавляем в ZIP-архив файл и его подпись
zip_arc.write(path_to_file, arcname=relative_path)
zip_arc.writestr('%s.sig' % relative_path, dgst)
# Добавляем в ZIP-архив манифест и его подпись
manifest_str = etree.tostring(applied_documents_node, pretty_print=True)
zip_arc.writestr('req_%s.xml' % request_code, manifest_str.encode('utf-8'))
zip_arc.writestr('req_%s.sig' % request_code,
get_text_digest(manifest_str))
zip_arc.close()
in_memory_file.seek(0)
# Преобразуем ZIP-архив в base64
encoded = base64.b64encode(in_memory_file.read())
in_memory_file.close()
return request_code, encoded
def encode_directory(directory):
u'''
Преобразование содержимого папки и её структуры в вид, пригодный для присоединения
к СМЭВ-сообщению согласно МР 2.4.4-2.5.6.
Результатом выполнения будет кортеж с уникальным GUID кодом (поле заголовка RequestCode)
и закодированный в base64 ZIP-архив с манифестом, файлами директории и соответствующими
файлами подписей.
ZIP-архив формируется в памяти.
:param unicode directory: Путь к папке, содержимое которой необходимо прикрепить.
:return: GUID и закодированный в base64 ZIP-архив.
:rtype: (unicode, unicode)
'''
# Генерируем код запроса
request_code = str(uuid.uuid4())
i = 1
in_memory_file = StringIO()
zip_arc = ZipFile(in_memory_file, 'w')
applied_documents_node = make_node('AppliedDocuments')
for (path, subdirs, files) in os.walk(directory):
for fn in files:
path_to_file = os.path.join(path, fn).replace('\\', '/').replace('\\\\', '/')
relative_path = path_to_file[len(directory):].lstrip('/')
dgst = get_file_digest(path_to_file)
dot_pos = fn.find('.')
applied_documents = [
{
'URL': relative_path,
'Name': fn,
'DigestValue': dgst,
# Пытаемся определить MIME-тип файла, но если нет - бинарный файл.
'Type': mime_types_map.get(fn[dot_pos:], 'application/octet-stream'),
# TODO: выяснить правила генерации кода документа
'CodeDocument': u'0000',
'Number': i,
},
# Файл с подписью по PKCS/7
{
'URL': u'%s%s' % (relative_path, '.sig'),
'Name': u'%s.sig' % fn,
'DigestValue': get_text_digest(dgst),
'Type': 'application/x-pkcs7-signature',
'CodeDocument': u'0000',
'Number': i + 1,
}]
i += 2
for doc in applied_documents:
app_doc_node = make_node('AppliedDocument')
dict_to_xmldoc(app_doc_node, doc)
applied_documents_node.append(app_doc_node)
# Добавляем в ZIP-архив файл и его подпись
zip_arc.write(path_to_file, arcname=relative_path)
zip_arc.writestr('%s.sig' % relative_path, dgst)
# Добавляем в ZIP-архив манифест и его подпись
manifest_str = etree.tostring(applied_documents_node, pretty_print=True)
zip_arc.writestr('req_%s.xml' % request_code, manifest_str.encode('utf-8'))
zip_arc.writestr('req_%s.sig' % request_code, get_text_digest(manifest_str))
zip_arc.close()
in_memory_file.seek(0)
# Преобразуем ZIP-архив в base64
encoded = base64.b64encode(in_memory_file.read())
in_memory_file.close()
return request_code, encoded
def parse_problem(
self,
domain_filename: str,
problem_filename: typing.Optional[str] = None
) -> 'up.model.Problem':
domain_res = self._pp_domain.parseFile(domain_filename)
problem = up.model.Problem(
domain_res['name'],
self._env,
initial_defaults={self._tm.BoolType(): self._em.FALSE()})
types_map: Dict[str, 'up.model.Type'] = {}
object_type_needed: bool = self._check_if_object_type_is_needed(
domain_res)
for types_list in domain_res.get('types', []):
# types_list is a List of 1 or 2 elements, where the first one
# is a List of types, and the second one can be their father,
# if they have one.
father: typing.Optional['up.model.Type'] = None
if len(types_list) == 2: # the types have a father
if types_list[1] != 'object': #the father is not object
father = types_map[types_list[1]]
elif object_type_needed: # the father is object, and object is needed
object_type = types_map.get('object', None)
if object_type is None: # the type object is not defined
father = self._env.type_manager.UserType(
'object', None)
types_map['object'] = father
else:
father = object_type
else:
assert len(
types_list
) == 1, "Malformed list of types, I was expecting either 1 or 2 elements" # sanity check
for type_name in types_list[0]:
types_map[type_name] = self._env.type_manager.UserType(
type_name, father)
if object_type_needed and 'object' not in types_map: # The object type is needed, but has not been defined
types_map['object'] = self._env.type_manager.UserType(
'object', None) # We manually define it.
has_actions_cost = False
for p in domain_res.get('predicates', []):
n = p[0]
params = OrderedDict()
for g in p[1]:
param_type = types_map[g[1] if len(g) > 1 else 'object']
for param_name in g[0]:
params[param_name] = param_type
f = up.model.Fluent(n, self._tm.BoolType(), params, self._env)
problem.add_fluent(f)
for p in domain_res.get('functions', []):
n = p[0]
params = OrderedDict()
for g in p[1]:
param_type = types_map[g[1] if len(g) > 1 else 'object']
for param_name in g[0]:
params[param_name] = param_type
f = up.model.Fluent(n, self._tm.RealType(), params, self._env)
if n == 'total-cost':
has_actions_cost = True
self._totalcost = cast(up.model.FNode, self._em.FluentExp(f))
problem.add_fluent(f)
for g in domain_res.get('constants', []):
t = types_map[g[1] if len(g) > 1 else 'object']
for o in g[0]:
problem.add_object(up.model.Object(o, t))
for a in domain_res.get('actions', []):
n = a['name']
a_params = OrderedDict()
for g in a.get('params', []):
t = types_map[g[1] if len(g) > 1 else 'object']
for p in g[0]:
a_params[p] = t
if 'duration' in a:
dur_act = up.model.DurativeAction(n, a_params, self._env)
dur = a['duration'][0]
if dur[0] == '=':
dur_act.set_fixed_duration(
self._parse_exp(problem, dur_act, types_map, {},
dur[2]))
elif dur[0] == 'and':
upper = None
lower = None
for j in range(1, len(dur)):
v = Fraction(dur[j][2])
if dur[j][0] == '>=':
if lower is None or v > lower:
lower = v
elif dur[j][0] == '<=':
if upper is None or v < upper:
upper = v
else:
raise SyntaxError(
f'Not able to handle duration constraint of action {n}'
)
if lower is None or upper is None:
raise SyntaxError(
f'Not able to handle duration constraint of action {n}'
)
d = up.model.ClosedDurationInterval(
self._em.Real(lower), self._em.Real(upper))
dur_act.set_duration_constraint(d)
else:
raise SyntaxError(
f'Not able to handle duration constraint of action {n}'
)
cond = a['cond'][0]
self._add_condition(problem, dur_act, cond, types_map)
eff = a['eff'][0]
self._add_timed_effects(problem, dur_act, types_map, eff)
problem.add_action(dur_act)
has_actions_cost = has_actions_cost and self._durative_action_has_cost(
dur_act)
else:
act = up.model.InstantaneousAction(n, a_params, self._env)
if 'pre' in a:
act.add_precondition(
self._parse_exp(problem, act, types_map, {},
a['pre'][0]))
if 'eff' in a:
self._add_effect(problem, act, types_map, a['eff'][0])
problem.add_action(act)
has_actions_cost = has_actions_cost and self._instantaneous_action_has_cost(
act)
if problem_filename is not None:
problem_res = self._pp_problem.parseFile(problem_filename)
problem.name = problem_res['name']
for g in problem_res.get('objects', []):
t = types_map[g[1] if len(g) > 1 else 'object']
for o in g[0]:
problem.add_object(up.model.Object(o, t))
for i in problem_res.get('init', []):
if i[0] == '=':
problem.set_initial_value(
self._parse_exp(problem, None, types_map, {}, i[1]),
self._parse_exp(problem, None, types_map, {}, i[2]))
elif len(i) == 3 and i[0] == 'at' and i[1].replace(
'.', '', 1).isdigit():
ti = up.model.StartTiming(Fraction(i[1]))
va = self._parse_exp(problem, None, types_map, {}, i[2])
if va.is_fluent_exp():
problem.add_timed_effect(ti, va, self._em.TRUE())
elif va.is_not():
problem.add_timed_effect(ti, va.arg(0),
self._em.FALSE())
elif va.is_equals():
problem.add_timed_effect(ti, va.arg(0), va.arg(1))
else:
raise SyntaxError(f'Not able to handle this TIL {i}')
else:
problem.set_initial_value(
self._parse_exp(problem, None, types_map, {}, i),
self._em.TRUE())
problem.add_goal(
self._parse_exp(problem, None, types_map, {},
problem_res['goal'][0]))
has_actions_cost = has_actions_cost and self._problem_has_actions_cost(
problem)
optimization = problem_res.get('optimization', None)
metric = problem_res.get('metric', None)
if metric is not None:
if optimization == 'minimize' and len(
metric) == 1 and metric[0] == 'total-time':
problem.add_quality_metric(
up.model.metrics.MinimizeMakespan())
else:
metric_exp = self._parse_exp(problem, None, types_map, {},
metric)
if has_actions_cost and optimization == 'minimize' and metric_exp == self._totalcost:
costs = {}
problem._fluents.remove(self._totalcost.fluent())
problem._initial_value.pop(self._totalcost)
use_plan_length = all(
False for _ in problem.durative_actions)
for a in problem.instantaneous_actions:
cost = None
for e in a.effects:
if e.fluent == self._totalcost:
cost = e
break
if cost is not None:
costs[a] = cost.value
a._effects.remove(cost)
if cost.value != 1:
use_plan_length = False
else:
use_plan_length = False
if use_plan_length:
problem.add_quality_metric(
up.model.metrics.MinimizeSequentialPlanLength(
))
else:
problem.add_quality_metric(
up.model.metrics.MinimizeActionCosts(
costs, self._em.Int(0)))
else:
if optimization == 'minimize':
problem.add_quality_metric(
up.model.metrics.
MinimizeExpressionOnFinalState(metric_exp))
elif optimization == 'maximize':
problem.add_quality_metric(
up.model.metrics.
MaximizeExpressionOnFinalState(metric_exp))
return problem
