Saravanan666/pypi-org huggingface dataset:
Package: tssenrich
tssenrichCalculateTSS enrichmentfor ATAC-seq data. (see also theENCODE standards)Installationpip install tssenrichorpip install --user tssenrichUsageusage: tssenrich [-h] [--genome {hg38,hg19,mm10,</path/to/file.bed.gz>}] [--names] [--memory <float>] [--processes <int>]
                 [--mapping-quality <int>] [--samtools-path <path/to/samtools>] [--log <path/to/log.txt>]
                 [--tmp-dir <temp/file/dir/>] [--flank-distance <int>] [--flank-size <int>]
                 <path/to/file.bam> [<path/to/file.bam> ...]

calculate TSS enrichment for ATAC-seq data

positional arguments:
  <path/to/file.bam>    Path to input BAM file

optional arguments:
  -h, --help            show this help message and exit
  --genome {hg38,hg19,mm10,</path/to/file.bed.gz>}
                        genome build or path to BED file [hg38]
  --names               include sample names in output
  --memory <float>      memory limit in GB [2]
  --processes <int>     number of processes/threads to use [1]
  --mapping-quality <int>
                        ignore reads with mapping quality below the given value [0]
  --samtools-path <path/to/samtools>
                        path to an alternate samtools executable [/opt/anaconda3/envs/tssenrich/bin/samtools]
  --log <path/to/log.txt>
                        path to log file
  --tmp-dir <temp/file/dir/>
                        directory to use for temporary files
  --flank-distance <int>
                        distance from tss of outer ends of flanks [1000]
  --flank-size <int>    size of flanks (for determining average depth) [100]

