Saravanan666/pypi-org huggingface dataset:
Package: pytaskmaster
Simple way to create build script on python.FeaturesCLI tool for launch taskConfig manager on JSON filesGenerator for configuration headersUsageCreatemaster.pyin project folder or usemaster -tfor create templatemaster.py.Seemaster -hfor more information.For zsh users_master(){typeset-Aopt_args__get_tasks(){file="master.py"if[-n"${opt_args[-f]}"];thenevalfile="${opt_args[-f]}"fiif[-n"${opt_args[--file]}"];thenevalfile="${opt_args[--file]}"fitasks_command="ls$file2>/dev/null 1>/dev/null && master -f \"${file}\" -s"eval${tasks_command}2>/dev/null|grep'^  [a-zA-Z]'|whileread-rab;doecho$a$b|sed's/^[\ \t]* \([a-zA-Z]\)/\1/g'|sed's/[\ \t]*--\(.*\)/:\1/g';done;}__tasks(){local-ataskstasks=(${(fo)"$(__get_tasks)"})_describe'tasks'tasks}_arguments'(-h --help)'{-h,--help}'[show this help message and exit]'\'(-s --show-tasks)'{-s,--show-tasks}'[show all tasks from master file]'\'(-f --file)'{-f,--file}'[use custom FILE for run tasks]:file:_files'\'(-t --template)'{-t,--template}'[create `master.py` from template]'\'1::tasks:__tasks'\'2::files:_files'}compdef_mastermasterSource codeYou can access the source code at:https://github.com/Plambir/pytaskmasterRelease History1.1.0 (2015-05-18)Add CLI scriptRefactoringpytaskmastermodule1.0.0 (2015-03-15)First working version
Package: pytask-parallel
pytask-parallelParallelize the execution of tasks withpytask-parallelwhich is a plugin forpytask.Installationpytask-parallel is available onPyPIandAnaconda.org. Install it with$pipinstallpytask-parallel#or$condainstall-cconda-forgepytask-parallelBy default, the plugin usesconcurrent.futures.ProcessPoolExecutor.It is also possible to select the executor from loky orThreadPoolExecutorfrom theconcurrent.futuresmodule
as backends to execute tasks asynchronously.UsageTo parallelize your tasks across many workers, pass an integer greater than 1 or'auto'to the command-line interface.$pytask-n2$pytask--n-workers2#Startsos.cpu_count()-1workers.$pytask-nautoUsing processes to parallelize the execution of tasks is useful for CPU bound tasks such
as numerical computations. (Hereis an
explanation on what CPU or IO bound means.)For IO bound tasks, tasks where the limiting factor are network responses, access to
files, you can parallelize via threads.$pytask--parallel-backendthreadsYou can also set the options in apyproject.toml.# This is the default configuration. Note that, parallelization is turned off.[tool.pytask.ini_options]n_workers=1parallel_backend="processes"# or loky or threadsSome implementation detailsParallelization and DebuggingIt is not possible to combine parallelization with debugging. That is why--pdbor--tracedeactivate parallelization.If you parallelize the execution of your tasks using two or more workers, do not usebreakpoint()orimport pdb; pdb.set_trace()since both will cause exceptions.Threads and warningsCapturing warnings is not thread-safe. Therefore, warnings cannot be captured reliably
when tasks are parallelized with--parallel-backend threads.ChangesConsult therelease notesto find out about what is new.Developmentpytask-paralleldoes not call thepytask_execute_task_protocolhook
specification/entry-point becausepytask_execute_task_setupandpytask_execute_taskneed to be separated frompytask_execute_task_teardown. Thus,
plugins which change this hook specification may not interact well with the
parallelization.There are two PRs for CPython which try to re-enable setting custom reducers which
should have been working, but does not. Here are the references.https://bugs.python.org/issue28053https://github.com/python/cpython/pull/9959https://github.com/python/cpython/pull/15058
Package: pytaskpool
pytaskpool (v1.5)A simple multiprocess function pooler which create results generatorspytaskpool use the python multiprocessing modulepytaskpool provide an easy way to execute python functions in a pool of process (not threads) for using all your CPU
cores. Functions results can then be then obtained in order or not (via a generator method).pytaskpool works on windows and linux.Download and docs:http://pypi.python.org/pypi/pytaskpoolSource code & Development:https://github.com/govlog/pytaskpoolIssues:christopher.amiaud@gmail.comInstallationpytaskpool is available in the python index package (pip),
It can be installed running the following command:$ pip install pytaskpoolor by git like this:$ git clone https://github.com/govlog/pytaskpool
$ cd pytaskpool
$ sudo python setup.py installor even in a zip over http :https://github.com/govlog/pytaskpool/archive/master.zipUsageThis sample code will simultanously launch 8 functions with differents parameters using a pool of 8 processes.
The results returned by all launched functions will be get by the method get_sorted_results(), which is a generator
returning the functions results in order.The excepted execution time should be around 1 second.Sample code:import pytaskpool as tp
from time import sleep

