Saravanan666/pypi-org huggingface dataset:
Package: konbinine
konbiniおまえはもうショットいる。なに？！Opinionated wrapper for Autodesk Shotgun I meanShotGrid Python APIbecause the API usage requirements is 便利じゃないでしょう？コンビニね～ As there is an existing PyPI project usingkonbininame, this repo project name
on PyPI will bekonbinine.How to UseFor Python 3.8 and newer! While Autodesk madeshotgun_api3to be compatible with Python 2 and 3,konbinineusesdataclassthat is only available in Python 3.7 onwards. Starting with v0.1.6, Python 3.8 will be the minimum
version due to the usage of TypedDict.konbinineis designed to be used with web framework (such as Django, Flask, etc.) that interacts with ShotGrid. This
library has not been tested inside Digital Content Creation (DCC) software such as Maya, 3ds Max or Houdini.Technically it should just work but that is outside the scope of this library.New ProjectFirst time setupAddkonbinineto your project'srequirements.txt.???Profit (in improving code readability and debugging)Using konbinineI recommend configuring the environment variables before running the following code.Set it using your.envfile or through the shell session etc.# if your studio subscribed to Shotgun prior to the ShotGrid rename, the URL should# looks like https://yourstudioname.shotgunstudio.com or somethingKONBINI_BASE_URL=https://yourstudioname.shotgrid.autodesk.comKONBINI_SCRIPT_NAME=YOURSHOTGRIDAPISCRIPTNAMEHEREKONBINI_API_KEY=YOURSHOTGRIDAPIKEYHEREfromkonbinineimportKonbinifromkonbinine.enumsimportSgEntitykon=Konbini()booking_schemas=kon.get_sg_entity_schema_fields(SgEntity.BOOKING)# whatever booking schemas results hereExisting Project that Uses shotgun_api3You will need to... rewrite/refactor your code to usekonbinine! Pretty much the main reason whykonbininewas
created is to improve the Developer Experience (DX) when interacting with ShotGrid.Quickstart for Developerspip install -r requirements.txtExtending konbinineComing soon!TODOImplementSequencedataclassHandle Image/Movie upload gracefully (currently for Project entity only)
Package: koncept
Koncept Image Quality Assessment Modelsfrom kuti import applications as apps
from kuti import generic as gen
from kuti import image_utils as iu
import pandas as pd, numpy as np, os, urllib

# download and read the meta-data for the KonIQ-10k IQA database
koniq_meta_url = "https://github.com/subpic/koniq/raw/master/metadata/koniq10k_distributions_sets.csv"
urllib.request.urlretrieve(koniq_meta_url, 'koniq10k_distributions_sets.csv')
df = pd.read_csv('koniq10k_distributions_sets.csv')

# download some images from the test set of the database via direct link
url_list = 'http://media.mmsp-kn.de/koniq10k/1024x768/' + df[df.set=='test'].image_name[::50]
gen.make_dirs('tmp/')
for url in url_list:
    file_name = url.split('/')[-1]
    urllib.request.urlretrieve(url, 'tmp/'+file_name)

from koncept.models import Koncept512
k = Koncept512()

# read images and assess their quality
images = [iu.read_image(p) for p in 'tmp/' + df[df.set=='test'].image_name[::50]]
MOS_pred = k.assess(images)

