Saravanan666/pypi-org huggingface dataset:
Package: debugging-benchmark
debugging-benchmarkQuickstartGenerating Passing and Failing Inputs:fromdebugging_benchmark.calculator.calculatorimportCalculatorBenchmarkRepositoryfromdebugging_framework.toolsimportGrammarBasedEvaluationFuzzercalc=CalculatorBenchmarkRepository().build()param=calc.to_dict()fuzzer=GrammarBasedEvaluationFuzzer(**param)fuzzer.run()gen_inps=fuzzer.get_generated_inputs()Evaluation:fromdebugging_benchmark.calculator.calculatorimportCalculatorBenchmarkRepositoryfromdebugging_framework.evaluatorimportEvaluationfromdebugging_framework.toolsimportInputsFromHellEvaluationFuzzertools=[InputsFromHellEvaluationFuzzer]subjects=SieveOfEratosthenesStudentAssignmentBenchmarkRepository().build()result=Evaluation(tools=tools,subjects=subjects[0:1],repetitions=1,timeout=3600).run()Deeper Look into the Class StructureCheck out the Class Diagram for a first overview. Further down in this section we take a look at some key functions of interest.Class DiagramBenchmarkRepositoryandBenchmarkProgramcan be found indebugging_framework/benchmark.pyStudentAssignmentBenchmarkProgram,StudentAssignmentRepositoryandGCDStudentAssignmentBenchmarkRepositorycan be found indebugging_benchmark/student_assignments.pyThe faulty programs can be found atdebugging_benchmark/student_assignments/problem_1_GCDand the correct implementation atdebugging_benchmark/student_assignments/reference1.pybuild()Returns a List of BenchmarkPrograms. Calls internally _construct_test_program(). This function is our interface._construct_test_program()Returns a BenchmarkProgram. Calls internally construct_oracle() to construct a oracle for our program.construct_oracle()Where the magic happens.
Returns a Functions which loads the faulty and correct implementation, executes both with the input and checks if they are the same or not. If they are the same return OracleResult.PASSING, if not return OracleResult.FAILINGto_dict()PLACEHOLDERInstall, Development, TestingInstallIf all external dependencies are available, a simple pip install PLACEHOLDER suffices.
We recommend installing PLACEHOLDER inside a virtual environment (virtualenv):python3.10 -m venv venv
source venv/bin/activate

pip install --upgrade pip
pip install PLACEHOLDERDevelopment and TestingFor development and testing, we recommend using PLACEHOLDER inside a virtual environment (virtualenv).
By doing the following steps in a standard shell (bash), one can run the PLACEHOLDER tests:git clone https://github.com/martineberlein/debugging-benchmark
cd debugging-benchmark

python3.10 -m venv venv
source venv/bin/activate

pip install --upgrade pip

