Saravanan666/pypi-org huggingface dataset:
Package: kperm
KPerm - Toolkit for Analysis of Permeation Cycles in Potassium ChannelsKPerm, released together with ourJCTCpaper, is a Python package specifically for identifying selecivity filter occupancy in molecular dynamics (MD) simulations of potassium channels.InstallationYou are recommended to install the latest release of KPerm viapipin a virtual environment with Python >=3.8.pipinstallkpermExamplesJupyter NotebookPermeation Cycle in MthK with charge-scalingCommand-line Interface# same as Channel.run(), computing SF occuapncy and identifying permeation eventskpermrun-scoord_file-ftraj_1traj_2traj_3...# speed things up if you are not interested in SF oxygen flip and water occupancykpermrun-scoord_file-ftraj_1traj_2traj_3...--noFlip--noW# compute summary of permeation events of all selected simulations# use it after running "kperm run"kpermstats-scoord_file-ftraj_1traj_2traj_3...Documentationhttps://degrootlab.github.io/KPerm/CitationLam, C. K., & de Groot, B. L. (2023). Ion Conduction Mechanisms in Potassium Channels Revealed by Permeation Cycles. Journal of Chemical Theory and Computation.doi:10.1021/acs.jctc.3c00061
Package: kpet
Kubernetes Python Exploration ToolCommand line tool to explore the Kubernetes API using Python expressionsMotivationExplore theKubernetes APIby using «k8s tailored» REST client while supporting Python expressions for formatting and filterting data.InstallpipinstallkpetUsage examplesShow the current kubernetes context configuration (detected from your KUBECONFIG file)kpetshowList all the API endpointskpetgetGet the kubernetes API server versionkpetgetversionGet the list of nodeskpetgetapi/v1/nodesGet the PodIP for all pods, check thespecial symbolsfor other symbols.kpetgetapi/v1/pods-f"{name} is using IP {_s.podIP}"Print the name for all running podskpetgetapi/v1/pods-f"{name}"-s"_s.phase=='Running'"Print the name for all nodes which are Readykpetgetapi/v1/nodes-f"{name}"-s"[c for c in _s['conditions'] if c.type=='Ready' and c.status=='True']"
Package: kpfm
Kelvin Probe Force Microscopy (KPFM) data analysis.MotiviationCollect useful code for custom Kelvin probe force microscopy experiments into a single repository.
The motivation for using a single repository is prior experience andthis article.StructureA tentative structure for the repository iskpfm
├── __init__.py
├── _version.py
├── experiment
│   └── __init__.py
├── tests
│   ├── __init__.py
│   └── test_kpfm.py
├── scratch
│   ├── __init__.py
│   └── temporary_code.py
└── util
    ├── __init__.py
    └── plot.pyEach experiment is contained in its own module.