# compare with the ground-truth quality mean opinion scores (MOS)
MOS_ground = df[df.set=='test'].MOS[::50]
apps.rating_metrics(MOS_ground, MOS_pred);
Package: koncert
:studio_microphone: KONCERT : NICE 본인인증 스크래핑NICE 본인인증 스크래핑 라이브러리ORCINUS: 해군교육사령부 모바일 인터넷편지 시스템을 만들면서 본인 인증을 서비스 내부로 집어넣어야 했는데, 구현 과정에서 분리시킨 프로젝트입니다.NICE 본인인증의 패킷 요청 및 응답을 분석하고,지원 서비스NICE 휴대폰본인확인사용방법참고NICE아이디 휴대폰본인확인 서비스 설명 페이지
Package: konch
Configures your Python shellkonchis a CLI and configuration utility for the Python shell, optimized for simplicity and productivity.Automatically importany object upon startupSimple, per-project configuration in a single file (it’s just Python code)No external dependenciesUsesIPython,BPython, orptpythonif available, and falls back to built-in interpreterAutomatically loadIPython extensionshttps://konch.readthedocs.io
Package: kondo
KondoThe name is inspired byMarie Kondo's tidying adventures.Throw away experiments that don't spark joy with this tiny module.InstallationPyPIpip install kondoSourcepip install git+https://github.com/activatedgeek/kondo.git@masterNOTE: Prefer pinning to a reference than the master branch for unintended updates.Minimal Usage ExampleCreate newExperimentclassfromkondoimportSpec,Experiment,RandIntType,ChoiceTypeclassMyExp(Experiment):def__init__(self,foo=100,bar='c',**kwargs):super().__init__(**kwargs)self.foo=fooself.bar=bardefrun(self):print('Running experiment with foo={}, bar="{}".'.format(self.foo,self.bar))@staticmethoddefspec_list():return[Spec(group='random',params=dict(foo=RandIntType(low=10,high=100),bar=ChoiceType(['a','b','c'])),n_trials=3,),Spec(group='fixed_foo',params=dict(foo=200,bar=ChoiceType(['a','b','c'])),n_trials=3,)]Make sure to capture all keyword arguments to the super class using**kwargsas above.CreateHyperparameterspecfromkondoimportHParamshparams=HParams(MyExp)HParamsclass automagically recognizes all the possible parameters to the
experiment specified as arguments to the constructor with default values. Thespeccan be any key value pairs (and can include constant values which will
remain common across all trials).Other types available can be seen inparam_types.py.Generate trials and create a new experiment each timefor_,trialinhparams.trials():exp=MyExp(**trial)exp.run()A sample output for these three trials with randomly selected values forfooandbaris shown below. Each line represents the dictionary sent in to the
constructor of theMyExpclass.Runningexperimentwithfoo=93,bar="b".
Runningexperimentwithfoo=30,bar="c".
Runningexperimentwithfoo=75,bar="c".
...You can also generate trials from only a subset of groups by using thegroupsargument asfor_,trialinhparams.trials(groups=['fixed_foo']):# ... same as earlierignore_groupsis a similar argument with the filtering out effect.Now, you can keep tuning the spec during your hyperparameter search andthrow
away the ones that don't spark joy!.The full example file is available atbasic.py.Advanced UsageSeeExperimentobject for other important attributes.
The only thing to care about are@propertyannotated methods, especially the
ones for logging.Thetestsdirectory is a good place to discover all possibilities.LicenseApache 2.0
Package: kondo-ml
kondo-MLkondo-ML is a package containing various instance selection algorithms
usable with regression models. The implementations are compatible with sklearn and follow
its outlier detection interface.This is still a work in progress and some documentation is missing. Please refer to the source code
for each algorithm in the instance_selection folder.InstallThe package can be installed via pippip install kondo_mlOverview of algorithmsAlgorithmGoalRegCNNSize reductionRegENNNoise filterRegENNTimeNoise filter/drift handlingDROP-RXNoise filter/size reductionShapleyUtility assignmentFISHDrift HandlingSELCONSize reductionMutual InformationNoise filterAlgorithm sourcesRegCNN & RegENN:https://link.springer.com/chapter/10.1007/978-3-642-33266-1_33DROP-RX:https://www.sciencedirect.com/science/article/abs/pii/S0925231216301953Shapley:https://proceedings.mlr.press/v97/ghorbani19c/ghorbani19c.pdfFISH:http://eprints.bournemouth.ac.uk/18567/1/FISH_journal_preprint.pdfSELCON:https://arxiv.org/abs/2106.12491Mutual Information:https://research.cs.aalto.fi//aml/Publications/Publication167.pdfThe SELCON implementation is taken from the author's github with minor changes:https://github.com/abir-de/SELCOnExample# import instance selection algorithm of your choice
from kondo_ml.instace_selection import RegENNSelector
# initialize selector 
reg_enn = RegEnnSelector(alpha=1,nr_of_neighbors=3)
# predict labels (1 to use that instance, -1 to ignore)
labels = reg_enn.fit_predict(X,y)
# transform -1/1 labels into boolean 0/1 labels
from kondo_ml.utils import transform_selector_output_into_mask
boolean_labels = transform_selector_output_into_mask(labels)
# use selected instances for model training (any model, LR here as an example)
from sklearn.linear_model import LinearRegression
model = LinearRegression().fit(X[boolean_labels],y[boolean_labels])More examples can be found in the notebooks of the examples folderContributionPlease feel free to contribute documentation, tests or new algorithms to this package.
And let me know if you find any mistakes in the implementations
Package: konductor
Yes, there is no documentation at the moment, its not really intended as usable to the outside world atm, I personally need a convenient pip install.KonductorModel training framework bundled with performance evaluation and comparison tools for rapid prototyping. Go deep into setting up automatic configuration for ablations or quickly throw in a dataloader, model and loss function and run distributed training in seconds.The aims of this project areEmpower you to only need to touch a few parts of the framework to get some wacky non-standard training loop done.Easily roll in existing code bases into this framework so you can git clone yolo-69, register it to konductor, throw in your data and start training instead of whatever random framework of their codebase.
Package: konduto-sdk
A Python SDK for integrating with theKonduto rest api. Compatible with python 3.6+, this repo not is a official repository from Konduto.
Feel free to contribute with the project.Getting StartedSetup a local environment:I expected that you already python3 installed in your machine$makesetupRunning testsThe CI command that setups all requirements and runs tests to assure everything is configured accordingly.$maketestLicenseCopyright Alefh Sousa 2020.Distributed under the terms of theMITlicense, konduto-sdk is free and open source software.
Package: konfchanger
KonfChangerThis project is a simple command line utility that can be used to backup and restore a set of configuration file and folders.Use CasesToggle light/dark themeBackup configs to replicate the same settings in another systemReplicate and automate basic system configs post installation of a new distroBackup existing configs to restore in case of session/distro breakand many more....TODOBackup current set of configurationsRestore a named config packRestore a named config pack with backing up current set of configurationsSchedule applying of config packsSchedule backing-up of set of configsAdd back/restore options for ApplicationsAtomChromeLatte DockVimKonsoleProvide configuration file to give options on source for backup and restoreProvide options to add folder/files to add for back/restore thus entending to uncovered applications and settingsProvide option to listen to events and change configurations based on the change
Package: konfi
konfikonfi lets you create config templates similar todataclasses.
These templates are then used to load the config from different sources.
konfi guarantees that the loaded config corresponds to the template even
going as far as making sure items of a list are of the right type.This means you no longer have to worry about the validity of the config,
if the config is correct it will load and if it isn't it will raise an
error telling you why not.InstallationYou can install konfi fromPyPI:pipinstallkonfiExamplefromtypingimportOptionalimportkonfi@konfi.template()classUserInfo:name:strcountry:Optional[str]@konfi.template()classAppConfig:name:str="konfi"user:UserInfokonfi.set_sources(konfi.YAML("config.yml",ignore_not_found=True),konfi.Env(prefix="app_"),)config=konfi.load(AppConfig)greeting=f"Hello{config.user.name}"ifconfig.user.country:greeting+=f" from{config.user.country}"print(greeting)print(f"Welcome to{config.name}!")For more examples see theexamples/directory.DocumentationIf you're ready to jump in, you can find the documentation onRead the Docs.
Package: konfigmapedit
KonfigmapeditEdit multi-file Kubernetes configmaps by downloading them into a folder, let you edit in a shell and uploads them.InstallationYou can install the Konfigmapedit from PyPi:pip install konfigmapeditThe konfigmapedit is supported on Python 3.6 and above on Linux/MacOS.How to use# This creates a temp dir on a local machine and downloads a kubernetes configmap into it and invokes a shell in the temp dir.
# The -n flag is the namespace and the configmap1 is the name of the configmap.
$ konfigmapedit -n app1 configmap1
configmap/configmap1 in namespace app1:
You are now in an interactive shell. Edit the configmap files and exit the shell to upload the changes.
$ konfigmapedit-g6r00xk9
# here you can use shell commands, like ls, vim, nano, etc. or just open it in any editor.
# after you finished the editing you can exit the shell (ctrl+D or exit command) and the konfigmapedit will display the changes and if you accept them it will upload the changes.k9s pluginYou can use it as a k9s plugin too, where Ctrl-F on configmaps will invoke this tool.Install instructions:https://k9scli.io/topics/plugins/plugin:editConfigMap:shortCut:Ctrl-Fdescription:Edit as filesscopes:-cmcommand:konfigmapeditbackground:falseargs:-'-n'-$NAMESPACE-$NAME
Package: konfik
>>The Strangely Familiar Config Parser<<Konfikis a simple configuration parser that helps you access your config variables using dot (.) notation.
This lets you to do this —foo_bar_bazz=config.FOO.BAR.BAZZ— instead of this —foo_bar_bazz=config["FOO"]["BAR"]["BAZZ"]Konfik currently supportsTOML,YAML,DOTENVandJSONconfiguration formats.⚙️ InstallationInstall Konfik via pip:pip install konfik💡 UsageLet's see how you can parse a TOML config file and access the configuration variables. For demonstration, we'll be using the followingconfig.tomlfile:# Contents of `config.toml`title="TOML Example"[owner]name="Tom Preston-Werner"dob=1979-05-27T07:32:00-08:00# First class dates[servers][servers.alpha]ip="10.0.0.1"dc="eqdc10"[servers.beta]ip="10.0.0.2"dc="eqdc10"[clients]data=[["gamma","delta"],[1,2]]Load the above config file and access the variables using dot notation:frompathlibimportPathfromkonfikimportKonfik# Define the config pathBASE_DIR=Path(__file__).parentCONFIG_PATH_TOML=BASE_DIR/"config.toml"# Initialize the konfik classkonfik=Konfik(config_path=CONFIG_PATH_TOML)# Print the config file as a Python dictkonfik.show_config()# Get the config dict from the konfik classconfig=konfik.config# Access and print the variablesprint(config.title)print(config.owner)print(config.owner.dob)print(config.database.ports)print(config.servers.alpha.ip)print(config.clients)The.show_config()method will print your entire config file as a colorized Python dictionary object like this:{'title':'TOML Example','owner':{'name':'Tom Preston-Werner','dob':datetime.datetime(1979,5,27,7,32,tzinfo=<toml.tz.TomlTzobjectat0x7f2dfca308b0>)},'database':{'server':'192.168.1.1','ports':[8001,8001,8002],'connection_max':5000,'enabled':True},'servers':{'alpha':{'ip':'10.0.0.1','dc':'eqdc10'},'beta':{'ip':'10.0.0.2','dc':'eqdc10'}},'clients':{'data':[['gamma','delta'],[1,2]]}}Konfik also exposes a few command-line options for you to introspect your config file and variables. Run:konfik --helpThis will reveal the options associated with the CLI tool:Konfik -- The strangely familiar config parser ⚙️

