#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import OutputMessageConnector #import modułów konektora msg_stream_connector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
import cv2 #import modułu biblioteki OpenCV
import Tkinter as tk #import modułu biblioteki Tkinter -- okienka
import subprocess
service_controller = DevServiceController(
"filter_video_service.json"
) #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection(
"videoInput", OutputMessageConnector(service_controller)
) #deklaracja interfejsu wyjściowego konektora msg_stream_connector, należy zwrócić uwagę, iż identyfikator musi być zgodny z WEJŚCIEM usługi, do której "zaślepka" jest podłączana
service_controller2 = DevServiceController("save_video_service.json")
service_controller3 = DevServiceController("filter_audio_service.json")
service_controller3.declare_connection(
"audioInput", OutputMessageConnector(service_controller3))
def update_all(root, cap, filters):
read_successful, frame = cap.read() #odczyt obrazu z kamery
###############################################################
# tu ma być czytanie audio frame po framie
###############################################################
new_filters = set()
if check1.get() == 1: #sprawdzenie czy checkbox był zaznaczony
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import Tkinter as tk
import threading
#import modułów konektora msg_stream_connector
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import InputMessageConnector
#import modułu klasy testowego kontrolera usługi
from ComssServiceDevelopment.development import DevServiceController
import cv2 #import modułu biblioteki OpenCV
import numpy as np #import modułu biblioteki Numpy
#utworzenie obiektu kontroletra testowego, jako parametr podany
#jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller = DevServiceController("src/output_descriptor.json")
#deklaracja interfejsu wejściowego konektora msg_stream_connector,
#należy zwrócić uwagę, iż identyfikator musi być zgodny z WYJŚCIEM usługi,
#do której "zaślepka" jest podłączana
service_controller.declare_connection(
"videoOutput", InputMessageConnector(service_controller))
#utworzenie połączenia wejściwoego należy zwrócić uwagę,
#iż identyfikator musi być zgodny z WYJŚCIEM usługi,
#do której "zaślepka" jest podłączana
connection = service_controller.get_connection("videoOutput")
print 'starting output script'
#główna pętla programu
while True:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import OutputMessageConnector
from ComssServiceDevelopment.development import DevServiceController
import sys
import cv2
import json
from Tkinter import *
service_controller = DevServiceController("src/input_descriptor.json")
service_controller.declare_connection("out1", OutputMessageConnector(service_controller))
hosts = {
# "resize" :"localhost:11113",
"loop_detection":"localhost:11115",
"gif_encoder" :"localhost:11116"
}
fields = ('max_gif_length [s]',
'min_gif_length [s]',
'min_time_between_gifs [s]',
'max_acceptable_distance',
'smudge_length [frames]',
'smudge_opacity [0-1]')
start_vals = ('3',
'1.5',
'0.5',
'1000',
import matplotlib.animation as animation
from ComssServiceDevelopment.connectors.tcp.object_connector import InputObjectConnector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
TITLE = 'Analiza spektrum'
FPS = 25.0
nFFT = 1024
RATE = 44100
#próg szumu
background_noise = 0.5
current_note = 0
service_controller = DevServiceController("configuration.json") #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection("outputGraph", InputObjectConnector(service_controller)) #deklaracja interfejsu wejściowego konektora msg_stream_connector, należy zwrócić uwagę, iż identyfikator musi być zgodny z WYJŚCIEM usługi, do której "zaślepka" jest podłączana
connection = service_controller.get_connection("outputGraph")
fig = plt.figure()
#zakres częstotliwości
x_f = 1.0 * np.arange(-nFFT / 2 + 1, nFFT / 2) / nFFT * RATE
half_x_f = x_f[1::2]
ax = fig.add_subplot(111, title=TITLE, xlim=(x_f[0], x_f[-1]), ylim=(0, 2 * np.pi * nFFT**2 / RATE))
ax.set_yscale('symlog', linthreshy=nFFT**0.5)
line, = ax.plot(x_f, np.zeros(nFFT - 1))
def data_gen():
prev_note = 0
while True:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.stream_connector import OutputStreamConnector
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import OutputMessageConnector #import modułów konektora msg_stream_connector
from ComssServiceDevelopment.connectors.tcp.object_connector import OutputObjectConnector #import modułów konektora object_connector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
import pyaudio
import json
import Tkinter as tk #import modułu biblioteki Tkinter -- okienka
service_controller = DevServiceController("audioVolumeService.json") #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection("audioInput", OutputStreamConnector(service_controller)) #deklaracja interfejsu wyjściowego konektora msg_stream_connector, należy zwrócić uwagę, iż identyfikator musi być zgodny z WEJŚCIEM usługi, do której "zaślepka" jest podłączana
service_controller.declare_connection("filtersOnInput", OutputObjectConnector(service_controller)) #analogicznie jak wyżej dla interfesju sterującego
#record
CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
RECORD_SECONDS = 1
def update_all(root, stream, filters):
#frames = []
#for i in range(0, int(RATE/CHUNK*RECORD_SECONDS)):
#data = stream.read(CHUNK)
# frames.append(data)
# read_successful\
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import OutputMessageConnector
from ComssServiceDevelopment.development import DevServiceController
from GifConverter import video_info
print 'starting stub input script'
if len(sys.argv) < 3:
print 'provide FFMPEG_BIN and video file as args'
print 'provided: ' + str(sys.argv[1:])
exit()
ffmpeg_bin = sys.argv[1]
file_path = sys.argv[2]
config_name = os.path.join( os.path.dirname(__file__), "service.json")
service_controller = DevServiceController(config_name)
service_controller.declare_connection("videoInput", OutputMessageConnector(service_controller))
timer = 2.0 # seconds
send_val = 1
def send_msg():
global send_val
print send_val
# send
if send_val == 3:
print '\tsend cmd !'
msg_obj = {
'path': file_path,
'w': w,
'h': h,
'frames': frames
__author__ = 'michal'
from ComssServiceDevelopment.development import DevServiceController
from ComssServiceDevelopment.connectors.tcp.object_connector import OutputObjectConnector
service_controller = DevServiceController('service.json')
service_controller.declare_connection("In", OutputObjectConnector(service_controller))
if __name__ == "__main__":
__doc__ = 'test of StorageService'
with open('Post.txt', 'rU') as f:
read_data = f.read()
input_con = service_controller.get_connection("In")
input_con.send(read_data)
raw_input("Press Enter to continue...")
input_con.close()
__author__ = 'michal'
from ComssServiceDevelopment.development import DevServiceController
from myObjectConnector.MyObjectConnector import MyInputObjectConnector
service_controller = DevServiceController('service.json')
service_controller.declare_connection(
"SniffService", MyInputObjectConnector(service_controller))
if __name__ == "__main__":
__doc__ = 'MySnifferService test'
input_con = service_controller.get_connection("SniffService")
while True:
msg = input_con.my_read()
print(msg)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import OutputMessageConnector #import modułów konektora msg_stream_connector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
import cv2 #import modułu biblioteki OpenCV
import Tkinter as tk #import modułu biblioteki Tkinter -- okienka
service_controller = DevServiceController("filter1service.json") #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection("videoInput", OutputMessageConnector(service_controller)) #deklaracja interfejsu wyjściowego konektora msg_stream_connector, należy zwrócić uwagę, iż identyfikator musi być zgodny z WEJŚCIEM usługi, do której "zaślepka" jest podłączana
def update_all(root, cam):
read_successful, frame = cam.read() #odczyt obrazu z kamery
if (frame is not None):
frame_dump = frame.dumps() #zrzut ramki wideo do postaci ciągu bajtów
service_controller.get_connection("videoInput").send(frame_dump) #wysłanie danych
root.update()
root.after(20, func=lambda: update_all(root, cam))
def authorize():
service_controller.update_params({"authorizationOn": 1}) #zmiana wartości parametru "authorizationOn" jezeli przycisk byl kliniety
root = tk.Tk()
root.title("Autoryzacja") #utworzenie okienka
cam = cv2.VideoCapture(0) #"podłączenie" do strumienia wideo z kamerki
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.object_connector import OutputObjectConnector
from ComssServiceDevelopment.development import DevServiceController
import random
import json
import time
service_controller = DevServiceController("alarmService.json")
service_controller.declare_connection("czujnikOpadowInput", OutputObjectConnector(service_controller))
stacje = ['Bardo', 'Boboszów', 'Bystrzyca', 'Darnków', 'Duszniki', 'Gorzuchów', 'Kłodzko', 'Krosnowice', 'Kudowa Zdr.',
'Lądek Zdr.']
obj={}
#Generowanie wartości opadów
def update_all():
obj.clear()
for s in stacje:
wartosc = random.random()*600
obj[s] = wartosc
# return obj
service_controller.get_connection("czujnikOpadowInput").send(obj) #wysłanie wartości parametrow z czujnika
while True:
z = update_all()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.udp.multicast import OutputMulticastConnector
from ComssServiceDevelopment.development import DevServiceController
import dpkt
import time
import sys
import pickle
import socket
service_controller = DevServiceController("tcp_splitter/tcp_splitter.json")
service_controller.declare_connection("pcapInput", OutputMulticastConnector(service_controller))
class P():
def __init__(self,ts,buf):
self.ts=ts
self.buf=buf
def open_pcap(file_name):
f = open(file_name,"rb") #works only in binary mode
p = dpkt.pcap.Reader(f)
return p
def packetizer(p):
for ts, buf in p:
yield (ts,buf)
print ts, len(buf)
print "+++++++++++++++++++++"
# yield (ts,str(e))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import Tkinter as tk
import threading
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import InputMessageConnector #import modułów konektora msg_stream_connector
from ComssServiceDevelopment.connectors.tcp.object_connector import InputObjectConnector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
import cv2 #import modułu biblioteki OpenCV
import numpy as np #import modułu biblioteki Numpy
service_controller = DevServiceController("picasso.json") #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection("videoOutput", InputMessageConnector(service_controller))
service_controller.declare_connection("debugOutput", InputObjectConnector(service_controller))
connection = service_controller.get_connection("videoOutput")
conn_objs = service_controller.get_connection("debugOutput")
while True: #główna pętla programu
objects = conn_objs.read()
obj = connection.read() #odczyt danych z interfejsu wejściowego
frame = np.loads(obj) #załadownaie ramki do obiektu NumPy
#print objects
cv2.imshow('Preview',frame) #wyświetlenie ramki na ekran
cv2.waitKey(1)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import Tkinter as tk
import threading
#import modułów konektora msg_stream_connector
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import InputMessageConnector
#import modułu klasy testowego kontrolera usługi
from ComssServiceDevelopment.development import DevServiceController
import cv2 #import modułu biblioteki OpenCV
import numpy as np #import modułu biblioteki Numpy
#utworzenie obiektu kontroletra testowego, jako parametr podany
#jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller = DevServiceController("src/output_descriptor.json")
#deklaracja interfejsu wejściowego konektora msg_stream_connector,
#należy zwrócić uwagę, iż identyfikator musi być zgodny z WYJŚCIEM usługi,
#do której "zaślepka" jest podłączana
service_controller.declare_connection("videoOutput", InputMessageConnector(service_controller))
#utworzenie połączenia wejściwoego należy zwrócić uwagę,
#iż identyfikator musi być zgodny z WYJŚCIEM usługi,
#do której "zaślepka" jest podłączana
connection = service_controller.get_connection("videoOutput")
print 'starting output script'
#główna pętla programu
while True:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import OutputMessageConnector
from ComssServiceDevelopment.development import DevServiceController
import sys
import cv2
import json
from Tkinter import *
service_controller = DevServiceController("src/input_descriptor.json")
service_controller.declare_connection(
"out1", OutputMessageConnector(service_controller))
hosts = {
# "resize" :"localhost:11113",
"loop_detection": "localhost:11115",
"gif_encoder": "localhost:11116"
}
fields = ('max_gif_length [s]', 'min_gif_length [s]',
'min_time_between_gifs [s]', 'max_acceptable_distance',
'smudge_length [frames]', 'smudge_opacity [0-1]')
start_vals = ('3', '1.5', '0.5', '1000', '5', '0.3')
print '>starting input script'
def _send_params_to_host(host_str, new_params):
__author__ = 'michal'
from ComssServiceDevelopment.development import DevServiceController
from ComssServiceDevelopment.connectors.tcp.object_connector import OutputMessageConnector
service_controller = DevServiceController('service.json')
service_controller.declare_connection(
"In", OutputMessageConnector(service_controller))
if __name__ == "__main__":
__doc__ = 'test of MyService'
service_controller.get_connection("In").send('SomStringToService')
service_controller.get_connection("In").close()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import InputMessageConnector #import modułów konektora msg_stream_connector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
import cv2 #import modułu biblioteki OpenCV
import numpy as np #import modułu biblioteki Numpy
service_controller = DevServiceController(
"save_video_service.json"
) #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection(
"videoOutput", InputMessageConnector(service_controller)
) #deklaracja interfejsu wejściowego konektora msg_stream_connector, należy zwrócić uwagę, iż identyfikator musi być zgodny z WYJŚCIEM usługi, do której "zaślepka" jest podłączana
connection = service_controller.get_connection(
"videoOutput"
) #utworzenie połączenia wejściwoego należy zwrócić uwagę, iż identyfikator musi być zgodny z WYJŚCIEM usługi, do której "zaślepka" jest podłączana
while True: #główna pętla programu
try:
obj = connection.read() #odczyt danych z interfejsu wejściowego
frame = np.loads(obj) #załadownaie ramki do obiektu NumPy
cv2.imshow('Camera', frame) #wyświetlenie ramki na ekran
cv2.waitKey(1)
except Exception as e:
connection.close()
cv2.destroyAllWindows()
break
# -*- coding: utf-8 -*-
import json
from ComssServiceDevelopment.connectors.tcp.object_connector import InputObjectConnector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
service_controller = DevServiceController(
"alarmService.json"
) #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection(
"wynikPredykcjiOutput", InputObjectConnector(
service_controller)) #analogicznie jak wyżej dla drugiego interfejsu
#Output zapisuje do pliku wynik.json w celu wykorzystania do wywietlania danych na stronie
wynik = service_controller.get_connection("wynikPredykcjiOutput")
while True: #główna pętla programu
obj = wynik.read() #odczyt danych z interfejsu wejściowego
z = json.dumps(obj, indent=1, ensure_ascii=False).encode('utf-8')
f = open('wynik.json', 'w')
f.write(z)
f.close()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import Tkinter as tk
import threading
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import InputMessageConnector #import modułów konektora msg_stream_connector
from ComssServiceDevelopment.connectors.tcp.stream_connector import InputStreamConnector
from ComssServiceDevelopment.connectors.tcp.object_connector import InputObjectConnector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
import pyaudio
import numpy as np #import modułu biblioteki Numpy
service_controller = DevServiceController("audioVolumeService.json") #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection("audioOutput", InputStreamConnector(service_controller)) #deklaracja interfejsu wejściowego konektora msg_stream_connector, należy zwrócić uwagę, iż identyfikator musi być zgodny z WYJŚCIEM usługi, do której "zaślepka" jest podłączana
service_controller.declare_connection("filtersOnOutput", InputObjectConnector(service_controller)) #analogicznie jak wyżej dla drugiego interfejsu
CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
RECORD_SECONDS = 20
WAVE_OUTPUT_FILENAME = "server_output7.wav"
WIDTH = 2
frames = []
p = pyaudio.PyAudio()
stream = p.open(format=p.get_format_from_width(WIDTH),
channels=CHANNELS,
rate=RATE,
output=True,
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import OutputMessageConnector #import modułów konektora msg_stream_connector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
import cv2 #import modułu biblioteki OpenCV
import Tkinter as tk #import modułu biblioteki Tkinter -- okienka
import subprocess
service_controller = DevServiceController("filter_video_service.json") #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection("videoInput", OutputMessageConnector(service_controller)) #deklaracja interfejsu wyjściowego konektora msg_stream_connector, należy zwrócić uwagę, iż identyfikator musi być zgodny z WEJŚCIEM usługi, do której "zaślepka" jest podłączana
service_controller2 = DevServiceController("save_video_service.json")
service_controller3 = DevServiceController("filter_audio_service.json")
service_controller3.declare_connection("audioInput", OutputMessageConnector(service_controller3))
def update_all(root, cap, filters):
read_successful, frame = cap.read() #odczyt obrazu z kamery
###############################################################
# tu ma być czytanie audio frame po framie
###############################################################
new_filters = set()
if check1.get()==1: #sprawdzenie czy checkbox był zaznaczony
new_filters.add(1)
if check2.get()==1:
new_filters.add(2)
if check3.get()==1:
new_filters.add(3)
if check4.get()==1:
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import OutputMessageConnector
from ComssServiceDevelopment.development import DevServiceController
from GifConverter import video_info
print 'starting stub input script'
if len(sys.argv) < 3:
print 'provide FFMPEG_BIN and video file as args'
print 'provided: ' + str(sys.argv[1:])
exit()
ffmpeg_bin = sys.argv[1]
file_path = sys.argv[2]
config_name = os.path.join(os.path.dirname(__file__), "service.json")
service_controller = DevServiceController(config_name)
service_controller.declare_connection(
"videoInput", OutputMessageConnector(service_controller))
timer = 2.0 # seconds
send_val = 1
def send_msg():
global send_val
print send_val
# send
if send_val == 3:
print '\tsend cmd !'
msg_obj = {'path': file_path, 'w': w, 'h': h, 'frames': frames}
msg = json.dumps(msg_obj)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import InputMessageConnector #import modułów konektora msg_stream_connector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
import cv2 #import modułu biblioteki OpenCV
import numpy as np #import modułu biblioteki Numpy
service_controller = DevServiceController("save_video_service.json") #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection("videoOutput", InputMessageConnector(service_controller)) #deklaracja interfejsu wejściowego konektora msg_stream_connector, należy zwrócić uwagę, iż identyfikator musi być zgodny z WYJŚCIEM usługi, do której "zaślepka" jest podłączana
connection = service_controller.get_connection("videoOutput") #utworzenie połączenia wejściwoego należy zwrócić uwagę, iż identyfikator musi być zgodny z WYJŚCIEM usługi, do której "zaślepka" jest podłączana
while True: #główna pętla programu
try:
obj = connection.read() #odczyt danych z interfejsu wejściowego
frame = np.loads(obj) #załadownaie ramki do obiektu NumPy
cv2.imshow('Camera',frame) #wyświetlenie ramki na ekran
cv2.waitKey(1)
except Exception as e:
connection.close()
cv2.destroyAllWindows()
break
from ComssServiceDevelopment.development import DevServiceController
'''
Quick and dirty service to end the stream gracefuly.
10075/10070
'''
if len(sys.argv) < 2:
print "please provide port to stub"
exit()
ports = map(int, sys.argv[1:])
print 'starting universal sub on port: ' + str(ports)
# replace controller's config on the fly
service_controller = DevServiceController("src/output_descriptor.json")
cfg = service_controller.service_conf
cons = []
for port in ports:
con_name = 'con_' + str(port)
cfg['outputs'][con_name] = {
"port": port,
"ip": "127.0.0.1"
}
service_controller.declare_connection(con_name, InputMessageConnector(service_controller))
connection = service_controller.get_connection(con_name)
cons.append(connection)
#
print 'start.. now !'
# -*- coding: utf-8 -*-
import json
from ComssServiceDevelopment.connectors.tcp.object_connector import InputObjectConnector
from ComssServiceDevelopment.development import DevServiceController #import modułu klasy testowego kontrolera usługi
service_controller = DevServiceController("alarmService.json") #utworzenie obiektu kontroletra testowego, jako parametr podany jest plik konfiguracji usługi, do której "zaślepka" jest dołączana
service_controller.declare_connection("wynikPredykcjiOutput", InputObjectConnector(service_controller)) #analogicznie jak wyżej dla drugiego interfejsu
#Output zapisuje do pliku wynik.json w celu wykorzystania do wywietlania danych na stronie
wynik = service_controller.get_connection("wynikPredykcjiOutput")
while True: #główna pętla programu
obj = wynik.read() #odczyt danych z interfejsu wejściowego
z = json.dumps(obj, indent=1, ensure_ascii=False).encode('utf-8')
f = open('wynik.json', 'w')
f.write(z)
f.close()
