Saravanan666/pypi-org huggingface dataset:
Package: tempmailwrapper
tempmailwrapperThis is an improved and updated version of the outdated Github projectTempmail. Changes:Completely up to date with the new Temp Mail API on RapidAPI.Full Python3 supportCode improvementsDescriptionPython API wrapper forTemp Mail.Disposable email- is a free email service that allows to receive email at a temporary address that self-destructed after a certain time elapses. You can view full API specification inhereorhere.PrerequisitesPython 3.XInstallation$ pip install tempmailwrapperUsageStart by navigating toRapidAPIto obtain an API key. Create an account, fill in your details and subscribe to one of the plans. There's a free plan allowing for up to 100 request/day for free.Once you have the API key, you can follow these examples:Setting up a temporary email:$ from tempmailwrapper import tempmailwrapper
$ tm = tempmailwrapper.TempMail(api_key="YOUR_API_KEY_HERE")
$ random_email_address = tm.get_email_address()
$ specific_email_address = tm.get_email_address(username='testing', domain='subcaro.com')Get list of all emails for an email address:$ from tempmailwrapper import tempmailwrapper
$ tm = tempmailwrapper.TempMail(api_key="YOUR_API_KEY_HERE")
$ email_address = tm.get_email_address()
$ print(random_email_address) # Now send an email here.
$ emails_list = tm.get_emails(email_address)Get specific email:$ from tempmailwrapper import tempmailwrapper
$ tm = tempmailwrapper.TempMail(api_key="YOUR_API_KEY_HERE")
$ email_address = tm.get_email_address()
$ print(email_address) # Now send an email here.
$ emails_list = tm.get_emails(email_address)
$ first_email_id = emails[0]['mail_id']
$ email = tm.get_one_message(first_email_id)
$ print(email.text) # Tip: use a library like BeautifulSoup to navigate your way easier through HTML-formatted emails.
Package: tempman
Tempman can be used to create temporary directories. These temporary
directories can then be easily cleaned up by callingclose, or using
the directory as a context manager.By using a fixed root for temporary directory, Tempman also allows
cleanup of directories older than a specified timeout.Exampleimport tempman

with tempman.create_temp_dir() as directory:
    assert os.path.exists(directory.path)
    assert os.path.isdir(directory.path)

