Saravanan666/pypi-org huggingface dataset:
Package: ing-theme-matplotlib
ing-theme-matplotlibing_theme_matplotlibis a python package with a light and a darkmatplotlibandseabornstyle that allows you to create your plots using ING colors and ING Me font. It was adapted from theqbstylespackage.Dark styleLight styleInstallationpipinstalling_theme_matplotlibUsageYou can use the dark Matplotlib style theme in the following way:froming_theme_matplotlibimportmpl_stylempl_style(dark=True)And to use the light Matplotlib style theme, you can do the following:froming_theme_matplotlibimportmpl_stylempl_style(dark=False)⚠️ Make sure to runfrom ing_theme_matplotlib import mpl_styleandmpl_style()indifferent cellsas shown above. Seethis issue.Adding ING LogoAssume that below is the function we use for plotting;defline_plot(ax):rng=np.random.RandomState(4)x=np.linspace(0,10,500)y=np.cumsum(rng.randn(500,4),0)ax.set_title('Line Graph')ax.set_xlabel('— Time')ax.set_ylabel('— Random values')ax.plot(x,y,label=['Bitcoin','Ethereum','Dollar','Oil'])ax.legend(['Bitcoin','Ethereum','Dollar','Oil'],loc=1,fontsize='medium')ax.set_xlim([0,10])ax.set_ylim([-20,60])ax.figure.set_figwidth(16)ax.figure.set_figheight(8)ax.spines['right'].set_position(('axes',1.05))ax.spines['right'].set_color('none')You can add the default ing logo to your plot by calling add_logo function inside the plotting function.froming_theme_matplotlib.mpl_styleimportadd_logompl_style()line_plot(add_logo())You can also add custom logos to your plot by giving the path where the image is located.froming_theme_matplotlib.mpl_styleimportadd_logompl_style(dark=False)line_plot(add_logo(bottom_left='ing_theme_matplotlib/logos/RPAA_Logo_RGB_Line.png'))For more examples seeExamplePlots.ipynb.Seaborn UsageSimilar to above, you can implement plots in Seaborn. The main difference is how the logo is added.mpl_style(dark=False)defbar_plot():logo=add_logo()tips=sns.load_dataset("tips")ax=sns.barplot(x="tip",y="day",data=tips,ax=logo.axes)bar_plot()For more examples see [Example Seaborn Plots.ipynb](Example Seaborn Plots.ipynb).Supported chart typesLine plotsScatter plotsBubble plotsBar chartsPie chartsHistograms and distribution plots3D surface plotsStream plotsPolar plotsplt.Figure()It is important to note that we useplt.Figure_ING()in place ofplt.Figure()due to changes in Matplotlib version 3.4.1.
Asplt.subplots()works smoothly, it is best to stick to that methodology.What licence do we use?ING Style plotting is licensed under theApache 2.0 License.ing-theme-matplotlibis forked fromqbstyles.
Package: ingzero
ing0Producitivty tool to workaround dubious complexity.Usage:

  ing0 baggify
  ing0 summary
  ing0 fastapi routes
  ing0 vm available
  ing0 vm create NAME DISTRIBUTION RELEASE ARCH
  ing0 vm exec NAME [COMMAND ...]
  ing0 vm spawn NAME
  ing0 vm boot NAME
  ing0 sqli NAME
