Saravanan666/pypi-org huggingface dataset:
Package: tomate
A minimalist pomodoro timer.RequirementsTo run Tomate, you will need the following software:Python ≥ 3.6aplayaplayis the native ALSA wav player, used to play a bell tone at the
end of a pomodoro period.To install Tomate, we also recommend using thepippackage manager.Once all the requirements are fulfilled, you may proceed with the
installation.InstallingTo install Tomate system-wide, simply run:sudopip3installtomateTo install Tomate manually from source, the steps are as follows:gitclonegit@github.com/abusque/tomate.gitcdtomatesudo./setup.pyinstallUsingOnce installed, you can use Tomate by simply running the following:tomateThis will start a 25 minute timer, after which a soft bell will
ring. To start another pomodoro, simply re-run the command.
Package: tomatic
Tomaticis a library that helps add automatic setup capabilities onPythonprograms and avoids that configuration files became bloated with unnecessary lines of code. It has originally designed to be used inDjangoprojects working directly insettings.pybut can be used with any other Python program.RequirementsRequires at leastPython 3.5due the use of type hints (PEP484).InstallingUsepipto installTomatic, running:pip install tomaticOr you can clone or download this repository for manual install.DocumentationRead the fulldocumentationto get details of how to use it.
Package: tomato
tomato: au-tomation without pain!tomatois the instrument automation package developed at Empa. Currently supported
hardware is:dummy: a Dummy device for testing purposesbiologic: device for BioLogic potentiostats via the EC-Lib library, Windows only.See theDocumentationfor more detailed info.Contributors:Peter KrausLoris ErcoleAcknowledgementsThis project has received funding from the European Union’s Horizon 2020 research and innovation programme under grant agreement No 957189. The project is part of BATTERY 2030+, the large-scale European research initiative for inventing the sustainable batteries of the future.
Package: tomato-clock
🍅 Tomato ClockTomato Clock is a straightforward command-line Pomodoro application.Pomodoro Technique番茄工作法InstallationInstall pythonInstall via pip:pipinstalltomato-clockInstall via source code:gitclonehttps://github.com/coolcode/tomato-clock.gitcdtomato-clock
chmod+xtomato.pyHow to useif you install via piptomato# start a 25 minutes tomato clock + 5 minutes breaktomato-t# start a 25 minutes tomato clocktomato-t<n># start a <n> minutes tomato clocktomato-b# take a 5 minutes breaktomato-b<n># take a <n> minutes breaktomato-h# helpif you install via source code./tomato.py# start a 25 minutes tomato clock + 5 minutes break./tomato.py-t# start a 25 minutes tomato clock./tomato.py-t<n># start a <n> minutes tomato clock./tomato.py-b# take a 5 minutes break./tomato.py-b<n># take a <n> minutes break./tomato.py-h# helpTerminal Output🍅tomato25minutes.Ctrl+Ctoexit🍅🍅----------------------------------------------[8%]23:04⏰Desktop NotificationMacOSbrewinstallterminal-notifierterminal-notifieractually is a cross-platform desktop notifier, please refer to ➜terminal-notifierUbuntunotify-sendVoice NotificationsTomato Clock usessay(text-to-speech) for voice notifications.MacOSMacOS already hassay. seehereormore detailUbuntuSee this link:saysudoapt-getinstallgnustep-gui-runtimeWindowsCheck this one:https://github.com/SeanBracksDev/tomato-clock
Package: tomato_commander
Tomato CommanderSimple library for controlling static leases on a tomato router.Free software: GNU General Public License v3Documentation:https://tomato-commander.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.1 (2017-09-20)First release on PyPI.
Package: tomato-cooker
cooked-tomatoTimetable scheduler for phone attention turns in Som EnergiaHistoryThis project is the result of an internal Som Energia Hackathon held on 11-03-2022 about MiniZinc
with the goal of reimplementing the previous solution based on apruned backtracking.PrerequisitesBefore you begin, ensure you have met the following requirements:You must have at leastpython 3.8. You can get this python version throughpyenv. See more here ->https://github.com/pyenv/pyenv#installationYou should have aLinux/Macmachine. Windows is not supported and we are not thinking in it.Installationpipinstallcooked-tomatoUsageimportasynciofromtomato_cooker.grillimportGrillTomatoCookerfromtomato_cooker.modelsimportTomaticProblem,tomatic# define a problemtomatic_problem_params={"nPersons":4,"nLines":2,"nHours":3,"nNingus":1,"nDays":5,"maxTorns":2,"nTorns":[3,3,3,3,],"indisponibilitats":[{1},{1},{2},{1},{1},{2},{2},{2},{2},{2},{3},{3},{2},{3},{3},{2},{3},{2},{2},{1},]}tomatic_problem=TomaticProblem(**tomatic_problem_params)# choose a list of minizinc solvers to usersolvers=["chuffed","coin-bc"]# create an instance of the cookertomato_cooker=GrillTomatoCooker(tomatic.MODEL_DEFINITION_PATH,solvers)# Now, we can solve the problemsolution=asyncio.run(tomato_cooker.cook(tomatic_problem))print(solution)ContributeFork the repository on GitHub.Set up your development setup$>pipinstall-e.[dev,tests]Run the tests to confirm they all pass on your system.$>pytestMake your change and run the entire test suite again and confirm that all tests pass including the ones you just added.Create us a GitHub Pull Request to the main repository’s master branch. GitHub Pull Requests are the expected method of code collaboration on this project.ChangesHistoric of changes.LicenseThis project uses the following license:GNU AFFERO GENERAL PUBLIC LICENSE.
Package: tomato-engine
tomato-engineEngine for prototyping and playing with cellular automata.MotivationTomato-engine aims to be an easy to use, extensible and hackable
framework for running cellular automata simulations controlled
via Python.It handles much of the overhead involved in getting a simple
realtime visualization of the cellular automata to run, while
providing an object oriented interface through which the user
can easily craft their own cellular automata ruleset, and leave
tomato-engine to handle all the rest.Installationpip3 install tomato-engineExample and basic usageNew rules are implemented on a Python module, which must contain
the class Cell, which inherits from CellTemplate and specifies
how the cell should update on each iteration through the function
Cell.update.For simple, binary totalistic automata rulesets such as the Conway's Game of
Life, the class can be as simple as this:fromtomato.classesimportcellclassCell(cell.CellTemplate):defupdate(self,state_matrix):self.state_matrix=state_matrix# Dead cellifself.value==0:ifself.live_neighbors==3:self.value=1else:self.value=0# Live cellelse:ifself.live_neighborsin(2,3):self.value=1else:self.value=0@propertydefneighbors(self):returnself.moore_neighborhood@propertydeflive_neighbors(self):returnsum(self.neighbors)This module is then imported and passed to the Board class, which
provides the user interface.importtomatoasttfromtomato.functionsimportutilsfrommy_rulesimportgame_of_lifeasrule# Board dimensions in number of automata in each directionboard_dimensions=(100,100)# Scaling factor for the board in the displaycell_size=4# Convenience function for generating a numpy matrix# of random binary valuesstate_matrix=utils.random_matrix(board_dimensions,2)board=tt.Board(rule,cell_size=cell_size)# Opens the simulation windowboard.start(state_matrix)Also check out ourrepository of rulesetsmade for tomato-engine.More information on how to craft new rulesets and interact with
your simulation can be found on our readthedocs: (coming soon!)
Package: tomatolib
========================================
Asynchronous server component library.. image::https://travis-ci.org/tangmi001/tomatolib.svg?branch=master:target:https://travis-ci.org/tangmi001/tomatolib:alt: Travis status for master branch.. image::https://codecov.io/gh/tangmi001/tomatolib/branch/master/graph/badge.svg:target:https://codecov.io/gh/tangmi001/tomatolib:alt: Codecov.. image::https://img.shields.io/github/license/tangmi001/tomatolib.svg:target:https://github.com/tangmi001/tomatolib/blob/master/LICENSE:alt: License.. image::https://img.shields.io/pypi/v/tomatolib.svg:target:https://pypi.org/project/tomatolib:alt: PyPIFeaturesManage common modules (MySQLModule, HttpServerModule) with Application class.Web routing configures the handler through the decorator.SQL normalization, avoiding heavy ORM, while also making readability.Getting startedServerAn example using a server:.. code-block:: python# hello_handler.py

