Saravanan666/pypi-org huggingface dataset:
Package: tracewrapper
TracewrapperWrapper for Pythons sys.settraceAllows you to run multiple traces at once and also allows you to queue up a class instead of the default show_trace() function.  Also allows you to filter events, modules and functions.To Install:pip3 install tracewrapper

or

python -m pip install tracewrapperExample:from tracewrapper import tracewrapper
import opcode

#Show_Trace function just like you'd feed to sys.settrace()
def show_trace1(frame, event, arg):
    code = frame.f_code
    offset = frame.f_lasti
    print(f"Trace1| {event:10} | {str(arg):>4} |", end=' ')
    print(f"{frame.f_lineno:>4} | {frame.f_lasti:>6} |", end=' ')
    print(f"{opcode.opname[code.co_code[offset]]:<18} | {str(frame.f_locals):<35} |")
    return show_trace1

#Another Show_Trace function just like you'd feed to sys.settrace()
def show_trace2(frame, event, arg):
    code = frame.f_code
    offset = frame.f_lasti
    print(f"Trace2| {event:10} | {str(arg):>4} |", end=' ')
    print(f"{frame.f_lineno:>4} | {frame.f_lasti:>6} |", end=' ')
    print(f"{opcode.opname[code.co_code[offset]]:<18} | {str(frame.f_locals):<35} |")
    return show_trace2

#Show_Trace as a class
class TClass(tracewrapper.TracerClass):
    def trace(self, frame, event, arg):
        code = frame.f_code
        offset = frame.f_lasti
        print(f"Trace3| {event:10} | {str(arg):>4} |", end=' ')
        print(f"{frame.f_lineno:>4} | {frame.f_lasti:>6} |", end=' ')
        print(f"{opcode.opname[code.co_code[offset]]:<18} | {str(frame.f_locals):<35} |")
        return self

#Demo fibanaci function to trace
def fib(n):
    i, f1, f2 = 1, 1, 1
    while i < n:
        f1, f2 = f2, f1 + f2
        i += 1
    return f1

#Instanciate the tracewrapper() class
tracer=tracewrapper.tracewrapper()

#Add our two demo show_trace functions
tracer.add(show_trace1)
tracer.add(show_trace2)

#Instanciate TClass() our inherited TracerClass()
tc=TClass()

#Add TracerClass's trace method to Tracer
tracer.add(tc.trace)

#Activate it
tc.start()

#Start tracing
tracer.start()

#Call our demo function
fib(6)

