Saravanan666/pypi-org huggingface dataset:
Package: klove
KLOVENumerical modelling of waves on thin elastic plateskloveis a Python package designed to study wave propagation on thin elastic plates based on the
Kirchhoff–Love theory. The plate can be loaded with elements that will affect the propagation of elastic waves: the aim
is to find the solution to this problem numerically. Key features of the code are:Easy to use interface--- simply define the plate and scatterers (pins, masses, mass-spring or beam resonators).Multiple scattering simulations--- with plane wave and point load excitation.Far field quantities--- with plane wave excitation.Diffraction by gratings--- with calculation of efficiencies.Quasi-normal mode analysis and expansion--- by solving a nonlinear eigenvalue problem.Calculation of phononic band diagrams--- with utilities to define the path along the edges of the Brillouin zone.Auto-differentiable--- allowing for gradient-based optimization of elastic wave propagation.DocumentationSee the website with API reference and some examples atbenvial.gitlab.io/klove.InstallationFrom PypiSimply runpipinstallkloveIf you want more numerical backends (pytorch, autograd and jax), including
auto-differentiation and GPU acceleration, install the full version:pipinstallklove[full]From conda/mambaFor the full installation including GPU/autodiff supportmambainstall-cpytorch-cnvidiapytorchpytorch-cuda=12.1jaxlib=*=*cuda*jaxpipinstallklove[full]From sourceClone the repositorygitclonehttps://gitlab.com/benvial/klove.gitcdkloveInstall the package locallypipinstall-e.For the full version:pipinstall-e.[full]From gitlabBasic:pipinstall-egit+https://gitlab.com/benvial/klove.git#egg=kloveFull:pipinstall-egit+https://gitlab.com/benvial/klove.git#egg=klove[full]
Package: klp
KELPA simple python replacement for homebrew for installing binary packages on MacOSWhy?I built Kelp to scratch my own itch while using Homebrew. For example if you use homebrew to install terraform, it is
cumberson to switch between different terraform versions. Here is why I built Kelp:No waiting for a formula to become available on homebrewSwitch between different versions of a package easilyKeep all your computers up to date with a single installation manifestInstall multiple packages at one time.How To Installcurl https://github.com/crhuber/kelp/releases/download/v0.2.2/kelp -o ~/kelp
chmod +x ~/kelpHow Does it Work?It downloads all the packages in a~/.kelp/.kelp.jsonfile to~/.kelp/bin. It can download any binary file on github releases.How Do I Use It?Download the latestkelprelease from github releasesInitliaze Kelpkelp initAdd kelp to your PATHexport PATH=~/.kelp/bin/:$PATHAdd a new packagekelp add wercker/stern:latestInstallkelp installHow do I install multiple packages at one time?Edit~/.kelp/.kelp.jsonand add all your favorite packages there. For example mine looks ike{
    "sharkdp/fd": "latest",
    "sharkdp/bat": "latest",
    "ubnt-intrepid/dot": "latest",
    "tsenart/vegeta": "latest",
    "junegunn/fzf-bin": "latest",
    "termit/flycut": "latest",
    "rxhanson/rectangle": "latest",
    "lwouis/alt-tab-macos": "latest",
    "versent/saml2aws": "latest",
    "watchexec/watchexec": "latest",
    "wercker/stern": "latest",
    "hashicorp/terraform": "https://releases.hashicorp.com/terraform/0.11.14/terraform_0.11.14_darwin_amd64.zip",
    "ogham/exa": "latest",
    "Marginal/QLVideo": "latest",
    "JohnCoates/Aerial": "latest",
    "istio/istio": "latest",
    "aws/aws-iam-authenticator": "https://amazon-eks.s3-us-west-2.amazonaws.com/1.14.6/2019-08-22/bin/darwin/amd64/aws-iam-authenticator",
    "helm/helm": "v2.16.0"
}Run kelpkelp installWhat if the package I want is not on github releases?Easy. Just add the http(s) link to the binary like so to your .kelp.json filekelp add hashicorp/terraform https://releases.hashicorp.com/terraform/0.11.13/terraform_0.11.13_darwin_amd64.zipTroubleshootingWhy wasnt my package installed ?Kelp looks for binaries made for MacOS, if it finds a binary for linux or windows it will skip downloading it.Why is kelp so slow?I used PyInstaller to freeze this Python applications into stand-alone executable which means its a little slow when executingDoes it work for Linux?Not yet
Package: kl-pbx
pbxpip install -r kl_pbxuseimport libfrom kl_pbx import PBXProjectHelper,PBXTreeType,PBXGetSetfrominit projectmain_target="UnityFramework"
 projectpath = os.path.join(self.work_project_path, "Unity-iPhone.xcodeproj/project.pbxproj")
  pbx_helpr = PBXProjectHelper(projectpath)add groupmygroup = pbx_helpr.add_group("ios", "")add a system lib to grouppbx_helpr.add_file(main_target, "user/lib/libz.1.2.5.tbd", mygroup, PBXTreeType.SDKROOT)add a system framwork to groupframeworkgroup = pbx_helpr.add_group("Frameworks", "", mygroup)
 pbx_helpr.add_file(main_target, "System/Library/Frameworks/AudioToolbox.framework", frameworkgroup, PBXTreeType.SDKROOT, PBXGetSet(attribs))add files to group
