Saravanan666/pypi-org huggingface dataset:
Package: kingbird-dashboard
User Interface for KingbirdFree software: Apache licenseSource:http://git.openstack.org/cgit/openstack/kingbird-dashboardBugs:http://bugs.launchpad.net/kingbird-dashboardFeaturesTODOEnabling in DevStackAdd this repo as an external repository into yourlocal.conffile:[[local|localrc]]
enable_plugin kingbird_dashboard https://github.com/openstack/kingbird-dashboardManual InstallationBegin by cloning the Horizon and Kingbird Dashboard repositories:git clone https://github.com/openstack/horizon
git clone https://github.com/openstack/kingbird-dashboardCreate a virtual environment and install Horizon dependencies:cd horizon
python tools/install_venv.pySet up yourlocal_settings.pyfile:cp openstack_dashboard/local/local_settings.py.example openstack_dashboard/local/local_settings.pyOpen up the copiedlocal_settings.pyfile in your preferred text
editor. You will want to customize several settings:OPENSTACK_HOSTshould be configured with the hostname of your
OpenStack server. Verify that theOPENSTACK_KEYSTONE_URLandOPENSTACK_KEYSTONE_DEFAULT_ROLEsettings are correct for your
environment. (They should be correct unless you modified your
OpenStack server to change them.)Install Kingbird Dashboard with all dependencies in your virtual environment:tools/with_venv.sh pip install -e ../kingbird-dashboard/And enable it in Horizon:ln -s ../kingbird-dashboard/kingbird_dashboard/enabled/_90_project_kingbird_panelgroup.py openstack_dashboard/local/enabled
ln -s ../kingbird-dashboard/kingbird_dashboard/enabled/_91_project_kingbird_kingbirds_panel.py openstack_dashboard/local/enabledTo run horizon with the newly enabled Kingbird Dashboard plugin run:./run_tests.sh --runserver 0.0.0.0:8080to have the application start on port 8080 and the horizon dashboard will be
available in your browser athttp://localhost:8080/
Package: king-caesar
Thumbail GeneratorPython CLI that generates a thumbnail image based on a videoGenerate image thumbnailpython generate_thumbnail.py <video path> <thumbnail image path>Notes:  Thumbnail image path must contain image file nameGenerate gif thumbnailpython generate_gifnail.py <video path> <thumbnail image path>Notes:  Thumbnail gif image path must contain .gif file nameSupported filesVideo: mp4, mkvImage: .png, .jpg, .gif**on generate_gifnail
Package: kingcow
kingcow这是一个用于网页请求、网页解析和爬虫的库网页标签解析kingcow提供了网页标签的解析，您只需提供标签的名称与属性，他就会返回属性的值importkingcowaskca=kc.get('https://www.taobao.com/')# 返回一个kingcow.Request对象，使用GET发送请求print('a.html_tag('a','href'))这段代码会打印出淘宝网首页的所有链接，你可以根据这些链接访问淘宝网的其他站点网页数据解析kingcow提供网络数据解析，可以快速方便解析网页数据，您只需提供标签和属性(可选)importkingcowaskca=kc.get('https://docs.python.org/zh-cn/3.8/tutorial/index.html')a.html_analysis('p')代码会打印出Python官方文档中为标签p的数据还可以用json类方法获取返回json网页爬取kingcow提供了Request类以及get,post函数这些请求方法，这几种请求方法的参数大致相同，但get和post中请不要填method。主要参数说明url:str类型，为网页地址data:请求数据，网页指定提交类型为application/x-www-form-urlencodedjson:请求类型，网页指定提交类型为application/jsonheaders:请求头method:模式，如GET,POSTcode:如果有data参数，会将data参数加密成code编码ip:使用代理ipSpider爬虫Spider爬虫有两个类，分别为Spider和Spider_For_Threading，我们先来介绍SpiderSpiderSpider是一个爬取多个网站的爬虫类，所需的参数大致与Request类相同，不同的是Spider不需要提供url，只需提供url的集合(不是set,是list)，还可以提供step，为爬取间隔。Spider初始化后不会爬取网站，必须要用户使用Spider.request方法爬取Spider还有四个类方法（Spider.request除外）:html_data:网页数据解析html_tag:网页标签解析xml_data:xml数据解析json_get:json标签项提取json:json提取Spider_For_ThreadingSpider_For_Threading是Spider的多线程版本，速度是Spider的四分之一，具体方法同Spider
Package: kingdom-core
🏰 Kingdom CoreLibrary containing the core modules for the kingdom-python-server.InstallationUse the package managerpipto installkingdom-core.pipinstallkingdom-coreYou can usepoetryas well.poetryaddkingdom-coreUsagefromkingdom_core.utilsimportfilesorm_files=files.find("orm.py","/")ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMITThis file is based onMake a README.
Package: kingdom-sdk
🏰 Kingdom SDKLibrary containing the core modules for the kingdom-python-server.FeaturesSee thechangelogto see all the features supported.InstallationUse the package managerpipto installkingdom-sdk.pipinstallkingdom-sdkYou can usepoetryas well.poetryaddkingdom-sdkUsagefromkingdom_sdk.utilsimportfilesorm_files=files.find("orm.py","/")TestTo test the database package, you need do it manually, running a migration. Make sure the database is configured before.cdtests/poc/
alembicrevision--autogenerate
alembicupgradeheadThe rest, runpytest.Don't commit the generated revision.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: kingfisher
WelcomeKingfisher is a fast and flexible program for procurement of sequence files (and
their annotations) from public data sources, including the European Nucleotide
Archive (ENA), NCBI SRA, Amazon AWS and Google Cloud. It's input is one or more
"Run" accessions e.g. DRR001970, or a BioProject accessions e.g. PRJNA621514 or
SRP260223.For more documentation, seehttps://wwood.github.io/kingfisher-download/
Package: kinghorn
KinghornPython 3 library for caching AWS resourcesPurposeThis library provides caching of AWS resources, which can save development time and money making API calls, as well as reduce the chances of errors taking place from running scripts against resources in flux. I use it to cache resources such as EC2 instances, volumes, and snapshots for retrieval in later scripts. I disliked having to call an API and perform an O(n^2) operation to unwrap my instance metadata every time I did something with boto3. With Kinghorn I can easily place resources in dictionaries for constant time access.OpinionsI've chosen to discard metadata and "unwrap" entity metadata for storage. I've used clients instead of resources for Kinghorn to make it easy to alter the library to access low level API functions if needed. The library expects appropriate credentials in ~/.aws/credentials.Installation instructions for Mac OS Xruby -e "$(curl -fsSLhttps://raw.github.com/mxcl/homebrew/go)"brew install pythoncurl -Ohttp://python-distribute.org/distribute_setup.pypython distribute_setup.pycurl -Ohttps://raw.github.com/pypa/pip/master/contrib/get-pip.pypython get-pip.pypip3 install boto3python3 -m kinghornPublishingBump version insetup.pyandkinghorn/__init.py__and run ./publish.shConfigurationConfiguration is handled with environment variables, as follows:KINGHORN_ENVIRONMENT - Which environment your API credentials are for, for example factory, production, etc.KINGHORN_LOGGING_OUT - Set to 1 to log to std out, useful for local testing and debuggingKINGHORN_LOGGING_LEVELKINGHORN_LOGGING_FILEKINGHORN_CACHE_LOCATIONFilespublish.sh- Helper script to publish to PyPIsetup.py- Metadata for publishing packages.gitignore- Files to ignore for gitkinghorn/__main__.py- Basic validation script for modulekinghorn/__init__.py- Exports all public functionskinghorn/kinghorn.py- The librarykinghorn/test_kinghorn.py- An example file describing some ways to use the library and testing all functionsFuture feature ideasAdditional entities for different services in AWS as I need themAutomated configurable cache expirationPassthrough to the AWS API on cache miss
Package: kingnest
Ultramax PackageThis is a nester package. You can useGithub-flavored Markdownto write your content.|-- package/
|   |-- dist/
|   |-- src/
|   |   |-- kingnest/
|   |   |   |--init.py
|   |   |   |-- nest.py
|   |   |   |-- 更多模块.py
|   |-- test/
|   |-- LICENSE
|   |-- pyproject.toml
|   |-- README.md目录结构
package/：这是项目的根目录。
dist/：这个目录将包含打包的文件，包括源码分发包（.tar.gz 文件）和轮子分发包（.whl 文件）。这些文件是通过运行 python -m build 生成的。
src/：这个目录包含你的源代码。这是一种常见的目录结构，可以帮助避免一些 Python 导入问题。
kingnest/：这是包的主目录，它包含 Python 源代码。这个目录的名称应该与包名称一致。init.py：这个文件是一个特殊的文件，它标记 kingnest/ 目录为一个 Python 包，这样它就可以作为一个模块导入了。这个文件可以为空，或者包含初始化代码。
nest.py：这是主要 Python 文件。递归函数在这里。
module1.py: 类和其他代码应在这里
module2.py:
module3.py:
test/：这个目录包含单元测试。
LICENSE：这个文件列出项目采用的开源许可证。这是非常重要的，因为它定义了其他人可以如何使用你的代码。
pyproject.toml：这是项目的配置文件。在这里，定义项目的元数据（如名称、版本、作者等）以及项目的依赖关系。
README.md：这个文件应该包含项目的介绍和使用说明。这是项目的主要文档，尽可能详细和清晰。Python 模块打包发布到PyPI：组织代码
目录结构如上创建 pyproject.toml
pyproject.toml 是 Python 包的配置文件。在这个文件中指定包的名称、版本、作者、许可证等信息，以及包的依赖关系。
现在 Python 社区推荐使用 pyproject.toml，因为它提供了一种更标准化和灵活的方式来管理包的配置。创建 README.md 和 LICENSE
在项目根目录下创建一个 README.md 文件，说明包是什么，以及如何使用它，并包含一个 LICENSE 文件，指明包的许可证。使用 build 命令来打包你的项目。首先，需要安装 build 模块：pip install build然后，在你的项目根目录下运行以下命令来打包你的项目：python -m build这将会在 dist/ 目录下创建一个源代码分发包（.tar.gz 文件）和一个轮子分发包（.whl 文件）。使用 twine 命令来发布包到 PyPI（Python Package Index）。首先，你需要安装 twine：pip install twine然后，可以运行以下命令来上传你的包：twine upload dist/*在这个过程中，要输入 PyPI 用户名和密码。如果还没有 PyPI 账户，可以在 PyPI 网站上创建一个。
启用两用验证后，必须使用API令牌登录
用户名设为token密码设置为令牌值，包括pypi-前缀如果使用Twine来将程序上传至PyPI，像这样来设置$HOME/.pypirc文件，每次上传模块就不用输入用户名密码了。
[pypi]
username =tokenpassword = pypi-*****在Linux操作系统中，$HOME是一个环境变量，它指向当前用户的主目录。通常，这个目录位于/home目录下。
当您在终端中执行cd命令时，它会将当前工作目录更改为HOME所指示的目录。从官方源安装
pip install -ihttps://pypi.org/simple/kingnest==0.0.6临时使用pip install -i https://pypi.tuna.tsinghua.edu.cn/simple some-package从文件安装
pip install -r requirements.txt
Package: kingpin
Kingpin: the chief element of any system, plan, or the like.Kingpin provides 3 main functions:API Abstraction- Job instructions are provided to Kingpin via a JSON based DSL (read below). The schema is strict and consistent from one action to another.Automation Engine- Kingpin leverages python’stornadoengine.Parallel Execution- Aside from non-blocking network IO, Kingpin can execute any action in parallel with another. (Read group.Async below)DocumentationDocumentation is hosted athttps://kingpin.readthedocs.org
Package: kingsoftcloud-sdk-python
Ksyun Cloud Python SDK is the official software development kit, which allows Python developers to write software that makes use of ksyun Cloud services.The SDK works on Python versions:2.7 and greater, including 3.xQuick StartFirst, install the library:$pipinstallkingsoftcloud-sdk-pythonor download source code from github and install:$gitclonehttps://github.com/kingsoftcloud/sdk-python$cdkingsoftcloud-sdk-python$pythonsetup.pyinstall
Package: kingspan-connect-sensor
kingspan-connect-sensorAPI to get oil tank fromKingspan SENSiT sensorsTo make use of the API, you will need the credentials you used to register with the App. You do not need other details such as the tank ID as these are already associated with your account.Installationpython3-mpipkingspan-connect-sensorUsageNOTEfrom version 2.0.0, the API changes to use attributes rather than methods for tank parameters.Reading documents:fromconnectsensorimportSensorClientclient=SensorClient()client.login("test@example.com","s3cret")tanks=client.tankstank_level=tanks[0].levelThetanksmethod returns aTanksobject which can be queried for the status of the specific tank.Async UsageFrom version 2.0.0, an asyncio verison of the client is available:asyncwithAsyncSensorClient()asclient:awaitclient.login("test@example.com","s3cret")tanks=awaitclient.tankstank_level=awaittanks[0].leveltank_capcity=awaittanks[0].capacitytank_percent=100*(tank_level/tank_percent)print(f"Tank is{tank_percent:.1f}% full")Tanks objectAs of version 3.0,historyno longer returns a Pandas dataframe to simplify packge dependencies. Instead, an list of dicts is returned, where each list element is a sample from the web API, sorted by logging time. There should be one record per day. Each dict has the following keys:reading_date: a datetime object indicating the time a measurement was madelevel_percent: integer percentage fulllevel_litres: number of lites in the tankYou can construct a Pandas dataframe simply using:tanks=awaitclient.tankshistory=awaittanks[0].historydf=pd.DataFrame(history)ScriptsReporting on the current status of the tank usingkingspan-status:%kingspan-status--username=test@example.com--password=s3cret

HomeTank:Capacity=2000SerialNumber=20001999Model=UnknownLevel=90%(1148litres)LastRead=2021-10-0900:42:47.947000

History:Readingdate%FullLitres30-Jan-202100:2994122431-Jan-202100:5980104001-Feb-202100:2978100802-Feb-202100:5976986kingspan-notifiercan be used to check the status of a tabk and report via email when the tank is likely to run out of oil. As of version 3.0,pandasis no longer installed as a dependency so you mustpip install pandasmanually to usekingspan-notifier.%kingspan-notifier--configkingspan.ini
Currentlevel1148litres
Nonotification;196daysoilremainCommand line options include:--config CONFIG: a config file in ini-format--no-update: don't update cache with new data (defaults to updating the DB cache)--window WINDOW: the number of days history to consider (default: 14 days)--notice NOTICE: the number of days before out-of-oil forecast to warn (default: 14)An example config file is:[sensit]username=test@example.compassword=s3cretcache=/home/me/kingspan.dbstart-date=2021-01-31[smtp]server=smtp.isp.co.ukusername=ispuseremail=test@example.compassword=smtps3cretThe cache is an SQLite database and will be intialised if not present.
Package: kings-selenium
kings_selenium基于chrome的使用selenium将web端和appium常用方法封装集成成一个简单的类,其中节点查询和点击都是基于异步的,不需要再在程序中使用time.sleep(x)安装pip install -ihttps://pypi.org/simple/kings_selenium配置 config.json配置文件,路径为当前项目的根目录创建一个config文件夹,里面再创建config.json公共POLL_FREQUENCY异步查询节点轮循时间,单位秒,默认0.5TIMEOUT节点查询超时时间web端CHROME_DEBUGGER_ADDRESS谷歌浏览器调试地址，默认,使用此参数需要先启动谷歌浏览器调试模式
127.0.0.1:9222DRIVER_LOCATIONchrome driver驱动路径,使用web时必填appiumCOMMAND_EXECUTOR
appium启动调试地址，默认http://127.0.0.1:4723/wd/hubDESIRED_CAPABILITIESappium启动联调参数,使用appium时必填,如
"DESIRED_CAPABILITIES": {
    "platformName": "iOS",
    "platformVersion": "14.0",
    "deviceName": "Kings",
    "udid": "xxx",
    "appPushTimeout": 300000,
    "noReset": "True",
    "webkitgtk:browserOptions": {
      "excludeSwitches": [
        "enable-automation"
      ],
      "args": [
        "--incognito",
        "--headless",
        "--disable-infobars",
        "--disable-javascript"
      ]
    }
  }使用from kings_selenium.selenium_web import SeleniumWeb

seleniumWeb = SeleniumWeb(True)
seleniumWeb.open_url_debug("https://www.baidu.com")
seleniumWeb.send_keys_by_id("kw", "hello")
seleniumWeb.click_by_id("su")app端
from kings_selenium.selenium_phone import SeleniumPhone

"""模拟京东app点击我的"""
seleniumPhone = SeleniumPhone('/Users/wilson/Desktop/jd.ipa')
seleniumPhone.click_by_xpath('//XCUIElementTypeStaticText[@name="我的"]')
Package: kinguin-client
kinguin-clientA tiny API wrapper in Python for Kinguin e-commerce API (Kinguin-eCommerce-API)Installationpip install kinguin-clientBasic Usagefrom kinguin_client import Kinguin

client = Kinguin(api_key="API_KEY")

client.balance().get()
{'balance': 0}

client.orders().get()
{'results': [], 'item_count': 0}LicenseMIT
Package: kingunit
KingUnit安装依赖pipinstall-rrequirements.txt安装allure确保已经安装了JDK（1.8+），然后根据操作系统安装allure。Windows:打开https://github.com/allure-framework/allure2/releases下载最新版本的allure，解压到任意目录，进入bin文件下，运行allure.bat，闪现一下说明安装成功，之后将bin目录添加到环境变量。Mac:brewinstallallure运行测试fromkingunitimportKingUnitif__name__=='__main__':KingUnit.run()
Package: kinisot
IntroductionKinisotis a Python program to compute kinetic isotope effects from two Gaussian output files, one of which is a ground state and the other a transition state. It is developed in thePaton research groupat Colorado State University.This is a Python version ofKinisot, inspired by the Fortran version originally written byHenry Rzepa. This version does not require parameter files to run and allows easy manipulation of temperature andvibrational scaling factors. The level of theory and basis set are detected from in the output files and the program will attempt to assign the appropriate scaling factor based on data from theTruhlar group. Isotopic substitutions are to be specified by the command line, such that separate computations with Gaussian are not required. The program diagonalizes the mass-weighted Hessian matricies to obtain harmonic vibrational frequencies and Bigeleisen-Mayer Reduced Isotopic Partition Function Ratios. One difference with the Gaussian program itself is that the lowest five/six normal modes (translations and rotations) are not projected out, however, this is also the approach taken byquiver. Testing  this approach against calculation of the Reduced Isotopic Partition Function Ratios by hand (!) using the frequencies in the Gaussian output files led to agreeement up to 4DP. A one-dimensional tunneling correction is also included, which is the Bell infinite-parabola model.Also see related discussions oncomputing KIE valuesThe current version is currently hard-coded to consider2D/1H,13C/12C and17O/16O isotopic replacements. This can be modified in Hess_to_Freq.py.A video guide to using an older version this software is available at Youtube:InstallationTo installKinisotwithcondaorpipy:conda install kinisot -c conda-forge
pip install kinisotUsagepython-mkinisot--rctreactant_output--tsts_output--iso1,2,3(-ttemperature)(-sscalefactor)The two output files contain Gaussian frequency calculations performed for the reactant and transition state at the same level of theory.The--isoflag is required and specifies a string of atom number(s) which are to be substituted for heavier isotopes. Multiple atom numbers require quotation marks and are separated by spaces.The-toption specifies temperature (in Kelvin). N.B. This does not have to correspond to the temperature used in the Gaussian calculation since the Reduced Isotopic Partition Function Ratios are evalulated at the requested temperature. The default value is 298.15 K.The-soption is a scaling factor for vibrational frequencies. Empirical scaling factors have been determined for several functional/basis set combinations, and these are applied automatically using values from the Truhlar group based on detection of the level of theory and basis set in the output files. The ZPE-scaling factors are selected if available. The default value when no scaling factor is available is 1 (no scale factor).See examples/ for more examples
Package: kinjax
kinjaxkinjaxis a Python package that provides functions for computing the forward kinematics and Jacobian of a robot. It uses JAX to enable fast computations on GPUs.InstallationTo install the module, run:pip install kinjaxUsageTo use kinjax, you need to provide it with a URDF file that describes the robot you want to compute the forward kinematics and Jacobian for. You can then callget_fk_fnandget_jacobian_fnto create functions that can compute the forward kinematics and Jacobian of the robot, respectively.Here's an example of how to usekinjaxto compute the forward kinematics and Jacobian of a robot:importjaximportjax.numpyasjnpimportkinjaxend_effector_link_name="hand"dof=6# Load the URDF filelink_dict,joint_dict=kinjax.get_link_joint_dict("robot.urdf")# Compute the forward kinematics function for the robotfk_fn=kinjax.get_fk_fn(link_dict,joint_dict,dof,end_effector_link_name)# Compute the Jacobian function for the robotjac_fn=kinjax.get_jacobian_fn(link_dict,joint_dict,dof,end_effector_link_name)# Compute the forward kinematics and Jacobian for a given joint configurationq=jnp.array([0.1,0.2,0.3,0.4,0.5,0.6])T_fk=fk_fn(q)J=jac_fn(q)LicenseThis project is licensed under the MIT License
Package: kinjector
KinJectorInject/eject JSON/YAML data to/from KiCad Board files.Free software: MIT licenseDocumentation:https://devbisme.github.io/kinjectorFeaturesParameters in one or more JSON or YAML files can be injected into a
KiCad PCB file.Parameters from a KiCad PCB file can be extracted and stored in a
JSON or YAML file.The currently-supported set of parameters can control the design rules, net classes,
assignment of netclasses to particular nets, plotting options,
and (X,Y)/orientation/top-bottom-side position of part footprints.Subsets of parameters can be used to restrict the scope of effects upon the PCB.A script is provided to allow injection/ejection of JSON/YAML data to/from
a KiCad PCB file. In addition, thekinjectormodule can be used within
other Python scripts to manipulate KiCad PCB files.History1.0.0 (2021-09-16)Decided this tool was mature to the point it could be called 1.0.0.0.0.6 (2020-02-14)yaml.load() will accept a KiCad board file as legal YAML, so place additional checks
to detect yaml files and prevent over-writing .kicad_pcb files with YAML.0.0.5 (2019-06-19)Rearranged hierarchy of board data to more closely reflect KiCad board setup dialog.0.0.4 (2019-06-10)Added ability to inject/eject plot settings (but not drill settings).0.0.3 (2019-06-07)Added ability to inject/eject layer enables and visibility.0.0.2 (2019-05-29)Added ability to inject/eject part (X,Y), orientation, and PCB top/bottom-side.Added ability to inject/eject board design rules.Now works with both JSON and YAML file formats.Unit tests added.Command-line tool added.Documentation added.0.0.1 (2019-05-15)First release on PyPI.
Package: kin-kernel
📖 DigitalKin.ai - KinKernelWelcome to the DigitalKin KinKernel ! This package is designed to enable developers to create Cells, which are autonomous agents that can be integrated into the Internet of Agents (IoA) ecosystem powered by DigitalKin.👀 OverviewThe KinKernel provides a framework for creating and managing Cells. Each Cell represents a distinct autonomous agent with a specific role and behavior within the IoA. The KinKernel ensures that all Cells adhere to a standard interface and can communicate effectively within the ecosystem.💡 FeaturesAbstract base classes for standardizing Cell creationResponse models for consistent communicationHelper methods for schema information accessConfiguration managementExample Cell implementation🛠️ InstallationBefore installing the KinKernel, ensure you have Python installed on your system. This package requires Python 3.10 or higher.To install the KinKernel
With pipy:pipinstallkin-kernelOr clone the repository and install the dependencies:gitclonehttps://github.com/DigitalKin/kin-kernel.gitcdkin-kernel-kit
pipinstall-rrequirements/prod.txtFor development purposes, you may also want to install the development dependencies:pipinstall-rrequirements/dev.txt✨ LinterExecute linters:flake8kinkernelblackkinkernel--check--diffblackkinkernelmypykinkernelpylintkinkernel💻 UsageTo create a new Cell, you'll need to subclass theCellclass provided in the kinKernel and implement the required methods and properties.Here's a simple example of a Cell that processes input data:frompydanticimportBaseModelfromkinkernelimportCellfromkinkernel.configimportConfigModel,EnvVarclassMyInputModel(BaseModel):value1:intvalue2:strclassMyOutputModel(BaseModel):processed_value:intclassMyCell(Cell[MyInputModel,MyOutputModel]):role="Processor"description="Processes input data"input_format=MyInputModeloutput_format=MyOutputModelconfig=ConfigModel(env_vars=[EnvVar(key="ENV_VAR_1",value="value1"),EnvVar(key="ENV_VAR_2",value="value2"),])asyncdef_execute(self,input_data:MyInputModel)->MyOutputModel:# Process the input_data as neededexec_result={"processed_value":input_data.value1*2}returnMyOutputModel(**exec_result)You can then instantiate and execute your Cell as follows:my_cell=MyCell()input_data=MyInputModel(value1=10,value2="example")output_data=my_cell.execute(input_data)print(output_data)For a more detailed example, refer to theexamples/simple_cell_example.pyfile in the repository.🧪 TestingThe CDK comes with a set of unit tests to ensure that your Cells work as expected. To run the tests, execute the following command:pytest👥 ContributionContributions to the KinKernel are welcome! If you have suggestions for improvements or find any issues, please open an issue on our GitHub repository.🤗 SupportIf you have any questions or need support with the KinKernel, please reach out to us atcontact@digitalkin.ai.Thank you for using the DigitalKin Cell Development Kit. We look forward to seeing the innovative Cells you'll create for the Internet of Agents!Kin-kernel © 2023 by DigitalKin is licensed under CC BY-NC-SA 4.0