#Stop Tracing
tracer.stop()
Package: tracex
TraceXTrace variables and the operations on them using graphviz visualizations.wrap the variables in Float() and perform operationscall draw() function on the variables just like print()NOTE: PRs are currently not accepted for source code. If there are issues/problems, please create an issue.InstallationInstall using pippip install tracexUsageIntegrating TraceX is a piece of cake. All you need is some variables.Python APIfromtraceximportFloat,drawa=Float(2)b=Float(-3)c=a*bd=c+Float(10)e=Float(-2)f=d*eprint(f)draw(f)ExamplesNOTE: PRs are currently accepted for examples. If there are examples you've created, please create a PR.TraceX Demo:https://colab.research.google.com/drive/1pmO0X_yWU814_nKCjQSalVddseXSXHLL?usp=sharingTraceX Fibonacci:https://colab.research.google.com/drive/168kDOblsbNSReP0m47_1OGuUXVSbxy2S?usp=sharing
Package: tracex-parser
TraceX ParserThis python package parses ThreadX trace buffers into both human and machine-readable formats.
Don't know where to begin? Check out thequick-startdocumentation.
More documentation about ThreadX trace buffers can be foundhere.InstallViapip$python3-mpipinstalltracex-parserViasnap[!NOTE]
This installation method only allows you to use the command line file parser, not the Python library$sudosnapinstalltracex-parser$sudosnapaliastracex-parser.parse-trxparse-trx# Register the `parse-trx` command, otherwise you will need to use tracex-parser.parse-trx$sudosnapconnecttracex-parser:removable-media# Required to allow reading of files outside of /home[!NOTE]
Due to how snap packages work, there are restrictions on which files snaps are allowed to access.
Currently only/home,/media,/run/media,/mntare able to be read.
For example attempting to read a file in/tmpwill throw aNo such file or directoryerrorExample trace buffersIn the repository source there are a couple example TraceX traces which can be used to verify that things are working correctly.As a python moduledocumentation>>>fromtracex_parser.file_parserimportparse_tracex_buffer>>>events,obj_map=parse_tracex_buffer('./demo_threadx.trx')>>>events[4265846278:thread 7 threadResume(thread_ptr=thread 6,prev_state=0xd,stack_ptr=0x12980,next_thread=), 4265846441:thread 7 mtxPut(obj_id=mutex 0,owning_thread=0x6adc,own_cnt=0x1,stack_ptr=0x129a0), 4265846566:thread 7 mtxPut(obj_id=mutex 0,owning_thread=0x6adc,own_cnt=0x2,stack_ptr=0x129a0)]>>>obj_map[0xeea4]{'obj_reg_entry_obj_available **': '0x0', 'obj_reg_entry_obj_type **': '0x1', 'thread_reg_entry_obj_ptr': '0xeea4', 'obj_reg_entry_obj_parameter_1': '0xef4c', 'obj_reg_entry_obj_parameter_2': '0x3fc', 'thread_reg_entry_obj_name': b'System Timer Thread'}As a command line utilitydocumentationThefile_parsermodule can also be run as a script, which will provide simple statistics on the trace as well as dumping all the events in the trace.
It can be run by either:Running the module manually:python3 -m tracex_parser.file_parserUsing the newly installed command:parse-trxBoth run methods are identical.$parse-trx-vvv./demo_threadx.trxParsing ./demo_threadx.trxtotal events: 974object registry size: 16delta ticks: 40402Event Histogram:queueSend     493queueReceive  428threadResume  19threadSuspend 16mtxPut        4isrEnter      3isrExit       3semPut        2semGet        2mtxGet        2threadSleep   2All events:2100:thread 2 queueReceive(queue_ptr=0x6b84,dst_ptr=0x115a0,timeout=WaitForever,enqueued=0x13)1939:thread 2 queueReceive(queue_ptr=0x6b84,dst_ptr=0x115a0,timeout=WaitForever,enqueued=0x12)1778:thread 2 queueReceive(queue_ptr=0x6b84,dst_ptr=0x115a0,timeout=WaitForever,enqueued=0x11)1617:thread 2 queueReceive(queue_ptr=0x6b84,dst_ptr=0x115a0,timeout=WaitForever,enqueued=0x10)1456:thread 2 queueReceive(queue_ptr=0x6b84,dst_ptr=0x115a0,timeout=WaitForever,enqueued=0xf)...
Package: trac-GenshiMacro
DescriptionThe GenshiMacro allows you to write and render Genshi templates directly
in wiki pages with a newGenshiprocessor.Your templates will have access to the request asreq, which can be
useful for tasks like URL generation, rendering form tokens for POST
requests, and checking for a logged-in user.Note: no security considerations whatsoever went into the making of
this plugin.  It might be a terrible idea.  Trac core dev Remy Blank
said:> Genshi templates allow executing arbitrary Python code. So you basically
> give users who can insert the macro anywhere (wiki page, ticket comment,
> etc) permission to act as the user running Trac, including running run
> any shell command.
>
{{{#!Genshi
<div>${open('/etc/apache2/htpasswd').read()}</div>
}}}