def my_func(x):
    sleep(1)
    return x ** x

mypool = tp.TaskPool(8)

for r in range(8):
    mypool.launch(my_func, r)

unsorted = [r for r in mypool.get_unsorted_results()]
sorted = [r for r in mypool.get_sorted_results()]

print ("unsorted :",unsorted)
print ("sorted   :",sorted)Terminal output should look like this:$ time python examples/pytask_ex2.py
unsorted : [1, 1, 4, 27, 256, 46656, 3125, 823543]
sorted   : [1, 1, 4, 27, 256, 3125, 46656, 823543]

real    0m1,055s
user    0m0,800s
sys     0m0,272s
Package: pytasks
Example#test.pyfrom pytasks import Appfrom datetime import datetime as dtfrom datetime import timedelta as tdclass T:def __init__(self, taskid):self.times = 10    #<--------------the largest number of this task will be executedself.now = dt.now()self.every = td(seconds=4)  #<------frequency of task being polledself.taskid = taskiddef __call__(self):    #<--------------content of taskprint self.taskid, ":", dt.now()-self.nowself.now =dt.now()def schedule(self):    #<--------------task'schedule：return dt.now()+td(seconds=2)         #return bool() or datetime.datetime(...)[means the time to run task]task1 = T(1)task2 = T(2)#set task2's scheduletask2.schedule = lambda: True if os.environ['LOGNAME']=='root' else Falseapp = App()app.add(task1)app.add(task2app.run()
Package: py-task-scheduler
task-scheduler is an in-process scheduler to arrange and run the task periodically according to YAML config fileInspired byscheduleUsage$pipintalltaskscheduler$taskscheduler-ftasks.ymlThe format of tasks.yml is as below:task:
   <First task name>
     schedule_time_unit: [seconds/minutes/hours/day/monday/Thusday]
     schedule_time_every: 1
     prepare:
        - <shell command>
        - <shell command>
     jobs:
       <jobname>:
         - <shell command>
       <jobname>:
         - <shell command>In the example below, we have two jobs in tasks.yml, apreparejob is used to install the additional package and print some messages:task:
   schedule_task1:
     schedule_time_unit: seconds
     schedule_time_every: 2

     jobs:
       test1:
         - echo 'Hi, this is task-scheduler'

   schedule_task2:
     schedule_time_unit: minutes
     schedule_time_every: 2

     prepare:
       - pip install pyyaml

     jobs:
       test1:
         - echo 'Hello world'Usage: py-task-scheduler -f task.yaml