assert not os.path.exists(directory.path)APItempdir.create_temp_dir(dir=None)Creates a temporary directory and returns an instance ofTemporaryDirectory. The directory will be deleted when the instance
ofTemporaryDirectoryis closed.Ifdiris set, the temporary directory is created as a sub-directory
ofdir.TemporaryDirectoryHas the following attributes:path- path to the temporary directoryclose()- delete the temporary directory, including any files and
sub-directoriesTemporaryDirectoryis a context manager, so usingwithwill also
delete the temporary directory.tempdir.root(dir, timeout=None)Creates a factory for temporary directories, all of which will be under
the directorydir. ReturnsRoot.Iftimeoutis set, any sub-directories with an age greater thantimeoutseconds will be deleted on cleanup. Cleanup occurs duringroot.create_temp_dir(), and can also be triggered manually by
callingroot.cleanup(). The age of a sub-directory is determined by
the modification or access time, whichever is later.timeoutcan
either be a number of seconds, or an instance ofdatetime.timedelta.RootHas the following attributes:create_temp_dir(): creates a temporary directory in the same way
astempman.create_temp_dir(), except that the parent directory is
always the directory of theRoot. Also callscleanup().cleanup(): iftimeoutis set, delete old sub-directories as
described above.Installationpip install tempman
Package: tempmon
=======================================tempmon -- Temperature monitor daemon=======================================tempmon uses temperusb_ to read temperature value from TEMPer_ sensorson the USB bus and OWM_ to find the local reported temperature andpublishes the results to `plot.ly`_.. _temperusb: https://pypi.python.org/pypi/temperusb.. _TEMPer: http://www.amazon.com/gp/product/B002VA813U/ref=as_li_tl?ie=UTF8&camp=1789&creative=390957&creativeASIN=B002VA813U&linkCode=as2&tag=hellflynet-20&linkId=VHDXEZ2QB74BXBM5.. _plot.ly: https://plot.ly.. _OWM: http://openweathermap.org/Setup=====#. Sign up for a plot.ly account.#. From your `plot.ly settings page`_, create one stream token persensor device#. Install tempmon and its dependencies. A virtualenv works fine forthis.#. Sign up for a OWM account and find your API key on `your settingspage <http://openweathermap.org/my>`__.4. Create a configuration file using YAML syntax and containing atleast the basic plot.ly authentication data:::plotly:username:api-key:stream-tokens:- token1- token2weather:api-key:place: "City, State"5. Run ``tempmon -c $CONFIG_FILENAME``.  Add ``-v`` to see the logoutput on the console for debugging.Other Configuration Settings============================graph-titleThe title of the graph defaults to "Temperature".retention-periodThe number of days for which data should be kept. tempmon uses thisvalue to compute the number of points to save based on the``frequency``.frequencyHow often to collect data, in minutes. This value is approximatelyhow fast tempmon will poll the device. The minimum frequency is 1minute.unitsThe units to report the temperature in. Either ``celsius`` or``fahrenheit``. Defaults to ``fahrenheit``... _plot.ly settings page: https://plot.ly/settings/api
Package: tempmorph
TempMorphTempMorph is a Python package that helps you convert a temperature from one scale to another. This version currently works on Celcius, Fahrenheit, Kelvin, Reaumur, and Rankine.UsageThings to Note:1 = Celcius2 = Fahrenheit3 = Kelvin4 = Reaumur5 = RankineOutput = Float:fromtempmorph.convimportTempConv# 30 is the value, 1 is Celcius (scale)temp=TempConv(30,1)# Returns 87.6 (30 Celcius in Fahrenheit)temp.fahrenheit()Output = String + Symbol:fromtempmorph.convimportTempConvtemp_str=TempConv(373,3)temp_str.celcius(1)#                ^# By adding one as an argument, output will be '99.85 °C'
Package: tempo120
Tempo120A racing game written using Python/pygame during thebpb(Bundeszentrale für politische Bildung)game jam 2023. The game jam's topic was mobility.You may download an executable version onitch.io.AboutTempo120is a very simple car racing game. You may control your vehicle using the cursor keys or WASD.The higher the speed the more difficult it is to control the vehicle. You do not need to accelerate all the time. The speed stays same unless you brake or drive besides the road.How to...InstallThe most recent compiled version can be found onitch.io. This repository includes the source code and assets needed to build / extend the game.Build own levels/tracksThe game stores its tracks in .png-images. In theory, the images may have an arbitrary size, but you may encounter memory issues if they get too big.Each pixel in the image represents a field within the game.The track's background should be in (100, 255, 0, 255) green what is interpreted as grass. The track itself should be drawn on it using grey. I used (139, 139, 139, 255) as color and a plain, round brush with a size of 14 pixels. The track is surrounded by "tires" (0, 0, 0, 255) which stop the vehicle completely. In the default track, tires are placed in a distance of 7 pixels around the track.A plain white (255, 255, 255, 255) line indicates the end of the track - when reaching it, the round ends and you may insert your name which may occur in the high scores.There is a single plain red (255, 0, 0, 255) pixel on the track which defines the vehicle's starting position.If you build your own levels, don't forget to share them!Build a standalone executableYou can build an executable usingpyinstaller --onefile tempo120.pyIf you havepyinstallerinstalled...You must then copy the assets folders (gfx, muzak) and optionally the scores into the generated dist folder, rename it to "tempo120" and zip it.The executable runs on the type of machines you have executed pyinstaller at.Possible extensionsThe first version of the game was written on a single day during a game jam. That's why the current version has only a limited functionality - driving along a race track, trying not to get off the road.Possible extensions could be:adding other field types (water, obstacles)adding other vehicle typesintroducing something to avoid cheating (you can basically drive backwards...)introducing more roundsadding further trackssome kind of an integration of further tracksmultiplayer modeI like the game and may port it to c++ once.Change Logv1.0.0 (03.08.2023)adding missing assets to the Python releasev0.8.0 (02.08.2023)included track debugging fromMapleMonarchadded a setup script, you may now download the current release fromPyPiv0.6.0 (23.07.2023)added tires to disallow cheatingpatched the engine noise (repeating, volume in dependence to speed)some smaller improvementsNotesI tried to use bitmap tiles instead of simply filled polygons - the game gets much slower.LicenseThe game is licensed under the GPL 3.0.
Package: tempo-api-python-client
tempo-api-python-clientPython bindings for Tempo Rest API.This is a Tempo API client library to simplify the interaction with Tempo timesheets. The implementation supports Tempo API v3 and v4.Pip release is available:https://pypi.org/project/tempo-api-python-client/Tempo Rest API documentation can be found athttps://apidocs.tempo.io/InstallationInstall current release by pippip install tempo-api-python-clientGetting StartedYou need an API token for communicating with tempo REST APIs.For v3 usefrom tempoapiclient import client_v3

