Python-сообщество

 import argparse
import os
import sys
import sounddevice as sd
import soundfile as sf
class Music:
    __record_flag = False
    __playing_flag = False
    __current_time = 0
    __fs = 48000
    __duration = 5  # seconds
    sd.default.samplerate = __fs
    def __init__(self):
        self.parser = self.create_parser()
        self.myrecording = None
        self.file_name = self.parser.file
        sd.default.channels = tuple(map(int, self.parser.channels))
        sd.default.device = tuple(map(int, self.parser.device))
        self.mode = self.parser.mode
        self.__duration = int(self.parser.time)
        self.__loop = self.parser.loop.__contains__("True")
    @staticmethod
    def create_parser():
        parser = argparse.ArgumentParser()
        parser.add_argument('-c', '--channels', nargs='+')
        parser.add_argument('-d', '--device', nargs='+')
        parser.add_argument('-m', '--mode', default="play")
        parser.add_argument('-f', '--file', default="./resources/sounds/game.wav")
        parser.add_argument('-t', '--time', default="20")
        parser.add_argument('-p', '--pid', default="pid.txt")
        parser.add_argument('-l', '--loop', default="False")
        # print(parser.parse_args(sys.argv[1:]))
        return parser.parse_args(sys.argv[1:])
    def record(self):
        print("Start recording")
        myrecording = sd.rec(self.__duration * self.__fs)
        sd.wait()
        print("Recorded successful")
        # self.sd.play(myrecording)
        # self.sd.wait()
        sf.write(self.file_name, myrecording, self.__fs)
    def play_audio(self, arr):
        # print(self.__playing_flag)
        sd.play(arr, loop=self.__loop)
        sd.wait()
    def play_rec(self, arr):
        sd.playrec(arr)
        sd.wait()
    def stop_playing(self):
        # self.sd.play("./res/non.wav")
        sd.stop()
    def play_file(self):
        print("playing track")
        data, fs = sf.read(self.file_name)
        self.play_audio(data)
    def do_reverse(self):
        data, fs = sf.read(self.file_name)
        sf.write(self.file_name, data[::-1], fs)
    def show(self):
        print(sd.query_devices())
music = Music()
# music.show()
if music.mode == 'play':
    music.f = open(music.parser.pid, 'w')
    music.pid = str(os.getpid())
    # print(music.pid)
    music.f.write(music.pid)
    music.f.close()
    music.play_file()
elif music.mode == 'record':
    music.record()
elif music.mode == "reverse":
    music.do_reverse()
elif music.mode == "stop":
    music.stop_playing()
elif music.mode == 'play_rec':
    music.f = open(music.parser.pid, 'w')
    music.pid = str(os.getpid())
    # print(music.pid)
    music.f.write(music.pid)
    music.f.close()
    music.play_file()
# print("thats all")

 import socket
import socketserver
import threading
class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        data = self.request.recv(1024)
        data = data.decode('utf-8')
        cur = threading.current_thread()
        responce = cur.name + ' '+ self.client_address[0]+' ' +data
        responce = responce.encode('utf-8')
        self.request.sendall(responce)
class MyTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
    pass
class Ser:
    def __init__(self):
        self.server = MyTCPServer(('localhost', 12345), MyTCPHandler)
        self.thread_server = threading.Thread(target=self.server.serve_forever)
        self.thread_server.daemon = True
        self.id = []
    def start(self):
        self.thread_server.start()
    def loop(self):
        while True:
            pass
s = Ser()
s.start()
s.loop()

 class BOT(object):
    token = config.token
    admin = 'admin'
    def __init__(self):
        self.bot = twx.botapi.TelegramBot(self.token)
        self.bot.get_me()
        last_updates = self.bot.get_updates(offset=0).wait()
        try:
            self.last_update_id = list(last_updates)[-1].update_id
        except IndexError:
            self.last_update_id = None
        print('last update id: {0}'.format(self.last_update_id))
    def process_message(self, message,user):
        text = message.message.text
        chat = message.message.chat
        chat_id = message.message.chat.id
        chat_username = message.message.chat.username
        date = time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime(message.message.date))
       
        text = text.strip()
        user_file = ''
        user_file += str(user.id)
        to_logs = str(date) +':Got message: from chat: {1} username:{2}'.format(text,chat_id,chat_username) + """:'{0}'""".format(text)
        print(to_logs)
        with open('log\log.txt','a') as f_obj:
            f_obj.write(to_logs + '\n')
        
        bot_message = twx.botapi.send_message(chat_id,"Привет пользователь!")
        print(bot_message)