Package: inheritance
inheritance models for mendelian diseases-----------------------------------------[![Build Status](https://travis-ci.org/brentp/inheritance.svg?branch=master)](https://travis-ci.org/brentp/inheritance)This module is a general-purpose framework for evaluating if a family exihibits, for example, and autosomal dominant pattern.The logic for this was tuned in [gemini](https://github.com/arq5x/gemini) but we make it available here as a more general purpose library to encourage:1. community driven improvements2. use outside of gemini3. more comprehensive testingFinding variants that match autosomal dominance in a trio, for example is very simple to find,however, after considering multiple generations, arbitrary family sizes, depth cutoffs, and unknowngenotypes and phenotypes to support to real-world datasets it becomes tedious and error-prone.Supported inheritance tests===========================+ autosomal dominant+ autosomal recessive+ de novo+ X-linked dominant, recessive, and de novo+ compound heterozygote+ mendelian violationUsage=====For now, the use is via api only. Users can look at the tests to see how to use. Most functions have a signature like:```Pythonauto_dom(self, min_depth=0, gt_ll=False, strict=True, only_affected=True)```where the arguments enforce a minimum depth, a maximum genotype likelihood, strictness (mostly related to parent-offspring requirements)and wether to allow unaffecteds to have the variant (or be homozygous alt).ToDo====1. add support for X-linked soon.2. add a simple example of running on a VCF+PED3. code coverage4. code documentationTesting=======Tests can be run as:```nosetests --with-coverage -x --with-doctest --cover-package inheritance```Overview========the generic code is in `inheritance/inheritance.py` and a specific implementation that we use in gemini is in `inheritance/pyeval.py`.To make this available for a new resource, for example to `bcftools` we would look at the implementation of Filter in `inheritance/pyval.py`and make the generated strings match those expected by `bcftools`.
Package: inheritance-explorer
Theinheritance_exploreris an open source python package for inspecting
other packages. In particular, it focuses on class inheritance structures, allowing
you to produce graphs that recursively map out child classes from a given
starting class. There are a number of useful applications: from learning structures
of unfamiliar code bases to identifying duplicate code.Useful links:github repository,full documentationInstallationTo install the latest release into your current active environment:$pipinstallinheritance_explorerIf you want to produce static images of any graphs, you’ll also need to
installgraphvizfollowing the instructions athttps://graphviz.org/download/.graphvizis not needed for the interactive plotting and similarity calculations (see
Quick Start below).Quick StartBasic class mappingThe primary function of theinheritance_exploreris to trace out the class
inheritance starting from a single parent class and recursively traversing all
child classes. To get started, initialize aClassGraphTreewith the starting
class:frommatplotlib.axesimportAxesfrominheritance_explorerimportClassGraphTreebase_class=Axes# the starting class to map fromcgt=ClassGraphTree(base_class)# traces an inheritance treeFrom here, there are a number of ways to visualize the inheritance graph.From a jupyter notebook, you can construct apyvisinteractive network graphwith:graph=cgt.build_interactive_graph(width="1200px",height="1200px",bgcolor='#222222',font_color='white')graph.show('_tmp.html')# render the pyvis interactive graphIf you havegraphvizinstalled, you can also render a static graph either todisplay in a jupyter notebook or save to file. To display in a notebook:cgt.show_graph()To save a file, you can access the underlyinggraphobject directly:cgt.graph.write('matplotlib_Axes.png')Function trackingTheClassGraphTreecan also track a selected function of a class during traversal.
When a child class overrides the function, the source code is stored. To use this
functionality, use thefuncnamekeyword argument to provide the function name
as a string:frommatplotlib.axesimportAxesfrominheritance_explorerimportClassGraphTreebase_class=Axes# the starting class to map fromcgt=ClassGraphTree(base_class,funcname='clear')By default, after the traversal completes, the different versions of the function
that is tracked will be run through a code-similarity calculation. Cases where the
similarity fraction is above a cutoff value (default of .75), the two nodes will be
connected on the resulting graph:Additionally, you can inspect the source code itself for any of the classes that
define it usingcgt.get_source_code(class_name). If in a jupyter notebook,
you can view it with syntax highlighting withfromIPython.displayimportCodeCode(cgt.get_source_code('PolarAxes'),language="python")For a complete description of the code similarity calculation and how to
modify it, check out the full documentation.Command line usageinheritance_explorerprovides some command line functionality, check thefull documentationfor details.
Package: inheritson
InheritsONFill in missing data that is inherited by a reference field in a flat list of dictionaries without inheritance depth limit.Name is a portmanteau of Inheritance and JSON.Usage>>>frominheritsonimportfill>>>fill([{"id":"parent","common":"value"},{"id":"child","parent_id":"parent"},{"id":"grandchild","parent_id":"child"}])[{'id':'parent','common':'value'},{'id':'child','common':'value','parent_id':'parent'},{'id':'grandchild','common':'value','parent_id':'child'}]
Package: inhoj
[![Build Status](https://travis-ci.org/mtchavez/python-package-boilerplate.png?branch=master)](https://travis-ci.org/mtchavez/inhoj)
[![Requires.io](https://requires.io/github/mtchavez/python-package-boilerplate/requirements.svg?branch=master)](https://requires.io/github/johnidm/inhoj/requirements?branch=master)The set of the useful Python code snippets## Install` pip install inhoj `## Why?## Features#### Print in terminal with colors#### Catch signals to allow graceful process shutdown## RequirementsPackage requirements are handled using pip. To install them do` pip install-rrequirements.txt `## TestsTesting is set up using [pytest](http://pytest.org) and coverage is handled
with the pytest-cov plugin.Run your tests with`py.test`in the root directory.Coverage is ran by default and is set in the`pytest.ini`file.
To see an html output of coverage open`htmlcov/index.html`after running the tests.## Travis CIThere is a`.travis.yml`file that is set up to run your tests for python 2.7
and python 3.2, should you choose to use it.
Package: inhpc-dm
inhpc_dmJupyterLab extension for InHPC-DE data managementWORK IN PROGRESS!RequirementsJupyterLab >= 3.0OverviewThis extension consists of a front-end part (basically an enhanced filebrowser) and a back-end (server) part,
that has the job of mounting remote file systems and invoking transfer commands.ContributingDevelopment installNote: You will need JupyterLab and NodeJS to build the extension package.# Clone the repo to your local environment# Change directory to the inhpc_dm directory# Install packagepipinstall.# Link your development version of the extension with JupyterLabjupyter-labextensionbuild.# Enable server extensionjupyterserverextensionenable--userinhpc_dm# Rebuild extension Typescript source after making changesjlpmrunbuild# Run Jupyter labjupyter-labUninstallpipuninstallinhpc_dm
Package: inhum
inhumDeveloper GuideSetup# create conda environment$mambaenvcreate-fenv.yml# update conda environment$mambaenvupdate-ninhum--fileenv.ymlInstallpipinstall-e.# install from pypipipinstallinhumnbdev# activate conda environment$condaactivateinhum# make sure the inhum package is installed in development mode$pipinstall-e.# make changes under nbs/ directory# ...# compile to have changes apply to the inhum package$nbdev_preparePublishing# publish to pypi$nbdev_pypi# publish to conda$nbdev_conda--build_args'-c conda-forge'$nbdev_conda--mambabuild--build_args'-c conda-forge -c dsm-72'UsageInstallationInstall latest from the GitHubrepository:$pipinstallgit+https://github.com/dsm-72/inhum.gitor fromconda$condainstall-cdsm-72inhumor frompypi$pipinstallinhumDocumentationDocumentation can be found hosted on GitHubrepositorypages. Additionally you can find
package manager specific guidelines oncondaandpypirespectively.
Package: ini2csv
INI2CSVA simple utility that converts and combines a folder of .ini files with identical keys into one csv file. The keys of the .ini files become the headers of the csv file, and the values of each file become a row.Package Installation and Usageini2csv is available on PyPI and can be installed usingpip:pip install ini2csvTo use ini2csv, the library needs to first be imported in your project:import ini2csvIncluded functionsini2csv has two main interface functions:process_folderandprocess_filesEach of these functions take two arguments.process_foldertakes in thefolder nameandoutput .csv file nameas arguments.process_filessimilarly takesa list of file namesandoutput .csv file nameas arguments.# Argument listprocess_folder(folder_name:str,output_filename:str)process_files(file_names:List[str],output_filename:str)Use CaseSuppose you have a folder of .ini files, where each file contains data for one instance of an item. Each file thus represents one row in a .csv file, and each key in the file represents the headers in the .csv file. A folder of such .ini files can then be converted into a csv file and saved for ease of other pre-existing data-processing pipelines.
Package: ini2toml
ini2tomlAutomatically translates.ini/.cfgfiles intoTOMLImportantThis project isexperimentaland under active development
Issue reports and contributions are very welcome.DescriptionThe original purpose of this project is to help migratingsetup.cfgfiles
toPEP 621, but by extension it can also be used to convert any compatible.ini/.cfgfile toTOML.Please notice, the provided.ini/.cfgfiles should follow the same syntax
supported by Python’sConfigParserlibrary (here referred to as INI syntax)
and more specifically abide byConfigUpdaterrestrictions (e.g., no
interpolation or repeated fields).Usageini2tomlcomes in two flavours:“lite”and“full”. The “lite”
flavour will create a TOML document that does not contain any of the comments
from the original.ini/.cfgfile. On the other hand, the “full” flavour
will make an extra effort to translate these comments into a TOML-equivalent
(please notice sometimes this translation is not perfect, so it is always good
to check the TOML document afterwards).To get started, you need to install the package, which can be easily done
usingpipx:$pipxinstall'ini2toml[lite]'# OR$pipxinstall'ini2toml[full]'Now you can useini2tomlas a command line tool:# in you terminal$ini2toml--help$ini2tomlpath/to/ini/or/cfg/fileYou can also useini2tomlin your Python scripts or projects:# in your python codefromini2toml.apiimportTranslatorprofile_name="setup.cfg"toml_str=Translator().translate(original_contents_str,profile_name)To do so, don’t forget to add it to yourvirtual environmentor specify it as aproject dependency.More details aboutini2tomland its Python API can be found inour docs.TipIf you consider contributing to this project, have a look on ourcontribution guides.NoteThis project was initially created in the context of PyScaffold, with the
purpose of helping migrating existing projects toPEP 621-style
configuration when it is made available onsetuptools.
For details and usage information on PyScaffold seehttps://pyscaffold.org/.
Package: iniabu
IntroductionThe goal of this project is to give you access
to various published solar abundance tables of elements as isotopes
from a Python terminal.
As one might guess,iniabustands for initial abundances.
Functions that are useful for everyday’s life as an
astrophysicist, cosmo-, or geochemist,
are here made available in an easy to use interface.
More information can also be found in thescientific background sectionin the documentation.
Aside from querying the databases,
theiniabutool allows you directly
to calculate isotope ratios,
δ-values,
or ratios in bracket notation
for fast comparison with your observations or measurements.
These calculations can also be performed “numpy-style”,
i.e., element-wise on whole arrays.The iniabu project is a young undertaking
of the newly establishedGalactic Forensics Laboratory.
We strive to support the open source culture
and would be happy to hear how you use this tool,
but also to see what you would like to have improved.To get you started,
check out theInstallation and Usagepage.
If you would like to contribute,
which we for sure welcome,
please have a look at our,
hopefully detailed,Developers Guide.
We welcome all contributions,
from simple typo fixes in the documentation,
to feature contributions!InstallationThe stable version of this package
is available and PyPi
and can be installed as:$pipinstalliniabuAlternatively,
you can install the latest version
directly from GitHub:$pipinstallgit+https://github.com/galactic-forensics/iniabu.gitIssues and feature requestsIf you find a bug or have other problems or questions
with this project, have a look at theGitHub issue page.
Your issue might already have been discussed.
Otherwise feel free to open a new issue.
Please be as detailed as possible.If you would like a new feature,
please feel free to file a feature request.
If you are interested in contributing
this feature yourself, say so and we can
help to get you started.ContributingContributions to this project are welcome.
Please see theDevelopers Guidefor detailed instructions on how to contribute.Relationship to previous packageThis package is in its idea based on a
software package that was was written at
Lawrence Livermore National Laboratory,
and replaces that specific package,
which can in it’s archived form be foundhere.
That package’s latest release was v0.3.1
and it was released under GPLv2.
Note that the codebase for this version was
rewritten from ground-up.This new and improved version
is available on PyPi
and replaces the previous version there.
The new package is not backwards compatible
and is initially released as v1.0.0.
Package: iniconf
Iniconf is a simple and easy to use tool for creating and parsing INI files.To create an INI file:from iniconf.creator import IniCreator
cfg = IniCreator('/path/to/template/file.ini', '/path/to/destination/file.ini')
cfg.generate_file()To read a configuration:from iniconf.config import Config
cfg = Config(['/path/to/file1.ini', '/path/to/file2.ini', '/path/to/folder/full/of/files'])
print cfg.config
Package: iniconfig
iniconfig: brain-dead simple parsing of ini filesiniconfig is a small and simple INI-file parser module
having a unique set of features:maintains order of sections and entriessupports multi-line values with or without line-continuationssupports “#” comments everywhereraises errors with proper line-numbersno bells and whistles like automatic substitutionsiniconfig raises an Error if two sections have the same name.If you encounter issues or have feature wishes please report them to:https://github.com/RonnyPfannschmidt/iniconfig/issuesBasic ExampleIf you have an ini file like this:# content of example.ini[section1] # commentname1=value1# commentname1b=value1,value2# comment[section2]name2=line1line2then you can do:>>>importiniconfig>>>ini=iniconfig.IniConfig("example.ini")>>>ini['section1']['name1']# raises KeyError if not exists'value1'>>>ini.get('section1','name1b',[],lambdax:x.split(","))['value1', 'value2']>>>ini.get('section1','notexist',[],lambdax:x.split(","))[]>>>[x.nameforxinlist(ini)]['section1', 'section2']>>>list(list(ini)[0].items())[('name1', 'value1'), ('name1b', 'value1,value2')]>>>'section1'ininiTrue>>>'inexistendsection'ininiFalse
Package: ini-config-parser
ini_config_parserProvides convenient interface for easily managing multiple enviroments (ex: test, prod) just from one config.iniUsage# config_parser.pyini_parser_singleton=IniParserSingleton().get_environment_as_cmd_arg()config=ini_parser_singleton.config# config.pyfromconfig_parserimportconfigPORT=config("PORT",int)TOKEN=config("TOKEN"); config.ini[global]PORT=1000TOKEN=""[prod]PORT=8000TOKEN="foo"[test]TOKEN="bar"Now if you runpython3 your_project.py prod: PORT == 8000 and TOKEN == "foo"
If you runpython3 your_project.py test: PORT == 1000 and TOKEN == "bar"You can also get current environment from file:# config_parser.pyini_parser_singleton=IniParserSingleton().get_environment_from_file(".env")
Package: ini-config-reader
This is a simple project to read python configurations from INI files.
Has the following features:It uses the Singleton pattern to configure the reader only once and
used it across an application.Reloads the configurations when the configuration file is changed.Read OS variables as Strings, e.g., ‘%(LANG)s’The configurations are automatically converted to a python data typeCollect a configuration section as a dictionaryThe available data types are: - Strings, surrounded by ‘’ or “” -
Integers - Floats - Lists, [1,2,3] - Dictionaries, {‘test’: {‘is_dict’:
True}}InstallingTo use the config_reader simple install using pip$pipinstallini-config-readerRequirementsPython3 tested for versions 3.5, 3.6 and 3.7UsageThe conf_reader has three class variables, INI_FILE, RELOAD and
DICT_CACHE.VariableDescriptionINI_FILEPath to the file that contains the configurationsRELOADSet if the INI file should be reloaded when changes are detectedDICT_CACHEWhen collecting the section as dictionary store it in a dict to avoid processing the readingRegular usageSince the config_reader implements the singleton pattern the user only
needs to configure the INI_File once. Then the get method and
get_section_dict can be used as static methods.fromconf_reader.readerimportConfReaderConfReader('/etc/configuration/my_config.ini')ConfReader.get('Section_1','configuration_1')# Can be used in different modulesDecoratorThe config_reader uses a decorator to inject configuration in
functions. To use it the INI_FILE must be already configured and a
config variable must exist in the function’s signature.fromconf_reader.readerimportConfReader,read_conf@read_conf("SECTION_1",'config_2')defread_with_arguments(*args,config,**kwargs):passConfReader('/etc/configuration/my_config.ini')read_with_arguments()LicenseThis project is licensed under the MIT License - see theLICENSE.txtfile for details
Package: inifaction
Overviewinifactionmakes possible to write an INI style file and setup aWebfactionproject with it through Webfaction’sAPI.It has a command line utility but it’s possible to also use the API implementation ofinifactionas a module.Command line utilityCreate a template to configure a project:inifaction template -f config.iniAfter making the needed changes, call the API of Webfaction and setup the project:inifaction setup -f config.iniIf any error happens, it will continue with the setup. Later on, you can setup only the section where the error happened:inifaction setup -f config.ini -s domainsAs a moduleThe API is created instantiatinginifaction.api.APIwith the URL as parameter. Login requires user, password and the machine:# Setup the API
from inifaction import API_URL
from inifaction.api import API

api = API(API_URL)
api.login('user', 'password', 'Web210')All the configuration sections of Webfacion’s API are available atinifaction.itemsas items. Those items hold all the needed information to call the API with certain parameters, depending on the API’s call.For example, we can create an email address:from inifaction.items import Email

email = Email('example@email.net', ['example_target_mailbox', 'target@emai.net'],
            autoresponder_on=True, autoresponder_subject='Hi!', autoresponder_message='Hello!',
            autoresponder_from='dont-answer@email.net', script_machine='', script_path='')Calling the item’sargsfunction with the API call type (create,updateordelete), returns the needed parameters to making that call. This happens automatically on API’s level:# Create the email
api.create(email)

# Change the item and update it
email = email._replace(email_address='other@emai.net')
api.update(email)

# Check if it exists
api.exists(email)

# List all the emails
api.list('emails')

# Delete the email
api.delete(email)

# Delete all the emails
api.delete_all('emails')It’s possible to subclass the default items and create customized ones, it only requires to changeinifaction.SECTIONSandinifaction.NAMESvalues to point to the customized item.
Package: inifini
inifiniA Python multipurpose framework for building any web-serverNothing is done yetInstallationpipinstallinifiniReason for this FrameworkDeveloping a web-server should be funStoryI was trying to develop something with Flask (came first to my mind)
but I needed a background-worker which collided Flasks reloading system.
Like a normal programmer, instead of searching for an alternative framework
I just decided to make my own.
And I also didn't need the template-engine as the frontend would
be developed with a proper web-framework like react