from aiohttp import web
from tomato.transport.http import Routes


routes = Routes()

@routes.get('/hello')
@routes.get('/hello/{name}')
async def xxx(request):
    name = request.match_info.get('name', "Anonymous")
    text = "Hello, " + name
    return web.Response(text=text).. code-block:: python# hello.py

from hello_handler import routes
from tomato.util import Application
from tomato.transport import HttpServerModule


app = Application()
app['http_server'] = HttpServerModule(host='localhost', port=1024, routes_list=[routes, ])
# app.run()
# app.stop()
app.run_forever()MySQL.. code-block:: pythonimport asyncio
from tomato.util import Application
from tomato.store import MySQLModule
from tomato.store import SqlClauseAssemble
from tomato.store import SqlParamCollections


app = Application()
# setting parameter is a dictionary type
app['mysql'] = MySQLModule(setting=mysql_setting)
app.run()
sql_assemble = SqlClauseAssemble()
sql_assemble.wanted_words = ['platform_id', 'open_id']
sql_assemble.table_name = '`app_account_users`'
where_params = SqlParamCollections()
where_params.add_normal_param(('open_id', '=', 18888888888, True))
sql_assemble.where_params = where_params
(sql, params) = sql_assemble.get_query_clause()
print((sql, params))
loop = asyncio.get_event_loop()
result_list = loop.run_until_complete(app['mysql'].get_all(sql,params))
print(result_list)
app.stop()Redis.. code-block:: pythonfrom tomato.util import Application
from tomato.store import RedisModule


