Saravanan666/pypi-org huggingface dataset:
Package: inspectds
inspectdsA CLI utility to print metadata of datasets in various formats (e.g. NetCDF, zarr, GRIB etc)powered byxarrayPrerequisitesYou need the following binary dependencies:Python >= 3.9Optionally,eccodes, which  is necessary for GRIB support.InstallationThe recommended way of installation ispipx:pipx install inspectds

# or if you want support for GRIB

pipx install 'inspectds[grib]'If you want to install the latest development version from git, then use:pipx install 'git+https://github.com/pmav99/inspectds.git#egg=inspectds[grib]'UsageNetcdf$ inspectds tests/data/example_1.nc

Dimensions: (lat: 5, level: 4, lon: 10, time: 1)
Coordinates:
  * lat      (lat) int32 20 30 40 50 60
  * lon      (lon) int32 -160 -140 -118 -96 -84 -52 -45 -35 -25 -15
  * level    (level) int32 1000 850 700 500
  * time     (time) datetime64[ns] 1996-01-01T12:00:00
Data variables:
    temp     (time, level, lat, lon) float32 ...
    rh       (time, lat, lon) float32 ...Zarr$ inspectds tests/data/store.zarr

Dimensions: (lat: 19, lon: 36, time: 12)
Coordinates:
  * lat      (lat) int64 -90 -80 -70 -60 -50 -40 -30 ... 30 40 50 60 70 80 90
  * lon      (lon) int64 -180 -170 -160 -150 -140 -130 ... 130 140 150 160 170
  * time     (time) datetime64[ns] 2001-01-31 2001-02-28 ... 2001-12-31
Data variables:
    aaa      (lon, lat, time) int64 ...GRIB$ inspectds tests/data/example.grib

Dimensions: (number: 2, time: 3, isobaricInhPa: 2, latitude: 3, longitude: 4)
Coordinates:
  * number         (number) int64 0 1
  * time           (time) datetime64[ns] 2017-01-01 ... 2017-01-02
    step           timedelta64[ns] ...
  * isobaricInhPa  (isobaricInhPa) float64 850.0 500.0
  * latitude       (latitude) float64 90.0 0.0 -90.0
  * longitude      (longitude) float64 0.0 90.0 180.0 270.0
    valid_time     (time) datetime64[ns] ...
Data variables:
    z        (number, time, isobaricInhPa, latitude, longitude) float32 ...
    t        (number, time, isobaricInhPa, latitude, longitude) float32 ...More info:inspectds --helpDevelopmentmamba env create --file ci/py3.11.yml --name inspectds_dev
