Saravanan666/pypi-org huggingface dataset:
Package: kurvy
Kurvy ~ Trigonometric Curve Approximation Toolkit💡 What is it?kurvyis a Python package that helps approximate trigonometric curves by implementing a gradient descent algorithm.FeaturesFind the optimal parameters for trigonometric-like data.Customize training loops.Add momentum to parameter updates.Apply L2 regularization.Randomly generate trigonometric data and errors.🛠️ SetupInstall it fromPyPIby runningpip install kurvy.DependenciesThe code was written withPython 3.9.16, and it is recommended to run it in a virtual environment.
All the required libraries are listed in therequirements.txtfile in this repo.🚀 ExecutionOnce the package has been installed, it is simply a case of experimenting with the various classes and functions. For a quickstart, please see thedemo.📝 DocumentationDocumentation is currently available in the form of docstrings.⚖️ LicenseThe project is licensed under the MIT license.
Package: kuryr-kubernetes
Project descriptionKubernetes integration with OpenStack networkingThe OpenStack Kuryr project enables native Neutron-based networking in
Kubernetes. With Kuryr-Kubernetes it’s now possible to choose to run both
OpenStack VMs and Kubernetes Pods on the same Neutron network if your workloads
require it or to use different segments and, for example, route between them.Free software: Apache licenseDocumentation:https://docs.openstack.org/kuryr-kubernetes/latestSource:https://opendev.org/openstack/kuryr-kubernetesBugs:https://bugs.launchpad.net/kuryr-kubernetesOverview and demo:https://superuser.openstack.org/articles/networking-kubernetes-kuryrRelease notes:https://docs.openstack.org/releasenotes/kuryr-kubernetes/Contribution guidelinesFor the process of new feature addition, refer to theKuryr Policy.
Package: kuryr-tempest-plugin
Team and repository tagsTempest Integration of KuryrOverviewThis project defines a tempest plugin containing tests used to verify the
functionality of a kuryr installation. The plugin will automatically load
these tests into tempest.For more information about Kuryr see:https://docs.openstack.org/kuryr/latest/For more information about Kuryr-kubernetes see:https://docs.openstack.org/kuryr-kubernetes/latest/For more information about Tempest plugins see:https://docs.openstack.org/tempest/latest/plugin.htmlFree software: Apache licenseDocumentation:https://docs.openstack.org/kuryr-tempest-plugin/latest/Source:https://opendev.org/openstack/kuryr-tempest-pluginBugs:https://bugs.launchpad.net/kuryrInstallingClone this repository and call from the repo:$ pip install -e .Running the testsTo verify the functionality of Kuryr by running tests from this plugin;
From the tempest repo, initialize stestr:$ stestr initThen, to run all the tests from this plugin, call:$ tempest run -r 'kuryr_tempest_plugin.*'To run a single test case, call with full path, for example:$ tempest run -r 'kuryr_tempest_plugin.tests.scenario.test_cross_ping.TestCrossPingScenario.test_vm_pod_ping*'To retrieve a list of all tempest tests, run:$ tempest run -l
Package: kurzfile
Currently this provides classes and functions to parse and represent .KRZ/.K25
and .K26 files and a script to list all objects contained in such files.This is still alpha-quality software!There is a public, read-only Subversion repository for this package located atsvn://svn.chrisarndt.de/projects/kurzfile. To check out a working copy of
the current trunk, do:svn co svn://svn.chrisarndt.de/projects/kurzfile/trunk kurzfile
Package: kusp
KUSP: KIM Utility for Serving PotentialsThis utility package provides an easy and quick way to deploy any potential, ML
or otherwise to the KIM API. It is designed to be used as a quick prototyping and benchmarking
tool against OpenKIM tests and verification checks.
This ensures that any valid ML model is on equal footing with OpenKIM supported interatomic
potentials, and can directly guide uses in improving their models or datasets etc.Please note that KUSP is supplementary tool for model validation and development,
and for high performance production runs, you are advised to use the KIM model drivers.Difference between KUSP and TorchML model driverKUSP used Python interpreter to run any ML model in its native environment, and then
converts the output to KIM API compatible format. KIM API communicates with the model using
the KUSP Python server, which uses sockets to communicate.While this is easy and quick, it is  not the most efficient way to run ML models. Besides
the overhead of Python interpreter, you also have the communication overhead between
Python and C++ code, and overhead of the data transfer process, which is usually 100-400ms
per call. This is not a problem for very large models, but for small models, this overhead
can be significant.Also, KUSP is not designed to be portable from user to user, while with KIM API
you can install any model as simply askim-api-collections-management install user <model>.
Hence, while KUSP is good for prototyping, users are encouraged to covert their models
to KIM API compatible models, and use the KIM model drivers for production runs.KUSP ProtocolKUSP uses a simple protocol to communicate with the KIM API. The protocol expects the
configuration information in following order,[Necessary] First 4 bytes: size of integer on the system (int_width), 32 bit integer
    [Necessary] Next int_width bytes: number of atoms (n_atoms), default int_width integer
    [Necessary] Next int_width x n_atoms bytes: atomic numbers
    [Necessary] Next 8 x 3 x n_atoms bytes: positions of atoms (x, y, z), double precision
    [Optional] Next int_width x n_atoms bytes: Which atoms to compute energy for (contributing atoms)DependenciesKUSP is a minimal dependency package, but it requires KIM API to serve potentials in simulator