Package: py_tata
Tata - Test Automation and Troubleshooting AssistantTata is a command-line utility designed for checking the configuration of host machines within specified tasks. It provides a simple and efficient way to automate tests related to host settings.Supported TasksTata supports the following tasks:check_hostname:Verifies that the hostname of the machine matches the specified value.tasks:-task:check_hostnametarget_hostname:"test"check_ping:Checks if the specified IP address or domain is reachable via ping.tasks:-task:check_pingtarget_ip:"127.0.0.1"linux_check_ipv4_forwardingtasks:-task:linux_check_ipv4_forwardingenabled:nolinux_check_ipv6_forwardingtasks:-task:linux_check_ipv6_forwardingenabled:noTask ConfigurationTasks are defined in a YAML file with the following format:tasks:-task:check_hostnametarget_hostname:"test"-task:check_pingtarget_ip:"127.0.0.1"-task:check_pingtarget_ip:"ya.ru"-task:linux_check_ipv4_forwardingenabled:no-task:linux_check_ipv6_forwardingenabled:noInstallationPreferred method: pipxpipxinstallpy_tata
pytata./tasks.yamlAlternative method: pippipinstallpy_tata
python-mpy_tata.cli.app./tasks.yamlSupported Python VersionsTata is compatible with Python versions 3.10 and above.Thank you for using Tata! If you have any questions or encounter any problems, please don't hesitate to reach out.
Package: pytation
PytationWelcome to the Pytation project!  Use Pytation to quickly build reliable
test stations for your custom hardware projects.  Although building
manufacturing test stations is the primary goal of this project, you can
also build repeatable development and validation test stations.
The framework allows you to run tests using a variety of runners including the
graphical PySide6 runner and command line runner.Project links:Documentationon GitHub PagesReleaseson pypiSource Codeon GitHubQuick StartYou will need Python 3.9 or newer.  You can install this package using pip:pip3 install -U pytationAlternatively, you can clone the repo:git clone https://github.com/jetperch/pytation.git
cd pytation
pip3 install -U -r requirements.txt
python3 setup.py qtYou can then run the example:python3 -m pytation gui pytation_examples.simple.STATIONOn Windows, you may need to usepythonrather thanpython3.LicenseAll pytation code is released under the permissive Apache 2.0 license.
See theLicense Filefor details.
Package: pytato
Imagine TensorFlow, but aimed at HPC. Produces a data flow graph, where the
edges carry arrays and the nodes are (give or take) static-control programs
that compute array outputs from inputs, possibly (but not necessarily)
expressed inLoopy. A core assumption is
that the graph represents a computation that’s being repeated often enough that
it is worthwhile to do expensive processing on it (code generation, fusion,
OpenCL compilation, etc).Documentation(read how things work, see an example)Github(get latest source code, file bugs)Pytato is licensed to you under the MIT/X Consortium license. See
thedocumentationfor further details.Numpy compatibilityPytato is written to pose no particular restrictions on the version of numpy
used for execution. To use mypy-based type checking on Pytato itself or
packages using Pytato, numpy 1.20 or newer is required, due to the
typing-based changes to numpy in that release.
Package: pytatsu-tui
What is this?A way to save/manage *OS blobs usingpytatsuPrerequisitesWindows/Linux/macOSPython(>= 3.10)TkinterUsage$python3-mpipinstallpytatsu-tui--upgrade

$tatsu-tui