usage: konfik [-h] [--path PATH] [--show] [--show-literal] [--var VAR] [--version]

optional arguments:
  -h, --help      show this help message and exit
  --path PATH     add config file path
  --show          print config as a dict
  --show-literal  print config file content literally
  --var VAR       print config variable
  --version       print konfik-cli version numberTo inspect the value of a specific variable in a./config.tomlfile you can run:konfik --path=config.toml --var=servers.alpha.ip✨ 🍰 ✨
Package: konfsave
KonfsaveKonfsave is a config manager. That is, it allows you to save, back up, and easily switch between different (per-user) system configurations.
Each configuration is stored as a profile; the script allows you to save the current configuration as a named profile,
and then load them by name. It's also possible to take these profiles somewhere else by exporting or importing them, or just copying their folder.By default, Konfsave manages your KDE configuration - specifically, its appearance and workspace settings. This can be easily changed inconfig.ini.
If you'd like to learn more about how to adjust the configuration, see thewiki.
You can also specify additional files to include or exclude once using command line options.Inspired byhttps://github.com/Prayag2/konsave.RequirementsPython 3.8+ is required. On some systems, this means that you must usepython3instead ofpython.Installation & UsageThe configuration file,config.ini, is stored in$XDG_CONFIG_HOME/konfsave(usually it's~/.config/konfsave).Usage instructions can be viewed withkonfsave --help.There are 2 installation options:PyPIKonfsave is onPyPI, which means that it can be installed withpip:python -m pip install konfsaveAfter this, you should be able to run Konfsave directly from the terminal. If not, trypython -m konfsave.The crude wayThis method is not recommended unless you're debugging or rewriting Konfsave.__main__.pycan be run as is; just download the repository.
You can also runinstall.shwhich will copy files to.configand link__main__.pyto.local/bin/konfsave.
Unlike the PyPI method, this will not allow you to easily update the program.Future featuresStandardizing groups so that someone else's profile can specify what it supportsOptionally storing profiles as Git repositories and syncing them using remotesLicenseCopyright (c) 2021 Illia Boiko (selplacei) and contributors. All source code in this repository may only be used under the terms and conditions found in the LICENSE file.
Package: kong
KongKong is a simple interface to Kongregate (http://www.kongregate.com/)
statistics. It was originally written to provide 360 Kid-style statistics
reporting, as a small boredom-based project, and has not really grown since
its inception.Usage>>> import kong
>>> api = kong.Kongregate()
>>> user = kong.User(api, "MostAwesomeDude")BugsNo bugs currently known. Feel free to email the author or open new bugs on
github.LicenseKong and all other files in this package are available under the terms of the
MIT X11 license, reproduced in COPYING and also in the library.Changelog0.2.1Add changelog to distribution.0.2Fixed README.Added changelog.Removed print statements from library.Created real API objects: Kongregate, User, KongException.Cleaned up code, improved run times.0.1Initial import.Added setup.py.Split off scripting functionality into separate script, scripts/kongregate.
Package: kongalib
Libreria Python di comunicazione con i serverEasyByte Konga. Tramitekongalibè possibile connettersi ad un server Konga (integrato in Konga Pro o
standalone in Konga Server), eseguire query sui database e manipolarne i dati
facilmente. La libreria comprende anche i moduli aggiuntivikongauiekongautil, utili ad interfacciarsi ed integrarsi con Konga e Konga Client.InstallazioneSono forniti pacchetti wheel binari per sistemi operativi Windows, macOS e Linux;
l’installazione per questi sistemi è pertanto banale e si effettua tramitepip:pip install kongalibCompilazione manualeSe si desidera è possibile compilare i sorgenti. I prerequisiti per compilarekongalibsono i seguenti:WindowsSono supportate le versioni di Windows dalla 7 in su. Come prerequisiti è
necessario installare:Microsoft Visual Studio 2017SDK di KongaMacOS XSono supportate le versioni di macOS dalla 10.8 in su. Come prerequisiti è
necessario installare:XCode (assicurarsi di aver installato anche i tool da linea di comando)SDK di KongaLinuxBenchè il pacchetto binario wheel per Linux supporti tutte le distribuzioni
Linux moderne (specificamanylinux), al momento la compilazione da parte di
terzi è supportata ufficialmente solo se si usa una distribuzione Linux basata su
Debian, in particolare Ubuntu Linux dalla versione 16.04 in su. Sono necessari i
seguenti pacchettideb:build-essentialg++python-deveasybyte-konga-devLa compilazione è possibile tramite la usuale procedura dei pacchetti Python:python setup.py installNoteSotto piattaforma Windows per la corretta compilazione è necessario
impostare la variabile d’ambienteKONGASDKalla directory d’installazione
dell’SDK di Konga. Notare inoltre che l’SDK di Konga è compilato con
Visual Studio 2017 e non è compatibile con Python 2.x (che sotto Windows
richiede Visual Studio 2008); se si desidera usarekongalibcon Python 2.x
sotto Windows, è necessario usare lawheelprecompilata installabile
tramitepip.RisorseDocumentazione di kongalibLa documentazione della libreria per la versione ufficiale corrente e per
le versioni     ufficiali passate è sempre accessibile da qui.Documentazione del dizionario dei datiPer informazioni circa la struttura dei database Konga (nozione necessaria
per accedere correttamente ai dati)Script di utilità comune per KongaGli script contenuti in questo repository possono essere utati come esempi
nell’uso di kongalib.
Package: kong-batch
KongDocumentationWhat does this do?Suppose you use a batch cluster somewhere to run parallel workloads. Normally
you'd write dedicated submission code for each type of system and use the
relevant shell commands to monitor job progress. How do you keep track
of what happened to jobs? How do you even keep track of which job did what?With kong, you can organize your jobs intofolders(not actual folders on disk),
however you feel like it. Kong can keep track of job statuses and reports
them to you in a clean and organized view. You can manage your jobs
in kong, kill them, resubmit them, remove them. Kong also normalizes things
like where the your job can find scratch space, where to put log files
and where to put output files. This is done by a set of environment variables
available in every job, regardless of backend (calleddriver):variable namevalueKONG_JOB_IDKong-specific job ID (not the batch system one)KONG_JOB_OUTPUT_DIRWhere to put output filesKONG_JOB_LOG_DIRWhere log files goKONG_JOB_NPROCHow many core your job can useKONG_JOB_SCRATCHDIRscratch dir for the jobYou can write job scripts that are mostly agnostic to which driver is
used to execute the job. Some things remain specific to your environment,
especially things that are implemented on top of the actual batch system. This
includes things like licenses, queue names, and any other specific configuration.
Kong allows you to provide arguments like this either via configuration, or on
a job by job basis.InterfaceREPLKong provides a command line like program. If you run
Package: kong-config-builder
Kong Config BuilderKong declarative configuration builder.This project translates Python files toKong Declarative configuration Yaml files. Most of times you don't need a database, just more organization.InstallUsing Python 3.7+pipinstallkong_config_builderUsageTake a look atExample File.ContributeFor development and contributing, please followContributing GuideandALWAYSrespect theCode of Conduct
Package: kong-control-plane
kong-control-planeUse this Kong CDK Construct Library to deploy Kong control plane on Amazon EKS .This CDK library automatically creates and configures recommended architecture on AWS by:Amazon EKSWell architected EKS cluster from networking standpointCluster autoscalerNode termination handlerSecrets management from AWS Secrets Manager using CSI drivermTLS using AWS ACM for pod to pod communication using private certificate authority and aws-pca-issuerUse of IAM Role for Service Account (IRSA) where applicableAWS EKS encryption at restMetrics server installationLogs and metrics to cloudwatch using AWS CloudWatch Container insightsElasticacheprivate accessibilitymulti azauto failoverauto minor version upgradecwl outputRDS FeaturesEncryption at restPrivate subnetsMultiazauto backupLogs output to CloudWatchnpm Package Installation:yarn add --dev kong-control-plane
# or
npm install kong-control-plane --save-devPyPI Package Installation:pip install kong-control-planeSampleTry outhttps://github.com/kong/aws-samplesfor the complete sample application and instructions.Resources to learn about CDKCDK TypeScript WorkshopVideo Introducing CDK by AWS with DemoCDK ConceptsRelatedKong on AWS Hands on Workshop -https://kong.awsworkshop.io/Kong Data plane on AWS contruct - FILLME