agnostic framework. Without KIM API user would need to implement own simulator interface.
To install KIM API, just use thecondapackage manager,condainstall-cconda-forgekim-api=2.3Environment VariablesTo tell the KUSP KIM API client where to find the KUSP server, you need to set the
environment variableKUSP_SERVER_CONFIGto the path of the configuration file.exportKUSP_SERVER_CONFIG=/path/to/kusp_server_config.yaml
Package: kustomize
Build your Kubernetes manifests for Kustomize in Python!PyPI:https://pypi.org/project/kustomize/Repository:https://github.com/yougov/python-kustomizeDocumentation:https://python-kustomize.readthedocs.io/en/latest/OverviewThe reason for this project to exist is to make it easier to create dynamic
manifests to be exported for usage in Kubernetes’ “Kustomize” tool. And, by
using Python and supporting the “dataclasses” language feature, it also helps
reducing boilerplate by encouraging code reuse.Kustomize, by itself, is already a very powerful tool, and it’s possible to
deal with different apps and environments by using the “overlays” approach; but
it’s not dynamic enough if you need to define manifests parameters through
environment variables, for example. So this project aims to cover that gap.A complement for KustomizeThis project is by no means a replacement for Kustomize, but rather a
complement. The idea is to generate kustomization files from Python files, and
then usekubectl apply-korkustomize buildto transform them into
final manifests for Kubernetes (even applying them to the cluster).In other words, the idea is to “compile” Python files into Kustomize files, then
just use Kustomize for the rest of the deployment.InstallingThe only mandatory dependency to this project isPyYAML. Besides this, you
can haveattrinstalled if you want to use their classes, and, if you’re
running on Python 3.6, you can installdataclassesto use them - although
this project is tested on Python 3.7 and 3.8 only, it probably runs fine on 3.6.This package will be available askustomize; you may install it with pip,
for example:$ pip install kustomizeThis will also installPyYAMLif it’s not already installed.Alternatively, you can use any other package manager capable of installing
packages from PyPI.UsageThe summary is:You write a source directory with Python files representing the Kustomize
files (see directories atpython-kustomize/tests/fixtures/);You run:$ pykustomize <source-dir> <dest-dir>where<dest-dir>will be
the directory where Kustomize YAML files will be put at;Then you can apply the generated Kustomize files into your cluster:$ kubectl apply -f <dest-dir>and done!
Package: kustomize-wrapper
Kustomize WrapperA Python wrapper for the KubernetesKustomizetool
and related tooling.More readable, more concise one-linersEasy linting (with integratedkubeval)Integrates into your Python tooling (e.g. use it withtox)Automatic download of external Go binariesCross-platform (installs matching Go binaries on Linux, macOS, Windows)Installationpython3 -m pip install kustomize-wrapperWhy should I use this toolForget about severalkustomizecalls, piping your calls intokubevalorkubectl applycommands. Using Kustomize is now even more pleasant!Instead of:lint:script:-kustomize build deployment/overlays/development | kubeval --strict-kustomize build deployment/overlays/integration | kubeval --strict-kustomize build deployment/overlays/production | kubeval --strictYou can now write:lint:script:-kustomize lint deployment/overlays/*Instead of:production:script:-cd deployment/base-kustomize edit set image IMAGE="foobar/application:${CI_COMMIT_SHA}"-cd ../..-kustomize build deployment/overlays/production | kubectl apply -f -You can now write:production:script:-kustomize apply deployment/overlays/production --edit deployment/base \set image IMAGE="foobar/application:${CI_COMMIT_SHA}"Usagekustomize --helpPhilosophy:Build automaticallyKustomize commands become CLI optionsKubeval options become CLI options oflintcommandPython toxAdd kustomize-wrapper to yourtox.ini, then Tox takes care of downloading:[testenv:kubernetes]description=Validate Kubernetes manifestsdeps=kustomize-wrappercommands=kustomize lint {posargs:--ignore-missing-schemas --fail-fast\deployment/application/overlays/development\deployment/application/overlays/integration\deployment/application/overlays/production\}Allows you to override arguments: (Use--in case you add command line options)tox -e kubernetes -- --fail-fast deployment/application/base
Package: kusto-pandas
KustoPandas is a wrapper around a Pandas DataFrame which allows you to use the syntax of theKusto Query Languageto transform the data frame.  Under the hood the commands are converted to the corresponding Pandas method, so you get all the performance of Pandas, but with the nice syntax of Kusto.For installation use pippython-mpipinstallkusto_pandasSee the following jupyter notebooks for example usageKustoPandas walkthroughTrump approval ratingsHere are some very basic usage examples.  Please see the walkthrough above for more details.importpandasaspdfromkusto_pandasimportWrapdataframe=pd.read_csv("data.csv")w=Wrap(dataframe)w.where("Column1 > 0").summarize("count(), AvgOfCol1 = avg(Column1) by Column2")In the above, multiple tabular operators are chained together, however if you prefer you can enter the full Kusto queryw.execute("""w| where Column1 > 0| summarize count(), AvgOfCol1 = avg(Column1) by Column2""")If you are working in a Jupyter notebook, then you may find it more convenient to use an IPython magic
Package: kustopy
Getting startedkustopy is a Python SDK for Azure Data Explorer (Kusto).Ingestion using pyspark dataframes, is quite slow (compared to ingestion using pandas dataframes).
But data is immediately in database after the command is run, while for pandas dataframes it can take
while for data to appear.Installation and ImportpipinstallkustopyfromkustopyimportKustoPyClientaskpcClient setup# Set up the query clientclient=kpc.Client(cluster='https://sample.kusto.windows.net/',database='sample',client_id=client_id,client_secret=client_secret,tenant_id=tenant_id,truncation=False)Queries# Get list of all tables available in databaseclient.get_table_names()# Get list of all tables available in databaseclient.get_schema(table_name='SampleTable')# Write standard kusto queries. To get the response as pandas dataframe set dataframe to True.client.query(user_input='SampleTable | take 100 | where fruit=="apple"',data_frame=True)Ingestions# Drop table from the databaseclient.drop_table(table_name='SampleTable')# Drop table from the databaseclient.drop_dublicates(table_name='SampleTable')# Write pandas or pyspark dataframe to the database. If the table exists you will get an Error.client.write_table(data_frame=df,table_name='SampleTable',folder='Sample')# Write pandas or pyspark dataframe to the database. If the table exists it will be replaced, otherwise created.client.write_replace_table(data_frame=df,table_name='SampleTable',folder='Sample')# Write pandas or pyspark dataframe to the database. If the table exists it will be expanded, otherwise created.client.write_append_table(data_frame=df,table_name='SampleTable',folder='Sample')
Package: kustosz
Kustosz - backend server repositoryFocus on the worthwhile content with Kustosz, open source self-hosted web application.This repository contains backend server.InstallationSeeKustosz installation documentationfor instructions on how to deploy or try Kustosz.Seebackend development documentationfor instructions on how to build Kustosz backend from source and run development version of code.ContributingAll contributions are welcome!If you have found a problem or want to ask a question, feel free tosubmit an issue. There's no template to follow. Usually it's good idea to describe what did you do, what did you expect to happen and what happened instead.If you want to contribute code, just fork the repository andsubmit a pull request. Instructions on setting up local development environment can be found atdocs.kustosz.org.LicenseKustosz is distributed under terms ofEuropean Union Public Licence
Package: kusto-tool
kusto-toolA high-level Python library and CLI to make it easier to use Azure Data Explorer
(aka Kusto), especially for data scientists.Experimental, work-in-progress, unstable API.DocumentationTODODatabase APITable management.set-or-append table.set-or-replace table.drop table.append table.create table.create-merge tableFunction management.create-or-alter function.drop functionQuery limit settingsset notruncation etc.Policy managementretention policysharding policyAccess management.show [table|database] principals.add [table|database] [users|admins]Query expression APIprojectwheredistinctsummarizejoinparenthesize or/and expressionsextendorder by, sortasc, descevaluatetake, limitmv-expandInspect columns from table by queryingsamplesample-distinctmv-applydatatablefacetfindforkgetschemainvokelookupparsepartitionpivotrangesearchserializetop, top-hittersKusto prefix function translator classspecial types (datetime, timespan, dynamic)nice error messages when column not found in table etc.Agg functionssumifcountifdcountifbinary_all_andbinary_all_orbinary_all_xormake_bag / make_set / make_listarg_max, arg_min, take_any, take_anyifavgifhll, hll_mergemax, maxif, min, minifpercentiles, percentiles_array, percentileswstdev, stdeviftdigest, tdigest_mergevariance, variancep, varianceifOther functions and operators[start|end]of[day|week|month|year]betweentypecasting: real(), long(), datetime() etc.math functions: log, sin, cos etc.string functions: strlen etc.nulldate functions: getyear, getmonth etc.case / iffhashwelch_testarray_ functions
Package: kutana
KutanaThe library for developing systems for messengers and social networks. Great
for developing bots. Refer toexamplefor the showcase of the library abilities.This library uses generalized attachment types, possible actions e.t.c. for flexibility
to use plugins with different backends.Installationpython-mpipinstallkutanaDocumentationYou can read the extended description of the library in
thedocs/index.mdfile. At the moment,
the documentation is not in the best condition. If you would like
to contribute to its writing, welcome to the issues.RunningFrom CLIFollowing command will populate application's config, add specified backends and
load plugins from specified folder.python3-mkutanarunexample/config.yml# usage: kutana [-h] {init,run} ...## helpfull cli utility## positional arguments:#   {init,run}#     init      initiate kutana project#     run       run kutana project using provided config (working directory will be changed to the one with config file)## optional arguments:#   -h, --help  show this help message and exitRefer to the exampleconfig.ymlfor the configuration details.From codefromkutanaimportKutanafromkutana.backendsimportVkontakteLongpollfromkutana.loadersimportload_plugins_from_path# Create applicationapp=Kutana()# Add manager to applicationapp.add_backend(VkontakteLongpoll(token="VK-GROUP-TOKEN"))# Load and register pluginsforplugininload_plugins_from_path("example/plugins/"):app.add_plugin(plugin)if__name__=="__main__":# Run applicationapp.run()Example plugin (plugins/echo.py)fromkutanaimportPluginplugin=Plugin(name="Echo")@plugin.on_commands(["echo"])asyncdef_(msg,ctx):awaitctx.reply(ctx.body,attachments=msg.attachments)If your function exists only to be decorated, you can use_to avoid
unnecessary names.Available backendsVkontakte (forvk.comgroups)Telegram (fortelegram.orgbots)
Package: kuti
Keras utilities (Kuti)The project contains utilities for image assessment development with Keras/Tensorflow, including utilities for model training, custom generators, image management and augmentation. This is a poetry package forku.The library requires tensorflow >= 1.14 or 2.x installed.$ pip install kutiOverviewSome of the key components of each file:model_helper.py:ModelHelper: Wrapper class that simplifies default usage of Keras for regression models.generators.py:DataGeneratorDisk,DataGeneratorHDF5: Keras generators for on-disk images, and HDF5 stored features/imagesimage_utils.py:various utility functions for manipulating images (read, write to HDF5, batch resize, view batch)image_augmenter.py:ImageAugmenter: Create custom image augmentation functions for training Keras models.generic.py:H5Helper: Manage named data sets in HDF5 files, for us in Keras generators.ShortNameBuilder: Utility for building short (file) names that contain multiple parameters.applications.py:model_inception_multigap,model_inceptionresnet_multigap: Model definitions for extracting MLSP narrow featuresmodel_inception_pooled,model_inceptionresnet_pooled: Model definitions for extracting MLSP wide featuresYou can find more information in the docstrings.
Package: kutils
Permission is hereby granted, free of charge, to any person obtaining acopy of this software and associated documentation files (the "Software"),to deal in the Software without restriction, including without limitationthe rights to use, copy, modify, merge, publish, distribute, sublicense,and/or sell copies of the Software, and to permit persons to whom theSoftware is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be includedin all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ORIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALLTHE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OROTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OROTHER DEALINGS IN THE SOFTWARE.Description: kutils======Kyle's utilities.These are various data structures and tools that I think are useful andwant to re-use across projects.A Makefile is supplied to simplify certain tasks. This is aimed tosupport *the author's* workflow, and may not be as useful to otherpeople.+ ``build``: create a source distribution.+ ``clean``: remove caches, compiled bytecode, build artifacts, andany generated documentation.+ ``docs``: generate docs; if the ``DOCS`` variable isn't set, it defaultsto generating HTML docs.+ ``lint``: run pylint on ``$(LINTMOD)``, which should be the main projectmodule.+ ``setup``: use pip to install the project requirements.+ ``test``: run pytest on the ``tests`` module.+ ``viewdocs``: run ``$(SRVMOD)`` (which defaults to ``http.server``) on theHTML Sphinx documentation.Platform: UNKNOWN
Package: kutils4p
kutils4pSimple everyday utils and data structs written in vanilla python3.IncludesFile Utilsgenerate_files_of_typeis_non_zero_fileKDecoratorGeneric decorator class which calls "before" method before decorated function and "after" method on output decorated output. Flow can be interrupted by raising a KException to prevent "after" call.Data StructsRingBufferpython list wrapper which, when iterated, loops back to index 0 of contentsSpiralBufferpython list wrapper which, when iterated, proceeds forwards and then backwards through contentsInstallpip3 install kutils4p --user
Package: kutoa
KutoaWeave (Finnish: kutoa) annotated json code examples with fill-ins from and to markdown prose.License: MITThird party dependencies are documented in the folderthird-party.DocumentationUser and developerdocumentation of vastaanottaa.Bug TrackerAny feature requests or bug reports shall go to thetodos of kutoa.Primary Source repositoryThe main source ofkutoais on a mountain in central Switzerland.
We use distributed version control (git).
There is no central hub.
Every clone can become a new source for the benefit of all.
The preferred public clones ofkutoaare:on codeberg- a democratic community-driven, non-profit software development platform operated by Codeberg e.V.at sourcehut- a collection of tools useful for software development.ContributionsPlease do not submit "pull requests" (I found no way to disable that "feature" on GitHub).
If you like to share small changes under the repositories license please kindly do so by sending a patchset.
You can either send such a patchset per email usinggit send-emailor
if you are a sourcehut user by selecting "Prepare a patchset" on the summary page of your fork atsourcehut.StatusExperimental.NoteThe default branch isdefault.
Package: kuttyPy
KuttyPy Interactive Playground [ Microcontroller Training Utility ]The kuttyPy (/kʊtipʌɪ/) Microcontroller training utility allows live manipulation of the registers in microcontrollers via a connected computer containing its python library.  setReg and getReg function calls act as debugging and monitoring tools, and combined with Python's visualization and analytical utilities, this approach has immense pedagogical potential for beginners to the microcontroller world.The kuttyPy hardware is an ATMEGA32 microcontroller development board developed by theExpEYESproject, and is currently supported by this software. It contains the kuttyPy firmware, but can also be used to run other programs via its bootloader.What can I use it for?It's an atmega32 development board with a bootloader supporting the 'arduino' protocolThe bootloader also allows real-time manipulation of registers through commmands sent via the serial port.This is done by the associated Python library and companion GUIYou can monitor every inputToggle every outputDeal with Peripherals such as PWMs and CountersView ADC readings via an analog gaugeScan for sensors connected to the I2C BusMonitor readings from sensors [TSL2561 luminosity, and MPU6050 IMU supported]Compile code to hex with the avr-gcc compilerUpload hex via the built-in uploaderRapidly prototype and debug educational projects. For example, you can verify ADC input values before handing over control to the uploaded hex file which will likely have very limited debugging capabilities.Learn how registers are the key to microcontroller operation, as opposed to the Arduino ecosystem which prefers obfuscation of these details underneath abstraction layers.Monitor I2C SensorsScan for SensorsClick to monitor via analog gaugeList of I2C sensors supported thus far (Minimal data logging. Configuration options via the graphical utility might be incomplete)MPU6050 3 Axis Accelerometer, 3 axis Angular velocity (Gyro)TSL2561 Luminosity measurementsBMP280 Pressure and Temperature sensorMCP4725 Single channel DACPCA9685 PWM controllerMLX90614 Passive IRProgramming library and examples :READ THE DOCS