conda activate inspectds_dev
make init
make test
Package: inspected
Inspect.When documenting a library or software product written in Python, oftena README is not enough, but full-blown Sphinx is too much work or toorigid.Inspect is a command-line tool that will automatically document Pythoncode, but it returns the output as machine-readable JSON orhuman-readable Markdown, so you retain full control of how to render thedocumentation.Usage: inspect [] [options]Options: -m --markdown At what level to start headers. --include ...--exclude ...If you only need a single object documented (whether a function, a classor something else), you can use the.. raw:: html<object>argument:::# will only include documentation on `A`inspect fixtures/example.py AFiltering the output with ``--include`` and ``--exclude`` ensures thatyour code description only contains exactly what you want it to. Someexamples:::# only include class methods if they've been documentedinspect fixtures/example.py --include members.documented# only include classesinspect fixtures/example.py --include type:class# only document function `factorize` and class `Bean`inspect fixtures/example.py --include name:fun,name:B# only include documented methods on Bean# (these two are identical)inspect fixtures/example.py Bean --include documentedinspect fixtures/example.py --include name:Bean,members.documentedAs you can see, ``.`` traverses the hierarchy and ``:`` is the value totest against. (If you don't specify a value, we will test on presence.)``,`` separates multiple criteria that are OR'ed together.Todo:-  improve documentation-  unit test the filtering mechanism-  fill out missing information in the description JSON (if any)-  an ``intercalate`` utility that runs shell commands inside of ``%%``tags in a file and replaces the tags with the standard output fromthose commands
Package: inspect-it
Inspect.When documenting a library or software product written in Python, oftena README is not enough, but full-blown Sphinx is too much work or toorigid.Inspect is a command-line tool that will automatically document Pythoncode, but it returns the output as machine-readable JSON orhuman-readable Markdown, so you retain full control of how to render thedocumentation.Usage: inspect [] [options]Options: -m --markdown At what level to start headers. --include ...--exclude ...If you only need a single object documented (whether a function, a classor something else), you can use the.. raw:: html<object>argument:::# will only include documentation on `A`inspect fixtures/example.py AFiltering the output with ``--include`` and ``--exclude`` ensures thatyour code description only contains exactly what you want it to. Someexamples:::# only include class methods if they've been documentedinspect fixtures/example.py --include members.documented# only include classesinspect fixtures/example.py --include type:class# only document function `factorize` and class `Bean`inspect fixtures/example.py --include name:fun,name:B# only include documented methods on Bean# (these two are identical)inspect fixtures/example.py Bean --include documentedinspect fixtures/example.py --include name:Bean,members.documentedAs you can see, ``.`` traverses the hierarchy and ``:`` is the value totest against. (If you don't specify a value, we will test on presence.)``,`` separates multiple criteria that are OR'ed together.Todo:-  improve documentation-  unit test the filtering mechanism-  fill out missing information in the description JSON (if any)-  an ``intercalate`` utility that runs shell commands inside of ``%%``tags in a file and replaces the tags with the standard output fromthose commands
Package: inspect_mate
Welcome toinspect_mateDocumentationinspect_mate can easily separate:regular attribute.property attribute.regular method.static method.class method.all attributes,includeregular attributeandproperty attribute.all methods, include regular method,static methodandclass method.Quick LinksExampleimport:frominspect_mateimport(is_attribute,is_property_method,is_regular_method,is_static_method,is_class_method,get_attributes,get_property_methods,get_regular_methods,get_static_methods,get_class_methods,get_all_attributes,get_all_methods,)define a class:classBase(object):attribute="attribute"def__init__(self):self.initiated_attribute="initiated_attribute"@propertydefproperty_method(self):return"property_method"defregular_method(self):return"regular_method"@staticmethoddefstatic_method():return"static_method"@classmethoddefclass_method(cls):return"class_method"classKlass(Base):passinstance=Klass()usage:# tester_function(klass_or_instance, "attribute_name")>>>is_attribute(Klass,"attribute")True>>>is_property_method(Klass,"property_attribute")True>>>is_regular_method(Klass,"regular_method")True>>>is_static_method(Klass,"static_method")True>>>is_class_method(Klass,"class_method")True>>>is_attribute(instance,"attribute")True>>>is_attribute(instance,"initiated_attribute")True>>>is_property_method(instance,"property_attribute")True>>>is_regular_method(instance,"regular_method")True>>>is_static_method(instance,"static_method")True>>>is_class_method(instance,"class_method")True# getter_function(klass_or_instance), yield (attr, value)>>>get_attributes(Klass)[("attribute","attribute")]>>>get_property_methods(Klass)[("property_attribute","property_attribute")]>>>get_regular_methods(Klass)[("regular_method",Klass.regular_method)]>>>get_static_methods(Klass)[("static_method","Klass.static_method")]>>>get_class_methods(Klass)[("class_method","Klass.class_method")]>>>get_all_attributes(Klass)[("attribute","attribute"),("property_attribute","property_attribute")]>>>get_all_methods(Klass)[("regular_method",Klass.regular_method),("static_method","Klass.static_method"),("class_method","Klass.class_method")]Installinspect_mateis released on PyPI, so all you need is:$pipinstallinspect_mateTo upgrade to latest version:$pipinstall--upgradeinspect_mate
Package: inspector
Inspector is a re-implementation of Andrew Moffat’s Inspect-Shell
(https://github.com/amoffat/Inspect-Shell).What it doesInspector allows you to read, change or add global variables of your Python
program from another process (a shell) while your program is running.You could, for example, add a whole class to your program from the shell and
rewrite some function so that it starts using your newly-created class. All that
while your program continues to run! Yes, that’s pretty cool.How it worksInspector has 2 modes; server mode and shell mode. Server mode is run by your
Python program (in a separate thread), while the shell mode is run by the
inspector itself.Steps:addimport inspectorto your programrun your programrun the inspector withpython inspector.pytype code into the shellInspector also supports tab completion for your program’s variables.After you’re done, exit the shell by pressing Ctrl-D or Ctrl-C, or typingexit. You program will continue to run with all the changes made. You can run
the inspector again anytime you want.You can also import the inspector from a Python shell if you just want to see
how it works.Inspector works with Python 2 and 3. Seehttps://github.com/jzib/inspectorfor
more information.
Package: inspector-django
Inspector | Code Execution Monitoring ToolInspector is a Code Execution Monitoring tool to help developers find out technical problems in their application automatically, before customers do.RequirementsPython >= 3.xDjango >= 3.xInstallInstall the latest version of the package fromPyPI:pipinstallinspector-djangoConfigure the Ingestion KeyInsettings.pyadd the ingestion key of your project:INSPECTOR_INGESTION_KEY="xxxxxxxxx"Get a new Ingestion KeyYou can get a new key creating a new project in yourInspector dashboard.Activate the moduleAddinspector_djangoto installed apps:INSTALLED_APPS=[....,'inspector_django',]Register the middlewareTo monitor the incoming HTTP traffic you need to register the middleware.We suggest to add the middleware at the top of the list:MIDDLEWARE=['inspector_django.InspectorMiddleware',....]Ignore URLsIt could be needed to exclude some parts of your application from your monitoring data.
It could be something that doesn't impact your user experience, or if you prefer to focus your attention
on a small part of your system.TheINSPECTOR_IGNORE_URLalso support wildcards:INSPECTOR_IGNORE_URL=['static*','media*''assets*','js*','css*',]This is the default array. You have to copy this property in yoursettings.pyfile
and then add your custom entries.Official documentationCheckout ourofficial documentationfor more detailed tutorial.LicenseThis library is licensed under theMITlicense.
Package: inspectorio
Inspectorio API wrapperTheInspectorio API Wrapperis an unofficial Python library designed to facilitate interactions with theInspectorio API. This library offers a flexible interface supporting both synchronous and asynchronous operations to accessInspectorio'splatform, making it easier to integrateInspectorio'sfunctionalities into your Python applications.FeaturesSynchronous and Asynchronous Requests:Provides the flexibility to use Python's traditional synchronous or the async/await syntax for non-blocking API calls. This feature enables faster data retrieval, improved efficiency in I/O bound applications, and compatibility with various programming paradigms.Automatic Pagination Handling:Effortlessly manage API pagination with built-in methods to fetch all relevant data without manually handling page tokens or limits.Swagger Documentation Support:Directly based onInspectorio's Swagger documentation, ensuring comprehensive coverage of API endpoints and parameters.Secure Authentication:Simplified and secure handling of authentication tokens, abstracting the complexity of token management and headers.Error Handling:Provides structured error handling mechanisms, making it easier to debug issues related to API requests.DocumentationFor detailed information about the library's API, including classes, methods, and usage examples, please refer to theofficial documentationof the Python library.InstallationYou can installinspectoriodirectly from thePython Package Index (PyPI)following thispipcommand:pipinstallinspectorioUsageThe Inspectorio API Wrapper supports both synchronous and asynchronous interactions with the Inspectorio API. Here's how to get started with both:Synchronous UsageFor traditional blocking requests, you can use the InspectorioSight class. Here's a quick example to authenticate and list all reports:frominspectorio.sightimportInspectorioSight# Initialize the InspectorioSightapp=InspectorioSight()# Login with your credentialsusername="username@mail.com"password="__password__"app.login(username=username,password=password)# Fetch and list all reports, the method deals with paginationresult=app.list_all_reports()Asynchronous UsageIf your application requires non-blocking calls, replaceInspectorioSightwithAsyncInspectorioSight. This class offers the same functionalities but operates asynchronously:frominspectorio.sightimportAsyncInspectorioSight# For asynchronous operations, use the AsyncInspectorioSight class# Initialization and usage are similar to the synchronous version but with async/await syntaxasyncdefmain():app=AsyncInspectorioSight()awaitapp.login(username="username@mail.com",password="__password__")result=awaitapp.list_all_reports()# Remember to run your async function in an event loopBoth examples demonstrate how to authenticate and retrieve data from the Inspectorio API. Choose the approach that best fits your application's architecture.Code of ConductPlease note that theinspectorioproject is released with aContributor
Code of
Conduct.
By contributing to this project, you agree to abide by its terms.LicenseMIT © Matthias
Brenninkmeijer
Package: inspector-mils
inspector_milsInspect functions' arguments and keywords arguments at runtime using decorator.InstallationTo download inspector-mils, either fork this github repo or simply use Pypi via pippipinstallinspector-milsUsageImportinspectdecorator.frominspector_mils.inspectorimportinspectAdd@inspectto your function.@inspect
defmy_func_sample1(a,b):pass

my_func_sample1("param1","param2")Output[2022-11-0402:42:45.151303]Startinginspect..[2022-11-0402:42:45.151888]my_func_sample1()called..[2022-11-0402:42:45.151937]args:('param1','param2')[2022-11-0402:42:45.151978]kwargs:{}[2022-11-0402:42:45.152060]Endinginspect..LicenseMIT LicenseCopyright (c) 2022Permission 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: inspector-python
Inspector | Code Execution Monitoring ToolInspector is a Code Execution Monitoring tool to help developers find out technical problems in their application automatically, before customers do.RequirementsPython >= 3.xInstallInstall the latest version of the package from PyPI:pipinstallinspector-pythonGet a new Ingestion KeyYou need an Ingestion Key to create an instance of the Inspector class.You can obtain a key creating a new project in yourInspector dashboard.InitializationHere's a code example of how Inspector is normally initialized in a Python script:frominspectorimportConfiguration,Inspectorconfig=Configuration('xxxxxxxxxxxxxxxxxxx')inspector=Inspector(config)inspector.start_transaction('my python script')Official documentationCheckout ourofficial documentationfor more detailed tutorial.LicenseThis library is licensed under theMITlicense.
Package: inspectortodo
AboutInspectorTodo is a Python tool to track the status of todos in a software project, assuming that the project uses an
issue tracker, e.g. JIRA. In its simplest form it searches for all occurrences of the string TODO and checks whether it
is followed by an issue reference that is conform to a given regular expression.Download or clone this project and go to the resulting directory (Python >= 3.6 is required):pip install .Then you can run InspectorTodo:inspectortodo --helpIf you installed it in a virtualenv (which is recommended), then you always have to activate the virtualenv first.ExampleThe source code of InspectorTodo contains a small example project which can be parsed with the command (assuming you
are at project root of InspectorTodo)inspectortodo ./tests/inspectortodo/project_for_testing "IT-\d+" --version-pattern "Release-\d+" --version 2 --versions 1,2,3Traversing the folder treeInspectorTodo currently features two ways of traversing the folder tree of your project: iterating over all files on
OS level or iterating over all files under git control. The latter is used when the folder passed to InspectorTodo as
root dir is a git root.Config fileTo use advanced features you can use a config file by passing a file path via the --configfile option. If the file does
not exist a default config is created which you can adapt afterwards.If issues are tracked in an issue tracker like JIRA, InspectorTodo can validate whether issues that are referenced in a
todo are in an allowed status.JIRA serverConnection settings for a JIRA server.Issue filterA filter (currently tailored to Jira) that will only mark todos as invalid, if a field with namefilter_keyis present
and has at least one offilter_valuesvalues as its entry. Can be used,e.g.to show only todos pointing to issues
belonging to certain teams (e.g.on branches).StatusesA list of allowed statuses in the issue tracker, like "Backlog" or "Todo".FilesIf there are files in the project that should not be parsed (e.g. because they belong to another project), you can
configure a list of ignored paths here, relative to the project root. Compare the entries from the example config for
details.Copyright & LicenseInspectorTodo was conceived, written and executed byMartin Fink,Kai HelbigandWolfgang Münder.Licensed under the Apache License, Version 2.0 - seeLICENSE.mdin project root directory.
Package: inspect-requirements
Inspect requirementsInspect requirements is tool indendend to make it easier to compare requirements.txt files between multiple projects/applications.Basic usage:# e.g. in a directory structure as follows:$find.
./project1
./project1/requirements.txt
./project3
./project3/requirements-prod.txt
./project2
./project2/requirements
./project2/requirements/dev.txt# ..output would be like this:$inspect-requirements

Typeanumberor"q"tocontinue>a

Selectrepositories(or"a"forall)*1:project1
*2:project3
*3:project2

---Summary---
fastapi,2differentversions*project1/requirements.txt:"==0.75.0"*project3/requirements-prod.txt:"==0.74.0"*project2/requirements/dev.txt:"==0.74.0"starlette,1differentversions*project1/requirements.txt:"==0.19.1"*project3/requirements-prod.txt:"==0.19.1"*project2/requirements/dev.txt:"==0.19.1"psycopg2,2differentversions*project1/requirements.txt:"==2.9.3"*project3/requirements-prod.txt:*project2/requirements/dev.txt:"==2.9.3"pytz,1differentversions*project2/requirements/dev.txt:"==2022.1"
Package: inspektor
Inspektor is a program used to verify the code of your python project. It
evolved from a set of scripts used to check patches and code of python projects
of the autotest organization [1]. As the project grew and new modules started
to be developed, we noticed the same scripts had to be copied to each new
project repo, creating a massive headache when we needed to update said
scripts.Inspektor knows how to:Check code with the help ofpylint.Check indentation of your code with the help ofpycodestyle,
correcting it if you so deem appropriate.Check whether your code is PEP8 compliant, correcting it if necessary
(only works if you haveautopep8installed) if you so deem appropriate.If your project is hosted on the autotest github area, it can apply pull
requests made against it, and check if it introduced any regression from
the metrics outlined above.This all assumes you’re working on a version control checkout of your code.
Currently inspektor knows how to handle subversion and git.Installing inspektorYou can get inspektor through pip:$ sudo pip install inspektorBut you should avoid doing that if possible. A virtual environment deployment
tends to be better, since each installation is restricted to each environment:$ virtualenv .venv
$ source .venv/bin/activate
$ pip install inspektorIf you are developing inspektor, you can install it in your virtual environment
as an editable package. From this source code tree root:$ pip install -e .UsageGo to the root of your project source code cloneIf you want to check code with pylint:inspekt lintIf you want to check indentation:inspekt indentIf you want to check compliance to the PEP8:inspekt styleIf you want to check PR #123 for a project inside the autotest github area:inspekt github 123[1]http://autotest.github.io/
Package: inspeqai
Project DescriptionInspeqInstallationpipinstallinspeqaiGet API keysGet your API keys fromHereUsagefrominspeq.clientimportEvaluator#initializationinspeq_eval=Evaluator(sdk_api_key="YOUR_INSPEQ_API_KEY")# Example input datainput_data={"llm_input_query":"your_llm_input_query","llm_input_context":"your_llm_input_context","llm_output":"your_llm_output",}'''Note : Do not change the structure of input data keep the structure as itis. Put your data at places of your_llm_input_context, your_llm_input_queryand your_llm_output to  with the help of our evaluation metrices.'''print("\ngrammatical_correctness is:")print(inspeq_eval.grammatical_correctness(input_data))#get all metrices in one functioninspeq_instance.get_all_metrices(input_data)All Metrics provided by Inspeq sdkprint("\na. factual_consistency is:")print(inspeq_eval.factual_consistency(input_data))print("\nb. answer_relevance is:")print(inspeq_eval.answer_relevance(input_data))print("\nc. response_tone is:")print(inspeq_eval.response_tone(input_data))print("\nd. grammatical_correctness is:")print(inspeq_eval.grammatical_correctness(input_data))print("\ne. fluency is:")print(inspeq_eval.fluency(input_data))print("\nf. do_not_use_keywords is:")print(inspeq_eval.do_not_use_keywords(input_data))print("\ng. word_limit_test is:")print(inspeq_eval.word_limit_test(input_data))print("\nh.  conceptual_similarity is:")print(inspeq_eval.conceptual_similarity(input_data))Supported FeaturesMetrices:Factual Consistency:
Check if the generated text is consistent with known facts.Grammatical Correctness:
Assess the grammatical accuracy of the generated text.Do Not Use Keywords:
Identify and evaluate the use of specific keywords or phrases.Fluency:
Assess the overall smoothness and fluency of the generated textAnswer Relevance:
Determine the relevance of the generated text in the context of a given query orWord Limit Test:
Check if the generated text adheres to specified word limits.Response Tone:
Assess the tone and style of the generated response.Conceptual Similarity:
Measure how closely the generated text aligns with the intended conceptual content.
Package: inspie
- Intro:::::::::Inspie is an ever-expanding set of instagram services to help you meet your application challenges.It鈥檚 the freedom to manage instagram api on an easy way.- Installation:::::::::1. Clone.. code-block:: bashgit clone git@github.com:songroger/inspie.gitcd inspiepython setup.py install2. pip::pip install git+https://github.com/songroger/inspie.git@master- Usage:::::::::.. code-block:: pythonfrom inspie import InspieAPIi = InspieAPI("user", "pwd")photo_path = 'img_path'caption = "#tag caption!"i.upload_photo(photo_path, caption=caption)see more in examples_.. _examples: ./examples