Saravanan666/pypi-org huggingface dataset:
Package: tt7zcrack
tt7zcrackREADME i18n:中文说明Fast 7zip crack assistant tool which support GPU/CPU.RequirementsPython 3.5 or later.python installInstalltt7zcrackcan be easily installed using pip:pip install tt7zcrackQuick StartMacMake surebrewis installed.Createpwds.txtto store possible passwords, one password occupies one line. you can also useTTPassGento generate a large amount of passwords.# use passwords from pwds.txt to crack filett7zcrack--wordlistpwds.txtcrack.7zWhen the crack is complete, password will be shown like this:Linux/WindowsCurrently not supported.Usagett7zcrack--help
usage:tt7zcrack.py[-h][--wordlist[WORDLIST]][--engine{hashcat,jtr}][--clean][file]7zGPU/CPUcracktool

positionalarguments:file7zfilepath(default:None)optionalarguments:-h,--helpshowthishelpmessageandexit--wordlist[WORDLIST]wordlistdictpath,youcanuse'ttpaasgen'togenerate.(default:)--engine{hashcat,jtr}passwordrecoveryengine(default:hashcat)--cleancleanrelatedsecurefiles(default:False)if the hash file cannot generated correctly, you can usejtrengine to try again.The cracked password will be saved locally by the password cracking tool for next query. Use the following command to delete it. Note that this will delete all cracked results!tt7zcrack--clean7z commands# install 7z on Macbrewinstallp7zip# compress with password7za-p456test.7ztest.txt# extract with password7zx-p456test.7z# compress without password7zatest.7ztest.txt# extract without password7zxtest.7zThanks7zhashcat
Package: tta
Time Tracker Autocompleter for MuranosoftThis tool automatically fill out Time Tracker with messages from your git log.Installation:Install Python:OSX.Windows.Linux.Installtta(run console command):pip install ttaUsage:Type this command in console (in folder with your git repo):tta -u user -p qwerty -e gmail@gmail.comuser - Your username in Time Trackerqwerty - Your password in Time Trackergmail@gmail.com- Your email in git configOptions:Short optionOptionDescription-u–userTime Tracker username-p–passwordTime Tracker password-e–emailYour email in git config-d–directoryPath to git directory–start_dateStart date of period (EX: 2015-8-27)Default: first day of current month–end_dateEnd date of period (EX: 2015-8-29)Default: last day of current month–start_work_dayHour of start working day. Default:10–end_work_dayHour of end working day. Default:18-c–categoryTime Tracker category, default: Development.Categories:IDName17Client Support12Code Review2Development4Documenting15Graphic Design27Holiday29HR14Infrastructure28Marketing7Meeting8Miscellaneous30Office Management35Overtime leave9Project Management10Quality Assurance/Testing3Requirement Analysis6Research25Sick31Vacation non-paid26Vacation paidttawas written byKirill Ermolov.
Package: ttable
Synopsistt (truthtable) is a library aiming to provide a Pythonic toolkit for working with Boolean expressions and truth tables. Please see theproject sitefor guides and documentation, or check outbool.toolsfor a simple web application powered by this library.Installationtt is tested on CPython 3.6, 3.7, and 3.8. You can get the latest release from PyPI with:pip install ttableFeaturesParse expressions:>>> from tt import BooleanExpression
>>> b = BooleanExpression('A impl not (B nand C)')
>>> b.tokens
['A', 'impl', 'not', '(', 'B', 'nand', 'C', ')']
>>> print(b.tree)
impl
`----A
`----not
     `----nand
          `----B
          `----CEvaluate expressions:>>> b = BooleanExpression('(A /\ B) -> (C \/ D)')
>>> b.evaluate(A=1, B=1, C=0, D=0)
False
>>> b.evaluate(A=1, B=1, C=1, D=0)
TrueInteract with expression structure:>>> b = BooleanExpression('(A and ~B and C) or (~C and D) or E')
>>> b.is_dnf
True
>>> for clause in b.iter_dnf_clauses():
...     print(clause)
...
A and ~B and C
~C and D
EApply expression transformations:>>> from tt import to_primitives, to_cnf
>>> to_primitives('A xor B')
<BooleanExpression "(A and not B) or (not A and B)">
>>> to_cnf('(A nand B) impl (C or D)')
<BooleanExpression "(A or C or D) and (B or C or D)">Or create your own:>>> from tt import tt_compose, apply_de_morgans, coalesce_negations, twice
>>> b = BooleanExpression('not (not (A or B))')
>>> f = tt_compose(apply_de_morgans, twice)
>>> f(b)
<BooleanExpression "not not A or not not B">
>>> g = tt_compose(f, coalesce_negations)
>>> g(b)
<BooleanExpression "A or B">Exhaust SAT solutions:>>> b = BooleanExpression('~(A or B) xor C')
>>> for sat_solution in b.sat_all():
...     print(sat_solution)
...
A=0, B=1, C=1
A=1, B=0, C=1
A=1, B=1, C=1
A=0, B=0, C=0Find just a few:>>> with b.constrain(A=1):
...     for sat_solution in b.sat_all():
...         print(sat_solution)
...
A=1, B=0, C=1
A=1, B=1, C=1Or just one:>>> b.sat_one()
<BooleanValues [A=0, B=1, C=1]>Build truth tables:>>> from tt import TruthTable
>>> t = TruthTable('A iff B')
>>> print(t)
+---+---+---+
| A | B |   |
+---+---+---+
| 0 | 0 | 1 |
+---+---+---+
| 0 | 1 | 0 |
+---+---+---+
| 1 | 0 | 0 |
+---+---+---+
| 1 | 1 | 1 |
+---+---+---+Andmuch more!Licensett uses theMIT License.
Package: ttabooster
TTABoost - Boost Your  pre-trained Model With Test Time Augmentation SelectionTest time augmentation selection for image detection and classification.InstallpipinstallttaboosterUsage examplefromttabooster.TTABoostimportTTABoostermodel=load_model('pretrained-model.h5')# Load any keras modelx_test,y_test=...# Load your validation setAUGMENTATIONS_TEST=Compose([RandomSizedCrop((28,28),32,32,w2h_ratio=1.0,interpolation=1,always_apply=False,p=1.0),# Add your augmentations...])booster=TTABooster(model,batch_size=100,augmentations=AUGMENTATIONS_TEST)booster.benchmark_results(x_test,y_test)
Package: ttapi
## Installation### Using pippip install ttapi### Via sourceObtain the source by downloading from the web or cloning with git. In thedirectory containing setup.py run:python setup.py install## Examples### Chat botThis bot respond to anybody who write "/hello" on the chat.```pyfrom ttapi import Botbot = Bot(AUTH, USERID, ROOMID)def speak(data):name = data['name']text = data['text']if text == '/hello':bot.speak('Hey! How are you %s ?' % name)bot.on('speak', speak)bot.start()```### Simple```pyfrom ttapi import Botbot = Bot(AUTH, USERID, ROOMID)# Define callbacksdef roomChanged(data): print 'The bot has changed room.', datadef speak(data):       print 'Someone has spoken.',       datadef updateVotes(data): print 'Someone has voted.',        datadef registered(data):  print 'Someone registered.',       data# Bind listenersbot.on('roomChanged',  roomChanged)bot.on('speak',        speak      )bot.on('update_votes', updateVotes)bot.on('registered',   registered )# Start the botbot.start()```
Package: ttarray
This package provides a library with numpy-compatible api for calculations with
multi dimensional arrays in the tensor train format. This format allows for the
(lossy) compressed storage of very high dimensional arrays (think 2^200 or
more). This is possible due totruncationof small singular values.Vectors in the tensor train format are well known in the computational quantum
physics world as matrix product states (MPS). This format allows us to represent
and manipulate low-entangled quantum states in very high-dimensional Hilbert
spaces. It turns out that many states of interests like ground states of local
one dimensional Hamiltonians or thermal density matrices have low entanglement
and can thus be efficiently worked with in tensor train form. This approach has
opened the door to much progress in the numerical study of quantum systems.The package is build around the TensorTrainArray class which provides a numpy
compatible api and are designed to be used just as numpy arrays. Leveraging the__array_function__and__array_ufunc__protocols this even works for
routines in the normal numpy namespace or in some third party libraries.
However, it is important to note that not all operations can be performed
efficiently on tensor trains! Additional methods specific to the TensorTrain
format are provided as well.Under the hood, the data is stored as a normal python list of numpy (or
numpy-compatible) ndarrays which can be retrieved and manipulated manually. The
raw namespace provides the basic algorithm which can be aplied to this format.NoteAt present this package is a work in progress and is not yet complete
Package: ttask
ttask (WIP)tui task manager built in pythonusageskeya: add new task
r: remove selected task
j, k/ up, down: navigate selected task/ property
d: mark task as done 
w: write changes to todo.txt
q: quit and write changes
e: edit priorityinstallationpip3 install ttaskdependencieswindows:windows-cursesdemonotestodo.txt is put in your home folder
Package: ttastromech
Text to AstromechThis was originally created byHugo SCHOCH.
I just packaged it on pypi and use it for an R2D2 project I am working on.It works by assigning an R2-D2 sound to each letter of the alphabet, then, when you pass
it a string, it makes sounds like an astromech. Currently it only supports Linux and
macOS.OSAudio ProgrammacOSafplaylinuxplayfrom libsoxlinuxaplayfrom alsaInstallThe preferred method of installation is:pip install ttastromechUsagefromttastromechimportTTAstromechimporttimeif__name__=='__main__':r2=TTAstromech()try:r2.run()# make random astromech sounds by feeding it random strings of letterstime.sleep(2)exceptKeyboardInterrupt:print('bye ...')Or:astromech.py "my god, its full of stars ... oh wait, the wrong movie"MIT LicenseCopyright (c) 2015 SCHOCH HugoCopyright (c) 2017 Kevin J. WalchkoPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: ttAugment
TTAugmentPerform Augmentation during Inference and aggregate the results of all the applied augmentation to create a
final outputInstallationpip install ttAugmentSupported AugmentationLibrary supports allcolor,blurandcontrasttransformation provided byimgaugalong with custom Geometric Transformation.Mirror : Crop an image tocrop_to_dimensionand mirror pixels to match the size ofwindow_dimensionCropScale : Crop an image tocrop_to_dimensionand rescale the image to match the size ofwindow_dimensionNoAugment : Keep the input unchangedCrop : Crop an image tocrop_to_dimensionRot : Rotate an ImageFlipHorizontalFlipVerticalUsageHow to use when test image is muchlargerthan what the model requires, Don't worry the library has it covered,
it will generate fragments according to the specified dimension, so the inference can be performed while applying augmentation.window_size: Break the image into smaller images of said sizeoutput_dimension: It must be greater the input image in order for the fragments to be restored back on the
image.importnumpyasnpfromtt_augment.augmentimportgenerate_seg_augmenterstransformation_to_apply=[{"name":"Mirror","crop_to_dimension":(256,256)},{"name":"CropScale","crop_to_dimension":(256,256)},]foriinrange(0,10):image=np.random.rand(512,512,3)*255image=np.expand_dims(image,0)# Load augmentation object for the image, this includes to break the image in smaller fragments.tta=generate_seg_augmenters(image=image,window_size=(384,384),output_dimension=(1,512,512,3),transformation_to_apply=transformation_to_apply,)# Iterate over transformation_to_applyforiterator,transformationinenumerate(tta):# Iterate over individual fragmentsforaugmented_fragmentintransformation.transform_fragment():#     ---> transformed_fragment.shape = (1, 384, 384, 3)# Inference steps for augmented fragment# 1. perform image normalization#     ---> normalised_image = image_normalization(augmented_fragment)# 2. perform model prediction#     ---> prediction = model.predict(normalised_image)# 3. convert prediction to numpy with shape [batch, h, w, channel]# 4. place the prediction fragment on its position in the original image#     ---> transformation.restore_fragment(prediction)transformation.restore_fragment(augmented_fragment)# Aggregate the result for the input image over all applied augmentationstta.merge()output=tta.tta_output()
Package: tta-wrapper
# TTA wrapperTest time augmnentation wrapper for keras image segmentation and classification models.## Description### How it works?Wrapper add augmentation layers to your Keras model like this:```Input|           # input image; shape 1, H, W, C/ / / \ \ \      # duplicate image for augmentation; shape N, H, W, C| | |   | | |     # apply augmentations (flips, rotation, shifts)your Keras model| | |   | | |     # reverse transformations\ \ \ / / /      # merge predictions (mean, max, gmean)|           # output mask; shape 1, H, W, COutput```### Arguments- `h_flip` - bool, horizontal flip augmentation- `v_flip` - bool, vertical flip augmentation- `rotataion` - list, allowable angles - 90, 180, 270- `h_shift` - list of int, horizontal shift augmentation in pixels- `v_shift` - list of int, vertical shift augmentation in pixels- `add` - list of int/float, additive factor (aug_image = image + factor)- `mul` - list of int/float, additive factor (aug_image = image * factor)- `contrast` - list of int/float, contrast adjustment factor (aug_image = (image - mean) * factor + mean)- `merge` - one of 'mean', 'gmean' and 'max' - mode of merging augmented predictions together### Constraints1) model has to have 1 `input` and 1 `output`2) inference `batch_size == 1`3) image `height == width` if `rotation_angles` augmentation is used## Example```pythonfrom keras.models import load_modelfrom tta_wrapper import tta_segmentationmodel = load_model('path/to/model.h5')tta_model = tta_segmentation(model, h_flip=True, rotation_angles=(90, 270),h_shifts=(-5, 5), merge='mean')y = tta_model.predict(x)```
Package: ttb
# Библиотека со всякими полезностямиЗдесь есть функции:
-loading(delay): Прогрессбар. Вместоdelayвведите задержку.
-test(text): Можно оставить аргумент пустым или ввести текст.
-collatz(number): Теория 3N + 1. Вместоnumberвведите число.
Package: ttbotapi
ttbotapiTamTam Bot APIlibraryHow to UseThe Bot class encapsulates all API calls in a single class. It provides functions such assend_xyz(send_message,edit_messageetc.) and several ways to listen for incoming messages.Create a file calledecho_bot.py.
Then, open the file and create an instance of the Bot class.importttbotapiimportloggingttbotapi.logger.setLevel(logging.DEBUG)# Note: Make sure to actually replace TOKEN with your own API token.bot=ttbotapi.Bot(access_token='Bot Token')# After that declaration, we need to register some so-called decorator handlers.# Update handlers define filters which a message must pass. If a message passes the filter,# the decorated function is called and the incoming message is passed as an argument.# Let's define a message handler which handles incoming `/start` and `/help` bot_command in dialog chat type.@bot.update_handler(chat_type='dialog',bot_command=['/start','/help'])defsend_welcome(update):# A function which is decorated by an update handler can have an arbitrary name,# however, it must have only one parameter (the update)bot.send_message(text="Howdy, how are you doing?",user_id=update.message.sender.user_id,chat_id=None,link={'type':'reply','mid':update.message.body.mid})# Let's add another handler@bot.update_handler(chat_type='dialog',regexp='hi')defsend_hi(update):bot.send_message(text=f'Hi 👋,{update.message.sender.name}',user_id=update.message.sender.user_id,chat_id=None)# This one echoes all incoming text messages back to the sender. It uses a lambda function to test a message.# If the lambda returns True, the message is handled by the decorated function.# Since we want all messages to be handled by this function, we simply always return True.@bot.update_handler(func=lambdaupdate:update.message.body.text)defecho(update):bot.send_message(text=update.message.body.text,user_id=update.message.sender.user_id,chat_id=None)# Using long polling now our bot never stop workingbot.polling()# Alright, that's it! Our source file now looks fineTo start the bot, simply open up a terminal and enterpython echo_bot.pyto run the bot!
Test it by sending commands ('/start' and '/help') and arbitrary text messages.How to ContributeYou must followContributingGuidelines.We are committed to providing a friendly community, for more experience readCode Of Conduct.How to CommunicateYou're welcome to drop in and ask questions,
discuss bugs and such, CheckCommunicationMethods.Frequently Asked QuestionsPlease askAttributionThese Documents are adapted forMA24th Open Source Software,
For more informationcontact mewith any additional questions or comments.SupportJoin our channel onand.
Package: ttbotlib
INSTALLInstall bot-server based on ASGI API and ASGI-base webserver (for examplehttps://www.uvicorn.org/)$ pip install ttbot
$ pip install uvicornCODECreatebot.pyfromttbot.serverimportAction,Post,Request,ServerclassMyBot(Server):asyncdefmessage_handler(self,post:Post)->str:''' Called when bot mentioned in post, return text will be published as reply post '''post.user_id# int, who send postpost.chat_id# int, in what chatpost.post_no# int, post numberpost.text# str, post textpost.team_id# int, if chat from teampost.reply_no# int, if post has reply to other post (number)post.reply_text# str, if post has reply to other post (text)returnf'Received{post}'asyncdefaction_handler(self,action:Action)->dict:''' Called when user clicks on bot action link or button '''action.action# str, action nameaction.params# dict, params of actionaction.post# Post, post which attached actionaction.user_id# int, who send postaction.post.user_id# 0action.post.chat_id# int, in what chataction.post.post_no# int, post numberaction.post.text# ''action.post.team_id# int, if chat from teamreturn{'action':str(action)}asyncdefapi_handler(self,request:Request)->dict:''' Web server for bot local aims '''request.method# str, HTTP methodrequest.path# str, HTTP pathrequest.query# dict, parsed HTTP url query stringrequest.headers# dict, parsed HTTP headersrequest.data# dict, parsed json from HTTP bodyreturn{'request':str(request)}app=MyBot()RUNSECRET given when bot createdSECRET=123 uvicorn example.app:appAPIАПИ для получения сообщений боту (подписан pararam)curl -XPOST -d '{"user_id": 1, "chat_id": 2, "post_no": 3, "text": "text"}' 'http://localhost:8000/bot'АПИ действий бота (для кнопок, подписан pararam)curl -XPOST -d '{"user_id": 1, "chat_id": 2, "post_no": 3, "action": "submit", "params": {}}' 'http://localhost:8000/act'Собственное АПИ бота для не связанных с pararam операцийcurl -XPOST -d '{"a":1}' 'http://localhost:8000/api?s=1&s=2'
Package: ttc
TremTec CLIAs a TremTec Engineer, we need tools to make our daily work easier, because of that we've created the TremTec CLI, or just `ttc`. We intend to provider a lot of features like:

    - **WorkSpace Management**: Create separated environments for your packages `pip`, `node`, and other languages.
    - **Package Management**: Install, update and remove packages for your projects.
    - **GitLab Integration**: You can create Merge Requests, test ci files, list docker register images, and a lot more from the cli.

    ## Usage

    To install our cli tool, you need to:

    ```bash
    pip install ttc
    ```

    then you should configure you environment:

    ```bash
    ttc configure
    ```

    To see our command options, type

    ```bash
    ttc --help
    # or
    ttc -h
    ```

    ## Add autocompletion

    Just add to you `.bashrc` or `.zsh`:

    ```bash
    eval "$(_TTC_COMPLETE=source ttc)"
    eval "$(_TT_COMPLETE=source tt)"
    ```### Dev mode

    To install as a developer, first clone the project, go to a the cloned folder and then:

    ```bash
    pip install -e '.[dev]'
    ```

    ##

    Thanks for using tcc and have a happy code! 😊
Package: ttcal
This is a small library for calendar operations.Usage:>>> from ttcal import *
>>> Today()
2023-7-2-7
>>> Today() + 1
2023-7-3-7
>>> import datetime
>>> isinstance(Today(), datetime.date)
True
>>> Day(1991, 2, 20)
1991-2-20-2
>>> Month()
Month(2023, 7)
>>> Month() + 2
Month(2023, 9)
>>> Year()
Year(2023)
>>> Year() + 2
Year(2025)
>>> Day(2024, 2, 29)
2024-2-29-2
>>> Day(2024, 2, 29) + Period(months=2)
2024-4-29-4
>>> Day(2024, 4, 30) - Period(months=2)
2024-2-29-2
>>>
Package: ttchat
TTChatPeer-to-peer chat software written in Python.What is it for?TTChat is designed to be a safe chat system that will generate new keys for each session.
It's not intended to be used as WhatsApp or a similar chat program, it's for throwaway chats that don't need to/shouldn't be kept.How is it secured?TTChat uses 4096-bit long RSA keys for every message, other than for the public key exchange, which cannot be encrypted.This should not be a problem, as no computer can get the private key from the public key, and the keys are recreated for every new chat session.How does it work?Each machine will set up a server socket, and a client socket. The client will try to connect to a specified target, while the server accepts connections and checks if the origin is the target. If it's not, it'll kill the connection and wait for the target to connect. Once both peers have confirmed the targets, they will exchange public keys and be ready to chat.RequirementsPython v3.6+If you don't already have it, download ithere.cryptography>=2.8Download it usingpip install "cryptography>=2.8", or download the wheelhereand usepip install (.whl file).UsageTo get the module through PyPi:pip install ttchat.While TTChat comes with a fully functional__main__.pyfile, it is mainly meant to demonstrate how TTChat works. You can get the module to build your own UI that will work with any other program that uses TTChat, including the example one.The__main__.pyfileRun it as any other python script, usingpythonorpython3 __main__.py. It's a very short piece of code, as it just uses functions fromttchat.p2p. Simply give it a target machine and it'll start trying to connect.Once you seeReady to receive messages.and/orReady to send messages., the connection has been completed and messaging is ready.DocumentationTo see how to use the TTChat module yourself, check out theDocumentation.
Package: ttcv
VisionUtilsInstallationcd$ROOTpython3-mpipinstall-e.Usagefromttcv.sensor.realsense_sensorimportget_realsense_modules# for get realsensefromttcv.basic.basic_objectsimportBasObj# an example  moduleclassTestModule(BasObj):
defload_params(self,args):super().load_params(args=args)# your initalization heredefgui_run_module(self,inputs=None,method_ind=0):ifmethod==0:print('{} method 1 run ...'.format('+'*10))fromttcv.gui.basic_guiimportGuiModule,BasGUI# call GUIamodule=GuiModule(module=TestModule,type='test_module',name='Test Module',num_method=1)BasGUI(title='test GUI',modules=[amodule]+get_realsense_modules())