filepath is full path of diskpbx_helpr.add_file(main_target, filepath, mygroup, PBXTreeType.SOURCE_ROOT)add folders to group
folder is full path of diskpbx_helpr.add_folder(main_target, folderpath, mygroup, excludes=self.ios_build_config.excludes)add flagspbx_helpr.add_flags(main_target, "OTHER_LDFLAGS", ["-ObjC", "-lz", "-lstdc++"])change flagspbx_helpr.set_flags(main_target, 'IPHONEOS_DEPLOYMENT_TARGET', "11.0")change code signpbx_helpr.change_code_sign("Unity-iPhone","Apple Development: Chongyu Lu (F3Q2Q5F68Y)","hoc_jpsgp_dev")change package namepbx_helpr.change_package_name("Unity-iPhone", "com.package,kl")save all changepbx_helpr.save()
Package: kltpicker
KLTPickerKLT Picker: particle picking using data-driven optimal templates.Current version: 1.2.6Date: 10/2020This is the Python version containing the complete source code of the KLT Picker. A MATLAB version is available athttps://github.com/ShkolniskyLab/kltpicker_matlab.Please cite the following paper when using this package:
Eldar A, Landa B, Shkolnisky Y. KLT picker: Particle picking using data-driven optimal templates. J Struct Biol. 2020 May;210(2) 107473.Recommended Environments:The package has been tested on Ubuntu 16.04 and Windows 10. It should probably work on other versions of Windows and Linux, but has not been tested on them yet. Similarly for macOS.Python 3.6.0+ is required.The package makes use of the pyfftw package, which in turn uses the FFTW library. Before installing KLTPicker make sure you have the FFTW library installed on your system:http://www.fftw.org/fftw3_doc/Installation-and-Customization.html#Installation-and-CustomizationForoptionalGPU support, the package requires:NVIDIA CUDA GPU with the Compute Capability 3.0 or largerCUDA Toolkit: v9.0 / v9.2 / v10.0 / v10.1 / v10.2 / v11.0Install KLTPickerInstall KLTPicker via pip:We recommend installing KLTPicker via pip:$ pip install kltpickerIn order to enable the GPU support (provided that your system satisfies the above requirements):$ pip install kltpicker[gpu]Install KLTPicker from sourceThe tarball of the source tree is available via pip download kltpicker. You can install KLTPicker from the tarball:$ pip install kltpicker-x.x.x.tar.gzYou can also install the development version of KLTPicker from a cloned Git repository:$ git clone https://github.com/ShkolniskyLab/kltpicker.git

$ cd kltpicker

