Saravanan666/pypi-org huggingface dataset:
Package: tily
wsi_tilTumor-infiltrating lymphocytes prediction based on Whole Slide Imaging.InstallationThe tools uses Tensorflow v.1 and thats why requires Python 3.7
to be installed. If you have Python below 3.7.12 already installed
please simply run:pip install tilyIf you also need to install Python 3.7 please run the following:sudo make install
python3.7 -m pip install tilyUsageTo start the validation run the following:tily--input_tiff=<PATHTOTIF\SVSfile>
Package: tim
(‘Tim: Timed iteration monitorn============================nnA common pattern I have when writing code to import or treat large chunk of data is to do some printing to track the progress and some timing to monitor the speed.nSo I often end up with some variation of this in my code:nn```pythonnfrom datetime import datetimenstart = datetime.now()nn = 0nfor i in my_iter:n    n+=1n    print “\r”, i,n    # do stuffnprint start - datetime.now()nprint (start - datetime.now()) / n / 100n```nnnwhich is a lot to remember and type which in turn make it easy to introduce bugs in some edge case which you need then to debug.nnSo I wrote tim to help me do just that, so I have this pattern ready for use and working and can spend my time coding my data treatment instead of debbugging my helper code.nn*WARNING* : This is alpha level stuff, I'm still working out the proper way to do stuff so the API may still change a bit.nnHow to use timn————–nnCommon usage pattern would probably be:nn```pythonnimport timnntim.start()nfor i in my_iter:n    tim.pulse_print() # print current progressn    # do stuffntim.stop() # print overall stats and reset countern```nnIf you just need to monitor start and stop you can use:nn```pythonntim.start()n# calculationntim.stop() # print elapsed time and resetn```nnnInstallationn————nn    pip install timn’,)
Package: tima-mindif
TIMA Mindif Processor v2.0.1Getting Startedinstall from pypipip install tima-mindifInstall direct from git (Note: this is currently a private repository)pip install git+https://gitlab.com/csiro-geoanalytics/tima-utils/tima-mindif-processor.gitOr clone the repo so you can make changes or view the code, note the -e in the pip install is optional, it makes it so any code changes are automatically picked up.git clone https://gitlab.com/csiro-geoanalytics/tima-utils/tima-mindif-processor.git
<Navigate to the code directory>
pip install -e .If you would like to work on the code in a virtual env a pipfile is availablepip install pipenv
pipenv install
pipenv shellUsageOnce it's installed use the command 'tima-mindif'tima-mindif -h

usage: tima-mindif [-h] [--output OUTPUT] [--verbose] [--exclude-unclassified]
                   [--show-low-val] [--thumbs]
                   project_path mindif_root

Process TIMA data

positional arguments:
  project_path          Path to the TIMA project
  mindif_root           Path to the MinDif root

optional arguments:
  -h, --help            show this help message and exit
  --output OUTPUT, -o OUTPUT
                        Path to the desired output folder
  --verbose             Prints more information about app progress.
  --exclude-unclassified, -u
                        Exclude unclassified rock types from image
  --show-low-val, -l    Prints rock types with <0.01 in the legend.
  --thumbs              Create thumbnails.The script should be executed in the following manner:
tima-mindif tima_mindif_processor.py project/path mindif_root output_rootFor example:tima-mindif "/media/sf_Y_DRIVE/Data/Evolution" "/media/sf_Y_DRIVE/Data/Adam Brown" -o ./output
Package: timber
🌲 Timber - Great Python Logging Made EasyTimber.iois a hosted service for aggregating logs across your entire stack -any language,any platform,any data source.Unlike traditional logging tools, Timber integrates with language runtimes to automatically
capture in-app context, turning your text-based logs into rich structured events.
Timber integrates with Python through this library. And Timber'srich free-form query toolsandreal-time tailing, make drilling down into
important stats easier than ever.FeaturesSimple integration. Integrates with the Pythonlogginglibrary.Support for structured logging and events.Support for context.Automatically captures useful context.Performant, light weight, with a thoughtful design.Get StartedInstallationConfigurationUsageGuidesAutomatic ContextPerformanceTimber•Docs•Pricing•Security•Compliance
Package: timberas
Abouttimberasis a Python package with tools to support research and design of Australian timber structures. It can be used to determine the material properties, section properties, and design capacities for structural members as per Australian Standard AS1720.1:2020 (Timber Structures Part 1: Design Methods).DocumentationDetailed information ontimberasis available in package documentation attimberas.readthedocs.io. This includes project background, examples, and an API reference guide.Installationtimberascan be installed from the Python Package index:pip install timberasFor more detailed instructions, please refer to thedocumentation.Current FeaturesSection library: define sections and calculate section properties from typical Australian timber product dimensions, or from custom user input.Material library: create timber materials from typical Australian grade classifications (F-Grade, MGP, Glulam), or from custom user input.Design capacity calculations: solve the design capacities of structural timber members in tension, compression, bending, and shear, following AS1720.1 design methods.Questions, Feedback, and ContributionsIf you have questions, feedback, or suggestions for further development, please emailJoe Gattasor create an issue on thetimberasgithub repository.Similarly, if you find any bugs, or are interested to contribute to the project, please create an issue or email Joe.Licensetimberasis an open source engineering tool provided under an MIT License. Please refer to theLICENSEfile for more information.Please note that this software has been developed by student and academic engineering researchers, NOT by chartered or registered engineers.AcknowledgementsThis package has been developed from research projects supported by theUniversity of Queensland,ARC Future Timber Hub(2016-2021), andARC Advance Timber Hub(2022-).If you usetimberasfor projects or scientific publications, please consider citing our journal paper:Jiang, J., Ottenhaus, L. M., & Gattas, J. M. (2023). A parametric design framework for timber framing span tables.Australian Journal of Civil Engineering, 1-16.doi:10.1080/14488353.2023.2227432.
Package: timberjack
timberjackInstallYou can installtimberjackdirectly from the Github repo using:$ pip install https://github.com/mobify/timberjack/archive/master.zipSetup in DjangoTBD.Setup in FlaskThe timberjack logging tools come with a convenience class that allows the easy
configuration of a Flask application to use logging:from timberjack.contrib.flask import Timberjack

...

app = Flask(__name__)
timberjack = Timberjack(app)

...

log = timberjack.get_logger('my.logger')LicenseThis code is licensed under theMIT License.
Package: timberlake
AWS Attack AutomationTimberlake is an AWS attack automation utility that can execute one or more test cases. You can read the release blog here:linkTest cases are individual YAML documents that define the setup, execution, and cleanup steps for an attack procedure. These documents contain both metadata about the attack (e.g. MITRE mappings, permissions) as well as Python code for executing the attack.Timberlake is designed with modularity in mind. Test cases are defined and managed outside the tool and can be swapped around as needed for different execution scenarios.Notable features of Timberlake:Support for multiple credential profilesPremade operations avaiable to all test cases (e.g. compound API actions, canned policies, etc)API-level logging, including parametersVECTRintegration for tracking attack detailsExample use can be found inexamplesNote: Test cases should ideally be run in a non-production accountInstallpip install dist/*.whlPyPIpip install timberlakeIf you install from PyPI, you must also install the following dependencies:pip install git+https://github.com/SecurityRiskAdvisors/py-attire-schema.gitUsageusage: timberlake [-h] -c CONFIG [-p PHASES] [-a ARGS]

optional arguments:
  -h, --help            show this help message and exit
  -c CONFIG, --config CONFIG
                        config file path
  -p {execution,setup,cleanup} [{execution,setup,cleanup} ...], --phases {execution,setup,cleanup} [{execution,setup,cleanup} ...]
                        list of phases to execute; default = all
  -a ARGS, --args ARGS  args file pathConfig : path to config file; must existPhases : one or more phase names to execute; order doesn't matterArgs : YAML document of key-value pairs to override test case argsDetailsAnnotated schemasRefer totest-case-schema.ymlfor test case schema detailsRefer toconfig.ymlfor config file schema detailsAttack sequencingBasic executionBasic execution mode refers to execution without using the VECTR integrations.
The execution sequence is as follows:Collect test casesRun pre-execution hooks (e.g logging)Run test case blocks by phase (setup -> execution -> cleanup)Run post-execution hooksExitExecution details are logged to the TIMBERLAKE_LOGFILE location.VECTR executionVECTR execution mode refers to execution with added VECTR integration (via GraphQL).
The excution sequence is as follows:Collect test casesCreate assessment groups and campaigns in VECTRRun pre-execution hooks (e.g logging)Run test case blocks by phase (setup -> execution -> cleanup)Create test case in VECTRall test cases are tagged with "timberlake"test cases with errors are tagged with "error"Run post-execution hooksWrite ATTiRe log to location specified in config. Details captured in ATTiRe log:Cloud control plane API call detailsExitNote: Only code blocks in the execution phase create a test case and ATTiRe logSee alsohttps://github.com/FSecureLABS/leonidas: is a very similar concept, but test cases are performed as Lambda functions; test case schema is conceptually similar to what this tool wants to do and was a source of design inspiration
Package: timchen
TimchenTimchen.py utilizes thetimchen.tk apito get random timchen images.
It can be utilized both synchronously and asynchronously.Here is an example on how to use it asynchronously:importtimchenimportasyncioasyncdefmain():t=awaittimchen.get_random()print(t.url)print(t.description)loop=asyncio.get_event_loop()loop.run_until_complete(main())And here is an example on how to use it synchronouslyimporttimchendefmain():t=timchen.get_random_sync()print(t.url)print(t.description)main()Functions:get_random()Gets a random timchen picget_from_id()Gets a timchen pic from its IDget_all()Gets all the timchen pics as a tuple
Package: time2words
time2wordsModule for converting numerical representation of time to text.Currently this works only for relative time and the output shows an aproximation. E.g. “about five and a half months”.Including precise time and time of day is work in progress.Usagefrom time2words import relative_time_to_text
relative_time_to_text(years=5, months=8, days=5) # -> "less than six years"
Package: timeago
A very simple python lib, used to format datetime with*** time agostatement. Javascript version here.timeago.js.Such as:just now
12 seconds ago
3 minutes ago
2 hours ago
24 days ago
6 months ago
2 years ago

in 12 seconds
in 3 minutes
in 2 hours
in 24 days
in 6 months
in 2 yearsFor other languages see below.InstallpipinstalltimeagoUsage & Example# -*- coding: utf-8 -*-importtimeago,datetimenow=datetime.datetime.now()+datetime.timedelta(seconds=60*3.4)date=datetime.datetime.now()# localeprint(timeago.format(date,now,'zh_CN'))# will print `3分钟前`# input datetimeprint(timeago.format(date,now))# will print 3 minutes ago# input timedeltaprint(timeago.format(datetime.timedelta(seconds=60*3.4)))# will print 3 minutes ago# input date, auto add time(0, 0, 0)print(timeago.format(datetime.date(2016,5,27),now))# input datetime formatted stringprint(timeago.format('2016-05-27 12:12:03','2016-05-27 12:12:12'))# will print just now# inverse two parametersprint(timeago.format('2016-05-27 12:12:12','2016-05-27 12:12:03'))# will print a whileMethod & Parameteronly one APIformat.Three parameters of methodformat:date: the parameter which will be formatted, must be instance
ofdatetime/timedeltaor datetime formatted string.now: reference time, must be instance ofdatetimeor
datetime formatted string.locale: the locale code, defaulten.LocaleAt the time we’re speaking,following localeare available:arbgcadadeelenen_shorteseufa_IRfifrglguj_INhehuin_BGin_HIin_IDisitjakoltmlmynb_NOnlnn_NOplpt_PTpt_BRrorusksv_SEtathtrukvizh_CNzh_TWLocalizationFork the projectCreate a locale python script called[name_of_your_locale].pyfollowing the existing other locales.Add the name of your locale in the Readme to keep it updated
(alphabetically).Add test case following theenglish modelCreate the Pull Request.NotesFor complicated plurals, you can take example on the PL (Polish) localehere
Package: timeandplace
TimeAndPlace API & CLI ApplicationThis repo contains both a Python3 API, and a command-line application for interacting with@salamander2'sTimeAndPlaceservice over a network. The main reason behind this package is for use in another project I have planned for room occupancy tracking.What kind of data can be accessed?Currently, this is mostly a Read-Only API. The following data can be accessed when logged in:List of all student IDsA particular student's infoStudent location tracking**This data can be written via the APICLI usageThe command-line app uses "action commands" in the format of:timeandplace--username<username>--password<password><action>[optional:--endpoint<url>]A list of possible actions can be viewed by running:timeandplacehelpAPI usageAll interaction is done via theTimeAndPlaceobject. It has the following methods:client=TimeAndPlace()client.login(str,str)# These require login to be calledclient.getStudentInfo(int)->StudentInfoclient.getAllStudents()->List[int]client.getAllCourses()->List[CourseInfo]client.signInStudentToTerminal(int,int)client.signOutStudentFromTerminal(int,int)I recommend taking a look at thesingle source filefor more info on the API.
Package: time-app
Librarytime_appDescriptiontime_appis a convenient library for working with date and time in the Python programming language. It provides simple and powerful tools for managing temporal data, making operations such as formatting, parsing, comparison, and arithmetic with dates and times straightforward.Key FeaturesFormatting and Parsing Date/Time:Conversion of date and time to a string based on a specified format.Parsing a string with date/time into a Pythondatetimeobject.Date and Time Arithmetic:Convenient methods for adding and subtracting time, days, months, and years.Calculation of the difference between two dates.Comparison of Dates and Times:Comparison of dates and times for equality, greater/less than.Checking if the current date/time is within a specified time range.Timezone Handling:Support for working with different timezones.Conversion of time between different timezones.Managing Time Intervals:Handling time intervals.Support for periodic tasks and event scheduling.Usage Examplefromtime_appimportTimeApp# Creating an object with the current date and timenow=TimeApp.now()# Formatting the date into a stringformatted_date=now.format("%Y-%m-%d%H:%M:%S")print(f"Formatted date:{formatted_date}")# Date arithmeticfuture_date=now+TimeApp.timedelta(days=7)print(f"Date in 7 days:{future_date}")# Checking if the current date is later than the specified dateifnow>future_date:print("The current date is behind the future date.")else:print("The current date is ahead of the future date.")
Package: timeat
# timeatShow local time at given location.$ timeat london
London, UK: Fri Aug 22, 2014 04:44
London, ON, Canada: Thu Aug 21, 2014 23:44
London, KY, USA: Thu Aug 21, 2014 23:44
London, OH 43140, USA: Thu Aug 21, 2014 23:44
$# Contact
Miki Tebeka <miki.tebeka@gmail.com>https://bitbucket.org/tebeka/py-timeat
Package: timeawarepc
TimeAwarePC: A Python Package for Finding Causal Connectivity from Time Series DataTimeAwarePCis a Python package that implements the Time-Aware PC Algorithm for finding theCausal Functional Connectivityfrom time series data, based on recent research in directed probabilistic graphical modeling with time series[1]. The package also includes implementations of Granger Causality and the PC algorithm.InstallationYou can get the latest version of TimeAwarePC as follows.$ pip install timeawarepcRequirementsPython >=3.6Python packages automatically checked and installed as part of the setup. To use Granger Causality, additional dependency ofnitimewhich can be installed bypip install nitime.R >=4.0R packagekpcalgand its dependencies. They can be installed in R or RStudio as follows:> install.packages("BiocManager")
> BiocManager::install("graph")
> BiocManager::install("RBGL")
> install.packages("pcalg")
> install.packages("kpcalg")DocumentationDocumentation is available at readthedocs.orgTutorialSee theQuick Start Guidefor a quick tutorial of the main functionalities of this library and check if it is installed properly.ContributingYour help is absolutely welcome! Please do reach out or create a feature branch!CitationBiswas, R., & Shlizerman, E. (2022). Statistical Perspective on Functional and Causal Neural Connectomics: The Time-Aware PC Algorithm.https://arxiv.org/abs/2204.04845Biswas, R., & Shlizerman, E. (2021). Statistical Perspective on Functional and Causal Neural Connectomics: A Comparative Study. Frontiers in Systems Neuroscience.https://doi.org/10.3389/fnsys.2022.817962ReferencesR Clay Reid. (2012) From functional architecture to functional connectomics. Neuron, 75(2):209â€“217.Smith, S. M., Miller, K. L., Salimi-Khorshidi, G., Webster, M., Beckmann, C. F., Nichols, T. E., ... & Woolrich, M. W. (2011). Network modelling methods for FMRI. Neuroimage, 54(2), 875-891.Judea Pearl. (2009) Causality. Cambridge University press.Markus Kalisch and Peter Bhlmann. (2007) Estimating high-dimensional directed acyclic graphs with the pc-algorithm. In The Journal of Machine Learning Research, Vol. 8, pp. 613-636.Peter Spirtes, Clark N Glymour, Richard Scheines, and David Heckerman. (2000) Causation, prediction, and search. MIT press.
Package: timebandit
Time BanditTimer utilities for Python 3.5+ DevelopmentThese are handy automation and informational utilities. Add more, change some, make some additions/corrections...Please feel free to offer suggestions andchanges.Copyright © 1976-2020Michael TreanorInstallationTLDR: clone the repo and run./setup.shWHY?comparison of different methodsprofiling features under real world loads with decorators and log readersvisualize outcomes in unique waysPrerequisitesPython version 3.5+Recommended IDE setup:VSCodeIDESarah Drasner's Vue VSCodeExtension PackDon Jayamanne's PythonExtension PackInstalled by this setup as needed:HomebrewGNUcoreutilsfor macOS (brew install coreutils)Pre-Commitfor automated checksPoetryfor dependency management, building, publishing, and versioningInstallpip install timebandit

- or -if you wish to make modifications or contribute to the open source project:# clone the repogitclonehttps://www.github.com/skeptycal/# change to the repo directorycduser_bin_dir_repo# run the init script./init# optional: # use './init --nobrew' to skip install of homebrew and utilities./init--nobrewUsagefromtimebanditimporttimeit# as a decorator@timeitdefmyfunction(x):...dostuff...#     - or -# as a function callthe_result=timeit(myfunction(5))print(the_result)FeedbackSuggestions/improvements arewelcome!AuthorMichael Treanor
Package: timeblock
🕐 timeblockHelpful snippet for timing blocks, basicallycontexttimerwith a few tweaks / forked.pipinstalltimeblock==0.1.1fromtimeblockimportTimerwithTimer()astimer:sleep(1)print(timer.elapsed)# 1swithTimer(output=True):sleep(1)# logger.debug(f"Elapsed time: {timer.elapsed}"withTimer("sleepy time",output=print):sleep(1)# print("sleepy time took {:.3f} seconds".format(timer.elapsed))
Package: timebomb-client
Time Bomb ClientUNDER DEVELOPMENTJust enough to connect atimebomb-serverand play Time Bomb in your terminal.Dependenciestimebomb-clientsupports Python 3.6+.Installation requirespython-socketioandnpyscreen.InstallationInstall the latest stable release from PyPI:$pipinstalltimebomb-client--userRunConnect to a specifictimebomb-serverand start playing.$timebombHOST.ADDRESSRulesIf you're not familiar with this game and want to know more about the rules, check out theThealmost-Official Rulebook.Disclaimer: As this is a terminal implementation, the game is not strictly following those rules, some parts are automated (card shuffling, dealing, random picking, etc...).LicenseThis project is underMIT License.
Package: time-box
time_box介绍快速使用时间模块项目转移至：https://gitee.com/ZeroSeeker/lazytime软件架构软件架构说明安装教程pip安装pip3installtime-boxpip安装（使用淘宝镜像加速）pip3installtime-box-ihttps://mirrors.aliyun.com/pypi/simple使用说明demoimporttime_boxt=time_box.get_datetime()
Package: timecache
==============timecache==============`timecache` is a timeout-based cache implementation for Python 3.x withoutany external dependencies. Depending on the selected backend, the cache can bemade persistent to survive a fresh start of a script (currently, json andpickle files are supported as backend).Warning: this is an early alpha version so the interface may change in futureversions.Setup-----Install `timecache` using `pip`:::pip install -U timecacheExample-------A cache with a memory backend can be created as follows:::import timefrom timecache import Cache, FIVE_SECONDS# create cache with memory backendcache = Cache()# add a value to the cache with a default duration of 1 minutecache["one"] = 1# add a value to the cache with a duration of 5 secondscache.set("two", 2, FIVE_SECONDS)print("two in cache: {}".format("two" in cache))# show cache entryprint(cache)# wait for 6 stime.sleep(6)# show cache entryprint(cache)print("two in cache: {}".format("two" in cache))A cache with a json file backend can be created as follows:::import timefrom timecache import Cache, JsonBackend# create cache with json backendcache = Cache(backend=JsonBackend())if not cache.is_existing:# add a value to the cache with a default duration of 1 minuteprint("adding new value to the cache...")cache["one"] = 1print("saving cache to file '{}'".format(cache.filename))cache.save()# show cache entryprint(cache)When calling the script again the cached value will be loaded from thejson file.Decorators----------There are also the three decorators `memorycache`, `jsoncache`,`picklecache` that allows an easy caching of function return values.::import timefrom timecache import jsoncache, FIVE_SECONDS@jsoncache(cache_filename="add.json", ttl=FIVE_SECONDS)def add(x, y):return x + y# new cache entryprint(add(1, 2))# new cache entryprint(add(1, 3))# load existing cache entryprint(add(1, 2))# wait for 6 stime.sleep(6)# new cache entry, since old entry has expiredprint(add(1, 2))Debugging-------To debug the cache you can simply set the debug level.::import logginglogging.basicConfig(level=logging.DEBUG)Testing-------For testing additionally install `nose` and then run the tests:::pip install nosenosetestsHint----If you do not need a time-based cache, consider the `lru_cache` function ofPython's `functools` module(https://docs.python.org/3/library/functools.html).