# Run tests
pip install -e .[dev]
python3 -m pytest
Package: debuggingbook
Code for "The Debugging Book"This folder holds the code from "The Debugging Book".
Software has bugs, and finding bugs can involve lots of effort.  This book addresses this problem byautomatingsoftware debugging, specifically bylocating errors and their causes automatically.  Recent years have seen the development of novel techniques that lead to dramatic improvements in automated software debugging.  They now are mature enough to be assembled in a book – even with executable code.For details (and all of the book!), see the web site:https://www.debuggingbook.org/Using the CodeThe book has plenty of examples for using the code; you are encouraged to read it and then to use this code to try things out.ImportingYou can import the modules in your own projects and use the infrastructure, as infromdebuggingbook.DebuggerimportDebuggerwithDebugger():function__to_be_debugged()RunningYou can also execute the files directly to run the examples from the book, as in$./Debugger.pyEnjoy!LicenseCopyright (c) 2018-2021 CISPA, Saarland University, authors, and contributorsPermission 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: debug_print
===========debug_print===========This package comes from a basic idea that I have redone a couple of times originally in c andhave dropped as a single .py(or .h) file in many of my projects. This can be used by dumping the folderwith your project or you can install it by running `pip install debug_print`.While using debuggers/tests/a repl can be quite useful sometimes doing printf style debuggingalso has its merits especially for short-lived programs.The upside of this approach is that you don't have to repeat expressions or manually insert `__file__` and othercontext hints. Also the distinctive names make it easy to search for debug lines and delete them(since thispackage isn't really meant for production).This package is in beta partially because I want to add some options but mostly since I stillneed to figure out what to do with logging.ex```pythonimport debug_print as da = [1,2,3,4,5]d.debug_eval_print("a")```prints![ex1](debug_print_example1.png)or```pythond.debug_eval_print("[x+1 for x in range(len(a))]")```which prints![ex2](debug_print_example2.png)prints result/value of the expression/variable(using eval, the reasonto use eval is so you can print out the variable name/expressionand what it evaluates to without specifying it twice) with line number, function name, type.Soon it will print in color to stand out better.```pythond.debug_message("some message")```![ex3](debug_print_example3.png)just prints out a string(no eval) but with func name/line #/fileThe calls to debug_eval_print or debug_message default to blue if you wantsome of the expressions/messages to print in a different color just supplya different colorscheme.ex.```pythond.debug_eval_print("a[0]", colorscheme=d.ColorSchemes.FORE_RED)```prints![ex4](debug_print_example4.png)Some configuration(currently just which pieces of context info to include) can be configured by changing`d.default_settings` dict.Note: Originally `debug_eval_print` was `debug_print` but I wanted to emphasize that it uses evalunder the covers even though it makes the name longer.
Package: debug-print2
debug-printCapture the print function and add some output information to it for easy debugging.why？Is there such a situation？That you need to temporarily useprintdebugging in third-party packages or source code,
but you may forget where to addprintwhen thinking or jumping back and forth.Now you only need to install and importdebug_printto let print output the file name and line number,
which is more convenient for debugging.Install：pipinstalldebug-print2Usage:Just import the file to run.importdebug_printdebug_print.patch()
Package: debugsockets
Debugsockets is a enhancement for python sockets which adds  ICMP error handling and some neat logging/debugging capabilitiesFeaturesDebugsockets currently has following features:advanced loggingautomatic icmp errorhandlingtraceroute capabilityInstallationInstall debugsockets by running:pip3 install debugsocketsContributeIssue Tracker:https://github.com/jinjamator/debugsockets/issuesSource Code:https://github.com/jinjamator/debugsocketsRoadmapSelected roadmap items:create documentation ;)For documentation please refer tohttps://debugsockets.readthedocs.io/en/latest/LicenseThis project is licensed under the Apache License Version 2.0
Package: debugtoolkit
python-debugtoolkitDebugToolkit is a versatile Python package designed for debuggingThis library provides decorators to log various aspects of function execution. It includes decorators to log input arguments, execution time, garbage collection counts, and resource usage.Installationpip install debugtoolkitUsageTo use these decorators, simply import the decorators library and use the @ symbol followed by the decorator name before the function definition. For example:importdebugtoolkit@debugtoolkit.log_inputsdefmy_function(a,b):returna+bThis will log the input arguments every time my_function is called.ContributingContributions are welcome. Please submit a pull request with any improvements.
Package: debugtools
debugtools— Easily print useful debugging informationThis package provides a handful of functions you can use to print debugging
information.  There are basically two things that are useful about these
functions.  First, they’re only one or two letters each, so you can type them
really quickly while debugging.  Second, they append the name of the calling
function to whatever you’re printing, so you can easily see where each message
came from (and you don’t have to hunt down print statements once you finish
debugging).InstallationYou can installdebugtoolsusingpip:$ pip install debugtoolsUsageI typically the following import at the beginning of any file that I’m likely
to debug:fromdebugtoolsimportp,pp,pvThep()function behaves just likeprint(), except it appends the name
of the calling function to whatever you’re printing.  I often use it with no
arguments, just to see if a function is being called or not.Thepp()function is topprint.pprint()asp()is toprint().
Thepv()function callspp()with the dictionary of variables in the
calling scope, so it’s a good way to see what variables are defined in the
function you’re debugging.
Package: debug-tools
Debug ToolsBasic logger for Pythonloggingmodule.Usagepip install debug_toolsOr clone this repository locally by running the commands:git clone https://github.com/evandrocoan/debugtools
cd debugtoolsThen, runpython setup.py installorpython setup.py developto install it on development mode.fromdebug_toolsimportgetLogger# Enable debug messages: (bitwise)# 0   - Disabled debugging.# 1   - Basic logging messages.# 2   - AgentPlayer       class' notices.# 4   - StickIntelligence class' notices.# 127 - All debugging levels at the same time.log=getLogger(127,__name__)log(1,"Debugging")Cleaning the log file every start upIf you are logging the debug output to a file and you would like to clean/erase all the log file contents,
every time you re-create the logger,
you need first to unlock the log file lock, otherwise,
the file contents are not going to be erased.To unlock your log file,
you just need to calllog.setup(""),
with an empty string before creating a new logger.On Sublime Text, this could be done with te following:fromdebug_toolsimportgetLoggerlog=getLogger(debug_enabled,"wrap_plus","wrapplus.txt",mode='w')defplugin_unloaded():log.delete()Dynamically Reloading ItIf you want to reload the debug tools code on the fly, you can use this to import it:importimpimportdebug_tools.loggerimp.reload(debug_tools.logger)fromdebug_tools.loggerimportDebuggerfromdebug_tools.loggerimportgetLoggerDebugger.deleteAllLoggers()log=getLogger(1,"LSP")Using file logger configurationIf you want to load the logger configuration from a file, you need to replace the standard logging
module class with this one:import logging
import debug_tools