$ pip install .Uninstall KLTPickerUse pip to uninstall KLTPicker:$ pip uninstall kltpickerUpgrade KLTPickerJust use pip with -U option:$ pip install -U kltpickerGetting started:Please read the user manual for usage instructions, available at the homepage of the project on Github: https://github.com/ShkolniskyLab/kltpicker
Package: kltpicker2
KLTPicker2KLT Picker: particle picking using data-driven optimal templates.Current version: 2.0Project's homepage:https://github.com/ShkolniskyLab/kltpicker2Date: 01/2022This is the Python version containing the complete source code of the KLT Picker. A MATLAB version is available athttps://github.com/ShkolniskyLab/kltpicker2_matlab.Please cite the following paper when using this package:
Eldar A, Landa B, Shkolnisky Y. KLT picker: Particle picking using data-driven optimal templates. J Struct Biol. 2020 May;210(2) 107473.Recommended Environments:The package has been tested on Ubuntu 16.04 and Windows 10. It should probably work on other versions of Windows and Linux, but has not been tested on them yet. Similarly for macOS.Python 3.6.0+ is required.The package makes use of the pyfftw package, which in turn uses the FFTW library. Before installing KLTPicker make sure you have the FFTW library installed on your system:http://www.fftw.org/fftw3_doc/Installation-and-Customization.html#Installation-and-CustomizationForoptionalGPU support: see cupy instalation requirmentshttps://docs.cupy.dev/en/stable/install.html.Install KLTPickerInstall KLTPicker via pip:We recommend installing KLTPicker via pip:$ pip install kltpicker2In order to enable the GPU support (provided that your system satisfies the above requirements):$ pip install kltpicker2[gpu]Install KLTPicker from sourceThe tarball of the source tree is available via pip download kltpicker. You can install KLTPicker from the tarball:$ pip install kltpicker2-x.x.x.tar.gzYou can also install the development version of KLTPicker from a cloned Git repository:$ git clone https://github.com/ShkolniskyLab/kltpicker2.git

$ cd kltpicker2

$ pip install .Uninstall KLTPickerUse pip to uninstall KLTPicker:$ pip uninstall kltpicker2Upgrade KLTPickerJust use pip with -U option:$ pip install -U kltpicker2Getting started:Please read the user manual for usage instructions, available at the homepage of the project on Github: https://github.com/ShkolniskyLab/kltpicker
Package: kluff
Build and Deploy with KluffInstallation$ pip install -r requirements.txt

$ python setup.py installDevelopmentThis project includes a number of helpers in theMakefileto streamline common development tasks.Environment SetupThe following demonstrates setting up and working with a development environment:### create a virtualenv for development

$ make virtualenv

$ source env/bin/activate


### run kluff cli application

$ kluff --help


### run pytest / coverage

$ make testReleasing to PyPiBefore releasing to PyPi, you must configure your login credentials:~/.pypirc:[pypi]
username = YOUR_USERNAME
password = YOUR_PASSWORDThen use the included helper function via theMakefile:$ make dist

$ make dist-uploadDeploymentsDockerIncluded is a basicDockerfilefor building and distributingKluff CLI,
and can be built with the includedmakehelper:$ make docker