ENCODE standards:
| Genome | Concerning | Acceptable | Ideal |
| ------ | ---------- | ---------- | ----- |
| hg19   | < 6        | 6 - 10     | > 10  |
| hg38   | < 5        | 5 - 7      | > 7   |
| mm10   | < 10       | 10 - 15    | > 15  |Examplestssenrichexample.bam>score.txttssenrich--genomehg19--loglog.txt--memory2--processes2example1.bamexample2.bam>scores.txt
Package: tssim
tssimConvenient time series simulation/generation package.Free software: MIT licenseDocumentation:https://tssim.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.1 (2017-04-23)Add wrapped numpy random functions for easier time function creation.Restructure package structure into ‘core’ and ‘functions’.0.1.0 (2017-04-16)Add TimeSeries and TimeSeriesResult.Add TimeTrack and TimeTrackResult.Add TimeFunction.Add function examples.
Package: tssm
Time Series Scaling Module  (TSSM)TSSMis a python package for the up-scaling of time series or load such as electricity, heating, etc.WarningThis package is under heavy development!Getting startedInstall TSSMInstall tssm directly from PyPi as follows:pip install tssmFurther installation instructions can be found in thedocumentationunder 'Getting started'.Usageexample usages can be found in theexamples'folder.Basic workflowA small example how tssm can be used is described as follows:# import module and Daily period variablefromtssmimportTimeSeriesScalingModuleastssm,DAILY# initialize class with a number of buildings of 202 with a simultaneity factor of 0.786scaling=tssm(number_of_buildings=202,simultaneity_factor=0.786)# read profile from data.csv file and use the Electricity and Date columnscaling.data.read_profile_from_csv_with_date(path="./data.csv",column_of_load="Electricity",column_of_date="Date")# calculate linear scaled values with a daily simultaneity factor and average valuedaily_scaled_values=scaling.calculate_using_average_values(period=DAILY)ExamplesAfirst exampleshows the linear approach. It scales the time series between the scaled time series and an average.Asecond exampleshows the scaling approach. It scales the time series between the scaled time series and a scaling time
series.Athird exampleshows the normal distribution approach. It scales the time series by applying a normal
distribution to every time step.Afourth exampleshows the different ways to import the data.Afifth exampleshows the speed of the different approaches.LicenseThe module is licensed under BSD 3-Clause License.Further, License information can be foundhere.ReferenceAcknowledgementsContentThe documentation of the tssm code can be foundhere.
Package: tssolver
Tkinter Sudoku SolverAboutThis application solves classic sudoku puzzles. It is written in
Python with an interface built using tkinter.Some notable features about this application:Real-time visual representation of the solution algorithmSolve user-defined puzzles or use built-in sample puzzlesControl over the speed of the solverColorblind modeCompatibilityFull compatibility with Python 3.9 on Linux.More details regarding other Python version and operating systems can
be found in thedocumentation.InstallationRunningpip install tssolverwill use pip to install the package.
After installing,tssolverwill run the application.ContributingPlease report any bugs to theGitLab issue tracker.
SeeCONTRIBUTINGfor more details.LicenseThis program is free software and is licensed under the GNU General
Public License. For the full license text, view theLICENSEfile.Copyright © 2021 emerac
Package: tssplit
Trivial split for strings with multiple character delimiters, quotes and escaped charactersInstallationpipinstalltssplitUsageSyntaxdeftssplit(s,quote='"\'',quote_keep=False,delimiter=':;,',escape='/^',trim='',remark='#'):"""Split a string by delimiters with quotes and escaped characters, optionally trimming results:param s: A string to split into chunks:param quote: Quote chars to protect a part of s from parsing:param quote_keep: Preserve quote characters in the output or not:param delimiter: A chunk separator character:param escape: An escape character:param trim: Trim characters from chunks:param remark: Ignore all characters after remark sign:return: A list of chunks"""Examplefromtssplitimporttssplittssplit('--:--;--,--"--/--"--\'--:--\'--/"--^--',quote='"\'',delimiter=':;,',escape='/^',trim='')['--','--','--','----/------:----"----']tssplit('--:--;--,--"--/--"--\'--:--\'--/"--^--',quote='"\'',delimiter=':;,',escape='/^',trim='',quote_keep=True)['--','--','--','--"--/--"--\'--:--\'--"----']tssplit('--:--;--,--"--/--"--\'--:--\'--# Ignore this',quote='"\'',delimiter=':;,',escape='/^',trim='',quote_keep=True,remark='#')['--','--','--','--"--/--"--\'--:--\'--']Changelog2020.03.28    v1.0    Initial release2020.03.28    v1.0.1  Many quick fixes to make all things work in PyPI2020.03.29    v1.0.2  Minor fixes, Readme update, Long description provided2020.03.29    v1.0.3  Trim option to strip() characters from chunks2020.03.29    v1.0.4  Multiple characters for quotes, delimiters and escapes2022.02.04    v1.0.5  Addedquote_keepoption to preserve quote marks in the output or not2023.01.12    v1.0.6  Remark characters interrupt string parsing
Package: tsstats
TeamspeakStatsA simple Teamspeak stat-generator - based solely on server-logsInstallationInstall the package via PyPipip install tsstatsClone this repogit clonehttps://github.com/Thor77/TeamspeakStatsand install
withpython setup.py installJust use the package as is viapython-mtsstats[-h]UsageRun the scripttsstats[-h]Optionally create a config-file (seeConfiguration)The package works entirely off your Teamspeak server’s logs, so that
no ServerQuery account is necessaryExampletsstats -l /var/log/teamspeak3-server/ -o /var/www/tsstats.htmlParse logs in/var/log/teamspeak3-serverand write output to/var/www/tsstats.html.For more details checkout thedocumentation!
Package: tsstp
Templates Semi-Structured Text Parsertsstp is a Python module, the Template semi-structure text parser, which allows custom parsing of semi-structured text data using templates. tsstp was developed to enable programmatic access to semi-structured textual data generated by computational software in computational materials science, but it can be used to parse any semi-structured text that contains unique repetitive patterns, and can also be extended to other texts with special patterns and textual notation.Unlike regular file-specific parsers that require only input data, tsstp takes two files as input - the data to be parsed and the parsing template - and returns a result structure with extracted information.The same data can be parsed by different templates to produce results corresponding to the template. Templates are easy to create and users can define templates to extract data according to their needs and are encouraged to write their own ttp templates,through this way to achieve simple data reuse, catering to the FAIR principle.installpip install tsstphow to usefromtsstpimportDataTemplatedata_to_parse="""POSCAR\(4)31.000000000000008.3879995346000005    0.0000000000000000    0.00000000000000000.0000000000000000    8.3879995346000005    0.00000000000000000.0000000000000000    0.0000000000000000   23.0000000000000000O    Fe   Ni50    33     1Direct configuration= 1"""template="""{{ head }}{{ loop_num }}{{ Scaling }}{{ Coordinates1 }} ~ loop_num{{ Coordinates2 }} ~ 3{{ Coordinates3 }} ~ 3{{ elements }} ~ n{{ elements_num }} ~ nDirect configuration= {{ number }}"""# create parser object and parse data using template:parser=DataTemplate(data=data_to_parse,template=template)parser.parse()# print result in JSON formatresults=parser.result(format='json')print(results){"head":"POSCAR\(4)","loop_num":"3","Scaling":"1.00000000000000","Coordinates1":["8.3879995346000005","0.0000000000000000","0.0000000000000000"],"Coordinates2":["0.0000000000000000","8.3879995346000005","0.0000000000000000"],"Coordinates3":["0.0000000000000000","0.0000000000000000","23.0000000000000000"],"elements":["O","Fe","Ni"],"elements_num":["50","33","1"],"number":"1"}
Package: tstables
TsTables is a Python package to store time series data in HDF5 files
using PyTables. It stores time series data into daily partitions and
provides functions to query for subsets of data across partitions.Its goals are to support a workflow where tons (gigabytes) of time
series data are appended periodically to a HDF5 file, and need to be
read many times (quickly) for analytical models and research.ExampleThis example reads in minutely bitcoin price data and then fetches a
range of data. For the full example here, and other examples, seeEXAMPLES.md.# Class to use as the table descriptionclassBpiValues(tables.IsDescription):timestamp=tables.Int64Col(pos=0)bpi=tables.Float64Col(pos=1)# Use pandas to read in the CSV databpi=pandas.read_csv('bpi_2014_01.csv',index_col=0,names=['date','bpi'],parse_dates=True)f=tables.open_file('bpi.h5','a')# Create a new time seriests=f.create_ts('/','BPI',BpiValues)# Append the BPI datats.append(bpi)# Read in some dataread_start_dt=datetime(2014,1,4,12,00)read_end_dt=datetime(2014,1,4,14,30)rows=ts.read_range(read_start_dt,read_end_dt)# `rows` will be a pandas DataFrame with a DatetimeIndex.Here is how to open a pre-existingbpi.h5HDF5 file and get that
timeseries from it.f=tables.open_file('bpi.h5','r')ts=f.root.BPI._f_get_timeseries()# Read in some dataread_start_dt=datetime(2014,1,4,12,00)read_end_dt=datetime(2014,1,4,14,30)rows=ts.read_range(read_start_dt,read_end_dt)Running unit testsYou can run the unit test suite from the command line at the root of the
repository:python setup.py testPreliminary benchmarksThe main goal of TsTables is to make it very fast to read subsets of
data, given a date range. TsTables currently includes a simple benchmark
to track progress towards that goal. To run it, after installing the
package, you can runtstables_benchmarkfrom the command line or you
can import the package in a Python console and run it directly.importtstableststables.Benchmark.main()Running the benchmark both prints results out to the screen and saves
them inbenchmark.txt.The benchmark loads one year of random secondly data (just the timestamp
column and a 32-bit integer “price” column) into a file, and then it
reads random one hour chunks of data.Currently, here’s some benchmarks of TsTables (from a MacBook Pro with a
SSD):MetricResultsAppend one month of data (2.67 million rows)0.711 secondsFetch one hour of data into memory0.305 secondsFile size (one year of data, 32 million rows, uncompressed)391.6 MBHDF5 supports zlib and other compression algorithms, which can be
enabled through PyTables to reduce the file size. Without compression,
the HDF5 file size is approximately 1.8% larger than the raw data in
binary form, a drastically lower overhead than CSV files.ContributingIf you are interested in the project (to contribute or to hear about
updates), email Andy Fiedler atandy@andyfiedler.comor submit a pull
request.
Package: tst-monant
This is test repo of MonAnt-Crawler-ParserCrawler using Scrapy with Celery integrationRequirementsThese libraries are needed to be installedScrapy (pip install scrapy, alternative for Windows: conda install -c conda-forge scrapy)rabbitmq-serversudo apt-get install rabbitmq-serverbrew install rabbitmqCelery (pip install celery)Twisted with newer version (pip3 install git+https://github.com/twisted/twisted.git@trunk)RedisFlaskApi application must be running and provide API.If needed, set environment variablesMONANT_WEB_MONITORING_CENTRAL_STORAGE_USERNAMEandMONANT_WEB_MONITORING_CENTRAL_STORAGE_PASSWORDdepending on what API client stored in central data storage database should be used to authorize web monitoring application.RunningRabbitmq-server must be started (using command {RABBIT_PATH}/sbin/rabbitmq-server) \Start celery worker using command (inside folder monant-crawler-parser): celery -A celeryapp.application  worker --loglevel=infoRun worker.py
Package: ts-train
![Upload Python Package](https://github.com/minesh1291/ts-train/workflows/Upload%20Python%20Package/badge.svg)
![Sphinx Build](https://github.com/minesh1291/ts-train/workflows/Sphinx%20Build/badge.svg)![PyPI](https://img.shields.io/pypi/v/ts_train)
![GitHub commits since latest release (by date including pre-releases)](https://img.shields.io/github/commits-since/minesh1291/ts-train/latest?include_prereleases)[![Coverage Status](https://coveralls.io/repos/github/minesh1291/ts-train/badge.svg?branch=master)](https://coveralls.io/github/minesh1291/ts-train?branch=master)
![PyPI - Downloads](https://img.shields.io/pypi/dm/ts-train)
![visitors](https://visitor-badge.glitch.me/badge?page_id=minesh1291.ts-train)
![Size](https://github-size-badge.herokuapp.com/minesh1291/ts-train.svg)
<!– ![Downloads](https://img.shields.io/pypi/dm/ts_train.svg?label=Pypi%20downloads) –>
# ts-train
Time-Series data handling for Machine Learning TasksDocumentation:https://minesh1291.github.io/ts-trainSource code:https://github.com/minesh1291/ts-trainBug reports:https://github.com/minesh1291/ts-train/issues
Package: tstrait
tstraittstraitis a quantitative trait simulator oftskittree sequences.Documentation:https://tskit.dev/tstrait/docs/Source code:https://github.com/tskit-dev/tstraitTree sequence documentation:https://tskit.dev/learn/It provides:Simulation of quantitative traitsSimulation of genetic effect sizes from various distributionsSimulation of pleiotropic phenotypesSimulation of environmental noiseComputation of individual genetic values given the effect sizes of causal mutations
Package: tstring
tstringCurly-brace string templates in Python.pipinstalltstringUsagefromtstringimportTemplatetemplate=Template("{a}.{b}.{c}")print(template.substitute(a="d",b="e",c="f"))>>>"d.e.f"Support for optional variable substitutions is also included:template=Template("{a}.{b}[.{c}]")print(template.substitute(a="d",b="e",c="f"))>>>"d.e.f"print(template.substitute(a="d",b="e"))>>>"d.e"
Package: tsu
tsu tsudoA su and sudo wrapper for Termux.tsu(like tsu as in tsunami, you know ) is an su wrapper for the
terminal emulator and packages for Android, Termux.tsuwill focus only on dropping into root shell from termux.In order to run one off commands as root usetsudocommand which acts likesudo.Installationtsuis now available as a termux package. Install it like any other package with.pkg install tsuBackgroundTermux relies on LD_LIBRARY_PATH enviroment variables to find it's libraries.
For security reasons some environent variables seem to be reset by su, unless
an --preserve-environent flag is passed.tsu handles this for you and also launches your preferred shell.su by default will use sh or mksh, depending upon how it is on your device.ContributingKnow something you wanna add/improve, you're more than welcome to open a issue or create a pull request.The README was written in a hurry, so some help here too.LicenseLicensed under the ISC license. SeeLICENSE.
Package: tsubame
OverviewThis is a traceroute module written in Python. The module sends speculative probe packets and gets the results immediately. Currently, only IPv4 ICMP echo requests are supported as probe packets.Installation$ sudo pip install tsubameUsagePermissionYou need to have super user privileges or set CAP_NET_RAW capability to the Python interpreter binary.Programing Interfacefromtsubameimporttraceroutehost='example.com'tr=traceroute()results=tr.probe(host,hop_limit=8,count=1,timeout=1.0,ident=None)hostA target host name string or an IP address string.hop_limitMaximum number of hops. It must be an integer from 1 to 64.countThe number of probe packets for each hop. It must be an integer from 1 to 4.identIdentifier for parallel execution. The size must be 2 bytes. A unique value must be set for each traceroute context. By default, the PID will be set.Result StructureNested structure[[first_probe,second_probe,...,nth_probe],# hop 1[first_probe,second_probe,...,nth_probe],# hop 2...[first_probe,second_probe,...,nth_probe],# hop n]Each result itemIf received a response,(from_addr, delay_sec, is_target)e.g.('192.168.1.1', 0.0011992454528808594, False)elseNoneExampleSimple traceroute commandYou can use as a traceroute command as follows.$ sudo tsubame example.com
traceroute to example.com (93.184.216.34), 32 hops max
1  192.168.1.1  1.146 ms  1.374 ms  1.616 ms
2  * * *
3  * * *
4  * * *
5  * * *
6  111.87.3.234  118.376 ms  118.503 ms  119.928 ms
7  62.115.180.213  123.618 ms  123.894 ms  125.392 ms
8  62.115.155.89  120.319 ms  121.756 ms  122.066 ms
9  152.195.85.133  121.776 ms  123.551 ms  123.544 ms
10  93.184.216.34  127.130 ms  127.199 ms  129.053 ms
Package: tsuchinoko
TsuchinokoTsuchinoko is a Qt application for adaptive experiment execution and tuning. Live visualizations show details of
measurements, and provide feedback on the adaptive engine's decision-making process. The parameters of the adaptive
engine can also be tuned live to explore and optimize the search procedure.While Tsuchinoko is designed to allow custom adaptive engines to drive experiments, thegpCAMengine is a featured inclusion. This tool is based on a flexible and
powerful Gaussian process regression at the core.A Tsuchinoko system includes 4 distinct components: the GUI client, an adaptive engine, and execution engine, and a
core service. These components are separable to allow flexibility with a variety of distributed designs.Standard InstallationThe latest stable Tsuchinoko version is available on PyPI, and is installable withpip. It is recommended that you
use Python 3.9 for this installation.pipinstalltsuchinokoFor more information, see theinstallation documentation.Easy InstallationFor Mac OSX and Windows, pre-packaged installers are available. These do not require a base Python installation. See theinstallation documentationfor more details.Latest Windows InstallerLatest Mac OSX InstallerResourcesDocumentation:https://tsuchinoko.readthedocs.io/en/latestReport an issue in Tsuchinoko:New Bug ReportAbout the nameJapanese folklore describes theTsuchinokoas a wide and short snake-like creature living in the mountains of western
Japan. This creature has a cultural following similar to the Bigfoot of North America. Much like the global optimum of a
non-convex function, its elusive nature is infamous.
Package: tsudo
tsudoTsundere wrapper for sudo command.Spice up your sudo password prompt with cute remarks. Hand-picked from most
famous characters and internet memes. Also, you can add your own currated list
of insults (in the future).Installation$ pip install tsudo --userEnable sudo insultsUncomment this line from yoursudoersfile# Defaults insultsEnable credential cachingsudoers uses per-user time stamp files for credential caching. Once a user
has been authenticated, a record is written containing the user ID that was
used to authenticate, the terminal session ID, the start time of the session
leader (or parent process) and a time stamp (using a monotonic clock if one
is available).Since pexpect spawn another child process using pty, eachtsudocall will
have different credentials. However, you can still use another tty creds by
turning offtty_tickets.Add this line to yoursudoersfileDefaults !tty_tickets
Package: tsukkomi
WarningThis project is abandoned.We recommend you to usetypeguardinstead.  It has been well maintained,
and provides the mostly same API to tsukkomi so thattypeguardmodule
is drop-in replacement oftsukkomi.typedmodule.tsukkomidotsukkomifor python types.What is tsukkomi?tsukkomi is a japanese word means straight man in the comedy duos of western
culture. As straight man react partner’s ridiculous behaviors,tsukkomiwill react incorrect types.How to use tsukkomi?tsukkomitake type hints fromtyping. write code with annotation,
decorate all callable objects withtsukkomi.typed.typechecked.
FYI generic types are not supported, seetsukkomi dosen’t support genericsection for the detail.fromtypingimportSequencefromtsukkomi.typedimporttypechecked@typecheckeddefgreeting(name:str)->str:returnnamegreeting('a')# it is okgreeting(1)# this will raise `TypeError`tsukkomi dosen’t support generictsukkomi dosen’t supportgenerictype checking, includes types already
inherited a generic type liketyping.Sequence,typing.Mutableand etc.
following example codes can be passed bytsukkomi.typed.typechecked.importtypingfromtsukkomi.typedimporttypecheckedT=typing.TypeVar('T')classBoke(typing.Generic[T]):@typecheckeddefstupid(self,word:T)->T:returntype(word)@typecheckeddefcorrection(self,words:Sequence[T])->T:returnrandom.sample(words,1)[0]@typecheckeddefboke_and_tsukkomi(stupid_words:Sequence[str],correction:Sequence[str])->bool:returnany(s==cfors,cinzip(stupid_words,correction)))boke=Boke[str]()print(boke.stupid('hello world'))print(boke.correction([1,2,3]))print(boke_and_tsukkomi([1,2],[1.0,2.0]))Changelogs0.0.5 — 2016-05-19ModifiedInterpret None as type(None)
Package: tsukuru
What's "tsukuru"?"tsukuru" is simple GUI Makefile creator."tsukuru" can provide simple way to create Makefile from GUI."Tsukuru" means "Make" in Japanense.Nowadays, many IDEs provides smart way to build systems.But in C/C++ language, we sometimes have to make Makefile or CMkaeLists.txt.These tools has long history and wonderful functions,and helps building from one source code to very very large projects."tsukuru" aim is to private simple way to build C/C++ in provate project or small teams.In this situation,  If no skillfull Makefile user, someone needs to learn about Makefile.And in a few month, his/her knowledge about Makefile goes away...I would like to contribute these situation by providing simple GUI Makefile creator.This tools does not support deep and wide function,
but provide creating certain Makefile.UsageLisenceLisence is MIT lisenceContactIf you have any question, please use Github issue.
Package: tsuru
Tsuru API ClientPython client for theTsuruAPI.InstallationpipinstalltsuruSetupThe following environment variables must be set prior to using the lib.TSURU_URL, with port (if necessary) and without trailing dash. Example:http://my-tsuru.domain.vpc:8080TSURU_USERNAMETSURU_PASSWORDUsagefromtsuruimportAppforappinApp.list()print(app.name)