app = Application()
app['redis'] = RedisModule(setting=redis_setting)
app.run()
redis = RedisController()
loop = asyncio.get_event_loop()
loop.run_until_complete(redis.set('my-key', 'my-value'))
assert loop.run_until_complete(redis.get('my-key')) == 'my-value'
app.stop()Exampleserver <https://github.com/tangmi001/tomatolib/tree/master/examples>_mysql <https://github.com/tangmi001/tomatolib/blob/master/tomato/store/mysql/sql_clause_assemble.py>_Dependent libraryaiohttp <https://github.com/aio-libs/aiohttp>_Other contributorszhouqinmin:zqm175899960@163.com
Package: tomato-timer
🍅 Tomato TimerTomato Timer is a simple command line pomodoro app.InstallationInstall python fromhttps://www.python.org/Install via pip:$ pip install tomato-timerInstall via source code:$ git clone https://github.com/pashkatrick/tomato-timer.git
$ cd tomato-timer
$ chmod +x tomato.pyHow to useif you install via pip$ tomato                              # start a 20 minutes tomato clock + 10 minutes break in 9 times
$ tomato --work 25 --rest 5 --loop 4  # start a 25 minutes tomato clock + 5 minutes break in 4 times
$ tomato -h                           # helpif you install via source code$ ./tomato.py                              # start a 30 minutes tomato clock + 10 minutes break in 9 times
$ ./tomato.py --work 25 --rest 5 --loop 4  # start a 25 minutes tomato clock + 5 minutes break in 4 times
$ ./tomato.py -h                           # helpTerminal Output🍅 tomato 25 minutes. Ctrl+C to exit
 🍅🍅---------------------------------------------- [8%] 23:4 ⏰Desktop NotificationMacOS$ brew install terminal-notifierterminal-notifieractually is a cross-platform desktop notifier, please refer to ➜terminal-notifierUbuntunotify-sendVoice NotificationWe usesay(text-to-speech) for voice notificationMacOSMacOS already hassay. seehereormore detailUbuntusee this link:saysudo apt-get install gnustep-gui-runtime