$ docker run -it kluff --help
Package: klujax
KLUJAXA sparse linear solver for JAX based on the
efficientKLU algorithm.CPU & float64This library is a wrapper around theSuiteSparseKLU
algorithms. This means the algorithm is only implemented for
C-arrays and hence isonly available for CPU
arrays with double precision, i.e. float64 or complex128.Note that this will be enforced at import ofklujax!UsageTheklujaxlibrary provides a single functionsolve(A, b), which solves forxin
the linear systemAx=bA is a sparse tensor in COO-format with shapemxmand x and b
have shapemxn. Note that JAX does not have a native sparse matrix representation and
hence A should be represented as a tuple of two index arrays and a value
array:(Ai, Aj, Ax).importjax.numpyasjnpfromklujaximportsolveb=jnp.array([8,45,-3,3,19],dtype=jnp.float64)A_dense=jnp.array([[2,3,0,0,0],[3,0,4,0,6],[0,-1,-3,2,0],[0,0,1,0,0],[0,4,2,0,1]],dtype=jnp.float64)Ai,Aj=jnp.where(jnp.abs(A_dense)>0)Ax=A_dense[Ai,Aj]result_ref=jnp.linalg.inv(A_dense)@bresult=solve(Ai,Aj,Ax,b)print(jnp.abs(result-result_ref)<1e-12)print(result)[ True True True True True]
[1. 2. 3. 4. 5.]InstallationThe library is statically linked to the SuiteSparse C++ library. It can be installed on
most platforms as follows:pipinstallklujaxThere exist pre-built wheels for Linux and Windows (python 3.8+).If no compatible
wheel is found, however, pip will attempt to install the library from source... make
sure you have the necessary build dependencies installed.LinuxOn linux, you'll needgccandg++. Then just do a normal pip install:pipinstallklujaxWindowsOn Windows, installing from source is a bit more involved as typically the build
dependencies are not installed. To install those, download Visual Studio Community 2017
fromhere. During installation, go to Workloads and select the following workloads:Desktop development with C++Python developmentThen go to Individual Components and select the following additional items:C++/CLI supportVC++ 2015.3 v14.00 (v140) toolset for desktopThen, download and install Microsoft Visual C++ Redistributable fromhere.After these installation steps, run the following commands inside a x64 Native Tools
Command Prompt for VS 2017:set DISTUTILS_USE_SDK=1
pip install klujaxLicense & Credits© Floris Laporte 2022, LGPL-2.1This library was partly based on:torch_sparse_solve, LGPL-2.1SuiteSparse, LGPL-2.1kagami-c/PyKLU, LGPL-2.1scipy.sparse, BSD-3This library vendors an unmodified version of theSuiteSparselibraries in its source
(.tar.gz) distribution to allow for static linking.
This is in accordance with theirLGPL licence.
Package: klupywpredictor1.0
bloxflippackageExamplesCrashimportklupywpredictorsso=klupywpredictorss.crashvarName=o.crashpredictor()#  varName returns a dict {{'crashchance': str(chance), 'crashprediction': str(prediction)}chance=varName[crashchance]prediction=varName[crashprediction]print(chance,prediction)Minesimportklupywpredictorsso=klupywpredictorss.minesoutput=o.minespredictor(tileo,bombs)# tileo = How many tiles the user wants to open  # bombs = how many bombs on the fieldprint(output)Towersimportklupywpredictorsso=klupywpredictorss.towersoutput=o.towerspredictor()print(output)
Package: klupywpredictorx
bloxflippackageExamplesCrashimportklupywpredictorxo=klupywpredictorx.crashvarName=o.crashpredictor()#  varName returns a dict {{'crashchance': str(chance), 'crashprediction': str(prediction)}chance=varName[crashchance]prediction=varName[crashprediction]print(chance,prediction)Minesimportklupywpredictorxo=klupywpredictorx.minesoutput=o.minespredictor(tileo,bombs)# tileo = How many tiles the user wants to open  # bombs = how many bombs on the fieldprint(output)Towersimportklupywpredictorxo=klupywpredictorx.towersoutput=o.towerspredictor()print(output)
Package: klusterpy
KlusterPyKlusterPy is a simple machine learning library that provides clustering algorithm such asK-Means,K-Medoids,DBSCAN, andAgglomerative Clustering.DependenciesNumPyPython >= 3Installationpip install klusterpyExample Codefromklusterpy.cluster.dbscanimportDBSCANfromsklearnimportdatasetsimportnumpyasnpimportpandasaspdiris_data=datasets.load_iris()iris_df=pd.DataFrame(data=np.c_[iris_data['data']],columns=iris_data['feature_names'])dbscan=DBSCAN(epsilon=0.42,min_pts=5).fit(iris_df.values)dbscan.labelsContributorsDewita Sonya13515021Erick Wijaya13515057Kezia Suhendra13515063
Package: klu-test-pipeline
Klu.AI Python SDKDescriptionSDK for building AI Enabled appsDocumentation:https://docs.klu.aiGitHub:https://github.com/klu-ai/klu-sdkPyPI:https://pypi.org/project/klu/Free software: MITThe Klu.AI Python SDK is a library that provides access to the Klu.AI API, allowing users to interact with their workspace, applications, actions, data, models, and data indices.RequirementsThe Klu.AI Python SDK requires Python version 3.7 or later.InstallationTo install the Klu.AI Python SDK, simply run:pip install kluGetting StartedTo use the Klu.AI Python SDK, you must first obtain an API key from the Klu.AI website. Once you have your API key, you can create aKluClientobject:fromkluimportKluClientclient=KluClient("YOUR_API_KEY")Once you have aKluClientobject, you can access the different models available in the Klu API:fromkluimportKluClientclient=KluClient("YOUR_API_KEY")models=awaitclient.models.get("model_guid")There is also a separate function to stream action promptEach of these objects provides methods for interacting with the corresponding model in the Klu API. For example, to list all applications in your workspace, you can use:fromkluimportKluClientclient=KluClient("YOUR_API_KEY")applications=client.applications.list()In a similar manner, in order to get a list of data points for an action, you can do the followingfromkluimportKluClientclient=KluClient("YOUR_API_KEY")data=client.data.get_action_data("action_id")There is a special client that allows to stream action prompts.
The streaming url can be received from the action creation response.fromkluimportKluClientclient=KluClient("YOUR_API_KEY")prompt_response=awaitclient.actions.run_action_prompt("action_guid","prompt",streaming=True)asyncformessageinclient.sse_client.get_streaming_data(prompt_response.streaming_url):print(message)DocumentationFor more detailed information on how to use the Klu.AI Python SDK, please refer to theAPI documentation.CreditsThis package was created withCookiecutterand thewaynerv/cookiecutter-pypackageproject template.
Package: klv
KLV in PythonA Python  parser for KLV (Key Length Value) encoded data. KLV encoding is commonly used in the motion picture industry.http://en.wikipedia.org/wiki/KLVUnit TestsInstall nose:pipinstallnoseRun the commandnosetestsin the root directory.Encode Key/Valueimportklvkey=[0x03,0x2E,0x5F,0xAB,0x08,0x12,0x2F,0x0C,0xEE,0x33,0x00,0x01,0x02,0x45,0x6D,0xDD]value=[0x05,0x04,0x03,0x02,0x01]klv_msg=klv.encode(key,value)klv_msgwill be a bytearray; to convert to an array of ints, uselist(klv_msg)and to convert to a string of bytes, usestr(klv_msg).Decode KLV Messagesimportklvkey,value=klv.decode(klv_msg,16)Decode takes the formdecode(<klv>, <key length>)to accomodate messages with different length keys. Thekeyandvalueresults are bytearrays.
Package: klvm-rs
Theklvm_rswheel has python bindings for the rust implementation of klvm.BuildUsematurinto build the python interface. First, install into current virtualenv with$ pip install maturinWhile in thewheeldirectory, buildklvm_rsinto the current virtualenv with$ maturin develop --releaseOn UNIX-based platforms, you may get a speed boost onsha256operations by building
with OpenSSL.$ maturin develop --release --features=opensslTo build the wheel, do$ maturin build --releaseor$ maturin build --release --features=openssl
Package: klym-telemetry
KLYM TelemetryA small library to add instrumentation in KLYM apps.Publish in PYPIpip install twine

