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

 import PySimpleGUIQt as sg  
def systemtraybar():
    menu_def = ['BLANK'
    , ['&Open'
    , '---'
    , '&Save'
    , ['1', '2', ['a', 'b', 'cnew']]
    ,'&Properties'
    , 'Bot join'
    , 'Bot exit'
    , 'E&xit programm']]  
    tray = sg.SystemTray(menu=menu_def, filename=r'images/icon0.ico')  
    while True:  # The event loop  
        menu_item = tray.Read()  
        print(menu_item)  
        if menu_item == 'Exit':  
            break  
        #---------------menu----------------#
        elif menu_item == 'Open':  
            sg.Popup('Menu item chosen', menu_item)
        elif menu_item == 'test':
            print('test pushed')
        #---------------menu----------------#
        #general click  
        #elif menu_item == '__ACTIVATED__':
        #    print('__ACTIVATED__!!!!!!!!')

 from fs.copy import copy_fs
import wget
pict = 'https://luxe-host.ru/wp-content/uploads/f/f/7/ff73f244e19abdf561a4f8c9c7aa930e.png'
wget.download(pict, './Temp/')

 copy_fs('./Temp/', ('./123/'))

 import os
main_path = r'C:\Users\prime\PycharmProjects\Мотлох'
# os.mkdir(main_path + '\\Мотлох')
extensions = {
    'video': ['mp4', 'mov', 'avi', 'mkv', 'wmv', '3gp', '3g2', 'mpg', 'mpeg', 'm4v',
              'h264', 'flv', 'rm', 'swf', 'vob'],
    'data': ['sql', 'sqlite', 'sqlite3', 'csv', 'dat', 'db', 'log', 'mdb', 'sav',
             'tar', 'xml'],
    'audio': ['mp3', 'wav', 'ogg', 'flac', 'aif', 'mid', 'midi', 'mpa', 'wma', 'wpl',
              'cda'],
    'images': ['jpg', 'png', 'bmp', 'ai', 'psd', 'ico', 'jpeg', 'ps', 'svg', 'tif',
              'tiff'],
    'archives': ['zip', 'rar', '7z', 'z', 'gz', 'rpm', 'arj', 'pkg', 'deb'],
    'documents': ['pdf', 'txt', 'doc', 'docx', 'rtf', 'tex', 'wpd', 'odt'],
    '3d': ['stl', 'obj', 'fbx', 'dae', '3ds', 'iges', 'step'],
    'presentation': ['pptx', 'ppt', 'pps', 'key', 'odp'],
    'spreadsheet': ['xlsx', 'xls', 'xlsm', 'ods'],
    'font': ['otf', 'ttf', 'fon', 'fnt'],
    'gif': ['gif'],
    'exe': ['exe'],
    'bat': ['bat'],
    'apk': ['apk']
}
def create_folders_from_list(folder_path, folder_names):
    for folder in folder_names:  
        if not os.path.exists(f'{folder_path}\\{folder}'):  
            os.mkdir(f'{folder_path}\\{folder}')  
def get_subfolder_paths(folder_path) -> list:  
    subfolder_paths = [f.path for f in os.scandir(folder_path) if f.is_dir()]
    return subfolder_paths
def get_subfolder_names(folder_path) -> list:  
    subfolder_paths = get_subfolder_paths(folder_path)
    subfolder_names = [f.split('\\')[-1] for f in subfolder_paths]
    return subfolder_names
def get_file_paths(folder_path) -> list:  
    file_paths = [f.path for f in os.scandir(folder_path) if not f.is_dir()]
    return file_paths
def get_file_names(folder_path) -> list:  
    file_paths = [f.path for f in os.scandir(folder_path) if not f.is_dir()]
    file_names = [f.split('\\')[-1] for f in file_paths]
    return file_names
def sort_files(folder_path):
    file_paths = get_file_paths(folder_path)
    ext_list = list(extensions.items())
    for file_path in file_paths:
        extension = file_path.split('.')[-1]
        file_name = file_path.split('\\')[-1]
        for dict_key_int in range(len(ext_list)):
            if extension in ext_list[dict_key_int][1]:
                print(f'Moving {file_name} in {ext_list[dict_key_int][0]} folder\n')
                os.rename(file_path, f'{main_path}\\{ext_list[dict_key_int][0]}\\{file_name}')