$tatsu-tui-u/--unset# Unset the saved config directoryFor every device you have, you'll be asked to provide the following information:Device Model and Board ConfigurationExclusive Chip Identification(Decimal and Hex formats supported)ApNonce(Required for A12+)ThisDOES NOTfreeze your ApNonce if your device isn't jailbroken, do that beforehand.Generator(Required for A12+)(Eg. 0x1111111111111111 forunc0ver, 0xbd34a880be0b53f3 forElectra/Chimera/Odyssey/Taurine/Cheyote)PreviewAPI used for Apple's Stable FirmwaresAPI used for Apple's Beta FirmwaresCryptiiiic's Pytatsu
Package: pytautulli
pytautulliPython API wrapper for Tautulli.Installationpython3-mpipinstallpytautulliExample usageMore examples can be found in thetestsdirectory."""Example usage of pytautulli."""importasynciofrompytautulliimportPyTautulli,PyTautulliHostConfigurationIP="192.168.100.3"TOKEN="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"asyncdefasync_example():"""Example usage of pytautulli."""host_configuration=PyTautulliHostConfiguration(ipaddress=IP,api_token=TOKEN)asyncwithPyTautulli(host_configuration=host_configuration)asclient:print(awaitclient.async_command("get_activity"))asyncio.get_event_loop().run_until_complete(async_example())ContributeAllcontributions are welcome!Fork the repositoryClone the repository locally and open the devcontainer or use GitHub codespacesDo your changesLint the files withscripts/lintEnsure all tests passes withscripts/testEnsure 100% coverage withscripts/coverageCommit your work, and push it to GitHubCreate a PR against themainbranch
Package: pytaxa
pytaxainfoMinimum Python version: 3.5pytaxadocsCheck out sister R package:taxaInstallationStable versionpip install pytaxa
pip3 install pytaxaDev versionsudo pip install git+git://github.com/sckott/pytaxa.git#egg=pytaxa#ORgit clone git@github.com:sckott/pytaxa.git
cd pytaxa
make installUsagefrompytaxaimportconstructorsascscs.taxon_name("Poa")frompytaxaimportTaxonx=Taxon(None)x.is_empty()name=cs.taxon_name("Poa")rank=cs.taxon_rank("genus","ncbi")db=cs.taxon_database("ncbi","http://www.ncbi.nlm.nih.gov/taxonomy","NCBI Taxonomy Database","*")id=cs.taxon_id(12345,db)tx1=Taxon(name,rank,id,"L.")tx2=Taxon(cs.taxon_name("Poaceae"),cs.taxon_rank("family","ncbi"),cs.taxon_id(4479,db))tx3=Taxon(cs.taxon_name("Poa annua"),cs.taxon_rank("species","ncbi"),cs.taxon_id(93036,db))frompytaxaimportTaxaTaxa(tx1,tx2,tx3)frompytaxaimportHierarchyout=Hierarchy(tx1,tx2,tx)out.taxaout.ranklistout.all_empty()out.pop(ranks="family")ContributingSeeCONTRIBUTING.mdMetaPlease note that this project is released with aContributor Code of Conduct. By participating in this project you agree to abide by its terms.License: MIT; seeLICENSE fileChangelog0.0.6 (2018-06-26)First pypi release
Package: pytb
Utility for inspecting python stack of running process (x64 linux only)Features:Python3 friendly (pytb itself requires python2 to run, but process
being analyzed can be python3)Greenlet (gevent) friendly, can show stacktrace for each greenletWorks by just reading/proc/<pid>/mem, so doesn’t need to attach
to target process (e.g. if you don’t want to stop the target process,
or are debugging an unattachable process, like a D-state process)Bugs:Linux only, 64-bit only.Installation:pip install pytbUsage:sudo pytb [pid]will show you stacktrace of each python thread.If you want to also see greenlet stacktraces, usesudo pytb-g[pid]this will also show you greenlets stacktraces. NOTE: in order to find
all greenlets pytb looks for all gc tracked objects, so this may take a
while if you have lots of objects.Notes:Supports viewing python2 and python3 tracebacks (it will try to guess,
whether it’s 2 or 3, however you can help it by specifying -2 or -3
option)The utility works by reading/proc/<pid>/mem(this is why sudo is
needed). It usesnmandobjdumpfor finding inner python structures
in memory.It’s also possible that python process is compiled with different flags
that influence inner python’s structure fields alignment (on whichpytbheavily relies) In this case you can run it with-dpython-executableoption wherepython-executableis an
executable that contains debug symbols for the process you are
interested in.pytbwill launch gdb in this case and ask it for
offsets of fields it’s interested in.There is also a gotcha thatframe->f_code->co_filenamecontains not
an absolute path, but relative, and if your process has chdir’ed
somewhere, those relative paths will become invalid (they are used when
rendering stacktraces). For this situation there is--scriptdirdirargument which defaults to/proc/<pid>/cwdand serves as a root forco_filename.
Package: pyTBA
# pyTBAPython 3 Blue Alliance API Layer for parsing FIRST Robotics Competition event data.https://www.thebluealliance.com/## Features:* Simple and lightweight API for downloading and parsing BlueAlliance data* Data caching faster performance* OPR / Individual Stats calculation## Adding it to your code:To install with `pip`:```bashpip install pyTBA```To add PyTBA to your project, import the `pytba.api` module, and set an app id:```pythonfrom pytba import api as tbatba.set_api_key("<Your Name>", "<App Name>", "<App Version>")```## Basic Usage:The most basic usage is to make a query to an arbitrary URL in the TBA API.This is done by:```pythontba.tba_get('relative/url/goes/here')```PyTBA makes a request to the TBA API (https://www.thebluealliance.com/api/v2/)and returns the response, stored as a `dict`. (See [TBA API docs](https://www.thebluealliance.com/apidocs) for more information about keys)PyTBA can also retrieve data for entire events:```pythontba.event_get('<Event Code>')```This returns an `Event` object, which groups together location, team, match, awards, and rankings data.For example, to retrieve a list of `match` models from an `Event`:```pythonevent = tba.event_get('2016chcmp')matches = event.matches```More advanced usage can be found in the documentation in the source code.##Modules required:* `requests`* `cachecontrol`* `dpath`* `numpy` - for OPR calculation###Note about older versions:If you are updating from an older version (with the single blualliance.py file), be aware that the package structure has become more modularized. The core API code is now in the `pytba.api` module. The `Event` class is now under `pytba.models`. The decorators and utility methods are now under `pytba.util`, and OPR calcuation is now under `pytba.stat`. Check out [the init release](https://github.com/Thing342/pyTBA/releases/tag/init) if you need to clone the older code.
Package: pytbai
pytbaipytbai allows to create, manage and send TicketBai invoices to the Basque tax authorities.UsageYou need to configure your bussiness and software info in a JSON file:{"subject":{"entity_id":"99999974E","name":"BUSSINESS NAME"},"software":{"license":"TBAIGIPRE00000000501","dev_entity":"P2000000F","soft_name":"TBAI","soft_version":"1.0"}}Then create a invoice:frompytbaiimportTBaifromdecimalimportDecimaltbai=TBai(json)invoice=tbai.create_invoice("TB-2021-S",1,"First invoice","S")invoice.create_line("First product",Decimal("1"),Decimal("200"),Decimal("20"))invoice.create_line("Second product",Decimal("2"),Decimal("350"))Thejsonparameter is a previous JSON file you've created.Finally sign and send the invoice:result=tbai.sign_and_send("/path_to_p12_certificate","password")You can also get the full structure of TBai invoice:json_structure=tbai.get_json(invoice)TODORecipient dataMultiple recipient dataThird party / Recipient's invoicesCorrective invoicesCorrected or replaced invoicesTax free invoicesInvoices without national counterpartyChaining of previous invoiceHow to contributePlease read theCode of Conduct documentationfirst, then all contributions are done via Pull Requests on GitHub but don´t hesitate to open a new issue.CreditsThis project is made byCodeSyntax.
Package: pyTBC
pyTBCpyTBC is a python library which implements Trace-based clustering technique [1].InstallationThe source code is currently hosted on:https://github.com/antoniolopezmc/pyTBCTo install pyTBC library from pip, it is neccesary to execute:pipinstallpyTBCGenerating the documentationThe python package documentation in html, latex and pdf formats can be generated as follows:cddocs
makeReferences[1] A. Lopez-Martinez-Carrasco, J. M. Juarez, M. Campos, and B. Canovas-Segura, "A methodology based on trace-based clustering for patient phenotyping", Knowledge-Based Systems,vol. 232, no. 2, article 107469, 2021.
Package: pytbd
DescriptionInspired bytbdswizzler, this simple
python tool for manipulating Apple's.tbdformat.Installationpython3-mpipinstall--user-UpytbdUsageUsage: pytbd [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  append-arch  appench given arch to all .tbd files
  find-symbol  locate .tbd files where the given symbol is exported from
  json         output given tbd file as json
