Saravanan666/pypi-org huggingface dataset:
Package: clock-cli
Clock CLIA simple time zone converter for the command line.UsageInput a time (flexibly parsed byArrow) and
see the time localized in all your time zones. If a timezone is provided, the input time
is parsed in that time zone. Otherwise, the input time is parsed in your local time.$ clock "2022-08-10 22:00" -t "Asia/Hong_Kong"
Time zone            Local time
-------------------  -----------------------
America/New_York     2022-08-10 10:00 -04:00
America/Los_Angeles  2022-08-10 07:00 -07:00
Asia/Hong_Kong       2022-08-10 22:00 +08:00Add a new time zone using--add. When the entered text matches multipleIANA time zones, you will be prompted to choose
which you want.$ clock 2022 --add sin
Multiple time zones matched 'sin'. Which is correct?
0. Europe/Chisinau
1. Singapore
2. Europe/Helsinki
3. Europe/Busingen
4. Asia/Singapore
> :Clock CLI saves a list of output time zones in~/.clock; feel free to edit this list directly.$ cat ~/.clock
timezones = [ "America/New_York", "America/Los_Angeles", "Asia/Hong_Kong", ]Additional options are provided for output formatting and debugging.$ clock --help
Usage: clock [OPTIONS] TIME

  Shows a time in multiple time zones.

Options:
  -t, --timezone TEXT  Time zone of input time
  -f, --format TEXT    Output time format
  -d, --debug          Show debug messages
  --add TEXT           Add a time zone
  --help               Show this message and exit.LicenseCopyright 2022 Chris ProctorPermission 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: clocked
