Saravanan666/pypi-org huggingface dataset:
Package: expi-skel
Theexpi_skelpackage provides a template for creating packages
for theExtender Package Index(expi).  In addition to preconfigured
standard Python packaging files, such assetup.pyandMANIFEST.in,
the skeleton contains a sampleexpi.jsonfile andvi/directory.To create your own package, export theexpi_skel repositoryand use it as a
template:git clone https://bitbucket.org/cbinckly/expi_skel.git my_package_nameTheexpi.jsonfile contains additional metadata about the package, such
as compatible Sage 300 and Orchid Extender versions, which Sage Views and
Screens are involved, and information on visibility and licensing.The additional metadata enablesexpito automatically generate package
landing pages and selectively serve packages only to authorized users. It
enables thePython Package Manager for Extenderto perform
compatiblity checking so customizations are only ever installed on compatible
systems.Thevidirectory may contain Extender modules,*.vifiles, that
will be registered with Extender automatically after the Python package
installation has completed.
Package: expkg
Copyright (c) 2018 The Python Packaging AuthorityPermission 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: expl
DescriptionGenerate Exploit TemplateI've written this template generator to write my exploits.InstallationInstall frompip:pipinstallexplInstall from sourceclone it from repo:gitclonehttps://github.com/AlirezaKm/explInstall from source:cdexpl
pipinstall-e.Usage$explUsage: expl [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  both    Generate a Template for Local and Remote
  local   Generate Local Template
  remote  Generate Remote TemplateMore Info about commands$expllocal--helpUsage: expl local [OPTIONS] FILE

  Generate Local Template

Options:
  -a, --arch TEXT      Architecture of Executable File  [default: x86_64]
  --os TEXT            OS of Executable File  [default: linux]
  -e, --endian TEXT    OS of Executable File  [default: little]
  -l, --loglevel TEXT  Log Level of pwntools  [default: info]
  -r, --realpath TEXT  using realpath for Executable File  [default: False]
  --libc TEXT          Address of LIBC
  --heap               Adding heap functions
  -o, --output TEXT    write to output
  --help               Show this message and exit.Generate a template for a Local Executable File$expllocalvuln#!/usr/bin/python2frompwnimport*context(arch='x86_64',os='linux',endian='little',log_level='info')definfo(s):log.info(s)defexploit(r):r.interactive()if__name__=='__main__':r=process(['vuln'])print(util.proc.pidof(r))pause()exploit(r)
Package: explabox-demo-drugreview
explabox-demo-drugreviewWelcome to the demo of theexplaboxon theUCI Drug Reviewsdataset. To speed up the demo, we made a smaller subset of the train and test dataset. The demo
also includes a pretrained black-box classifier, which aims to predict whether areviewin the text got aratingofnegative(1-5),neutral(5-6) orpositive(6-10).To start the demo, you require:Python 3.8 or above (see theinstallation guide)Jupyter Notebook installed (see theinstallation guide)Install the demo via:pip3 install explaboxpip3 install explabox-demo-drugreviewImporting the necessary filesTo start the demo, open your Jupyter Notebook and run the following line:fromexplabox_demo_drugreviewimportmodel,dataset_fileThedataset_fileis the location of the dataset (drugsCom.zip), containing a train split (drugsComTrain.tsv) and test split (drugsComTest.tsv). You can import this dataset with theexplaboxwith the data in the columnreviewand labels in the columnrating:fromexplaboximportimport_datadata=import_data(dataset_file,data_cols='review',label_cols='rating')The model can directly be imported as-is. Make sure you explicitly include thatdrugsComTrain.tsvincludes thetrainsplit anddrugsComTest.tsvthetestsplit of the data:fromexplaboximportExplaboxbox=Explabox(data=data,model=model,splits={'train':'drugsComTrain.tsv','test':'drugsComTest.tsv'})Now you are ready to.explore,.examine,.exposeand.explainwith theexplabox!DocumentationHaving trouble? Want to know which functionalities theexplaboxincludes? Check out the documentation athttps://explabox.rtfd.io.
Package: explainability-challenges
explainability-challengesTestingThe test suite is executable via thepytestpackage.
First, installpytestwithpipinstallpytestThen, install the package locally for development purposes by runningpipinstall-e.in the root directory of the project.
Finally, run the test suite withpytestTo run only fast tests, runpytest-m"not slow"OS-Specific IssueFor Windows devices, if the script hangs due tokaleido, runpipuninstallkaleido
pipinstallkaleido==0.1.0.post1
Package: explainable-ai-image-measures
Compute IAUC, DAUC, IROF scores to measure the quality of image attributions (PyTorch)This package allows to evaluate the quality of attributions wrt. to your original iamge.
For that purpose, you can compute IAUC (Insert Area Under Curve, Insertion score), DAUC (Delete Area Under Curve, Deletion score) and IROF (Iterative Removal Of Features).Install viaPyPi:pip install explainable-ai-image-measuresThe shared idea behind all of them is to remove the most relevant pixels from the original image and replace it by a baseline color (DAUC, IROF) or to take blank a blank image and add the most relevant pixels again starting with the most relevant (IAUC). In contrast to IAUC and DAUC, IROF does this superpixel-wise.Create new images by removing / adding pixels / entire areasSend the newly created images through the network and save the probabilities.Compute the Area Under the Curve (AUC) for the recorded probabilities.Interpretation: For DAUC lower scores are better, for IROF and IAUC higher scores.In contrast to other publicly available code,all of the heavy computation is running on the GPU (no numpy or CPU in between)you can compute the scores for a single image also batch-wisethere is parametrization possible to suit your needsIAUC, DAUC and IROF is possible using a single packagemultiple attributions for multiple images are possible (see example.ipynb)Here a minimal code for a single image:importtorchfromcaptum.attrimportSaliencyimporttorchvision.modelsasmodelsfromexplainable_ai_image_measuresimportMeasuresdevice=torch.device("cuda"iftorch.cuda.is_available()else"cpu")model=models.resnet18(pretrained=True).to(device)image=torch.rand((1,3,224,224)).to(device)attribution=Saliency(model).attribute(image,target=17)# Average the attribution over the color channelsattribution=torch.mean(attribution,dim=1)measure=Measures(model,batch_size=250,irof_segments=70)score,y=measure.compute_IROF(image[0],attribution[0],17)
Package: explainable-cnn
Explainable CNNs📦 Flexible visualization package for generating layer-wise explanations for CNNs.It is a common notion that a Deep Learning model is considered as a black box. Working towards this problem, this project provides flexible and easy to usepippackageexplainable-cnnthat will help you to create visualization for anytorchbased CNN model. Note that it uses one of the data centric approach. This project focusses on making the internal working of the Neural layers more transparent. In order to do so,explainable-cnnis a plug & play component that visualizes the layers based on on their gradients and builds different representations including Saliency Map, Guided BackPropagation, Grad CAM and Guided Grad CAM.Architechture:star: Star us on GitHub — it helps!UsageInstall the packagepipinstallexplainable-cnnTo create visualizations, create an instance ofCNNExplainer.fromexplainable_cnnimportCNNExplainerx_cnn=CNNExplainer(...)The following method calls returnsnumpyarrays corresponding to image for different types of visualizations.saliency_map=x_cnn.get_saliency_map(...)grad_cam=x_cnn.get_grad_cam(...)guided_grad_cam=x_cnn.get_guided_grad_cam(...)To see full list of arguments and their usage for all methods, please refer tothis fileYou may want to look at example usage in theexample notebook.OutputBelow is a comparison of the visualization generated between GradCam and GuidedGradCamContributors ✨Thanks goes to these wonderful people (emoji key):Ashutosh Hathidara💻🎨🔬🚧✅⚠️Lalit Pandey🔬📖This project follows theall-contributorsspecification. Contributions of any kind welcome!ReferencesGrad-CAM: Visual Explanations from Deep Networks via Gradient-based LocalizationGrad CAM demonstrations in PyTorch
Package: explainable-exceptions
explainable-exceptionsArtificial Intelligence is being used in several fields, including
computer engineering and programming.During this work, we pretend to facilitate the process of programming as
much as possible adding the option to use a NLP (Natural Language
Processing) model to help the user to understand and solve the
exceptions that may appear while programming.As simple as using a magic cell, the user will be able to send the
exception to thehuggingface chatand
obtain a possible solution to solve the exception. In this process, the
user must be logged in his huggingchat account. Credentials can be saved
to be requested only once.After receiving the response, the user will be able to request another
response if the given one is not helpful enough.InstallTo installexplainable_exceptionsyou must use the following pip
command:pipinstallexplainable_exceptionsHow to useIn order to use the magic cell, we need to import it from thecoreofexplainable_exceptions. The cell is calledexplain.After that, we can label cells using the magic cell command (%%). We can
provide a huggingchat user or we can just use the command (if there are
not credentials, then it will ask to generate them).If an exception is raised inside a magic cell, it will be sent to the
huggingchat model to generate a possible solution. This response will be
shown by the jupyter standard output.fromexplainable_exceptions.coreimportexplainA usage example could be:%%explain`username`importrandomrandom.choice([])Whereusernamemust be replaced (if provided) by the username of the
huggingchat account that will be used to request information.#%%explain ruescogimportrandomrandom.choice([])CRITICAL:root:Traceback (most recent call last):
  File "/home/ruescog/explainable-exceptions/explainable_exceptions/core.py", line 81, in explain
    exec(cell, globals(), local_ns)
  File "<string>", line 5, in <module>
  File "/grupoa/config/miniconda3/lib/python3.8/random.py", line 290, in choice
    raise IndexError('Cannot choose from an empty sequence') from None
IndexError: Cannot choose from an empty sequence

WARNING:root:Be careful, the following response has been generated automatically by a Natural Language Processing Model, so the answer may be incorrect or false.Huggingchat response(online version):That error is raised byrandom.choice()function which is used for
generating random elements from iterables like lists, strings etc., and
it seems that there might be no element available to pick from.To fix
the issue you need to ensure that either pass some argument to the
function or check if any item exists before calling the function on that
object.You can refer to python documentation for more details :Random
Functions. In case you face similar issues please feel free to ask me , i am here
to help you :) . Also I am just starting so would love if you could rate
interact with me as well.Do you need another answer? (y/n) n