def run(self):
        print('Main loop started')
        while True:
            updates = self.bot.get_updates(offset=self.last_update_id).wait()
            try:
                for update in updates:
                    if int(update.update_id) > int(self.last_update_id):
                        self.last_update_id = update.update_id
                        self.process_message(update,twx.botapi.User)
                      
            except Exception as ex:
                print(traceback.format_exc())
if __name__ == '__main__':
    try:
        BOT().run()
    except KeyboardInterrupt:
        print('Exiting...')     

 async def main():
    authors = json.load(open(r'test/authors_list.txt'))[:100] # для теста
    async with aiohttp.ClientSession() as session:
        for x in authors:
            url = urljoin(config.SAMLIB_DOMAIN, x[0]); print(url)
            html = await crawler.fetch(session, url)
            if parser.SI_parse_index_counters(html):
                _upddate, _counters = parser.SI_parse_index_counters(html)
                _upddate = hooks.convert_date(_upddate)
            else:
                _upddate, _counters = '', [0, 0]
                # author_link, author_name, author_text, author_descr, last_update, works_count, works_size, last_check
            db.update_authors_counters([
                x[0],
                x[1],
                x[2],
                x[3],
                _upddate,
                _counters[1],
                _counters[0],
                datetime.datetime.now()
            ])

 def update_authors_counters(args):
    '''author_link, author_name, author_text, author_descr, last_update, works_count, last_check'''
    print(*args)
    query = '''
    INSERT INTO samlib_testdb (
    author_link, author_name, author_text, author_descr, last_update, works_count, works_size, last_check
    )
    VALUES
    (
       ?, ?, ?, ?, ?, ?, ?, ?
    );
    '''
    dbcurr.execute(query, args)
    dbconn.commit()

 # -*- coding: utf-8 -*-
import os
import socket
import struct
import time

 def checksum (string_to_check): #Честно скопипастил из первого источника, но предварительно разобрался что к чему
    sum = 0
    countTo = (len(string_to_check)/2)*2
    count = 0
    while count<countTo:
        thisVal = string_to_check[count + 1]*256 + string_to_check[count]
        sum = sum + thisVal
        sum = sum & 0xFFFFFFFF
        count = count + 2
    if countTo<len(string_to_check):
        sum = sum + string_to_check[len(string_to_check) + 1]
        sum = sum & 0xFFFFFFFF
    sum = (sum >> 16) + (sum & 0xFFFF)
    sum = sum + (sum >> 16)
    answer = ~sum
    answer = answer & 0xFFFF
    answer = answer >> 8 | (answer << 8 & 0xFF00)
    return answer

 def BULD_ICMP_PACKET(icmp_identifier, icmp_sequence):
    icmp_checksum = 0
    icmp_header = struct.pack("!BBHHH", 8, 0, icmp_checksum, icmp_identifier, icmp_sequence)
    bytesInDouble = struct.calcsize("d")
    icmp_data = bytes((192 - bytesInDouble) * 'Q', 'utf-8')
    icmp_data = struct.pack("d", time.time() ) + icmp_data
    icmp_checksum = checksum(icmp_header + icmp_data)
    icmp_header = struct.pack("!BBHHH", 8, 0, socket.htons(icmp_checksum), icmp_identifier, icmp_sequence)
    packet = icmp_header + icmp_data
    return packet #, socket.htons(icmp_checksum)

 def SEND_ONE(icmp_identifier, icmp_sequence, dst_addr, use_socket):
    packet = BULD_ICMP_PACKET(icmp_identifier, icmp_sequence)
    destination_address = socket.gethostbyname(dst_addr)
    print(struct.unpack("!BBHHH",packet[0:8]))
    use_socket.sendto(packet, (destination_address, 1))
    recPacket, addr = use_socket.recvfrom(1024)
    recPacketHeader = recPacket[20:28]
    icmp_type_r, icmp_code_r, icmp_checksum_r, icmp_identifier_r, icmp_sequence_r = struct.unpack("!BBHHH", recPacketHeader)
    use_socket.close()
    return icmp_type_r, icmp_code_r, icmp_checksum_r, icmp_identifier_r, icmp_sequence_r, addr

 my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)

 print(SEND_ONE(os.getpid() & 0xFFFF, 1,'8.8.8.8',my_socket))

 import telebot  