def remove_empty_folders(folder_path):
    subfolder_paths = get_subfolder_paths(folder_path)
    for p in subfolder_paths:
        if not os.listdir(p):
            print('Deleting empty folder:', p.split('\\')[-1], '\n')
            os.rmdir(p)
if __name__ == "main":
    create_folders_from_list(main_path, extensions)
    sort_files(main_path)

 def formatted_numbers():
    result = []
    header = "|{:^10}|{:^10}|{:^10}|".format('decimal', 'hex', 'binary')
    for i in range(16):
        s = f"|{i:<10d}|{i:^10x}|{i:>10b}|"
        result.append(s)
        print(s)
    return result

   bot.run(token)

 def run(self, *args: Any, **kwargs: Any) -> None:
        """A blocking call that abstracts away the event loop
        initialisation from you.
        If you want more control over the event loop then this
        function should not be used. Use :meth:`start` coroutine
        or :meth:`connect` + :meth:`login`.
        Roughly Equivalent to: ::
            try:
                loop.run_until_complete(start(*args, **kwargs))
            except KeyboardInterrupt:
                loop.run_until_complete(close())
                # cancel all tasks lingering
            finally:
                loop.close()
        .. warning::
            This function must be the last function to call due to the fact that it
            is blocking. That means that registration of events or anything being
            called after this function call will not execute until it returns.
        """
        loop = self.loop
        try:
            loop.add_signal_handler(signal.SIGINT, lambda: loop.stop())
            loop.add_signal_handler(signal.SIGTERM, lambda: loop.stop())
        except NotImplementedError:
            pass
        async def runner():
            try:
                await self.start(*args, **kwargs)
            finally:
                if not self.is_closed():
                    await self.close()
        def stop_loop_on_completion(f):
            loop.stop()
        future = asyncio.ensure_future(runner(), loop=loop)
        future.add_done_callback(stop_loop_on_completion)
        try:
            loop.run_forever()
        except KeyboardInterrupt:
            _log.info("Received signal to terminate bot and event loop.")
        finally:
            future.remove_done_callback(stop_loop_on_completion)
            _log.info("Cleaning up tasks.")
            _cleanup_loop(loop)
        if not future.cancelled():
            try:
                return future.result()
            except KeyboardInterrupt:
                # I am unsure why this gets raised here but suppress it anyway
                return None

 from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.support.ui import WebDriverWait
import time
def getLocation():
    options = Options()
    options.add_argument("--use-fake-ui-for-media-stream")
    timeout = 20
    driver = webdriver.Chrome(executable_path = './chromedriver.exe', chrome_options=options)
    driver.get("https://mycurrentlocation.net/")
    wait = WebDriverWait(driver, timeout)
    time.sleep(3)
    longitude = webdriver.find_elements_by_id('//*[@id="longitude"]')
    longitude = [x.text for x in longitude]
    longitude = str(longitude[0])
    latitude = driver.find_elements_by_xpath('//*[@id="latitude"]')
    latitude = [x.text for x in latitude]
    latitude = str(latitude[0])
    driver.quit()
    return #(latitude,longitude)
print(getLocation())

 class CommentForm(ModelForm):
    class Meta:
        model = Comments
        fields = ['kom_name', 'text']
 
        widgets = {
            "kom_name": TextInput(attrs={
                'class': 'form-control',
                'placeholder': 'Ваше Имя'
            }),
            "text": Textarea(attrs={
                'class': 'form-control',
                'placeholder': 'Комментарий'
            })
 
        }

 class Comments(models.Model):
    numbers = models.CharField('Ид новости', max_length=40, default='')
    kom_name = models.CharField('Имя комментатора', max_length=40, default='')
    text = models.TextField('Текст коммента', max_length=200)
 
    def __str__(self):
        return self.kom_name

 def add_comm(request):
 
    if request.method == 'POST':
        comm = CommentForm(request.POST)
        if comm.is_valid():
            comm.save()
            return redirect('news-detail')
 
    formaa = CommentForm()
 
    cont = {'comment': formaa}
 
    return render(request, 'news/detail_view.html', cont)

  <form method="post">
                        {% csrf_token %}
                        {{ comment.kom_name }}<br>
                        {{ comment.text }}<br>
                    <button class="btn btn-success" type="submit">Добавить коммент</button>
                    </form>
 
                    </p>

 ingredients = models.ManyToManyField(Ingredient,
                                         through='IngredientInRecipe')

 recipe = models.ForeignKey(Recipe, on_delete=models.CASCADE)
    ingredient = models.ForeignKey(Ingredient, on_delete=models.SET_NULL, null=True)
    amount = models.DecimalField(max_digits=6,
                                 decimal_places=1,
                                 validators=[MinValueValidator(1)]
                                 )

 ingredients = IngredientInRecipeSerializer(many=True)

 class IngredientInRecipeSerializer(serializers.ModelSerializer):
    """Serializer for ingredient in recipe objects"""
    
    ingredient = serializers.PrimaryKeyRelatedField(
        queryset=Ingredient.objects.all()
    )
    amount = serializers.DecimalField(max_digits=6,
                                      decimal_places=1)
    
    def create(self, validated_data):
        ingredient = validated_data.pop('ingredient')
        amount = validated_data.pop('amount')
        ingredient_in_recipe = IngredientInRecipe.objects.create(ingredient=ingredient,
                                          amount=amount)
        return ingredient_in_recipe