if log_config:

    with open(log_config, 'r') as f:
        logging.Logger.manager = debug_tools.Debugger.manager
        logging.Logger.manager.setLoggerClass( debug_tools.Debugger )

        logging.config.dictConfig(json.load(f))Sublime Text DependencyTo use this as a Package Control Dependencyhttps://packagecontrol.io/docs/dependenciescreate
thisdependencies.jsonfile on the root of your Package:{"windows":{">3000":["python-pywin32","portalockerfile","concurrentloghandler","debugtools"]},"*":{"*":["portalockerfile","concurrentloghandler","debugtools"]}}Update estimated_time_left from upstreamTo update the subtreeall/debug_tools/estimated_time_left,
from upstream updates you can use the command:gitsubtreepull--prefix=all/debug_tools/estimated_time_lefthttps://github.com/evandrocoan/EstimatedTimeLeftmasterTo send updates back to the upstream, use the following command:gitsubtreepush--prefix=all/debug_tools/estimated_time_lefthttps://github.com/evandrocoan/EstimatedTimeLeftmasterLicenseSee the fileLICENSE.txt
Package: debus
debus: a non-reference DBus implementationSummaryThis is an attempt to make a nice-to-use asynchronous DBus implementation without any extra dependencies and magic.Why?There are two main issues with using "the" dbus implementation with python:magical dependencies ("what isimport giand how do I get it to work on my embedded device?")foreign event loop mandatory for certain operations*, while in the end we only need ot read/write to a socket* AFAIR you can do synchronous calls wihtout the event loop, but definitely can't subscribe to signals without itDependeciesdebus uses cython. Thus, you need it (and a working build environment for C) to build debus.At runtime no extra dependencies (except python itself) is needed.Known limitationsOnly little-endian messages are supported so farMethods have to return a tuple to match dbus idea of multiple "out" parameters
Package: debussy-airflow
Debussy AirflowA set of Airflow Hooks, Operators and Sensors for Debussy Concert,the core component of Debussy Framework⚠️Not exactly a providerThis package provides operators, sensors, and hooks that enables runningDebussy Concerton Apache Airflow. However, it's not a traditional Airflow provider package in the sense Debussy Concert is not a tool, but rather a framework for data pipeline development and code generation. Therefore, our hooks, operators and sensors acts as interfaces, extending other Airflow providers, and abstracting their usage.InstallationYou can install this package viapip install debussy-airflowPrerequisitesAn environment runningapache-airflow2.2.0+ with the following requirements (already managed as dependencies):-apache-airflow-providers-google == 8.0.0-facebook-business == 13.0.0-mysql-connector-python == 8.0.24-paramiko == 2.8.1ModulesHooksdb_api_hookfacebook_ads_hookhttp_api_hookhttp_hookstorage_hookOperatorsbasic_operatordb_to_storage_operatorfacebook_ads_to_storage_operatorhttp_operatorrest_api_to_storage_operatorstorage_to_rdbms_operatorstorage_to_storage_operatorSensorshttp_sensorExamplesSee theexamplesdirectory for an example DAG.IssuesPlease submitissuesandpull requestsin our official repo:https://github.com/DotzInc/debussy_airflowWe are happy to hear from you. Please email any feedback to the authors atdataengineer@dotz.com.Project Contributors and MaintainersThis project is built with active contributions from:Lawrence FernandesNilton DuarteMaycon FrancisThis project is formatted viablack:pipinstallblack
black.Changelog0.0.1 - First release0.0.2 - Fix naming conventions for hooks, operators and sensors, and updated example_dags0.0.3 - Improved README description, and setup.py0.0.4 - Moved config to setup.cfg, added requirements.txt and CHANGELOG.md0.0.5 - Fix DbApiHookInterface class name on db_api_hook and import path on storage_to_rdbms_operator0.0.6 - Improvements on db_api_hook and storage_to_storage_operator, including support to PostgreSQL, and updated requirements
Package: debutils
debutilsUtilities to help Debian package maintainers.This tool is currently very unstable. Feel free to use it, but please report
any bugs you find. If you have an idea for a new feature or commands, then
please let me know!More infoTable of ContentsInstallationContributingOpening issuesPull requestsDevelopingWhyAcknowledgementsPackaging for DebianLicenseInstallationTo install from git:pip install git+https://codeberg.org/Maytha8/debutils.git#IrecommendusingpipxinsteadofpipTo install from pypi:pip install debutils#IrecommendusingpipxinsteadofpipContributingThere are several ways you can contribute to debutils.Opening issuesIf you find any bugs, or have any ideas for new functionality, please don't
hesitate toopen an issue.Pull requestsThere's a long list of TODOs. Some of them can be found inTODO, and
others are strewn throughout the code as TODO comments.You can help out by taking on one of these tasks and opening a pull request
with your changes.DevelopingClone this repo, and either usehatch run ./main.pyorhatch shell && ./main.pyto run the CLI. (usinghatch run debutilswill install debutils
inside the venv, changes to the code aren't applied)WhyI had a few useful scripts lying around, so I decided to put them together and
create debutils. (e.g.itpwriteris
now part of debutils.)Additionally, dh-make-golang's make command failed to work some of the time,
leading to me having to manually follow dh-make-golang's source code and
assemble a package myself, and the estimate commandalwaysfailed when I
tried it, even when I installed straight from the repo's HEAD.Acknowledgementsdh-make-golang- thegosubcommands are partially based on the work at dh-make-golangPackaging for DebianI haven't packaged this for Debian (yet) because there isn't enough interest.
AFAIK I'm the only one using this.If you reckon my work is worth having a package in Debian, feel free to file an
RFP at the Debian BTS (and X-Debbugs-CC me), or even better, package this
yourself (please add me to uploaders and let me know if you do so).Licensedebutils -- Utilities to help Debian package maintainers.
Copyright (C) 2023 Maytham Alsudany <maytha8thedev@gmail.com>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
Package: debutizer
DebutizerDebutizer is a tool for managing APT packages, targeted at users who need to
manage a suite of potentially interdependent packages and want to do so with
minimal boilerplate and modern continuous integration tooling.InstallationAPT Repository (Recommended)Naturally, Debutizer is available for installation as an APT repository, through
a PPA. If you're running on a Debian-based distribution, Debutizer can be
installed with the following commands:sudoadd-apt-repositoryppa:velovix/debutizer
sudoaptupdate
sudoaptinstalldebutizerPyPIDebutizer is also available on PyPI and can be installed like any other Python
package. This is a good option for non-Debian Linux environments, but you will
need to install Debutizer's system dependencies yourself.Pipx is the recommended way to install through PyPI, as it gives Debutizer its
own virtual environment to run in.pipx install debutizerYou can check if Debutizer's system dependencies are available by runningdebutizer check.From SourceStart by cloning the repository:gitclonehttps://github.com/velovix/debutizerThen, assuming you have Python 3.6+ and Pip installed, run the following
command in the directory you cloned into:pip3install--constraintconstraints.txt.This will take care of installing Python dependencies through Pip, but system
dependencies will have to be installed manually. Usedebutizer checkto see
which, if any, system dependencies are missing.DevelopmentIf you find a bug or need a new feature from Debutizer, please feel free to
create an issue! If you're feeling especially generous and would like to send
a pull request, take a look at this section for how to get started.Dev DependenciesDevelopment dependencies can be installed using Pip with thedevextra
included. This should be done in a virtualenv.pip3install--constraintconstraints.txt".[dev]"This project uses aconstraints.txtfile to pin dependencies. Since Debutizer
is often run as an APT package that uses distribution-supplied versions of our
Python dependencies, this pinning is mostly done for the benefit of keeping
development environments consistent.If you need to update the pinned version for a given dependency, you can run
the following commands within your virtualenv.pip3update<dependency>
pip3freeze--excludedebutizer--excludepython-debian>constraints.txtLintingDebutizer makes use of a few linting tools to keep code style consistent and to
reduce bugs. The CI will run these for you and fail if there are issues, but
you may find it convenient to set up the pre-commit hooks as well.pre-commitinstallTestingDebutizer uses PyTest for automated testing. Unit tests can be run with the
following command:pytesttests/unitUnfortunately, because integration tests build packages withpbuilder,
running integration tests requiressudo. Usingsudowith a virtualenv is
a bit tricky, but this unintuitive command will do it:sudo$(whichpython)-mpytesttests
Package: debyetools
debyetoolsImplementation of a tool for calculating self-consistent thermodynamic properties that can take into account all kinds of contributions to the free energy inluding explicit anharmonicity. The software presented here is based in the Debye approximation within the QHA using the crystal internal energetics parametrized at ground-state to project the thermodynamics properties at high temperatures.Made by Javier Jofre:javier.jofre@polymtl.caIf you usedebyetoolsin a publication, please refer to thesource code.  If you use the implemented method for the calculation of the thermodynamic properties, please cite the following publication:Jofre, J., Gheribi, A. E., & Harvey, J.-P. Development of a flexible quasi-harmonic-based approach for fast generation of self-consistent thermodynamic properties used in computational thermochemistry. Calphad 83 (2023) 102624. doi:https://doi.org/10.1016/j.calphad.2023.102624.@article{,
      author = {Javier Jofré and Aïmen E. Gheribi and Jean-Philippe Harvey},
      doi = {10.1016/j.calphad.2023.102624},
      issn = {03645916},
      journal = {Calphad},
      month = {12},
      pages = {102624},
      title = {Development of a flexible quasi-harmonic-based approach for fast generation of self-consistent thermodynamic properties used in computational thermochemistry},
      volume = {83},
      year = {2023},
   }Requirements for Python module:numpympmathscipyRequirements for Interface:For the interface it will also be necesary:matplotlibPySide6Installationpip install --upgrade debyetoolsGet startedTo start getting familiar with the interface you can downloadexamples input files.