import configparser
config = configparser.ConfigParser()
config.read("config.ini")
bot = telebot.TeleBot(config["Telegram"]["access_token"])
@bot.message_handler(func=lambda m: True, content_types=['new_chat_member'])
def user_join(message):
        bot.send_message(message.chat.id, 'welcome message', parse_mode="HTML", disable_web_page_preview=True)
if __name__ == '__main__':
    while True:
        try:
            bot.polling(none_stop=True)
        except Exception as e:
            print(e)
            time.sleep(15)

 import time
import vk
import xml.etree.ElementTree as ET
from urllib.request import Request, urlopen
headers = {"X-Access-Token": "xxxxxxxxxxxxxxx"}
request = Request("http://site.com", headers=headers)
response_body = urlopen(request).read()
tree = ET.fromstring(response_body)
paper = []
for offer in tree.findall('offer')[0:]:
    title = offer.get('title')
    paper.append({
        'title' : title
    })
for paper in papers:
    print(paper['title'])
    print()
    time.sleep(300)
# VK Posting
session = vk.AuthSession('xxxx', 'test@test.ru', 'password', scope='offline,wall,groups')
api = vk.API(session)
api.wall.post(owner_id='-1111', from_group='1', message=title)

 class DataProcessor(object):
    def process1(self, data):
         print "process 1 finished"
         return data
 
   def process2(self, data):
         print "process 2 finished"
         return data
   def process3(self, data):
         print "process 3 finished"
         return data
 
   def process4(self, data):
         print "process 4 finished"
         return data
 
   def make_all_processes(self, data):
        processes = [getattr(self, method) for method in dir(self) if method.startswith('process')]
        results = [process(data) for process in processes]
        return results

 results = multiprocessing.Manager().dict()                             
processes = []                                                           
for lookup in lookup_methods:                                          
    process = multiprocessing.Process(target=self._lookup_process_wrapper, args=(lookup, input_data, results))
    process.start()                                                     
    processes.append(process)                                             
                                                                                 
for process in processes:                                                 
    process.join()

  def lookup_process_wrapper(lookups_queue, data, results, config_dict):                             
    while True:                                                                 
         try:                                                                    
             lookup = lookups_queue.pop()                                        
         except:                                                                 
             break                                                               
         data_processor = DataProcessor(config_dict)                 
         lookup_method = getattr(data_processor, lookup)                              
         results[lookup] = lookup_method(data=data)

 	import telnetlib
	HOST = '10.90.90.90'
	PORT = 2
	command = 'show fdb port {} \n'.format(PORT))
	tn = telnetlib.Telnet(HOST)
	tn.read_until(b':') 
	tn.write('admin\n'.encode('ascii')) 
	tn.read_until(b':') 
	tn.write('password\n'.encode('ascii'))
	tn.read_until(b'#')
	tn.write(command.encode('ascii'))
	str_all = tn.read_until(b'#')
	tn.close()
	print (command)
	print (str_all)

 connectclientreference = suds.Client('http://api.vetrf.ru/schema/platform/cerberus/services/EnterpriseService_v1.4_pilot.wsdl', username= 'usrname', password='pass')
connectclientreference.service.GetBusinessEntityList('ns2: Listoption count 100') - вот тут ошибка. 
Видимо неправильный параметр передаю...