Package: tomaty
tomaty“you say tomato, I say stop wasting my time with lame python portmanteaus”tomaty is a pomodoro app featuring basic stats tracking and notifications with many more features on the way.Contentstomatywhygoalscontributinginstallingdependenciespypilocallyproblemsforkswhythe primary motivation for yet another pomodoro app was that none of the others I could find were:nativenot an electron appsimple but feature robust (flexible for user preferences)goalswhile tomaty’s current release is limited in features, i’m already working hard on another major release.the following features should be available in the coming2.0.0release:To-Do listbasic settings page for user configurationsetting: continuous modesetting: pausing (rather than resetting)setting: dark theme…and more!If you would like to see how things are going, checkout the project page fortomaty v2.contributing…please do!there are plenty ofopen issuesi’ve created for enhancing tomaty. just let me know if you are working on one so i can prioritize my time elsewhere on the project.installingdependenciesthis is a python3 project. please use python3.tomaty is built withGtkusing python’s pyGObject bindings,gi.the docs there haveinstructions for essentially all major operating systems, please use them!pypi(preferably) create a virtual environmentusing pip:pip install tomatyif you get errors about user privileges, particularly on linux or mac, trypip install--usertomaty. avoid usingsudowhenever possible in terms of installpippackages.To update, simplypip install--upgradetomaty. Be sure to do this often, I am constantly adding enhancements and patching bugs 🐛.locallyinstall the version you want from githubenter the directory of your local cloneusing pip:pip install-e.Assuming you are tracking master, a simplegit pull origin masterwill do for updates.problemsif you have problems installing and or getting a development setup going, please let me know in the issues and i can try to help. for mac users, checkout gabby’scommentsto see if they help you.forkssome friend(s) of mine have already started porting this project to other languages. you should check them out!boxcar-willie- tomaty… but in rust-lang. by@bitemyapp
Package: tomb
As an intro to tombo we’ll create a simple blog application:tombnewblogThis will generate a new folderblogwith the following folders in it:Namedescriptionapp/Contains the controllers, models, views, helpers,
mailers, and assets for the application.scripts/Tomb scripts for starting your application and any
scripts you use to deploy or run your application.config/Configure your application’s routes, database, and
more.db/Contains database schema and migration scriptslib/Any code that doesn’t fit in controllers, models,
helpers, and isn’t domain specific.requirements.txtThe dependencies needed for your tomb applicationtests/Unit tests and fixtures
Package: tomba
tombaIdentifique endereços, bairros e outras localizações brasileiras em um texto. 🏘Não sabe o que é oTomba?Essa biblioteca é experimental e está no seu estágio inicial de desenvolvimento.Objetivo:importtombatomba.get_locations("Contratação de empresa de engenharia para executar obras ""de pavimentação localizados no CEP 44100-000, no bairro Tomba.")Saída:[
    {"type": "zipcode", "start": 92, "end": 123},
    {"type": "neighborhood", "start": 113, "end": 118}
]DesenvolvimentoUtilizamos opoetrypara empacotamento e gerenciamento das dependências.Para instalar as dependências, executepoetry install.Para configurar ospacyem português, execute:poetry run python -m spacy download pt_core_news_smPara rodar os testes:poetry run pytestPara gerar um novo modelo:poetry run python tomba/models.py
Package: tomber
Tomber=========Description-----------Tomber is a python wrapper for [Tomb](https://github.com/dyne/Tomb).It relies on Python's subprocess module for Tomb commandexecution. This project was inspired by pytomb which was included inTomb ./extras in the past but is no longer maintained.The included test.jpg image file is used to test the `tbury()` and`texhume()` functions.To speedup forge, an entropy generator such as[haveged](http://www.issihosts.com/haveged/) can be installed.Compatibity----------Current version requieres at least Tomb v2.2 to run.If for any reason you need to use older Tomb version with tomber, pleaseinstall tomber v1.0.2Installation----------First, Tomb must be installed. Please refer to the[Tomb documentation](https://github.com/dyne/Tomb/blob/master/INSTALL.md)to get Tomb installed on your system.Second, tomber must be installed. Tomber can be installed from[PyPi](https://pypi.python.org/pypi) using[pip](https://pypi.python.org/pypi/pip). Enter the following commandinto terminal:pip install tomberAlternatively you can clone this public repository by entering the followingcommand into terminal.git clone https://github.com/reiven/tomberExample usage-------------```pythonfrom tomber import *# dig a tomb of 20mbtdig('test.tomb',20)# forge a keytforge('test.key', 'this is the passphrase for the key')# lock the tombtlock('test.tomb', 'test.key', 'this is the passphrase for the key')# open the tombtopen('test.tomb', 'test.key', 'this is the passphrase for the key', '/tmp/tomb')# close the tombtclose('test')```Running tests-------------Keep in mind that the included *test.py* file execute the`Tomb.slam()` command which will likely close any tombs, encryptedvolumes, you may have open.License-------This package is distributed under BSD License.See [LICENSE](https://github.com/reiven/pynientos/blob/master/LICENSE)
Package: tomb_reflect
tomb_reflectIntroEasily make your Pyramid-powered Web API introspectable.All it takes is:config.include('tomb_reflect',route_prefix='/api_info')# You could pass options to tomb_reflect_add_views to add auth, etc.config.tomb_reflect_add_views()With this, your app now responds to 2 new URLs.The first URL,/api_info/routes, returns a list of routes:{"hello":{"route_pattern":"/hello"},"hello_name":{"route_pattern":"/hello_name/{name}"},"tomb_reflect.routes#index":{"route_pattern":"api_info/routes"},"tomb_reflect.routes#show":{"route_pattern":"api_info/routes/{route_name}"}}The second URL,/api_info/routes/{route_name}, returns detailed info for a
specific route:{"route_name":"hello","route_pattern":"/hello","view":"inventorysvc.views.hello.hello"}ConfigurationIf you want the URLs to be under a different root path, change theroute_prefixin yourconfig.includecall:config.include('tomb_reflect',route_prefix='/super/secret/place')If you want the URLs to only be visible with certain permissions, require
special authorization, etc., you can pass options toconfig.tomb_reflect_add_views:# You can pass options to tomb_reflect_add_views to add auth, etc.config.tomb_reflect_add_views(decorator=SomeCustomDecorator,permission='reflect')Similarpyramid-describe- Only works for apps that usepyramid-controllerdispatch though
Package: tomb_routes
tomb_routesIntroA set of simple defaults forPyramidrouting.Pyramid’sURL dispatchhas separate concepts forroutesandviews.
This gives additional flexibility in that you can one route map to multiple
views, using different predicates (e.g.: predicates depending onAcceptheader, whether request is XHR or not, etc.). In many applications, this
flexibility is not needed and having bothroutesandviewsadds a bit
of complexity and duplication, and reduces DRYness. This module implements some
easy-to-use mechanisms that create a route and a view in one step, resulting in
simpler, easier to understand code. This kind of makes Pyramid’s routing look a
bit more likeFlask, albeit without Flask’s controversialthread locals.You can usesimple_routeas a decorator:fromtomb_routesimportsimple_routefrompyramid.responseimportResponse@simple_route('/hello/{name}')defmy_route(request,name):returnResponse('Hello%s'%name)or you can use it from the configurator:config.include('tomb_routes')config.add_simple_route('/hello/{name}',view_callable,renderer='json')InspirationsFrameworks with very simple routing (including so-called “microframeworks”) are
nothing new. Here are a few in the Python world:minionKleinFlaskPyramid is a very powerful and extensible web framework and it’s a framework
that we love, but sometimes we want very simple routing. This package brings
the simplified routing from microframeworks to Pyramid, so we can have our cake
and eat it too.
Package: tombulled-annotate
annotatePython Annotation SystemAboutAnnotations are tags that store object metadata (e.g. for functions/classes)InstallationFrom PyPIpip install tombulled-annotateFrom GitHubpip install git+https://github.com/tombulled/annotate@mainUsageMarkerAn annotation with a fixed valueimportannotate@annotate.markerdefdeprecated()->bool:returnTrue@deprecateddeffoo():pass>>>annotate.get_annotations(foo){'deprecated':True}AnnotationAn annotation with a configurable valueimportannotate@annotate.annotationdefmetadata(*,author:str,version:str)->dict:returndict(author=author,version=version,)@metadata(author='sam',version='1.0.1')deffoo():pass>>>annotate.get_annotations(foo){'metadata':{'author':'sam','version':'1.0.1'}}Repeatable AnnotationAn annotation that can be used to annotate the same object multiple timesimportannotate@annotate.annotation(repeatable=True)deftag(tag:str,/)->str:returntag@tag('awesome')@tag('cool')@tag('funky')deffoo():pass>>>annotate.get_annotations(foo){'tag':['funky','cool','awesome']}Inherited AnnotationAn annotation that gets added to subclasses of an annotated classimportannotate@annotate.annotation(inherited=True)defidentifier(identifier:str,/)->str:returnidentifier@identifier('abc')classClass:passclassSubclass(Class):pass>>>annotate.get_annotations(Class){'identifier':'abc'}>>>annotate.get_annotations(Subclass){'identifier':'abc'}Targetted AnnotationAn annotation that targets objects of specific typesimportannotateimporttypes@annotate.annotation(targets=(types.FunctionType,))defdescription(description:str,/)->str:returndescription@description('A really cool function')deffoo():pass>>>annotate.get_annotations(foo){'description':'A really cool function'}Non-Stored Annotationimportannotate@annotate.annotation(stored=False)defauthor(name:str,/)->None:pass@author('Tim')deffoo():pass>>>annotate.get_annotations(foo){}
Package: tombulled-attribute
attributeAttribute management made easyInstallationpip install git+https://github.com/tombulled/attribute@mainUsageCustom AttributefromattributeimportAttributeclassFoo:bar:str="hello!">>>bar=Attribute("bar")>>>bar.get(Foo)"hello!"Bundled AttributeimportattributeclassFoo:pass>>>attribute.name.get(Foo)"Foo"
Package: tombulled-param
paramEnhanced function parametersInstallationpip install git+https://github.com/tombulled/param.git@mainUsageFunctionsThe@paramsannotation works seamlessly with functions:fromparamimportParam,params@paramsdefget(url:str,params:dict=Param(default_factory=dict)):print("GET",url,params)>>>get("https://httpbin.com/get")GEThttps://httpbin.com/get{}ClassesThe@paramsannotation also works seamlessly with classes. Importantly, the@paramsannotation should be specified before@staticmethodor@classmethod.fromparamimportParam,paramsclassMyClass:@paramsdefget(self,url:str,params:dict=Param(default_factory=dict)):print("GET",url,params)@classmethod@paramsdefpost(cls,url:str,params:dict=Param(default_factory=dict)):print("POST",url,params)@staticmethod@paramsdefput(url:str,params:dict=Param(default_factory=dict)):print("PUT",url,params)>>>obj=MyClass()>>>>>>obj.get("https://httpbin.com/get")GEThttps://httpbin.com/get{}>>>>>>obj.post("https://httpbin.com/post")POSThttps://httpbin.com/post{}>>>MyClass.post("https://httpbin.com/post")POSThttps://httpbin.com/post{}>>>>>>obj.put("https://httpbin.com/put")PUThttps://httpbin.com/put{}>>>MyClass.put("https://httpbin.com/put")PUThttps://httpbin.com/put{}