"ingredients": [
    {
      "id": 1,
      "amount": 10
    },
    {
      "id": 2,
      "amount": 20
    }
  ],

{
    "ingredients": [
        {
            "ingredient": [
                "This field is required."
            ]
        },
        {
            "ingredient": [
                "This field is required."
            ]
        }
    ]
}

 import pyautogui 
import time
pyautogui.click(x=1095, y=568)
time.sleep(1)
i=0
while i<25:
    pyautogui.press('up')
    time.sleep(0.2)
   #   pyautogui.keyUp('w')
    i=i+1
pyautogui.keyDown('e')

 import random
import subprocess
from threading import Thread
results = []
start_processes = 6
def run_command(count, result_storage):
    cmd = str(subprocess.check_output(['ping', '-c', f'{body}', 'google.' + 'com'], text=True))
    result_storage.append(cmd)
threads = []
for _ in range(start_processes):
    ch = random.choices('1234567890', k=2)
    body = (''.join(ch))
    print(body)
    t = Thread(target=run_command, args=[body, results])
    t.start()
    threads.append(t)
for t in threads:
    t.join()

 N = int(input()) # hours
M = int(input()) # minute
T = int(input()) # dostavka min
hours = T % (60 * 24) // 60
minutes = T % 60
print(f'{((hours + N) + (minutes + M) // 60) % 24}:{(minutes + M) % 60}'

 N = int(input())
M = int(input()) 
T = int(input()) 
hours = (T % (60 * 24) // 60)
minutes = (T % 60)
thours = (((hours + N) + (minutes + M) // 60) % 24)
tminutes = ((minutes + M) % 60)
print(f'{thours:02}:{tminutes:02}')

 import time
import pandas as pd
from PyQt5 import uic, QtCore, QtGui, QtWidgets, QtTest
qtime = time.time()
#Параметры кноки:
        self.bt = QtWidgets.QPushButton(self.centralwidget) 
        self.bt.setGeometry(QtCore.QRect(110, 40, 180, 70))
        font = QtGui.QFont()
        font.setPointSize(12)
        font.setBold(False)
        font.setWeight(50)
        self.bt.setFont(font)
        self.bt.setAutoFillBackground(False)
        self.bt.setStyleSheet("background-color: qlineargradient(spread:repeat, x1:1, y1:1, x2:1, y2:0, stop:0 rgba(149, 149, 149, 255), stop:0.142045 rgba(220, 220, 220, 255));\n"
"")
        self.bt.setCheckable(True)
        self.bt.setObjectName("bt")
        MainWindow.setCentralWidget(self.centralwidget)
        self.retranslateUi(MainWindow)

 import json
import requests
import random
import httpx
with open('base1.json', encoding = 'UTF-8') as file:
    base_fl = json.load(file)
with open('base2.json', encoding = 'UTF-8') as file:
    base_bs = json.load(file)
url = 'https://url...'
userag = ["Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
          "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 Edg/107.0.1418.56"]
randomusag = random.choice(userag)
headers = {'User-Agent':randomusag}
client = httpx.Client(http2=True)
geturl = client.get(url, headers=headers)
ab = geturl.json()