Package: pytblocklib
pytblocklibOverview(This project is under development.)Pytblocklib is an library for blocking spam bots on YouTube.Pytblocklib は、Youtubeのスパムボットのブロックを補助するライブラリです。YouTube API設定不要、リスナー側のブロックにも対応しています。詳細はwikiを参照してください。YouTubeの仕様変更等により使用できなくなる場合があります。使用に際しては自己責任でお願いいたします。LICENSE:LGPL-3.0DescriptionPytblocklibs's goal is to provide easy blocking operation on YT.You can concentrate on thinking block algorithms.Function around livechat is based on mypytchatscript.Features:Functions focused on blocks, light weight, easy operation.You can block as a listener. (not need to give or take moderator privileges)NoScraping, noSelenium, no BeautifulSoup.Installpip install pytblocklibExamplefrompytblocklibimportWatcherimporttimew=Watcher("video_id")NG_WORDS=['NG_WORD1','NG_WORD2']blocklist=[]w.start()#Start checking loopwhilew.loop():#Get chat list from bufferchats=w.get_chats()forchatinchats:ifany(ng_wordinchat.messageorng_wordinchat.author_nameforng_wordinNG_WORDS):print("Found :message-`{}` by{}".format(chat.message,chat.author_name))#Block user by specifying author channel id.w.block(chat.author_id)blocklist.append(chat.author_id)time.sleep(3)#Example: Unblock all blocked users (only available during executing script)forauthor_idinblocklist:w.unblock(author_id)w.stop()Derived appAutoBlockerbysayamame_beansCompatible environmentPython 3.7.4 laterOS : Windows 10 / macOS Catalina / Ubuntu 18.04.2 LTSBrowser: Chrome v80 later / Firefox 75.0 later (requires browser cookie)VSNightbotProsSophisticated user interface on browser, integrated functions.Applicable for Twitch.Various blocking setting (e.g. blacklist, excess emotes, repetitions)ConsOnly srteamers can block spams on their broadcasting with moderator privileges, not per listener.YouTube StudioProsOfficial features.Various blocking setting (e.g. specify channel id, prohibited words)ConsOnly srteamers can block spams on their broadcasting with owner/moderator privileges, not per listener.PytblocklibProsNo need for YT API settings.Simple - functions focused on blocking spams.You can customize the blocking algorithm with a python script.You can block spams as a listener. (not need to give or take moderator privileges)ConsNeed to implement blocking procedures and user interface separately.Less portability : requires python environment.UsingThis program uses a customizedbrowser_cookie3library.The original copyright  ofbrowser_cookie 3belongs to borisbabic :https://github.com/borisbabic/browser_cookie3LICENSEGNU LESSER GENERAL PUBLIC LICENSE Version 3
Package: pytbo
Pytbo is a module aimed at simplifying the creation ofTelegram Botsusing Python.A minimum familiarity with Telegram Bots is required to use this library. Please take a look at theintroductionand theFAQbefore starting.Getting StartedTo start working with Pytbo, you must have a Bot token.
If you don’t know what we’re talking about, read how tocreate your first bot with BotFather.This is a simple _echo_ bot done with Pytbo that looks for updates every 5 seconds.importpytboimporttime# Bot Token received from TelegramBOT_TOKEN="MY_BOT_TOKEN"# Polling interval in secondsINTERVAL=5# Create bot objectbot=pytbo.BareBot(BOT_TOKEN)# Print bot informationprint("Bot ID......:%s"%(bot.id))print("Bot username:%s"%(bot.username))# Initialize offsetoffset=0# Infinite polling loopwhileTrue:# Look for updatesupdates=bot.getUpdates(offset)# Handle themforuinupdates:ifu.message:ifu.message.text:# If the update contains a message# that contains text, we reply to the# sender with the same text.bot.sendMessage(u.message.chat.id,u.message.text,reply_to_message_id=u.message.message_id)# Update offset to avoid receiving# the same update againoffset=u.update_id+1# Sleeptime.sleep(INTERVAL)InstallationTo install Pytbo, simply:$pipinstallpytboDocumentationA proper documentation is not yet available, but it will be.
However, useful methods and classes are documented inside the source code.Don’t be afraid to have a look inside, sometimes is the best way to learn.How to ContributeFork this repository on GitHub to start making your changes to themasterbranch (or branch off of it).Send a pull request.AknowledgementsThanks toKenneth Reitzand to all the other developers of therequestsmodule, which is used inside Pytbo and also as a blueprint for this repository and documentation layout.Release History0.1.0 (2016-04-23)BareBot class that wraps Telegram Bot APIs methodsTypes classes that wraps Telegram Bot APIs types0.0.1 (2016-04-14)Conception