Saravanan666/pypi-org huggingface dataset:
Package: traceon
TraceonTraceon is a general software package used for numerical electron optics. Its main feature is the implementation of the Boundary Element Method (BEM) to quickly calculate the surface charge distribution. The program supports both radial symmetry and general three-dimensional geometries. Electron tracing can be done very quickly using accurate radial series interpolation in both geometries. The electron trajectories obtained can help determine the aberrations of the optical components under study.Traceon is completely free to use and open source. The source code is distributed under theAGPLv3license.DocumentationExamplesAPI documentationCitationPlease cite the software as follows:L.B. van Velzen. Traceon software (version 0.3.1). 2023. https://doi.org/10.5281/zenodo.8127611InstallationInstall using the Python package manager:pip install traceonThe installation is known to work on Linux and Windows. Please reach out to me if you have any installation problems.ValidationsTo ensure the accuracy of the package, different problems from the literature have been analyzed using this software. See/validationdirectory for more information. The validations can easily be executed from the command line, for example:python3./validation/edwards2007.py--help
python3./validation/capacitance-sphere.py--help
etc...LicenseAGPLv3Help! I have a problem!Don't worry. You can reach me.Open an issueSend me an emailGalleryFeaturesv0.4.0:Introudce Fast Multipole Method (FMM) for large 3D problemsCompute 3D radial expansion coefficients using analytical formulasFurther speed up computation of 3D radial expansion coefficientsBig code quality improvement of validation/ filesv0.3.0:Use adaptive integration using GNU Scientific Library (GSL)Add support for boundary constraintUseVedofor better plotting capabilitiesUse higher order triangle elements for 3D (curved triangles)Precompute jacobians/positions for better performanceFirst implementation of element splitting based on charges (work in progress)v0.2.0:Use higher order charge distribution on line elements in radial symmetryUse higher order line elements (polynomials) in radial symmetryBetter integration techniques, especially with regards to the logarithmic singularitiesv0.1.0:Uses the powerfulGMSH libraryfor meshingSolve for surface charge distribution using BEMGeneral 3D geometries and radially symmetric geometriesDielectricsFloating conductorsAccurate electron tracing using adaptive time stepsField/potential calculation by integration over surface chargesFast field/potential calculation by radial series expansionSuperposition of electrostatic fields
Package: tracepooling
tracepooling-layerAdaptive pooling layer that applies a non-linear resampling of network activations on the temporal axis by applying a data-dependent temporal warping, which samples densely in information-rich regions and sparsely in information-poor regions.I. Martin-Morato, M. Cobos and F. J. Ferri, "Adaptive Distance-Based Pooling in Convolutional Neural Networks for Audio Event Classification," IEEE/ACM Transactions on Audio, Speech and Language Processing, 2020.TraceLayer is an adaptive (non-trainable) pooling layer which performs a non-linear temporal
transformation that follows a uniform distance subsampling criterion on the deep feature space.The layer can be applied to any convolutional neural network model for sound event recognition,
increasing the performance of the pre-trained model when there are mismatching test conditions.Installationpip install tracepoolingUsageTraceLayer is implemented as atensorflowlayer, so it can be added in a tensorflow model as:from tracepooling.TraceLayer import TraceLayerx = TraceLayer(2)(previous_layer)Where the input parameter is the desired downsampling factor for the time dimension.
Package: tracepy
Ray Tracing and Optical Design in PythonOverviewTracePy is a sequential ray tracing package written in Python 3 for designing optical systems in the geometric optics regime. It features lens optimization from Scipy.InstallationTo use TracePy you can either clone the repository and use the command "pip3 install ." in the download directory, or you can download TracePy directly through pypi with the command below.pip3 install tracepyExamplesTo get started using the software, you can look at the examples provided in the 'examples' folder. The UI for TracePy is most similar to BEAM4, and TracePy's ray tracing algorithm was recreated from Spencer and Murty's iconic paper, "General Ray-Tracing Procedure".ContributingI suggest reading Spencer and Murty's paper,"General Ray-Tracing Procedure"for an overview of TracePy's algorithm. There are also several open issues that we welcome collaborators on.
Package: tracerepo
Running testsTo run pytest in currently installed environment:poetryrunpytestTo run full extensive test suite:poetryrundoit# Add -n <your-cpu-core-count> to execute tasks in parallel
# E.g.poetryrundoit-n8-v0# -v 0 is added to limit verbosity to mininum (optional)
# doit makes sure tasks are run in the correct order
# E.g. if a task uses a requirements.txt file that other task produces
# the producer is run first even with parallel executionFormatting and lintingFormatting & linting:poetryrundoitformatpoetryrundoitlintBuilding docsDocs can be built locally to test thatReadTheDocscan also build them:poetryrundoitdocsdoit usageTo list all available commands fromdodo.py:poetryrundoitlistDevelopmentDevelopment dependencies fortracerepoinclude:poetryUsed to handle Python package dependencies.# Use poetry run to execute poetry installed cli tools such as invoke,
# nox and pytest.poetryrun<cmd>doitA general task executor that is a replacement for aMakefileUnderstands task dependencies and can run tasks in parallel
even while running them in the order determined from dependencies
between tasks. E.g. requirements.txt is a requirement for running
tests and therefore the task creating requirements.txt will always
run before the test task.# Tasks are defined in dodo.py
# To list doit tasks from command linepoetryrundoitlist# To run all tasks in parallel (recommended before pushing and/or
# committing)
# 8 is the number of cpu cores, change as wanted
# -v 0 sets verbosity to very low. (Errors will always still be printed.)poetryrundoit-n8-v0noxnoxis a replacement fortox. Both are made to create
reproducible Python environments for testing, making docs locally, etc.# To list available nox sessions
# Sessions are defined in noxfile.pypoetryrunnox--listcopiercopieris a project templater. Many Python projects follow a similar
framework for testing, creating documentations and overall placement of
files and configuration.copierallows creating a template project
(e.g.https://github.com/nialov/nialov-py-template) which can be firstly
cloned as the framework for your own package and secondly to pull updates
from the template to your already started project.# To pull copier update from github/nialov/nialov-py-templatepoetryruncopierupdatepytestpytestis a Python test runner. It is used to run defined tests to
check that the package executes as expected. The defined tests in./testscontain many regression tests (done withpytest-regressions) that make it almost impossible
to add features totracerepothat changes the results of functions
and methods.# To run tests implemented in ./tests directory and as doctests
# within project itself:poetryrunpytestcoverage# To check coverage of tests
# (Implemented as nox session!)poetryrunnox--sessiontest_pipsphinxCreates documentation from files in./docs_src.# To create documentation
# (Implemented as nox session!)poetryrunnox--sessiondocsBig thanks to all maintainers of the above packages!LicenseCopyright © 2021, Nikolas Ovaskainen.
Package: tracereq
Simple-Traceability-SRS-Documentsthis is repository how to make simple traceability from requirement documents,
you can check this out tolive demoComparative Studies of Several Methods for Building Simple Traceability and Identifying The Quality Aspects of Requirements in SRS Documents described inour paper at EECCIS2020. Please kindly cite the following paper when you use this tool. It would also be appreciated if you send me a courtesywebsiteandgoogle scholar, so I could survey what kind of tasks the tool is used for.@INPROCEEDINGS{9263479,  author={Asyrofi, Rakha and Hidayat, Taufik and Rochimah, Siti},  
booktitle={2020 10th Electrical Power, Electronics, Communications, Controls and Informatics Seminar (EECCIS)},   
title={Comparative Studies of Several Methods for Building Simple Traceability and Identifying The Quality Aspects of Requirements in SRS Documents},   
year={2020},  
pages={243-247},  
doi={10.1109/EECCIS49483.2020.9263479}}Developed by Asyrofi (c) 2021Cara menginstalinstalasi melalui pypi:pip install tracereqCara menggunakan programfromtracereq.preprocessing_evaluationimportprosesDatamyProses=prosesData(inputData='dataset.xlsx')myProses.preprocessing()Check out thisyoutube link:
Package: tracereq-sdk
TraceReq SDK for PythonThis is the Python SDK forTraceReqInstallationpipinstall--upgradetracereq-sdkUsage with Flaskimporttracereq_sdkapp=Flask(__name__)tracereq_sdk.init(api_key='xxx-xxx',flask_app=app.wsgi_app)Adding the above any flask service will start tracing requests.
No other additional code is required.Supported FrameworksFlask
Package: tracerite
Nicer error messages for PythonOther languages such as C++ have gotten quite useful error messages and
diagnostics with tips on how the fix the problems but Python is still stuck
with the bare stacktraces that are very intimidating and often not very helpful.TraceRite backtrace shows where the user has terminated the program.TraceRite hides the irrelevant IPython/notebook internals and concisely shows
what happened (the program was interrupted) and where that happened. This could
further be improved by converting the KeyboardInterrupt message into something
more suitable, like "You stopped the program", but what you see above is just
the default handling that never considered this particular error.Although IPython and Google Colab developers have done their tweaks to improve
backtraces, it is all too apparent that much remains to be done:Standard backtrace from Google Colab.Even for the experienced programmer, it is tedious to read through the wall of
text to find the relevant details of what went wrong.In more complex situations where one might get many screenfuls of standard
traceback, TraceRite produces scrollable outputs that concentrate on the relevant
details but also provide variable inspectors on each frame where it may be
relevant:TraceRite output with nested exceptions.UsageAt the beginning of your Notebook:%pip install tracerite
%load_ext traceriteBackgroundThis project is a proof of concept, showing a modern way to format error
messages in a human-readable manner. Heuristics are used to hide (by default)
irrelevant stack frames and show the actual location of the problem. Since it
would otherwise be impossible to find out the variable contents after the program
has crashed, a variable inspector built into each stack frame quickly reveals
problems with the variables mentioned at the source of error. Care is taken to
add revelant details such as notebook input field numbers and class names not
normally present in Python tracebacks, while hiding overly long paths and other
clutter.All output is in HTML and as such only works in Jupyter notebooks and other
browser-based systems (this should be useful for web development frameworks as
well). This allows interactivity and much better layout than that of the text
console.LicensePublic Domain or equivalent.Help wantedI won't be able to maintain this all by myself. If you like the idea of nicer
tracebacks, please offer your help in development! Pull requests are welcome
but it would be even better if you could pick up the whole project as your own.As of now, this project is in no way properly polished for release. Yet, it is
useful enough to such a degree that I always use it in my notebooks, and it
really makes Python development a much smoother experience.
Package: tracerlib
Tracerlib is a set of utilities to make tracing Python code easier.It providesTracerManager, which can allow multiple trace functions to
coexist. It can easily be enabled and disabled, either manually or as a
context manager in a with statement.Tracerclasses make handling the different trace events much easier.class TraceExceptions(Tracer):
    def trace_exception(self, func_name, exctype, value, tb):
        print "Saw an exception: %r" % (value,)Traceris also easily capable of filtering which events it listens
to. It accepts both aneventsparameter, a list of trace events it
will respond to, and awatchparameter, a list of paths it will
respond to in the form ofpackage.module.class.function.This can easily wrap a trace function, or you can subclassTracerand implement one of its helpfultrace_*()methods.And, a helper classFrameInspectorwhich wraps a frame and makes it
trivial to inspect the function name and arguments the function had been
called with.inspector = FrameInspector(sys._getframe())

print "Called", inspector.func_name
print "args:", inspector.args
print "kwargs:", inspector.kwargs
Package: tracery3
This is a (rough) port ofKate Compton’s
wonderfulTraceryto Python. The port
is byAllison Parrish.I’m always writing little one-off recursive template/grammar expansion
functions in my Python generative text projects. And Iloveworking with
Tracery! So I figured: why not save myself (and potentially others) some time
and just make it possible to use Tracery from within Python? This port is the
result!The port is a fairly literal Python translation ofthis versionoftracery.jsin the official repository’stracery2branch.InstallationInstall with pip like so:pip install tracery3You can also download the source code and install manually:python -m pip install "."UsageSeeKate Compton’s Tracery
tutorialfor information
about how Tracery works. In the Python port, you use Python dictionaries
instead of JavaScript objects for the rules, but the concept is the same
otherwise.import tracery
from tracery.modifiers import base_english

rules = {
    'origin': '#hello.capitalize#, #location#!',
    'hello': ['hello', 'greetings', 'howdy', 'hey'],
    'location': ['world', 'solar system', 'galaxy', 'universe']
}

grammar = tracery.Grammar(rules)
grammar.add_modifiers(base_english)
print(grammar.flatten("#origin#"))  # prints, e.g., "Hello, world!"Any valid Tracery grammar should work in this port. Thebase_englishmodifiers intracery.modifiersare a port of the modifiers in the JavaScript
package. Many aspects of Tracery are not standardized, so in some edge cases
you may get output that doesn’t exactly conform to what you would get if you
used the same grammar with the JavaScript version. (e.g., “None” in strings
where in JavaScript you might see “undefined”)Command lineYou can run the module on a JSON Tracery grammar file on the command line to output example lines:positional arguments:
    json        Input JSON file
    number      Number of lines to generate (default: 1)For example:$ python -m tracery potterpapers.json
Harry Potter and the Tchebyshev transforms of the first and second kind

$ python -m tracery potterpapers.json 3
Harry Potter and the Impact of Extremes in Outdoor Temperature and Sunshine Exposure on Birth Weight.
Harry Potter and the Chromatin Remodelling Enzymes SNF2H and SNF2L Position Nucleosomes adjacent to CTCF and Other Transcription Factors.
Harry Potter and the Model Organism Hermissenda crassicornis (Gastropoda: Heterobranchia) Is a Species Complex.LicenseThis port inherits Tracery’s original Apache License 2.0.Copyright 2016 Allison Parrish
Based on code by Kate Compton

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: tracescopio
Tracescopio: Simplifying Stack Trace Retrieval for Your Django Applications RemotelyTracescopio is a tool designed to make obtaining stack traces from your python app easy: the events are sent to your Tracescopio app. (You can install Tracescopio app in your own server.See more.)Get startedFirts of all, make sure your have your own server running.
After that, use the pip command to install the tracescopio in your app:pip install tracescopioPut the the your Tracescopio url server in your project's settings.py file:(...)
TRACERSCOPIO_SERVER = '<your tracescopio-app url>'Obtain the IDE code for your app:python manage.py shell
from tracescopio import scopio
TracescopioApp.new(name='foo', url='foo.com')
{'ide':some-code-for-your-app', 'msg':'Success'}Put the "ide" code in your project's settings.py file:(...)
APP_TRACESCOPIO_IDE = '<the ide code for you app>'Finally, to get the stack traces you can use the decorator or the middleware.DecoratorAdd the import(..)
from tracescopio.decorators import tracemeAdd the decorator@trace
def the_view_raising_some_exception(request, *args, **kwargs):
    (...)MiddlewareIn your settgins.py's middleware section, add the tracescopio middleware:(...)
MIDDLEWARE = [
	(...)
    "tracescopio.middleware.telemetria.TelemetryMiddleware",
]That is it!
Package: trace-skeleton
Thetrace_skeletonPython packageA python package for tracing the skeleton of a 2D image. This work uses theSkeleton Tracing algorithmdeveloped byLingDong.
This repo provides an easy to install python package for tracing the skeleton.
This is done to ease the use of the algorithm in other Python projects. We've
taken the SWIG C implementation for optimal performance.UsageQuick and easy installation:pipinstalltrace-skeletonExampleThe examples shown are a copy-paste from theoriginal repo.importtrace_skeletonimportcv2importrandomim=cv2.imread("../test_images/opencv-thinning-src-img.png",0)_,im=cv2.threshold(im,128,255,cv2.THRESH_BINARY);polys=trace_skeleton.from_numpy(im);forlinpolys:c=(200*random.random(),200*random.random(),200*random.random())foriinrange(0,len(l)-1):cv2.line(im,(l[i][0],l[i][1]),(l[i+1][0],l[i+1][1]),c)cv2.imshow('',im);cv2.waitKey(0)AdvancedThe aforementioned API's have a tiny linear time overhead for transforming input
and output between internal datastructures and python objects. Alternatively,
you can use the following:fromtrace_skeletonimport*im="\0\1\0\0\1\0\0\1\0..... "#image stored as a (char*)w=128#dimensionsh=64trace(im,w,h)# iterate over each point in each polyline# by popping them off the internal datastructure# len_polyline() gets the length of current polyline# -1 means no more polylineswhile(len_polyline()!=-1):n=len_polyline();foriinrange(0,n):# pop_point() retrieve and remove the next point# on the polyline. It returns the flat index in image# mod/div it with width to get (x,y) coordinateidx=pop_point()x=idx%w;y=idx//w;print(x,y)print("\n")
Package: tracetool
Tracetool Api for PythonPython file (tracetool.py)
is included in the Python/Src/tracetool folder.The library is compatible with Python 2, Python 3, and Iron Python (.NET).The library was also tested under BlenderSample code>>>fromtracetoolimportttrace>>>ttrace.debug.send("hello Python")Refer to github projecthttps://github.com/capslock66/Tracetoolfor full documentation
MIT LicenseCopyright (c) 2022 Thierry ParentPermission 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: tracetools
A simple library to print formatted trace messages (especially useful with the binary data):>>> trace(binary_data)
12:08:16.762628 >> 206 bytes sent:
       00 cc 30 31 30 30 72 30 05 80 20 c0 92 00 31 36         ..0100r0.. ...16
       38 39 39 30 30 31 31 32 33 34 35 36 37 38 39 30         8990011234567890
       30 30 30 30 30 30 30 30 30 30 30 30 30 32 30 30         0000000000000200
       30 30 31 34 39 34 35 30 34 34 39 34 38 30 30 32         0014945044948002
       33 31 31 37 30 35 31 31 31 32 30 38 31 34 39 30         3117051112081490
       30 31 30 30 30 30 33 32 38 39 39 30 30 31 31 32         0100003289900112
       33 34 35 36 37 38 39 30 44 31 38 30 39 32 30 31         34567890D1809201
       31 38 37 32 33 30 30 30 31 30 30 30 31 33 33 37         1872300010001337
       39 39 39 39 39 39 39 39 39 39 39 39 30 30 31 36         9999999999990016
       34 33 2b 68 7a ef c3 4b 1a 89 30 34 39 82 02 00         43+hz..K..049...
       00 9a 03 17 05 11 95 05 00 00 04 08 80 9f 10 02         ................
       00 00 9f 26 08 ed 2c d0 d2 98 94 fb aa 9f 36 02         ...&..,.......6.
       00 01 9f 37 04 8f a4 f2 bd 9f 1a 02 06 43               ...7.........C>>> trace(binary_data)
12:08:17.013138 << 110 bytes received:
       00 6c 30 31 31 30 72 30 00 00 0e 80 80 00 31 36         .l0110r0......16
       38 39 39 30 30 31 31 32 33 34 35 36 37 38 39 30         8990011234567890
       30 30 30 30 30 30 30 30 30 30 30 30 30 32 30 30         0000000000000200
       30 30 31 34 39 34 35 30 34 34 39 34 38 30 30 32         0014945044948002
       33 31 31 37 30 35 31 31 31 32 30 38 31 34 30 30         3117051112081400
       30 30 30 30 31 30 36 38 34 38 31 30 36 38 34 38         0000106848106848
       30 30 30 31 30 30 30 31 33 33 37 36 34 33               00010001337643Usage:>>> from tracetools.tracetools import trace
>>> trace(b'\x01\xFF17398172371892371982737981723')
22:27:00.967302
       01 ff 31 37 33 39 38 31 37 32 33 37 31 38 39 32         ..17398172371892
       33 37 31 39 38 32 37 33 37 39 38 31 37 32 33            371982737981723>>> trace(title='Some stuff received:', data=b'\x00\x6c\x30\x31\x31\x30\x72\x30\x00\x00\x0e\x80\x80\x00\x31\x36')
22:28:53.709328 Some stuff received:
       00 6c 30 31 31 30 72 30 00 00 0e 80 80 00 31 36         .l0110r0......16