tempo = client_v3.Tempo(
    auth_token="<your_tempo_api_key>",
    )

worklogs = tempo.get_worklogs(
    dateFrom="2019-11-10",
    dateTo="2019-11-11"
    )

for i in worklogs:
    print(i)For v4 usefrom tempoapiclient import client_v4

tempo = client_v4.Tempo(
    auth_token="<your_tempo_api_key>",
    )

worklogs = tempo.get_worklogs(
    dateFrom="2019-11-10",
    dateTo="2019-11-11"
    )

for i in worklogs:
    print(i)There are also functions to retrieveuserandteam-specific worklogs.Code FormatFlake8:flake8 --max-line-length=120 tempoapiclient/*Pylint:pylint --max-line-length=120 tempoapiclientContributingContribution is welcome. SeeCONTRIBUTING.mdfor more details.
Package: tempo-async
TempoAsynchronous wrapper for HTTP requests.Installationpipinstalltempo-asyncUsageimporttempourl='https://via.placeholder.com'num_reqs=100requests=[# map in any request parameters: url, query params, HTTP method, etc.tempo.RequestConfig(url=url)for_inrange(num_reqs)]if__name__=='__main__':tempo.run(requests,rate=10)# fetch 100 cat pictures, 10 a secondTake it a step further by collecting the responses,importtempourl='https://via.placeholder.com'num_reqs=100### cat picture bucketcatpics=[]###requests=[# map in any request parameters: url, query params, HTTP method, etc.tempo.RequestConfig(url=url)for_inrange(num_reqs)]if__name__=='__main__':tempo.run(requests,collector=catpics,rate=10)# indicated `catpics` should store responseprint(f'Pictures stored in list:{len(catpics)}')… and adding any number of processing functions to handle responses.importtempourl='https://via.placeholder.com'num_reqs=100catpics=[]requests=[# map in any request parameters: url, query params, HTTP method, etc.tempo.RequestConfig(url=url)for_inrange(num_reqs)]### processorsdefsay_hi(res)->None:# returns None so does not affect final processed response sent to collectorsprint('Hello cat!')defget_body(res)->str:# since it returns a value, this processor changes the final output of `tempo.run`body=res.textreturnbody###if__name__=='__main__':# process the requests in order of listed processorstempo.run(requests,collector=catpics,rate=10,processors=[say_hi,get_body])# processors' return values affect output sent to collectorsprint(f'Type of stored result:{type(catpics[0])}')# str, not Response objectContributingSubmit a pull request! Contributions are welcome!Please write test coverage for your changes and runtoxto test for backwards compatibility among the supported Python versions.TODOSOpen an issue, create a branch, and submit a PR. (Tests for everything!)Handle collection of results as a return value of therunfunction.Decorator for basic async request function accepting iterator of request arguments.Accept plain Python dictionaries and JSON in addition to RequestConfig objects for requests mapping.Logging.Exception handling.GitHub Actions.Retries with various back-off algorithms and HTTP response header search for 429 causes.Generator option forrunfunction.Allowcollectorargument to be an iterable, a function passed a response / processed response object, or a file out. Maybe even stdout.Like processors, allow multiple collectors (eg. file, queue).Local database for keeping track of requests and their status, for retry and interrupts.Asynchronous processor support.Handle streaming responses.CLIDocumentation page. Also, good docstrings.Test coverage tracking.…
Package: tempocli
TempoCLICommand line interface for interacting with Tempo.IntroductionEase repetitive Tempo tasks by using templates to fill in recurring
items without having to use web interface. Templates are yaml formatted
files that are semi-flexible in allowing what can be created.Theauthor_account_idcan be obtained by going to your profile in
JIRA and copying the ID from the URL.----
author_account_id: foo

issues:
  # Will use current date if one can't be determined.
  - issue: INT-8
    time_spent: 30m
    start_time: "9:30AM"

  # Can specify day of week easily.
  - issue: INT-10
    time_spent: 1h
    start_time: Monday at 9AM

  # Full on datetime with override.
  - issue: INT-11
    time_spent: 90s
    start_time: "2018-08-05 11:00:00"
    author_account_id: bar

  # Pass in extras that aren't exposed in DSL.
  # https://tempo-io.github.io/tempo-api-docs/#worklogs
  - issue: INT-11
    time_spent: 1h
    start_time: 8am
    extras:
      remainingEstimateSeconds: 300Installation$ pip install tempocliRunning$ tempocli --config <config> create --template <template>ConfigurationBy default,~/.tempocli.ymlis the path used for the configuration
file but that can be changed with the--configoption during
invocation. The configuration file should look like this:---
token: <token>It is also possible to specify the token using theTEMPOCLI_TOKENenvironment variable.DockerDockerHub$ docker run \
    --rm \
    --tty \
    --interactive \
    --volume ~/.tempocli.yml:/home/tempocli/.tempocli.yml:ro \
    --volume /some/dir/with/templates:/templates:ro \
    awiddersheim/tempocli \
    create --template /templates/template.ymlBuilding Locally$ docker build --tag tempocli --target prod .Development$ pip install --editable .
$ tempocli --helpTesting# Install development packages (preferably in a virtualenv)
$ pip install --editable .[dev]

# Run tests
$ pytest

# Run tests for available Python interpreters
$ tox

# Linting
$ flake8

# Can also lint in tox as well
$ tox -e flake8
Package: tempo-client
tempo-clientA Python client to Tempo Timesheet REST APISimple Client for interfacing to Tempo Timesheet.We use it to pull worklogs and aggregate to our billing system, so all endpoints
are not implemented. If you want more functions we would love a pull request.We don’t use the full OAuth2 authorization, just the API token generated from within JIRA.SeeTempo Timesheet Documentationfor more details.Supported functionsGet all accountsGet account infoGet worklogs for accountExampleimportiso8601fromtempo_client.clientimportTempoClientclient=TempoClient(access_token='xxxxxxxxx')from_date=iso8602.parse_date('2018-02-01')end_date=iso8602.parse_date('2018-02-28')worklogs=client.get_account_worklogs(account_key='ACCOUNT',start=from_date,stop=end_date)Changelog0.0.1First implementation of the client. Really need to add better error handling…
Package: tempora
Objects and routines pertaining to date and time (tempora).Modules include:tempora (top level package module) contains miscellaneousutilities and constants.timing contains routines for measuring and profiling.schedule contains an event scheduler.utc contains routines for getting datetime-aware UTC values.For EnterpriseAvailable as part of the Tidelift Subscription.This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.Learn more.
Package: temporal-boost
Temporal-boostUnder active developmentDocumentation in progressSmall framework based ontemporalio/sdk-python- createTemporalmicroservices as fast as you canQuick startfromtemporal_boostimportBoostAppfromtemporalioimportactivityfromtemporalioimportworkflow# Create `BoostApp` objectapp=BoostApp()# Describe your activities/workflows@activity.defn(name="test_boost_activity_1")asyncdeftest_boost_activity_1(foo:str,bar:str)->str:app.logger.info("This is built-in logger")returnf"1_{foo}{bar}"@activity.defn(name="test_boost_activity_2")asyncdeftest_boost_activity_2(foo:str,bar:str)->str:returnf"2_{foo}{bar}"@workflow.defn(name="TestCronWorkflow",sandboxed=False)classTestCronWorkflow:@workflow.runasyncdefrun(self)->None:app.logger.warning("With is cron workflow")returnNone# Add async workers to your app (FastAPI style)app.add_worker("worker_1","task_q_1",activities=[test_boost_activity_1],metrics_endpoint="0.0.0.0:9000")app.add_worker("worker_2","task_q_2",activities=[test_boost_activity_2])# Example of CRON workerapp.add_worker("test_cron","task_q_3",workflows=[TestCronWorkflow],cron_schedule="* * * * *",cron_runner=TestCronWorkflow.run)# Run your app and start workers with CLIapp.run()python3main.py# Usage: main.py [OPTIONS] COMMAND [ARGS]...# Options:#   --install-completion [bash|zsh|fish|powershell|pwsh]#                                   Install completion for the specified shell.#   --show-completion [bash|zsh|fish|powershell|pwsh]#                                   Show completion for the specified shell, to#                                   copy it or customize the installation.#   --help                          Show this message and exit.# Commands:#   cron#   runpython3main.pyrun# Usage: main.py run [OPTIONS] COMMAND [ARGS]...# Options:#   --help  Show this message and exit.# Commands:#   all#   test_cron#   worker_1#   worker_2python3main.pyrunworker_1# 2023-09-20T21:25:12 | INFO     | Worker worker_1 was registered in CLI# 2023-09-20T21:25:12 | INFO     | Worker worker_2 was registered in CLI# 2023-09-20T21:25:12 | INFO     | Worker test_cron was registered in CLI# 2023-09-20T21:25:12 | INFO     | Worker worker_1 started on task_q_1 queue
Package: temporal-cache
temporal-cacheTime-based cache invalidationInstallFrom pippip install temporal-cacheOr from sourcepython setup.py installWhy?I needed something that would automagically refresh at 4:00pm when markets close.@expire(hour=16)deffetchFinancialData():Interval CacheThe interval cache expires everytimeinterval since its first use@interval(seconds=5,minutes=2)defmyfoo():'''myfoo's lru_cache will expire 2 minutes, 5 seconds after last use'''Expire CacheThe expire cache expires on the time given, in scheduler/cron style.@expire(second=5,minute=2)defmyfoo():'''myfoo's lru_cache will expire on the second minute, fifth second of every hour, every day, etc'''CaveatsPython hashing symantics persist. Dicts will be frozen, lists will be converted to tuples. Users are advised to pre-freeze to avoid issues.
Package: temporal-embeddings-compass
Temporal Embeddings with a CompassThis package is a rewritten fork of the originalCADEpackage, which generates Temporal Word Embeddings with a Compass (TWEC).
It expands on theoriginal paperby creating the concept ofTemporal Document Embeddings with a Compass (TDEC).
It takes advantage of CADE's idea of creating a general, atemporal model (either word2vec or doc2vec) and freezing the hidden weights of that model (the "target embedding") to then be used to train individual time slices.
This results in alignment across time slices because similar outputs would require similar input word/document vectors.
As a result,words and documentscan be compared across time slices.There is currently a working representation of TDEC, I will get around to adding an implementation of TWEC.
Package: temporal-lib
temporal-libA library for working with datetime and other temporal concepts.ExplanationOriginally, I created a "Temporal"companion Appfor theFrappe Framework.
Over time, more of my non-ERPNext Python projects required or benefitted from the same helper functions and classes.So I'm splitting the project:All generic, reusable Python code will be stored in this package, and synchronized to PyPi.org.The remaining Frappe-specific code will remain on GitHub, and begin to reference this package as a requirement.Installationpip3installtemporal-libUsageThe library's namespace istemporal_lib.  For example:""" your_code.py """fromdatetimeimportdatetimeimporttemporal_libtoday_date=datetime.now().date()today_iso_string=temporal_lib.date_to_iso_string(today)print(today_iso_string)StandardsAll date strings are expected to be ISO-8601 extended.  Example: 2023-11-29LinksTo thetemporal-libpackage on PyPihere.A helpfulWikipedia articleabout ISO-8601.To myRust-basedfile-8601projecthere!(Deprecated) My original Pythonfile-8601projecthereFurther Readinghttps://blog.ganssle.io/articles/2018/03/pytz-fastest-footgun.htmlhttps://blog.ganssle.io/articles/2018/02/aware-datetime-arithmetic.htmlhttps://github.com/regebro/tzlocal/issues/90#issuecomment-699714858https://github.com/dateutil/dateutilAttributionsHourglass image on GitLab repository by The Oxygen Team, KDE; - KDE github;, LGPL,https://commons.wikimedia.org/w/index.php?curid=18609110
Package: temporaluuid64
A time-based 64-bit UUID generator. The basic idea behind is to provide a
universally unique identifier that satisfies the following conditions:Installationpip install temporaluuid64Technical DetailsThe time-based UUID consists of two components: a timestamp and a node ID.+----------------------+--------------------+
|  48-bit (timestamp)  |  16-bit (node_id)  |
+----------------------+--------------------+Sort entities in chronological orderEntities given their UUIDs must be able to be sorted in chronological order
without relying on additional data fields. This is why the timestamp bits
occupy the most significant bits.Suitable for distributed systemsEven if multiple identifiers are created at the exactly same time, given a
particular granularity (generally a millisecond), the UUID generator must be
able to provide a way to avoid collisions.