python setup.py bdist_wheel

twine upload dist/*Installationpip install klym-telemetryGet startedInstrumenting a fastapi appImport klym instrumenterfromklym_telemetry.instrumentersimportinstrument_appImport instrument decoratorfromklym_telemetry.utilsimportinstrumentInitialize automatic instrumentationinstrument_app(app_type='fastapi',app=app,service_name="test-klym-microservice",endpoint="http://localhost:4317")Full example:importtimefromfastapiimportFastAPIfromklym_telemetry.instrumentersimportinstrument_appfromklym_telemetry.utilsimportinstrument,klym_telemetryapp=FastAPI()instrument_app(app_type='fastapi',app=app,service_name="test-klym-microservice",endpoint="http://localhost:4317")@instrument(private_methods=True,attributes={"description":"Class to say hello"})classHello:@instrument(span_name="Get start message (private method)")def_get_start_message(self):return"Hello"defsay_hello(self):return{"message":self._get_start_message()+" World"}defsay_hello_with_name(self,name:str):return{"message":f"{self._get_start_message()}{name}"}@app.get("/")defroot():klym_telemetry.add_event_curr_span("Start sleeping")# Custom event examplefor_inrange(10):time.sleep(0.2)klym_telemetry.add_event_curr_span("Finished sleeping")returnHello().say_hello()@app.get("/hello/{name}")@instrument(span_name="Say hello with name",attributes={"description":"Class to say hello asynchrounously"})asyncdefsay_hello(name:str):return{"message":f"Hello{name}"}Instrumenting a celery appImport klym instrumenterfromklym_telemetry.instrumentersimportinstrument_appImport celery signal when worker startsfromcelery.signalsimportworker_initInitialize automatic instrumentationinstrument_app(app_type='celery',service_name="integrations",endpoint="http://localhost:4317")Full example:importosfromceleryimportCeleryfromcelery.signalsimportworker_initfromklym_telemetry.instrumentersimportinstrument_app# set the default Django settings module for the 'celery' program.os.environ.setdefault('DJANGO_SETTINGS_MODULE','core.settings.local')app=Celery('integrations')# Using a string here means the worker doesn't have to serialize# the configuration object to child processes.# - namespace='CELERY' means all celery-related configuration keys#   should have a `CELERY_` prefix.app.config_from_object('django.conf:settings',namespace='CELERY')app.autodiscover_tasks()app.conf.update(worker_pool_restarts=True,)@worker_init.connect()definit_celery_tracing(*args,**kwargs):instrument_app(app_type='celery',service_name="integrations",endpoint="http://localhost:4317")
Package: klyqa-ctl
Klyqa device control clientA commandline client for controlling your Klyqa devices.Using your klyqa account or dev mode for bulbs onboarded in dev mode.Install via pypi:pip install klyqa-ctlUse then as moduleimport klyqa_ctlor on theCommandline$ klyqa-ctl ...Git RepositoryYou can also clone this repository.You can run the python script directly with./klyqa_ctl/klyqa_ctl.pyUse pip for installation of required dependency packages.pip install -r requirements.txtTested and developed with Python v3.9.or build it as docker container.Build docker python script containerBuild docker container for automatic required dependency download and easy handling from within the project folder.docker build -t klyqa_ctl .Run docker python script containerdocker run --net=host --rm -it klyqa_ctlor to keep the container running:docker run --net=host --name=klyqa_ctl --entrypoint=python3 -itd klyqa_ctland then do a:docker exec klyqa_ctl python3 /bulb_cli.pyDebug modeIf you want more logging verbosity--debugHelp with all commands--helpInteractive clientIf you provide no bulb unit id and/or a command to send, the bulb discovery and selection will be shown and afterwards a command prompt.Use klyqa user accountAdd username and password to the arguments--username <emailaddress> --password <password>HostsUse production (default) or test host.--prod or --testLocal Modeklyqa-ctl --aes 00112233445566778899AABBCCDDEEFF --bulb_unitids db60e93f99Connection typestryLocalThanCloud (Default) for sending the command--tryLocalThanCloudUse--localfor local only connectionUse--cloudfor cloud only connectionExamples commandsSend request--requestSetting color rgb--color r g bSelecting bulbs directly by unit ids seperated by commas ","--bulb_unitids <bulb-unitid1>,<bulb-unitid2>,...Scenes--party, --TVtime, --fireplace, ...Use dev envFor running the bulbs in the development configuration locally without a klyqa account and with the default development AES key.--dev
Package: km2pg
km2pgLoad raw kissmetrics data from specified s3 bucket into specified postgres database.To installIn this directory, run the following command:python setup.py installTo useOnce installed, a new script, named km2pg should now be available in PATH, which can be used as follows:km2pg-b name_of_s3_bucket -m postgres_hostname -p postgres_port -d postgres_dbname -u postgres_username -w postgres_passwd -a aws_access_key -s aws_secret_keyFor more details, see km2pg –help.Requiresboto: Python library for AWSpsycopg: postgres Python client libraryCommentThis script can safely be run from an Amazon spot instance, where checkpointing is important, since the script can be interrupted at any moment.Strategykissmetrics deposits raw data into multiple json files:bucket/revisions/1.json
2.json
…
N.jsonkissmetrics provides an ‘index’ file at:bucket/index.csvThis index file lists all the json files that kissmetrics has currently deposited in the ‘revisions’ folder above.Our strategy is to process the json files in the order they appear in index.csv (which happens to be in order of increasing time).In our postgres instance, we will maintain our progress through index.csv. This approach assumes that kissmetrics only ever appends to index.csv, and never edits.