The GUI can be launched by executing the interface script from the debyetools repository main folder:python interface.pyOr you can launch  inside python:from debyetools.tpropsgui.gui import interface
interface()Debye tools can also be used as a library. Example: heat capacity of Al fcc using 3rd order Birch-Murnaghan EOSimportnumpyasnpimportdebyetools.potentialsaspotentialsfromdebyetools.ndebimportnDeb# EOS parametrization# =========================EOS_parameters=[-3.607736520e+05,9.929277050e-06,7.729289055e+10,4.604381753e+00]EOS=potentials.BM()EOS.fitEOS([0],[0],initial_parameters=EOS_parameters,fit=False)# Other Contributions parametrization# =========================p_electronic=[3.8027342892e-01,-1.8875015171e-02,5.3071034596e-04,-7.0100707467e-06]mass=0.026981500000000002Tmelting=933p_defects=8.46,1.69,Tmelting,0.1p_anharmonicity=0,1p_XS=0,0,0poissonsratio=0.37# F minimization using Slater approximaiton# =========================ndeb=nDeb(poissonsratio,mass,p_anharmonicity,EOS,p_electronic,p_defects,p_XS,mode='jjsl')T_initial,T_final=0.1,1000T=np.arange(T_initial,T_final,10)Pressure=0T,V=ndeb.min_G(T,EOS_parameters[0]*.9,P=Pressure)# Evaluation of thermodynamic properties# =========================tprops_dict=ndeb.eval_props(T,V,P=Pressure)To Do's:Improve error handlingImprove DocumentationAdd handling of anisotropic materialsPrediction of explicit anharmonicity parameters