Clocked=======A library to enable easier profiling, based _**loosely**_ on[MiniProfiler](http://miniprofiler.com/). For a more full-featuredimplementation for use in web development, check out the [GAE Mini Profiler](https://github.com/Khan/gae_mini_profiler). This library is meant to be morelightweight than a full MiniProfiler implementation so that you can quicklyload it into a project and start timing things.Use Case========I was looking to profile some code and came across [this blog post](http://www.huyng.com/posts/python-performance-analysis/) that covers thingsquite nicely. However, the coarse and fine grain timing sections leaves a lotup to reader and aren't very robust, so this library is meant to fill the gap.This library is meant to be used to do higher-level profiling,where you litter your code with profiling statements and generate a report toquickly find where your code is spending all of it's time. From there,fall back to tools like [timeit](https://docs.python.org/2/library/timeit.html) or [line_profiler](https://github.com/rkern/line_profiler).To start, initialize the session by calling```pythonClocked.initialize('at the root scope!')```Then run your code with ``clocked`` decorators and/or ``with Clocked``statements. At the end of the session, output a report with either``Clocked.verbose_report()`` or ``Clocked.hotspot_report()`` to see sometiming information.Supported ways to decorate--------------------------#### class level```python@clockedclass MyClass(object):def will_be_timed_one(self):...def will_be_timed_two(self):...```#### function level```pythonclass MyClass(object):@clockeddef will_be_timed(self):...def will_not_be_timed(self):...```Decorators aren't specific to classes, so you can apply them to individualfunctions like so```python@clockeddef some_function():...```How to use inline-----------------You can use the Clocked object to time something without using a decorator```pythonwith Clocked("i'm timing this!"):...```Generate a report-----------------To get at the timing information, the simplest thing to do is generate a report```python>>> Clocked.verbose_report()"""All timing information:-----------------------test raw simple (326.5 ms)loop 1 (326.5 ms)""">>> Clocked.hotspot_report()"""Hotspots:---------loop 4 (164.5 ms [19.9, 22.0], 8 hits)loop 3 (160.8 ms [19.9, 20.9], 8 hits)loop 2 (1.0 ms [0.2, 0.3], 4 hits)loop 1 (0.2 ms [0.2, 0.2], 1 hits)test raw simple (0.0 ms [0.0, 0.0], 1 hits)"""```Performance-----------To improve performance when testing single-threaded applications,enable faster uuid generation by turning on thread unsafe uuid generation with``clocked.cuuid.toggle_thread_unsafe_uuid(True)``
Package: clockify
ClockifyGeneral InformationSoftware:clockifyAuthor:Paulo Sérgio dos Santos JúniorAuthor's e-mail:paulossjunior@gmail.comSource Repository:https://gitlab.com/integration_seon/libs/application/clockifyGoalClockify is the only truly free time tracker and timesheet app for teams of all sizes. Unlike all the other time trackers, Clockify is available for an unlimited numbers of users for freeDocumentationThe Documentation can be found in thislinkInstalationTo install clockify, run this command in your terminal:pipinstallclockifyUsagefromclockifyimportfactoriesfrompprintimportpprintapi_key="<personal _token>"workspace_services=factories.WorkspaceFactory(api_key=api_key)worspaces=workspace_services.get_all_workspaces()forworkspaceinworspaces:pprint(workspace)CopyrightThis lib was PowerRight bySEON Application Lib Generator
Package: clockify-api
ClockifyDocumentationPackage DocumentationOfficial Clocify API referenceInstallation# Pippipinstallclockify-api# Poetrypoetryaddclockify-apiExample Usagefromclockify.sessionimportClockifySessionKEY="YOUR_API KEY"WORKSPACE="YOUR WORKSPACE ID"clockify_session=ClockifySession(KEY)projects=clockify_session.project.get_projects(WORKSPACE)forprojectinprojects:print(f"Project{project.name}, Client:{project.client_name}")
Package: clockify-api-client
Clockify API ClientSimple API client for Clockify.Simple Python API client for Clockify.Clockify API referenceBase endpointsClientProjectTaskTime EntryUserWorkspaceReports EndpointsReportsShared reports1. InstallationAdd package to your project:pipenv install clockify-api-client2. Usagefromclockify_api_client.clientimportClockifyAPIClientAPI_KEY='yourclockifyAPIkey'API_URL='api.clockify.me/v1'client=ClockifyAPIClient().build(API_KEY,API_URL)workspaces=client.workspaces.get_workspaces()# Returns list of workspaces.
Package: clockify-api-client-adgstudios
Clockify API ClientSimple API client for Clockify.Simple Python API client for Clockify.Clockify API referenceBase endpointsClientProjectTaskTime EntryUserWorkspaceReports EndpointsReportsShared reports1. InstallationAdd package to your project:pipenv install clockify-api-client2. Usagefromclockify_api_client_adgstudios_adgstudios.clientimportClockifyAPIClientAPI_KEY='yourclockifyAPIkey'API_URL='api.clockify.me/v1'client=ClockifyAPIClient().build(API_KEY,API_URL)workspaces=client.workspaces.get_workspaces()# Returns list of workspaces.
Package: clockifyclient
Clockify API Python clientPython client for the Clockify web APIFree software: GNU General Public License v3Documentation:https://clockify-api-client.readthedocs.io.FeaturesAdd a time entry to a Clockify workspaceAdd entry with start and end time, or open-ended in stopwatch modeSet Project time entryBatch edit Time entriesCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.2.0 (2020-09-23)Added bulk edit capabilitiesReformatted to Black and flake80.1.0 (2019-10-23)First release on PyPI.
Package: clockify-idleless
clockify-idlelessVery simple clockify script to track time without idle periods. Very opiniated approach serving the way I track my own time. The premise is that whatever time the user spends active on his/her computer correlates well with the time spent on a given project. The idea is to run the script at startup, forget about it and get reports of the approximate time spent working. If running on a workstation which is only used for work then that approximation should be good enough.RequirementsPython >= 3.5Quick SetupInstall Python 3.5+ if you haven't alreadyOn the command line run:pip install clockify-idlelessRun:clockify-idleless(it will exit with an error)Open[path to user home folder]/.clockify-idleless/config.iniFill inAPIKey(mandatory), you can get it fromClockify user settingsFill inDefaultProjectId(optional), you can get it from the url of the Clockify project page. Should be a string resembling4ba584e621c3d66367e2d149Runclockify-idleless(a tray icon should appear on the taskbar)Adding to startup on WindowsFind the script executable in the Python Scripts folder, something like:C:\Users\[user]\AppData\Local\Programs\Python\Python35\Scripts\clockify_idleless.exeOpen the startup folder by running (âŠž Win+R)shell:startupwhich should take you to a folder similar to:C:\Users\[user]\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\StartupCreate a shortcut ofclockify_idleless.exeon theStartupfolderForget about the script and track your active time on Clockify's website
Package: clockify-seon-sspo-client
Versionversion="v1.1.1"GoalCliente que envia comandos para o job do clockify. Por meio deste cliente é possível que o usuário solicite recuperações de dados do clockify.InstallationTo install clockify_seon_sspo_client, run this command in your terminal:pip install clockify_seon_sspo_clientUsage:frompprintimportpprintfromclockify_seon_client.factory.factoryimportFactoryfromclockify_seon_client.factory.service_enumimportService#Chamar essa função para cada projeto que for um workspace#Associar um ou mais projetos complexos a um workspace do Clockifyorganization="<organization uuid>"clockify_key="<clockify key>"application="<application uuid>"scrum_complex_project=Factory.create(Service.ScrumComplexProject)scrum_complex_project.integrate(organization,clockify_key,application)scrum_atomicproject=Factory.create(Service.ScrumAtomicProject)scrum_atomicproject.integrate(organization,clockify_key,application)team_member=Factory.create(Service.TeamMember)team_member.integrate(organization,clockify_key,application)stakeholder_participation=Factory.create(Service.StakeholderParticipation)stakeholder_participation.integrate(organization,clockify_key,application)
Package: clockin
This little python project provides the ability to do simple time reporting
on google calendars. It is using gdata as interface to google’s calendar
service.change-log2009/04/06 0.1.5increased gdata version to 1.3.0changed dependency from gdata.py to gdata2008/10/13 0.1.4made raster for time reporting configurable. in previous versions the
raster was hard coded to 5 minutes.2008/10/08 0.1.3passing clockin instance to plugin2008/10/03 0.1.2made package installable by easy_install2008/10/03 0.1.1added plug-in mechanism to implement custom hooks independenly from
the application itself #2if stopping time is in future we assume the user means “yesterday” #1splitted some files2008/08/18 0.0.1being more tolerant while handling numbers in descriptionenhanced syntax for passing optionsenhanced error handling for missing or wrong configurationfirst working version
Package: clockit
Tool for timing the execution of Python functions.InstallationInstall withpip:pip install clockitUsageRun as follows:$ python
>>> from clockit import clockit
>>> def f(x, y=1):
...     return x, y
...
>>> clocked = clockit(f, 1, y=2)
>>> clocked.result
(1, 2)
>>> clocked.time
0.0005593200330622494clockituses thetimeitmodule which accepts objects that are callable without arguments.
Package: clock-keeper
Clock KeeperA very minimalistic python module that lets you track the time your code snippets take to run.This package is available on PyPI! Run the following command on your terminal to use it in your project.pip install clock-keeperUsage example is as follows -Importing Class from module.fromclock_keeper.utilityimportTimerInstantiating timer object.timer=Timer()Starting and ending keeping time.timer.markStart()forloopinlengthy_task:# Computing the meaning of life.timer.markEnd()Output -started processing: 2022-01-19 16:24:57.534867
done processing: 2022-01-19 16:25:05.282381
this operation took: 0:00:07.747514ContributionsFeel free to fork this project and add testing functionality and better terminal logging (especially if you want it in your production use cases).Cheers,
Rajdeep. <3
Package: clocklock
ClockLockA streamlined Python utility that gracefully enforces timeouts on your Python functions. Crafted with precision and simplicity, ClockLock lets you leash your function time execution with ease. With its featured decorator and function runner, both equipped with a fallback mechanism, maintaining a smooth control flow has never been more efficient.How It WorksClockLock uses Python's concurrency mechanisms to keep your functions punctual. Providing an easy-to-use decorator and a direct function runner, your functions can be executed with a specified timeout limit - all within a few lines of code. If a function exceeds its time, a fallback function is triggered, facilitating a smooth control flow. Easy to set up and handy in its use, ClockLock guarantees your Python functions never overstay their welcome.Why ClockLock?Graceful: ClockLock manages function timeout smoothly and efficiently.Fallback mechanism: Provides an option to execute a fallback function if the primary function exceeds the given time.Versatile: Equally suited for small scripts and large applications.Pythonic: A clean, minimal, and familiar Python interface.FeaturesDecorator: Simply annotate a function with@clocklock.timeout(seconds=10)to keep it in check.Function runner: Useclocklock.timeout_fn(run_fn, timeout, fallback_fn, args, kwargs)to control the execution of a function.Fallback function: Define a fallback function which gets triggered in case the primary function timeouts.InstallationUse pip to install:pipinstallclocklockOr, if you use Poetry:poetryaddclocklockUsageFirst, import ClockLock:fromclocklockimporttimeout,timeout_fnThen, you can register a function for timeout:@timeout(seconds=1,fallback=lambda:"Fallback Task Complete")defslow_function():time.sleep(2)return"done"slow_function()# returns "Fallback Task Complete"Or, use the function runner:defslow_function():time.sleep(2)return"done"deffallback_func():print("Primary function exceeded time limit.")timeout_fn(seconds=1,func=slow_function,fallback=fallback_func)# prints "Primary function exceeded time limit."Please view the 'examples' directory for detailed usage examples.ContributingWe encourage you to contribute to ClockLock! Please check out theContributing to ClockLock guidefor guidelines about how to proceed.LicenseClockLock is released under theMIT License.
Package: clock-plot
clock_plotclock_plot provides a simple way to visualize timeseries data mapping 24 hours onto the 360 degrees of a polar plot.
For usage, please see theexamples.ipynbJupyter notebookInstallationTo install this package run:pip install clock_plotAvailable featuresTime features are automatically generated for your timeseries. These features include:FeatureTypeDescriptionExample ValuesyearintCalendar year2022monthstrCalendar month"January"year_monthintCalendar year and month in the format YYYYMM202201dayintDay of calendar year25datestrExpressed in the format YYYY-MM-DD"2022-01-25"weekintISO week of the calendar year5dayofweekstrShort version of day of week"Tue"weekendstrEither "weekday" or "weekend", where "weekend" is Saturday and Sunday"weekend" (Sat/Sun)"weekday" (Mon-Fri)hourintHour of the day in 24 clock14minuteintMinute of the hour42degreesintAngle around 24 hour clock-face measured in degrees341seasonstrSeason of the year defined based on month, with Winter being Dec-Feb"Winter" (Dec-Feb)"Spring" (Mar-May)"Summer" (Jun-Aug)"Autumn" (Sep-Nov)These can be used to filter your data and format your plot.For example you could filter for a particular year, plot seasons with different colors and weekday vs weekend days with different line dashes.
Examples of this are given in examples.ipynbWhen should you use these plots?Radar/polar plots (of which clock plots are a special case) aremuch maligned by visualisation experts, and for good reason. Whilst some of the common limitations are overcome with clock plots, two key ones remain:It is harder to read quantitative values than on a linear axisAreas scale quadratically (with the square of the value) rather than linearly, which can lead to overestimation of differencesClock plots are therefore most suited for cases where understanding absolute values is less important and one or more of the following is true:behaviour around midnight is particularly importantthere are a 2-3 daily peaks and understanding at a glance when those are occurring is more important than their exact magnitudeyou want a distinctive, eye-catching graphic to engage people with your workNote that they are particularly poorly suited to:timeseries with negative values (the radial axis becomes very unintuitive)timeseries with little within day variation (you just get circles!)If you're not sure which is best for a particular use case, you can quickly toggle between a clock plot and a linear plot by addingmode="line"to your clock_plot call.
Package: clockpuncher
ClockPuncherAbstractThis is a small python utility app that is being designed for time-tracking. As the name suggests, this is trying to replace track.toggl.com for tracking my own work.The end-goal is a local, open-source timer that is hackable and can automate specific tasks like uploading/submitting billable hours.Images'Production' GUI for usageDevelopment GUI with logger and debugger windowsInstallationThe best way is to usepipxand runpipx install clockpuncherorpipx run clockpuncher.On install a folder will be created in~/.local/Clockpuncherto contain local data storage. It should contain a sqlite db calledtimer.dband possibly wal files. It's literally just a sqlite database, you can access, query, and adjust as you would with any other database. This might be slightly different depending on your OS.You can delete this folder without issue, but you will lose all your stored data.Current Next Steps:Integrate sqlite DB of timer sessionsAdd inputs for specific task descriptions (text box)Add on-the-fly graph representationsTask BreakdownTotal Hours (per task and total)Total Billed (per task and total)Add report CSV outputAdd tests for main.py + gui modulePut on PyPISetup with pipx for app deploymentAdd user settings with persistent storageAdd database back-up/cold-storage optionRepo StructureThis repo follows a pretty standard layout withmain.pybeing the GUI front-end + database composed together to make the stopwatch app itself.Outline:clockpuncher/- contains all code required to run Clock Punchermain.py- The main file that combines GUI, database, and application logic to make the above imagesdatabase.py- Contains the Database class that does CRUD operations for main.pymodels.py- Dataclasses that represent rows in the Entries and Projects tableplatform_local_storage.py- Local storage location constants fordata/- Contains local data storage. In production it stores data indata/timer.dbgui/- All reusable GUI componentsbase_gui.py- Base GUI class with loggers and basic development/production switchers.dev_gui.py- This holds quick GUI screens tossed together for development.entry_visualization.py- Contains task_chart and entry_table components and their class definitionstimer.py- Contains Timer and Number GUI components that make up the clock displaytests- Test suite using Pytest + Hypothesis
Package: clockr
# clockr[![Build Status](https://travis-ci.org/shaggytwodope/clockr.svg)](https://travis-ci.org/shaggytwodope/clockr)clockr is a collaborative effort at a simple curses clock written in Python 3.#Reviews[Video by Yu-Jie Lin](https://www.youtube.com/watch?v=P3rv3rS40Ls)* A harsh critique, but the video nicely shows clockr.# Screenshot![clockr](http://i.imgur.com/gNyIXlX.png)# Installation* Arch Linux: clockr in the AUR* pip: clockrFor manual installation, clone the repository, cd into it and run```# python setup.py install```# Optionsusage: clockr [−h] [−V] [−c COLOR] [−d DATEFORMAT] [−n] [−t]**optional arguments:−h**, **−−help**show this help message and exit**−V**, **−v**, **−−version**show program’s version number and exit**−c** COLOR, **−−color** COLORchanges color of the clock.**−d** DATEFORMAT, **−−dateformat** DATEFORMATchanges the format in which the date is printed, see ’man date’ for support on formats. Not to be combined with the ’−−nodate’−argument.**−n**, **−−nodate**does not print the date in the clock**−t**, **−−twentyfourhours**prints the time in 24−hour format# Examples**clockr −−nodate −−twentyfourhours −−color** _white_Will display a white-colored 24-hour clock while omitting the date.The different colors avaialable are,_white red green yellow blue magenta cyan orange_And you can also use _random_ to chose a random color.# FAQQ: Can you add [feature]? When will [bug] be fixed?A: This project is completely run by volunteers and will most likely never be 100% bug-free as developers are humans too. You can help out yourself, though, by submitting a bug report!# Thanks and AuthorsMade with help from #linuxmasterrace on Snoonet thanks to n473, thimoteus, AWindowsKrill, timawesomeness, calexil, tirkaz and somehow R0flcopt3r, with additional help from bdalenoord and Noremac201.
Package: clockrange
clockrangeA clock-like periodic sequence generatorInstallationpipinstallclockrangeGetting StartedClockRangeprovides clock-like sequences according to the given specification:fromclockrangeimportClockRange# A typical 24h microsecond-granular clock.clock=ClockRange((24,60,60,1000,1000))# How many microseconds until the clock completes a full cycle?len(clock)# How does the clock look like when 150000 microseconds have passed?clock[150000]See more examples below.ExamplesClockRangeaccepts different specification formats:# These are equivalent:ClockRange((3,60))ClockRange(([0,1,2],60))ClockRange((range(3),60))ClockRange((range(0,3,1),60))# These result in .counters being different from .rendered:ClockRange((["A","B","Z"],60))ClockRange((range(4,10,2),60))ClockRangeinstances support random item access with O(1) runtime performance:clock=ClockRange((24,60,60))clock[0]# ClockState(counters=(0, 0, 0), cycles=0, rendered=(0, 0, 0))clock[1]# ClockState(counters=(0, 0, 1), cycles=0, rendered=(0, 0, 1))clock[86400]# ClockState(counters=(0, 0, 0), cycles=1, rendered=(0, 0, 0))ClockRange.__len__provides the cycle length:assertlen(ClockRange((12,)))==12assertlen(ClockRange((10,10)))==100assertlen(ClockRange((24,60,60)))==86400ClockRangeinstances can be iterated on:clock=ClockRange((24,60,60))it=iter(clock)next(it)# ClockState(counters=(0, 0, 0), cycles=0, rendered=(0, 0, 0))next(it)# ClockState(counters=(0, 0, 1), cycles=0, rendered=(0, 0, 1))ClockRangeiterators never get exhausted, so loop control needs to be performed manually:forstateinClockRange((24,60,60):ifstate.cycle==1:breakContributingTo run the test suite locally, clone and setup the repository for local development:pipenvinstall
pytest--cov-report=html
Package: clockwise
clockwise 🕰️Simple but expressive timing package in PythonInstallationpip install clockwiseMinimal Exampleimport clockwise

@clockwise.timing("foo")
def foo(a: int): 
   return a + 4

def main():
    for i in range(10):
        foo(i)
    clockwise.print_timings() 

if __name__ == '__main__':
    main()