{{{#!Genshi
<?python
  import os
  os.system("rm /path/to/env/db/trac.db")
?>
}}}
>
> So my advice is, only enable this macro on sites where you trust *all*
> users who can edit *any* wiki text with the web server's account.Configuration and UsageTo use the plugin, install it in your Trac environment and enable its
components intrac.ini:[components]
genshimacro.* = enabledYou can then write Genshi templates directly in wiki pages like so:{{{
#!Genshi
<div xmlns:py="http://genshi.edgewall.org/">
 <py:choose>
  <py:when test="req.session.authenticated">
   <form method="POST" action="${req.href.newticket()}">
    <input type="text" name="field_summary" placeholder="My new ticket"
           id="field-summary" />
    <input type="hidden" name="__FORM_TOKEN" value="${req.form_token}" />
    <input type="submit" />
   </form>
  </py:when>
  <py:otherwise>
   <b>To file a new ticket, you'll need to
      <a href="${req.href.login()}">log in</a> or
      <a href="${req.href.register()}">create an account</a>
      first.</b>
  </py:otherwise>
 </py:choose>
</div>
}}}
Package: traci
TraCI - Traffic Control InterfaceTraCI (short for Traffic Control Interface) is an API that provides access to a SUMO traffic simulation,
enabling controlling the behavior of multiple simulation objects during a live simulation.
It allows for external scripts to interact with the simulation and its vehicles, pedestrians, and infrastructure.InstallationTo use TraCI, you must first have an Eclipse SUMO installation. Install TraCI by simply executing:pip install traciAdaily versionis also available in TestPyPI:pip install -i https://test.pypi.org/simple/ traciGetting StartedTo use TraCI in your Python code, import thetracimodule. The following code snippet shows a basic example
of how to connect to a running SUMO simulation using TraCI:importtraci# Connect to SUMO simulationtraci.start(["sumo","-c","path/to/your/sumocfg/file.sumocfg"])# Simulation loopstep=0whilestep<1000:traci.simulationStep()# Your simulation logic herestep+=1# Close TraCI connectiontraci.close()Once connected to the SUMO simulation, TraCI provides a range of functions that can be used to query and modify
the state of the simulation. For example, you can use TraCI to control the behavior of individual vehicles,
modify the traffic light phases, or query the current state of the simulation.DocumentationThe TraCI documentation is available online athttp://sumo.dlr.de/docs/TraCI.html. The documentation provides detailed
information on the TraCI API, including a list of available functions and their parameters.ExamplesThere are someTraCI Tutorialsavailable.ContributingIf you find a bug in TraCI or have a suggestion for a new feature, please report it on the SUMO issue tracker athttps://github.com/eclipse/sumo/issues. If you would like to contribute
code to TraCI, please submit a pull request to the SUMO repository athttps://github.com/eclipse/sumo.LicenseTraCI is released under the Eclipse Public License 2.0 (EPL-2.0).
Package: trac-IncludeSource
DescriptionIncludeSourcePartialPlugin  allows source files to be partially or wholly
included in other wiki content.SamplesInclude entire file:[[IncludeSource(trunk/proj/file.py)]]Includes line 20-50 inclusive:[[IncludeSource(trunk/proj/file.py, start=20, end=50)]]Includes last 30 lines of file at revision 1200:[[IncludeSource(trunk/proj/file.py, start=-30, rev=1200)]]Include entire file but formatted plain:[[IncludeSource(trunk/proj/file.py, mimetype=text/plain)]]For docs on installation, configuration, and examples, please refer tohttps://trac-hacks.org/wiki/IncludeSourcePartialPlugin
Package: track
track 1.2.0Copyright 2011 EPFL BBCF <webmaster.bbcf@epfl.ch>Written by <lucas.sinclair@me.com>track is a python module for reading and writing genomic data.It was developed by the Bioinformatics and Biostatistics Core
Facility (BBCF) at the EPFL.track is released under the GNU General Public License 3.0. A copy
of this license is in the LICENSE.txt file.Full documentationThe full documentation can be found [on the website](http://xapple.github.com/track/).
Package: track2p
track2pCell tracking for longitudinal calcium imaging recordings.InstallationInstalling via pipFirst we need to set up a conda environment with python 3.9:conda create --name track2p python=3.9
conda activate track2pThen simply install the track2p package using pip:pip install track2pThats it, track2p should be succesfully set up :)
You can simply run it by:python -m track2pThis opens a GUI allowing the user to launch the algorithm and visualise the results interactively.(For instructions on running track2p without the GUI see the 'Run via script' under the 'Usage' section)UsageRun through GUIAfter activating the GUI throughpython -m track2pthe user should navigate to the 'Run' tab on the top left of the window and select 'Run algorithm' from the dropdown menu. This will open a pop-up window that will allow the user to set the paths to suite2p datasets and to set the algorithm parameters. Once these have been set the user can click on 'Run', which will launch the track2p algorithm, with the progress being printed in the window below.When the algorithm is finished, another pop-up window will appear, asking the user if they want to visualise the outputs in the GUI (for more information see section below).GUI visualisationThe GUI supports both visualisation after algorithm run (as described above), as well as visualising previously processed data. The latter can be done by navigating to File -> Load processed data on the top left of the GUI.Briefly the GUI allows the user to visualise the mean field of view on all days, with the ROIs of all matched cells visualised. The user can then interactively select a cell by clicking on the ROI on the mean image. This will display a zoomed-in view of this cell across all days on the right, and the extracted fluorescence time series below.Run via scriptTo run via script you can use therun_track2p.pyscript in the root of this repo as a template. It is exactly the same as running thrugh the gui, only that the paths and the parameters are defined within the script (for more on parameters etc. see documentation). When running make sure you are running it within the track2p environment, for example:conda activate track2p
python -m run_track2pOutputsAll the outputs of the script will be saved in atrack2pfolder created within thetrack_ops.save_pathdirectory specified by the user when running the algorithm. For an introduction on how to use the outputs for further downstream analysis we provide a useful demo notebookdemo_t2p_outlput.ipynbin the root of this repository. Note: You will need to additionally install jupyter for this to work. For example:conda install conda-forge::jupyterlab
Package: trackable
trackableA minimalistic machine learning model tracker and reporting toolDocumentation:https://MillenniumForce.github.io/trackableGitHub:https://github.com/MillenniumForce/trackablePyPI:https://pypi.org/project/trackable/Free software: MITtrackableis a package focussed on users already familiar with machine learning in Python and aims to:Provide a minimal model tracking tool with no frillsAn intuitive and lightweight apiInstallationThe latest released version can be installed fromPyPIusing:# pippipinstalltrackableFeaturesTo start usingtrackableimport the main reporting functionality via:fromtrackableimportReportIt's simple to start using the package. The example below (although simplistic) shows how easy it
is to pick up the api:fromsklearn.datasetsimportmake_classificationfromsklearn.linear_modelimportLogisticRegressionfromsklearn.ensembleimportRandomForestClassifierfromsklearn.metricsimportaccuracy_score,f1_score,roc_auc_scorefromtrackableimportReportX,y=make_classification()lr=LogisticRegression().fit(X,y)rf=RandomForestClassifier().fit(X,y)# Instantiate the report...report=Report(X,y,metrics=[accuracy_score,f1_score,roc_auc_score])# Add models...report.add_model(lr)report.add_model(rf)# Generate the report...report.generate()CreditsThis package was created withCookiecutterand thewaynerv/cookiecutter-pypackageproject template.
Package: trackbert
TrackbertA simple Python script for tracking shipments, primarily throughKeyDelivery.If your system providesnotify-send, you will get a desktop notification when the status of your shipment changes.Status information is stored in a SQLite database.Currently supported tracking providersKeyDelivery(paid, provides tracking for most carriers)Austrian PostGLSFedEx(requires an API key, seeFedEx Developer Resource Center)DHL(requires an API key, seeDHL Developer Portal)DPD (Austria)(may work for other countries as well, but untested)More tracking providers can be added easily by subclassingtrackbert.trackers.base.BaseTracker. This should be relatively self-explanatory if you look at the existing implementations. Pull requests are welcome!RequirementsThe script was developed and tested on Arch Linux using Python 3.11. The "Never" type hint is used, so I suppose it will not work on older Python versions. It should work on any Linux distribution. You can technically run it on Windows and macOS as well, but you will not get desktop notifications.In order to get desktop notifications, you need to havenotify-sendinstalled. On Arch Linux, this is provided by thelibnotifypackage. If your desktop environment does not provide a notification server, you have to install one yourself. How to do this is beyond the scope of this README.InstallationFirst, create a virtual environment and install the package:python-mvenvvenvsourcevenv/bin/activate
pipinstalltrackbertThen create aconfig.iniin your working directory (seeconfig.dist.ini) and fill in your KeyDelivery API details, which you can find in yourKeyDelivery API management. You can find your API key in your KeyDelivery account settings.You can also omit this step, but then you will only be able to track shipments from Austrian Post and GLS.UsageFirst, assure that the virtual environment is activated:sourcevenv/bin/activateIf you need to create a new config file, runtrackbert -g. You need this if
you want to provide API keys required for KeyDelivery or some of the other
tracking providers.To add a new shipment, runtrackbert --tracking-number <tracking-number> --carrier <carrier-id>. Find the required carrier ID in theKeyDelivery API management.To run the main loop, runtrackbert. This will check the status of all shipments every minute, and print the status to the console. If the status of a shipment changes, you will get a desktop notification.CaveatsDHLBy default, the script queries for updates for each active shipment once per minute. However, if you have the DHL API enabled, you will quickly run into the rate limit. Therefore, the script will only query for updates once per hour (if minute == 0). For the default 250 requests per day limit, this means that you can only track up to 10 shipments simultaneously.You may request a higher rate limit from DHL. See theDHL Developer Portalfor details. If you do this, you can setratelimited = 0(note that 0/1 is a boolean value in the config file) in yourconfig.inito disable the rate limit.LicenseThis project is licensed under the MIT License. See theLICENSEfile for details.
Package: trackbranch
trackbranchtrackbranchis a tool for developers that can be used to store
collections of branches in the form of profiles. This can be useful
for situations where you have multiple branches to group into the
same action.InstallationUsers can install thetrackbranchpackage via PyPi:$ pip install trackbranchOr, clone the repository, build it and install it with pip (depends onpython==^3.6,poetryandpip):$ poetry lock
$ poetry update
$ poetry build
$ pip install dist/*.whlGetting StartedSeetrackbranch --helpfor details on command line arguments
and program usage.UsageCreate a branch profilemy-profileconsisting ofbranch1andbranch2:# Add branch1 and branch2 to my-profile.
$ trackbranch -p my-profile add branch1 branch2
added 'branch1' to 'my-profile'
added 'branch2' to 'my-profile'This will automatically create a.trackbranch.jsonfile if one
cannot be found in the current directory or upwards.List all profiles:$ trackbranch ls
my-profile: ['branch1', 'branch2']List specific branches by providing-p|--profile:# List branches in the my-profile collection.
$ trackbranch -p my-profile ls
branch1 branch2For each branch inmy-profile, execute the command-c. Each{br}string
format piece is replaced by the branch name.# Execute -c for each branch found in my-profile.
$ trackbranch -p my-profile exec -c 'bash -c "git checkout {br}; git rebase -i base"'Removebranch1frommy-profile.# Remove branch1 from my-profile; branch2 remains.
$ trackbranch -p my-profile rm branch1
removed 'branch1' from 'my-profile'Completely clear outmy-profile.# Clear my-profile.
$ trackbranch -p my-profile clear
profile 'my-profile' has been removedLicenseThis project operates under The MITLicense.AuthorsNameEmailKevin Morriskevr@0cost.org
Package: trackc
trackcTrack view of chromosome conformation and multi-omics datatrackcis a python package for flexible visualization of rearrangement 3D genome and multi-omics data.
It builds on top ofmatplotlib, which allows for flexible adjustments.trackc’s key applicationsMark the abnormal interaction formed by the structural variation of the genome.Show the 3Dgenome interaction and multi-omics data after rearrangement.Flexible and convenient layout for multi-trackAvailable track typestrackstrackfunctionsDescriptionHi-C heatmaptl.extractContactRegions, tl.extractCisContact, mapCsupport multi-regions and reverse regionsmark regions on heatmapmapc_marklinesupport multi-regions and reverse regions,
mark square line on mapc heatmapVirtual4CVirtual4Csupport multi-regions and reverse regionsloop linkslinks_tracksupport multi-regions and reverse regionsbedbed_tracksupport multi-regions and reverse regions,
styles[bar, line, rectangle, triangle, link]
to show ChIP-seq peak or ATAC-seq peaks, TAD domains, SVs
bed or begGraphbigwigbigwig_tracksupport multi-regions and reverse regionsbedgraph matrixbdgmat_tracksupport multi-regions and reverse regions,
styles [heatmap, line]zoomin visualizationzoominsupport multi-regions and reverse regionsgene annotationgene_tracksupport multi-regions and reverse regionsscale barscale_trackgenome position scalemulti scale barmulti_scale_tracksupport multi-regions and reverse regionshigh light some position or regionsvhighlightsupport multi-regions and reverse regionsHere is an example ofdu_dynamic_2022article diagram implemented by trackc.InstallationPyPIInstall trackc by running:pipinstalltrackcDevelopment versionTo install trackc from GitHub, run:pip install git+https://github.com/seqyuan/trackc@mainUsagetrackc support both api and cli. Here is a cli example:trackccliconf.ymlconf.yml contenttrackc:-ax:l1height:1.25track_type:hicmaptrack_para:mat:method:extractContactRegionsclr:./github/seqyuan/trackc_data/examples/BxPC3.chr18.mcool::/resolutions/25000balance:Falserow_regions:-18:47400000-48280000-18:75280000-74030000mapC:map_type:trilabel:neo tadcmap:PuBuheight:40ax_on:Falsemaxrange:200minrange:10-ax:l2height:0.5track_type:bw_tracktrack_para:bw:./github/seqyuan/trackc_data/examples/GSM3178671_BxPC3_H3K27ac.bigwigregions:-18:47400000-48280000-18:75280000-74030000label:H3K27acbinsize:2000color:-'#5B7695'-ax:l3height:0.4track_type:multi_scale_tracktrack_para:regions:-18:47400000-48280000-18:75280000-74030000scale_adjust:Mbintervals:2tick_fontsize:7-ax:l4height:2.8track_type:gene_tracktrack_para:bed12:./github/seqyuan/trackc_data/examples/hg19_chr18.gene.bed12regions:-18:47400000-48280000-18:75280000-74030000line:12gene_fontszie:8DocumentationOur documentation provide the full list of possible track types and gallary guidelines for users.Extensive documentations are available athttps://trackc.readthedocs.ioCitationIf you use trackc in your analysis, Please cite trackc as follows:trackc: a package for flexible visualization of rearrangement 3D genome and multi-omics data
Package: trackcalc
trackcalctrackcalc is a tool to help you convert a list of tracks like this:01:33 first track
03:21 second track
…into something like this:00:00 first track
01:33 second track
… etcit takes a tracklist as input, and spits the calculated result to stdout.You can then redirect stdout into a file, or use sponge to update your tracks file in-place.ie:trackcalc tracks.txt > tracks_o.txtYou can use my other tool, albumsplit, to use this tracks file to split up an mp3 file into tracks.here is a vim macro I use to reformat tracks:$Bd$0Pa 0j
Package: track-changes
Generate History/ChangelogIt should work on MacOS, Linux and Windows with git >= 2.0 installed.Usagepip install track_changes
cd <project_root>
track_changes > HISTORY.md🎁 Release notes (0.7)Changesfix: fixed tempalted not being included
ref: fixed pypi readme markdown
ref: updated history md
fix: format
fix: github somehow ignored the newline
ref: updated changes log
fix: fixed errors on macos
ref: renamed
ref: updated doc; changelog
feat: usable
fix: fixed entrypoint; fixed version style
ref: rm redundant codeMetadataThis version -------- 0.7
Previous version ---- 0.1
Total commits ------- 12