Theutilmodule collects useful functions and decorators that are useful across a range of modules.
Tests are placed in thetestsmodule.
Scratch contains a place for code that will not be maintained.
If a particular experiment or procedure is useful over a longer period,
it can be moved to its own experiment module.Development life cycle of new codeWorkup data and write provisional code in an IPython notebookIf many data files are going to be processed in this way, move the routine to a new module inscratch.Workups inscratchcome with no guarantees that they will not break.In practice, it would be useful to create a new copy of the temporary code if there is likely to be significant breakage.If the experiment is useful enough, copy / edit the scratch code and move it to its own experiment folder. In doing so, we commit to leave the experiment in a usable, backward compatible state, which means consistent LabView code for collecting the data, as well as consistent, backward-compatible routines for working up the data.The idea would be that with a powerful set of utility, signal processing, and data analysis tools in thekpfmpackage, many analyses could be performed quickly at (1) or (2).
Even having a file in scratch (perhaps copied occasionally as the data analysis or LabView code changes significantly) is a significant improvement over code copied between IPython notebooks.
The other consideration is that it is a large investment of time to maintain code, so that code related to a “one-off” experiment should be saved, but not maintained.FeaturesTODODocumentationThe full documentation is athttp://kpfm.rtfd.org.History0.1.0 (2017-03-28)First release on GitHub.
Package: kp-fraydit
This library makes working with kafka in python easy. It simplifies the producing of records. The producer class persists
fields so that the fields of a record can be retrieved in various places from within your code base.The library that expands on the work of Confluent's kafka-python library to make an intuitive producer that simplifies coding. This producer acts as a Super Class that you can inherit all of your specific producers in your code. The implementation takes five lines of codeSet the KAFKA_REGISTRY_LISTENER and KAFKA_BROKER_LISTENER (2 lines of code)from kp_fraydit.producers.producer import Producerprod = Producer('my-topic')prod.addValueArgs(myField1='test')That is all that is needed to produce a record.It utilizes Confluent's amazing Exact-Once Semantics(EOS) architecture. That assurance takes time, however. To speed up the library, all producer instances pool their records and then the records are parallel processed. This enhances the speed of the library while maintaining the EOS assurance. The sacrifice of this pooling loses the guarantee of order preservation. The library allows for individual producer instances to maintain a separate pool that ensures order.The producer handles JSON and Avro schema automatically. Nested schema (Avro only) is handled. That means you can have records within records and the producer class knows how to handle that.You can discover what fields are available, which fields are required, optional fields, specify optional fields that you want to include on each write, all from within the attributes of the producer.https://fraydit.com
Package: kph
Python 2/3 ready implementation of the Kölner Phonetik (http://de.wikipedia.org/wiki/K%C3%B6lner_Phonetik) algorithm.Usage>>> import kph
>>> kph.encode("Horst Meier")
'078267'
>>> kph.encode("Horst Mayer")
'078267'
>>> kph.encode("Horst Meier") == kph.encode("Horst Mayer")
True
>>> kph.encode("Detlef Krumm") == kph.encode("Detlef Krum") == \
... kph.encode("Detlef Krunn") == kph.encode("Detlef Krun")
TrueLicensekph - Python module implementing the ‘Koelner Phonetik’ algorithm.
Copyright (C) 2011  Robert SchindlerThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.CopyrightCopyright 2011 by Robert Schindler <robert-sch@gmx.net>.
Python 3 compatibility added by Michael Herrmann <[first name] at [last name].io>.
Package: kpindex
kpindexVery simple package for obtaining the planetary Kp index data (seehttps://www.gfz-potsdam.de/en/kp-index/for more information)InstallationThis package depends on the following:numpyRecarrayToolsPyFileIOwhich are all available on PyPI.Installation is simple and can be done in one of four ways:Method 1This method simply uses the Pythonpip3command to download this
module and its dependencies:pip3 install kpindex --userMethod 2This method uses the Python wheel on the "releases" page of this
repository. Download the wheel, then isntall usingpip3:pip3 install kpindex-0.0.1-py3-none-any.whl --userMethod 3Don't trust my prepackaged stuff? OK, clone this repository and build
your own:git clone https://github.com/mattkjames7/kpindex.git
cd kpindex
python3 setup.py bdist_wheel
pip3 install dist/kpindex-0.0.1-py3-none-any.whl --userMethod 4So you don't like wheels? Fine. Clone the repository and just move the
"kpindex" folder to your$PYTHONPATH.Post-InstallIn order for the module to be able to download the Kp index data from
the FTP site, you will need to point it in the direction of a directory
where you have read and write access using the$KPDATA_PATHenvironment variable. This can be done either by running the following
in the terminal before starting Python, or inserting it into your~/.bashrcfile:export KPDATA_PATH=/path/to/the/dataUsageUsing this module is very simple: the first time you run it you will
need to update the database (also when you think the database is out of
date) e.g.importkpindexkpindex.UpdateLocalData()It may take a couple of minutes to download the data and convert it,
then you are ready to read the data:data=kpindex.GetKp(Date)whereDatecould beNone, in which case ALL of the Kp indices ever
will be returned;Datecould be a single date in the format yyyymmdd,
in which case only Kp indices fromt hat date will be returned; finally
it could be a two element array/list/tuple containing two dates, in this
case it will return all the indices from the start to the end date.Enjoy!
Package: kpireport-scp
pip install kpireport-scpThescpplugin writes the report contents to local disk and then copies
them to a remote host viascp. This can be used to copy the report to a
server’s webroot or simply keep a backup around.NoteCurrently only the HTML format is supported.NoteThis plugin utilizesfabricfor executing commands over SSH, which in
turn utilizesparamiko, which is licensed under LGPL 2.1. A copy of this
license is included inLGPL-2.1.mdin the plugin source.
Package: kplanes-nerfstudio
K-Planes nerfstudio integrationThis repository provides code to integrate theK-Planes modelintonerfstudio.It provides an alternative way to use k-planes in addition to theofficial repository, which allows access to nerfstudio's in-browser viewer and additional training capabilities.
Beware that some details about the training procedure differ from the official repository.InstallationInstall nerfstudio. This ispip install nerfstudio, but there are a few dependencies (e.g.torch,tinycudann) which may require further steps, so make sure to check their installation guide!Install the k-planes nerfstudio integration (this repository):pip install kplanes-nerfstudioIncluded ModelsTwo models are included here:kplaneswhich is tuned for the Synthetic NeRF dataset (i.e. chair, drums, etc.)kplanes-dynamicwhich is tuned to theDNeRF dataset(dynamic, monocular video).:exclamation: PRs are welcome for configurations tuned to different datasets :exclamation:You can run the static model by calling (remember to use the correct data directory!)ns-train kplanes --data <data-folder>and connect to the viewer using the link provided in the output of the training script.BenchmarksSynthetic NeRF(hybrid model)drumsmaterialsficusshipmicchairlegohotdogAVGPSNR26.3129.8232.4730.2733.7334.9836.5636.7732.61SSIM0.93940.95390.97880.87550.98570.98240.9820.97920.9596DNeRF(hybrid model)hell warriormutanthookballslegot-rexstand upjumping jacksAVGPSNR25.0634.2928.2243.0227.0333.5934.0433.4332.33SSIM0.94870.98390.95520.99540.9560.98170.98350.97970.973RoadmapExpected future updates to this repository:Including all datasets used in the K-Planes paperClarifying configuration of colliders (near-far)Add benchmarks and configs forlinearmodels
Package: kpler.sdk
The Kpler Python SDK provides access to Kpler data.It can be easily integrated into notebooks, scripts, and applications.It is available to all Kpler API clients (credentials required)Documentation :https://python-sdk.dev.kpler.comfromkpler.sdkimportPlatformfromkpler.sdk.configurationimportConfigurationfromkpler.sdk.resources.tradesimportTradesfromdatetimeimportdate,timedelta# Create configuration objectconfiguration=Configuration(Platform.Liquids,"<your email>","<your password>")# To change the platform use _change_platform method of Configuration classconfiguration._change_platform(Platform.Liquids)# Connect to one of the Kpler's client using your configuration object, ie: Tradestrades_client=Trades(configuration)# Get all possible columns returned by the get_trades querytrades_columns=trades_client.get_columns()# Do a get trades with default columns and with a maximum size of 5 for the dataframetrades_df=trades_client.get(size=5)# Get US imports over last weekus_imports=trades_client.get(to_zones=["United States"],products=["crude"],with_forecast=False,with_intra_country=True,start_date=date.today()-timedelta(days=7),columns=["vessel_name","closest_ancestor_product","closest_ancestor_grade","start","end","origin_location_name","destination_location_name",])
Package: kplot
kplotA little package to make it easy to make pretty plots in matplotlib without having to fiddle too much :-)UsageIn general, all that kplot will do is change the defaults in matplotlib via the style sheet that you want. In order to do this, simply add an import statement of the form"""python
import kplot.style
"""Where style is the style that you want! My person default right now is the kg style sheet. But there is also a dark mode, and an option that will work well for colorblind folk.
Package: kploy
Welcome to kploy, an opinionated Kubernetes deployment system for
appops. We use convention over configuration in order to enable you to
run microservices-style applications with Kubernetes as simple and fast
as possible.UsageSeekubernetes.sh/kployfor
installation and usage.DependenciesAll of the following are included in the setup:ThepyktoolkitPretty-print tabular data withtabulateReleases[x] In v0.10: adds experimentalpushandpullcommand viaKAR[x] In v0.9: addsscalecommand (autoscale yet TBD)[x] In v0.8: addsdebugcommand, some refactoring[x] In v0.7: adds support for environment data: automagic handling of
Kubernetes Secrets onrun[x] In v0.6:exportcommand creates snapshot of app; can be
imported when doinginit[x] In v0.5: simple support for helm charts via remotes (*.url)[x] In v0.4: support for namespaces (vianamespacefield in
Kployfile)[x] In v0.3: moved to Kubernauts org, new location ishttps://github.com/kubernauts/kploy[x] In v0.2:initcommand and app management: resources vialistand runtime statistics viastats[x] In v0.1:dryrunandruncommandsRoadmapkploy is now considered beta. This means the goal is now to stabilize
the API, gather usage experience and community feedback. See theissuelist for further
planned features.
Package: kpm-tools
KPM ToolsKPM Tools is an open-source Python package that extends the Kernel Polynomial Method (KPM) functionalities ofKwant, a popular software for quantum transport simulations in tight-binding models. Our package specifically enhances the KPM expansion capabilities within the realm of closed tight-binding systems.FeaturesAdvanced KPM expansion of typical spectral functions like Density of States, Green's Functions, Kubo Conductivity, and Chern Markers.Extremely efficient time evolution operator expansionAdditional functionalities like KPM vector factories producing tiles, and velocity and distance operators adapted to periodic boundaries.RequirementsPython >=3.9Kwant >= 1.4.4InstallationInstalling KPM ToolsYou can installKPM ToolsviapipfromPyPI:$pipinstallkpm-toolsImportant Note on Kwant DependencyWhileKPM Toolsrequires Kwant to function, direct installation of Kwant via pip can sometimes be problematic due to its specific build requirements. To ensure a smooth setup, we recommend the following installation approach:Try installing with pip (optional):You can attempt to install Kwant along with KPM Tools via pip:$pipinstallkpm-tools[kwant]If this installation fails, proceed to the next step.Install Kwant using Conda or follow Kwant's installation guide:We recommend using Conda to install Kwant, which typically handles its build requirements more reliably:$condainstall-cconda-forgekwantAlternatively, refer to theKwant installation pagefor detailed instructions on installing Kwant in different environments.After installing Kwant, you can then install KPM Tools using pip as shown above.Python APIPlease see thepython api referencefor details.ContributingContributions, especially in documentation and the 'concatenator' function/module, are very welcome. For more information, see ourContributor Guide.LicenseDistributed under the terms of theBSD 2-Clause license,KPM Toolsis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsMany of the ideas implemented in KPM Tools originate from the early work on KPM expansion on the paperComputation of topological phase diagram of disordered PbSnTe using the kernel polynomial method.Phys. Rev. Research 2, 013229 (2020)arXiv:1905:02215Consider citing that work if you use this package on a publication.Acknowledgments to KwantKPM Tools is built upon the robust and efficient foundation provided by Kwant. We extend our gratitude to the Kwant authors and contributors for their work in developing a versatile platform for quantum transport simulations. KPM Tools aims to complement Kwant's capabilities in KPM expansions, adhering to the high standards of quality and performance set by the Kwant project.See the original KPM implementation in Kwant:https://kwant-project.org/doc/1/tutorial/kpmhttps://kwant-project.org/doc/1/reference/kwant.kpmProject TemplateThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: kpn-api-store
kpn-api-store-pythonkpn-api-store-pythonis the Python client library for APIs provided by theKPN API Store.fromkpnapistore.messaging.sms_kpn.v1importClientclient_id="APP_CLIENT_ID"client_secret="APP_CLIENT_SECRET"client=Client(client_id,client_secret)client.send("KPN API","316xxxxxxxx","Hello from kpn-api-store-python!")
Package: kpn-dsh-mqtt-envelope
kpn-dsh-mqtt-envelopeInstallation:pip install kpn-dsh-mqtt-envelopeUsage:...# Import dsh_envelopeimportdsh_envelope...# Deserialize the mqtt message from kafka consumer(topic,message,tenant,publisher,publishertype,retain,qos,tracing)=dsh_envelope.unwrap(key,value)# Serialize the mqtt fields into kafka producer(key,value)=dsh_envelope.wrap(topic,message,tenant,publisher,publishertype,retain,qos,tracing)wheretype(key)andtype(value)arebytesas serialized/deserialized by DSH mqtt kafka bridge.Example:For akafka-pythonconsumer:fromkafkaimportKafkaConsumer,KafkaProducer# Initiate consumerconsumer=KafkaConsumer(...)# Subscribe to a stream with regex-pattern for <streamname>consumer.subscribe(pattern='^stream\\.<streamname>\\.[^.]*')formsginconsumer:(topic,message,tenant,publisher,publishertype,retain,qos,tracing)=dsh_envelope.unwrap(key,value)will return serialized values of the fields:topic: str
    mqtt topic suffix that the message is published to
message: bytes
    payload in bytes
tenant: str
    name of the tenant message is published from
publisher: str
    name of the publisher
publishertype: str
    type of the publisher
retain: bool
    if the message should be retained
    thus will be available in latest value store and through http-protocol-adapter
qos: int
    quality of service for mqtt
tracing: dict
    tracing span context in a python dictionary
Package: kpops
KPOpsKey featuresDeploy Kafka apps to Kubernetes: KPOps allows to deploy consecutive Kafka Streams applications and producers using an easy-to-read and -write pipeline definition.Manage Kafka Connectors: KPOps connects with your Kafka Connect cluster and deploys, validates, and deletes your connectors.Configure multiple pipelines and steps: KPOps has various abstractions that simplify configuring multiple pipelines and steps within pipelines by sharing common configuration between different components, such as producers or streaming applications.Handle your topics and schemas: KPOps not only creates and deletes your topics but also registers and deletes your schemas.Clean termination of Kafka components: KPOps removes your pipeline components (i.e., Kafka Streams applications) from the Kubernetes clusterandcleans up the component-related states (i.e., removing/resetting offset of Kafka consumer groups).Preview your pipeline changes: With the KPOps dry-run, you can ensure your pipeline definition is set up correctly. This helps to minimize downtime and prevent potential errors or issues that could impact your production environment.DocumentationFor detailed usage and installation instructions, check out
thedocumentation.Install KPOpsKPOps comes as aPyPI package.
You can install it withpip:pipinstallkpopsGitHub actionPlease refer to theGitHub Actions sectionfor the documentation.ContributingWe are happy if you want to contribute to this project.
If you find any bugs or have suggestions for improvements, please open an issue.
We are also happy to accept your PRs.
Just open an issue beforehand and let us know what you want to do and why.LicenseKPOps is licensed under theMIT License.
Package: kpplus
KPrototype plus (kpplus)DescriptionK-prototype is a clustering method invented to support both categorical and numerical variables[1]KPrototype plus (kpplus)is a Python 3 package that is designed to increase the performance ofnivoc's KPrototypes functionby usingNumba.This code is part ofStockholms diabetespreventiva program.Performance improvementAs anexample, I used one of theHeart Disease Data SetsfromUCIto test the performance.
This data set contains 4455 rows, 7 categorical variables, and 5 numerical variables.
We compare the performance between nicodv's kprototype function and k_prototype_plus.< nicodv's kprototype >
CPU times: user 2.14 s, sys: 18.2 ms, total: 2.16 s
Wall time: 1min 41s< k_prototype_plus >
CPU times: user 298 ms, sys: 9.24 ms, total: 308 ms
Wall time: 13.4 sNotice:Only Cao initiation is supported as the initiation method[2].System requirementInstalliationpip install kpplusUsagefromkpplusimportKPrototypes_plusmodel=KPrototypes_plus(n_clusters=3,n_init=4,gamma=None,n_jobs=-1)#initialize the modelmodel.fit_predict(X=df,categorical=[0,1])#fit the data and categorical into the mdoelmodel.labels_#return the cluster_labelsmodel.cluster_centroids_#return the cluster centroid points(prototypes)model.n_iter_#return the number of iterationsmodel.cost_#return the costsn_clusters:the number of clustersn_init:the number of parallel oprations by using different initializationsgamma (optional):A value that controls how algorithm favours categorical variables. (By default, it is the mean std of all numeric variables)n_jobs (optional, default=-1):The number of parallel processors. ('-1' means using all the processor)X:2-D numpy array (dataset)types:A numpy array that indicates if the variable is categorical or numerical.For example:types = [1,1,0,0,0,0]means the first two variables are categorical and the last four variables are numerical.AcknowledgementI'm extremely grateful toDr. Diego Yacaman MendezandDr. David Ebbevifor their support. They are two brilliant researchers who started this project with excellent knowledge of medical science, epidemiology, statistics and programming.Reference[1] Huang Z. Extensions to the k-Means Algorithm for Clustering Large Data Sets with Categorical Values. Data Mining and Knowledge Discovery. 1998;2(3):283-304.
[2] Cao F, Liang J, Bai LJESwA. A new initialization method for categorical data clustering. 2009;36(7):10223-8.
Package: kppy
kppy is a Python-module that provides full access to KeePass 1.x password databases which are used by the popular password manager KeePassX. Full access means:Open, save and close KP-files correctlyEdit KP-files correctly and comfortableAES encryptionFirst Python module for KeePass 1.x files that supports keyfiles, too.First Python-KeePass module for Python 3. (Python 2 is supported, too)Some explanation to KeePass databases:Database files are encrypted with AESDatabase entries are sorted in groupsGroups support subgroupsEvery entry has a title for better identificationExpiration dates for entries
Package: kpra-covid
Covid TrackerThis package gives information about covid19 cases reported and deaths around the worldTo runRun via docker:
    1. Clone this repo
    2. Run below commands from root directory of the project:
        - sh bin/build_docker.sh
        - sh bin/exe_docker.shRun without docker:
Clone this repo and run the below command from root directory (COVID)
    - sh bin/exe_covid.sh