IndexError: Cannot choose from an empty sequence
Package: explainable-rl
What is Explainable-RL?Explainable-RL is a Python package that provides a framework for explainable reinforcement learning (XRL), specifically for
pricing and business decisions. It allows users to upload any pricing dataset and train a tabular RL agent to learn the optimal
pricing policy. It has been created with speed and memory requirements in mind, and is able to train agents on large, multidimensional
datasets quickly. The package also provides a suite of explainability tools to help users understand the agent's decision-making process.Full documentation can be foundhere.A full demo can be found in the onboarding Jupyter notebook, found in the project'sGitHub.
Package: explainable-transformer
Explainable TransformersInstall by running following command:pip install explainable-transformers==0.2.0Usagefrom explainable_transformers.text_classification import TextClassificationExplainer

model_path = "cardiffnlp/twitter-roberta-base-sentiment-latest"
explainer = TextClassificationExplainer(model_path=model_path)

inp = ["I like you. I love you."]
shap_values = explainer.get_shap_values(inp)

print(shap_values.base_values)
print(shap_values.values)Future Scope:Want to give an option to enter either a single example or an entire dataset!For single example:Output is for localText Plot is enoughEntire Dataset:
_ Reason: To explain model outputs on a global scale
_ Output:A plot for global values (Required): Waterfall Plot!Download option for shap values of datasetSupport for multiple model types and NLP tasks!
Package: explainaboard-cli
ExplainaBoard CLIInstallFor CLI userspip install explainaboard_cliFor CLI developerspip install .UpdateThere are two packages associated with this CLI:explainaboard_api_clientandexplainaboard_cliexplainaboard_api_client: auto generated according to OpenAPI definition specified inopenapi.yaml. Version of this client is specified in the same yaml file (info.version).To update:pip install -U explainaboard_api_clientor specify a specific versionTo check the API version used in the live environment:curl https://explainaboard.inspiredco.ai/api/info(this information will be added to the UI in the future)explainaboard_cli: a thin wrapper for the API client to make it easy to use. It helps users configure API keys, choose host names, load files from local FS, etc. Usually, this package is relatively stable so you don't need to update unless a new feature of the CLI is released.To update:pip install -U explainaboard_cliPlease see examples in./tests
Package: explainaboard-client
ExplainaBoard ClientThis is a command line and API client that makes it easy for you to evaluate systems
usingExplainaBoard.PreparationInstall:First, install the client.pipinstallexplainaboard_clientAcquiring a Login and API Key:Create an account at theExplainaBoardsite and log in. Once you are logged in, you can click on
the upper-right corner of the screen, and it will display your email and API key, which
you can copy-paste.You can save these into environmental variables for convenient use in the commands
below:export EB_USERNAME="[your username]"
export EB_API_KEY="[your API key]"Use in PythonThe most common usage of this client will probably be to
evaluate systems on the ExplainaBoard server.
Below is an example of how you can do this in Python.importosimportexplainaboard_client# Set up your environmentexplainaboard_client.username=os.environ['EB_USERNAME']explainaboard_client.api_key=os.environ['EB_API_KEY']client=explainaboard_client.ExplainaboardClient()# Do the evaluationevaluation_result=client.evaluate_system_file(task='text-classification',system_name='text-classification-test',system_output_file='example/data/sst2-lstm-output.txt',system_output_file_type='text',dataset='sst2',split='test',source_language='en',)For more details on precisely how to specify all the variables, as well as how to do
other things such as search for and delete systems, see thedocumentation of the Python API.Use from the Command LineYou can also evaluate systems from the command line like this.python-mexplainaboard_client.cli.evaluate_system\--tasktext-classification\--system-nametext-classification-test\--system-output-fileexample/data/sst2-lstm-output.txt\--system-output-file-typetext\--datasetsst2\--splittest\--source-language'en'For more details, see thecommand line documentation.Having Trouble?Pleaseopen an issueon the
issues page and we'll be happy to help!
Package: explainax
Explainax: An Explainable AI Library for JAXInstallation|Documentationexplainaxis a JAX library for model explanation and interpretation.InstallationSimply install viapypi:pipinstallexplainax--upgradeOr upgrade to the latest version ofexplainax:pipinstallgit+https://github.com/BirkhoffG/explainax.git--upgrade
Package: explainerdashboard
This package makes it convenient to quickly deploy a dashboard web app
that explains the workings of a (scikit-learn compatible) fitted machine
learning model. The dashboard provides interactive plots on model performance,
feature importances, feature contributions to individual predictions,
partial dependence plots, SHAP (interaction) values, visualisation of individual
decision trees, etc.The goal is manyfold:Make it easy for data scientists to quickly inspect the inner workings andperformance of their model with just a few lines of codeMake it possible for non data scientist stakeholders such as co-workers,managers, directors, internal and external watchdogs to interactively
inspect the inner workings of the model without having to depend
on a data scientist to generate every plot and tableMake it easy to build a custom application that explains individualpredictions of your model for customers that ask for an explanationExplain the inner workings of the model to the people working withmodel in a human-in-the-loop deployment so that they gain understanding
what the model does do and does not do.
This is important so that they can gain an intuition for when the
model is likely missing information and may have to be overruled.The dashboard includes:SHAP values (i.e. what is the contribution of each feature to eachindividual prediction?)Permutation importances (how much does the model metric deterioratewhen you shuffle a feature?)Partial dependence plots (how does the model prediction change whenyou vary a single feature?Shap interaction values (decompose the shap value into a direct effectan interaction effects)For Random Forests and xgboost models: visualization of individual treesin the ensemble.Plus for classifiers: precision plots, confusion matrix, ROC AUC plot,PR AUC plot, etcFor regression models: goodness-of-fit plots, residual plots, etc.The library is designed to be modular so that it is easy to design your
own custom dashboards so that you can focus on the layout and project specific
textual explanations of the dashboard. (i.e. design it so that it will be
interpretable for business users in your organization, not just data scientists)A deployed example can be found athttp://titanicexplainer.herokuapp.com
Package: explain-me
Explain MeExamplefrom explain_me.visual import visualize_package





with open('preview.html', 'w+') as file:
    file.write("""
<html>
    <body>
        <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
        <script>
            mermaid.initialize({ startOnLoad: true });
            
            
//get svg element.
var svg = document.getElementsByTagName('svg')[0];

            
            
        </script>

        <div class="mermaid">
            classDiagram
    """)
    

    for line in visualize_package(nama_library):
        file.write(line+"\n")

    file.write("""
            
        </div>
        <a id="link" href="#">download</a>
    </body>
</html>
        """)
Package: explibrosa
explibrosaExploration and feature generation for speech in audio files using the librosa library in PythonInstallationTo install explibrosa use pip:pip install --index-urlhttps://test.pypi.org/simple/example_pkgNote: we currently use the test.pypi since we are still testing and experimenting.Installation instructions for librosa:You can use pip install librosaSee also:https://librosa.github.io/librosa/install.html
Package: explicit-di
Explicit DIA library for explicit Dependency InjectionDocumentation:https://depeche-py.github.io/explicit-di/Source code:https://github.com/depeche-py/explicit-diExplicit DI is modern Python library for explicit Dependency InjectionRequirementsPython 3.9+Installationpipinstallexplicit-di# ORpoetryaddexplicit-diExampleimportexplicit_dias_diclassA:passclassB:def__init__(self,a:A,config:str):self.config=configself.a=aclassC:def__init__(self,b:B):self.b=bdefcreate_b(a:A):returnB(a=a,config="foo")deffunction_with_dependencies(one:int,two:str,my_c:C):print(my_c)defmain():container=_di.Container()container.register(A)container.register(B,create_b)container.register(C)b=container.resolve(B)assertisinstance(b,B)container.inject(function_with_dependencies,one=1,two="two")
Package: explicit-django
Explicit-DjangoНабор компонентов для интеграции Explicit с Django.Базовая единица работы на транзакциях Django ORM.# persons/core/unit_of_work.pyfromexplicit.django.unit_of_workimportBaseUnitOfWorkfrompersons.core.persons.adapters.dbimportRepositoryasPersonsRepositoryfrompersons.core.persons.adapters.dbimportrepositoryaspersons_repository# (имя атрибута, инстанс репо)KNOWN_REPOS=(('persons',persons_repository),)classUnitOfWork(BaseUnitOfWork):persons:PersonsRepositorydef__init__(self,*args,**kwargs):super().__init__(*args,**kwargs)self._registry.register(*KNOWN_REPOS)Декоратор для преобразования ошибок валидации предметной области в ошибки валидации Djangofromexplicit.django.domain.validation.exceptionsimporthandle_domain_validation_errorclassViewSet(...):@handle_domain_validation_errordefcreate(self,request,*args,**kwargs):command=Command(...)bus.handle(command)Запуск тестов$toxe30984f (EDUEO-552 Вынос интеграции с django в отдельный пакет.)
Package: explicit-kafka
Explicit-KafkaНабор компонентов для интеграции explicit с kafka.Содержит реализацию адаптера обмена сообщениями через Kafka.Пример использованияНастройка адаптера# persons/core/apps.pyfromdjango.apps.configimportAppConfigasAppConfigBaseclassAppConfig(AppConfigBase):name=__package__def_setup_adapter(self):fromexplicit.kafka.adapters.messagingimportAdapterfromexplicit.kafka.adapters.messagingimportPublishConfigfromexplicit.kafka.adapters.messagingimportSubscribeConfigfrompersonsimportcore# конфигурация адаптераadapter_base_config={'bootstrap.servers':'kafka:9092'}publish_config=PublishConfig(adapter_base_config)subscribe_config=SubscribeConfig(adapter_base_config|{'group.id':f'edu.persons'})adapter=Adapter(subscribe_config=subscribe_config,publish_config=publish_config)core.adapter=adapterdefready(self):self._setup_adapter()Отправка сообщений# persons/core/persons/services/handlers/events.pydefon_person_created(event:'PersonCreated',messaging_adapter:'AbstractMessagingAdapter'):messaging_adapter.publish('edu.persons.person',event.dump())Подписка на сообщения# education/entrypoints/eventconsumer.pydefbootstrap():importjsonfromeducation.coreimportadapterfromeducation.coreimportbusfromeducation.core.persons.domain.eventsimportPersonCreatedTOPIC_EVENTS={'edu.persons.person':PersonCreated,}formessageinadapter.subscribe(*TOPIC_EVENTS):formessageinadapter.subscribe(*TOPIC_EVENTS):event=TOPIC_EVENTS[message.topic()](**json.loads(message.value()))bus.handle(event)bootstrap()Запуск тестов$tox
Package: expliot
EXPLIoTNoun: /ɛkˈsplʌɪəti:/A Framework for security testing and exploiting IoT products and IoT
infrastructure. It provides a set of plugins (test cases) which are used to
perform the assessment and can be extended easily with new ones.The nameEXPLIoT(pronouncedexpl-aa-yo-tee) is a pun on the wordexploitand explains the purpose of the framework i.e. IoT exploitation.It is written in Python.WebsiteOnline shop(for related hardware)DocumentationDiscord chat roomsAdditional resourcesIssues and bug reportsSource repository