Saravanan666/pypi-org huggingface dataset:
Package: dictstore
dictstoredictstore is a simple local data store for Python that aims to provide an interface similar to a python dictionary.Getting StartedInstallationpipinstalldictstoreUsage# file: sample_1.pyfromdictstoreimportDictStoredata=DictStore()d[1]=45# file: sample_2.pyfromdictstoreimportDictStoredata=DictStore()print(d[1])# output: 45Considerationsdictstore uses an in memory dictionary to support fast readsusing multiple DictStore instances for the same data file is not supported. Instead DictStore class returns the same instance for the same data file throughout the python code (Singleton behaviour).dictstore is best suited for CLIs or similar applications where values have to be remembered accross multiple runs.The data file is a plain readable text file and no encryption is offered by dictstore.dictstore might not be the fastest datastore, its promise is to get the work done and nothing more.dictstore will evaluate the type of value for all the nested objects in a given value, this is done using a Tree.This project has not be tested for concurrency safety. Please be cautious when using in projects involving multi-anything.KeysAll Hashable Data Types are supported as keys.Hashable Data TypesNameTypeStringstrIntegerintFloatfloatTupletupleValuesDictstore usesastpackage andast.literal_evalunder the hood, so currently all the data types supported byast.literal_evalexcept Ellipsis are supported as values.strings, bytes, numbers, tuples, lists, dicts, sets, booleans, None.For more information about ast.literal_eval visit the following link.https://docs.python.org/3/library/ast.html#ast.literal_eval
Package: dict-to-db
📣 简介1.用dict快速创建SQL表，方便用Python做一些小程序时，对数据存储的烦劳db.insert({"user":"张三","password":"1234","age":66})"""上面语句将会自动创建数据表 t1(表名可以人工指定),并将这条记录保存到t1表中,建表结构如下crate table t1(user text,password text,age  integer)"""2.支持将常见的Python数据结构保存到数据库，如list,tuple,Python对象，def定义的函数等insert_dict={# 举例支持的数据类型'str':'hello word','int':2,'float':3.3,'datetime':datetime.datetime.now(),'list':[1,2,3],'dict':{"A":1,"B":2},'dict2':{1:'3',4:'5'},'obj':object(),# 对象是支持保存到数据库的# 'func':  # def 定义的函数是支持保存到数据库的，lambda 函数是不支持的}3.可以快速将结构简单Excel表数据导入到数据库中，在一定程度上实现用SQL查询Excel【文字简介】：dict_to_db 是一个便捷的将Python dict对象保存到关系型数据库(现支持sqlite)的工具,
让dict数据保存到SQLite数据库同使用MongoDB的便捷有一定的相似性,适合小项目，单机项目，小爬虫等快速开发使用，并提供了几个便捷将Excel文件导入数据库的方法，可以实现结构简单的Excel
用SQL查询Excel里面的数据，然后导出新的Excel文件，还可以注册函数，用函数处理Excel的数据后再导出数据，实现更丰富的功能✨ 特性简洁明了的API设计，函数名称和SQL语法一定程度统一，方便使用增加更多方便快捷的数据插入函数insert_or_updateinsert_or_replaceexcel_to_db 从Excel中导入数据到数据库更多提升开发速度的小功能可以自动给插入数据添加插入时间，更新时间等可以自动 alter 合并表结构，方便便捷开发便捷的Excel处理函数，方便用SQL查询Excel文件并导出结果 (ps:结构过于复杂的Excel不适用)🔰 安装$pipinstalldict_to_db📝 使用简单入门importdatetimefromdict_to_dbimportDictToDbdb=DictToDb('demo.db')# 连接demo.db 数据库文件，没有则创建insert_dict={'str':'hello word','int':2,'float':3.3,'datetime':datetime.datetime.now(),'list':[1,2,3],'dict':{"A":1,"B":2},'dict2':{1:'3',4:'5'},'obj':object(),# 对象是支持保存到数据库的# 'func':  # def 定义的函数是支持保存到数据库的，lambda 函数是不支持的}# 这里会自动创建table，并将数据保存到该tabledb.insert(insert_dict)result=db.select(table_name='t1')# 默认的表名为t1,也可以自定义表名print(result[0]['dict2']==insert_dict['dict2'])# True  原始数据与查询数据 保持一致"""上述代码自动创建的数据表结构如下：CREATE TABLE t1 (str text ,int integer ,float double ,datetime timestamp ,list json_text ,dict json_text ,obj obj)"""连接数据库连接数据库文件db=DictToDb("demo.db")# 连接demo.db数据库自定义表名db.insert({"username":"张三",'age':66},table_name="user")# 手动指定表名为user创建表时 手动定义字段类型和字段描述信息定义字段类型和字段描述信息，通过dict 里面key的名字来定义， 格式为【字段名@字段类型#字段描述信息】，具体详细使用如下创建数据表并手动指定数据类型 【格式：字段名@字段类型】db.insert({"username":"张三",'age@text':66})#手动指定age类型为text，如不指定，程序自动判断为integer创建数据表并设置为主键【格式：字段名#字段描述信息（如是否是主键，default值，是否unique等）】db.insert({"username#pk":"张三",'age':66})# 手动指定username字段为主键创建数据表设置联合主键# 手动指定username和user_id为联合主键db.insert({"username#pk":"张三","user_id#pk":"66",'age':66})# 定义主键也可以使用全称 primary key  pk只是简写db.insert({"username#primary key":"张三","user_id#primary key":"66",'age':66})创建数据表并给字段设置默认值【格式：字段名#default xxx】db.insert({"username":"张三",'age#default 0':66})# 设置age的默认值为0
Package: dicttokv
dicttokvconverts nested dictionary and list object into key-value tuples.
tuples are useful for KeyValue Store and machine-learning.RequirementsPython 2.7 or later (not support 3.x)Featurestsv conversion method is included.Setup$ pip install dicttokvHistory0.1.0 (2013-12)
0.1.5 (2014-01-01)
Package: dict-to-object
dict-to-objectimportdicttoobjecttest_dict={"key1":1,"key2":{"key3":"value3"}}readonly_object=dicttoobject.dict_to_readonly_object(test_dict)print(readonly_object)# ReadOnlyObject(key1=1, key2=ReadOnlyObject(key3='value3'))try:readonly_object.key2=2exceptdicttoobject.DoNotWriteErrorase:print(e.attr_name)# key2print(e.attr_value)# 2writable_object=dicttoobject.dict_to_writable_object(test_dict)print(writable_object)# WritableObject(key1=1, key2=WritableObject(key3='value3'))writable_object.key2.key3=3print(writable_object.key2.key3)# 3writable_object.key4=4print(writable_object.key4)# 4dict_from_readonly=dicttoobject.object_to_dict(readonly_object)print(dict_from_readonly)# {'key1': 1, 'key2': {'key3': 'value3'}}dict_from_writable=dicttoobject.object_to_dict(writable_object)print(dict_from_writable)# {'key1': 1, 'key2': {'key3': 3}, 'key4': 4}
Package: dicttools
dicttoolsa set of dictionary utilities that attempt to make handling python dictionaries
a little easier.installing> git clonehttp://github.com/rlgomes/dicttools.git#egg=dicttools> cd dicttools
> python setup.py installor install directly from github with:> pip install -e git+git://github.com/rlgomes/dicttools.git#egg=dicttoolsusage`{r basicconsole} > import dicttools > dicttools.filter(lambda key, value: key > 2, { 1: None, 2:{ 3: None },4:{}}){4: {}} ``{r basicconsole} > dicttools.map(lambda key, value: (key, True), { 1: None, 2: 23,4:{}}){1: True, 2: True, 4: True} `
Package: dicttoxml2
Dict to XMLConverts a Python dictionary or other native data type into a valid XML string.
This is a fork that support Python 3.9 and forward versions and drop all EOL (<=3.6) versions altogether.
It is mostly backward-compatible, act as a drop-in replacement.InstallationThis module should work in Python 3.7+.The dicttoxml module ispublished on the Python Package Index, so you can install it usingpip.pip install dicttoxml2That should be all you need to do.Basic UsageOnce installed, import the library into your script and convert a dict into xml by running thedicttoxmlfunction:>>> import dicttoxml2
>>> xml = dicttoxml2.dicttoxml(some_dict)Alternately, you can import thedicttoxml()function from the library.>>> from dicttoxml2 import dicttoxml
>>> xml = dicttoxml(some_dict)That's it!AuthorAuthor: Ryan McGrealEmail:ryan@quandyfactory.comRepository:http://github.com/quandyfactory/dicttoxmlMaintainerAuthor: Ahmed TAHRIEmail:ahmed.tahri@cloudnursery.devRepository:http://github.com/Ousret/dicttoxmlCopyright and LicenceCopyright 2012 by Ryan McGreal.Released under the GNU General Public Licence, Version 2:http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
Package: dict-unpack
What does this tool do?A specialized dictionary splitting tool that allows you to unpack a dictionary from its internal array or list values and generate a list. Each list will have a complete copy of all key-value pairs.
It's somewhat similar to a matrix.
This tool is designed to split arrays within JSON data into multiple records, making it easier to insert into a database.Examplefor listdata = {
    "id": 1, 
    "name": "John", 
    "subject": [{"id": 22, "des": "math"}, {"id": 23, "des": "art"}]
}Allow overriding parent's same-named key-value pairs by default.unpack(data, ["subject"])

Output:
[{'id': 22, 'name': 'John', 'des': 'math'},
{'id': 23, 'name': 'John', 'des': 'art'}]Forbid overriding parent's same-named key-value pairs.unpack(data, ["subject"], ".")

Output:
[{'id': 1, 'name': 'John', 'subject.id': 1, 'subject.name': 'John'},
{'id': 1, 'name': 'John', 'subject.id': 1, 'subject.name': 'John'}]An empty list will be returned when a non-existent path is passed in.unpack(data, ["subject", "name"], ".")

Output:
[]For double-layer or multi-layer nestingdata = {
    "id": 1,
    "name": "John",
    "subject": [{
        "subjectid": 22,
        "des": [{"key": "a"},
                {"key": "b"}]
    }, {"subjectid": 23,
        "des": [{"key": "a"},
                {"key": "e"}]
        }]
}unpack(data, ["subject"])

Output:
[
{'id': 1, 'name': 'John', 'subjectid': 22, 'des': [{'key': 'a'}, {'key': 'b'}]}, 
{'id': 1, 'name': 'John', 'subjectid': 23, 'des': [{'key': 'a'}, {'key': 'e'}]}
]unpack(data, ["subject", "des"])

Output:
[
{'id': 1, 'name': 'John', 'subjectid': 22, 'key': 'a'}, 
{'id': 1, 'name': 'John', 'subjectid': 22, 'key': 'b'}, 
{'id': 1, 'name': 'John', 'subjectid': 23, 'key': 'a'}, 
{'id': 1, 'name': 'John', 'subjectid': 23, 'key': 'e'}
]If it is empty, override the same-named key-value pairs in the parent. If it is not empty, use the provided string as the delimiter to connect with the parent key.unpack(data, ["subject", "des"], "_")

Output:
[
{'id': 1, 'name': 'John', 'subject_subjectid': 22, 'subject_des_key': 'a'},
{'id': 1, 'name': 'John', 'subject_subjectid': 22, 'subject_des_key': 'b'},
{'id': 1, 'name': 'John', 'subject_subjectid': 23, 'subject_des_key': 'a'},
{'id': 1, 'name': 'John', 'subject_subjectid': 23, 'subject_des_key': 'e'}
]for arrayunpack(
dictionary = {"id": 1, "name": "John", "grades": [85, 92, 78]},
index      = ["grades"],
delimiter  = None
)Array-type fields only allow single-level unpacking.Output:
[
{"id": 1, "name": "John", "grade": 85},
{"id": 1, "name": "John", "grade": 92},
{"id": 1, "name": "John", "grade": 78}
]
Package: dictupdate
Dict UpdaterIt used to update any nested dict and list object . Also provide the option
to update nested dictionary within the list by searching mechanism .Feature Offer :Update the dictionary object .Delete nested dictionary value .Append nested list object .How to Install the librarypipinstalldictupdateExampleUpdating simple dictionary objectfromdictupdateimportDictUpdater# source to updatesource={"a":{"b":"value_need_to_update"}}# target to updatetarget={"a":{"b":"existing value updated","c":"new value added"}}dict_update=DictUpdater.update(data=source,update_value=target)print(dict_update)Output :{'a': {'b': 'existing value updated', 'c': 'new value added'}}Updating Recursive dictionary with list object.Updating dictionary with listing object which again contain dictionary object, Normal recursive update operation will
fail to update these type value because it required extra search layer. To tackle this issue DictUpdater.update have
extra parameter which help to identify key and update value .operation mapping value structure{  
< search path separated by seperator(->)::operation : search_key
 }Let's understand what is search path
Bellow  given dictionary object which contain list  .source={"a":[{"search":1,"b":[{"c":"required_to_update","value":"target"},{},{}]},{}]}There is 'target' value is present . If you look carefully there is path generated from root location .
which is 'a->b', So technically search path in list contain value is a dictionary key path followed by seperator .Let try to understand , what is search value ? . In a list of dictionary , which dictionary object we want to update .
Means filter dictionary by  search.{ 
  a::operation : search,
  a->b:operation : c,
}

"search" and "c" are dictionary key which help to indentify dict objet .What kind of operation currently it supports .
update : update the all search dictionary .
update_append : update the all search dictionary ,if it failed then append the value in list.
insert : it is default operation .
append : it append the value in dictionary .
delete : it delete the dict value in list.Example to update recursive list dictionary object .Update the only target valuefromdictupdateimportDictUpdaterfrompprintimportpprintasppsource={"a":[{"search":1,"b":[{"c":"required_to_update","value":"target"},{},{}]},{}]}# things which required to update must have exact structure .update_value={"a":[{"search":1,"b":[{"c":"required_to_update","value":"new_value"}]}]}print("-------------- Before Update --------------")pp(source)new_value=DictUpdater.update(data=source,update_value=update_value,operation_mapping={"a::update_append":"search","a->b::update_append":"c"},data_muted=False)print("-------------- After Update --------------")pp(new_value)Output :-------------- Before Update --------------
{'a': [{'b': [{'c': 'required_to_update', 'value': 'target'}, {}, {}],
        'search': 1},
       {}]}
-------------- After Update --------------
{'a': [{'b': [{'c': 'required_to_update', 'value': 'new_value'}, {}, {}],
        'search': 1},
       {}]}
Package: dictutils
dictutilsA collection of useful tools for manipulating dictionaries.dictutils.qsdictTakes a list of dicts or objects and convert it into nested dicts.lst=[{"shape":"circle","colour":"blue","count":5},{"shape":"circle","colour":"pink","count":15},{"shape":"square","colour":"yellow","count":29},{"shape":"square","colour":"blue","count":10}]qsdict(lst,"shape","colour","count")# returns{"circle":{"blue":5,"pink":15},"square":{"yellow":29,"blue":10}}qsdict(lst,"colour","shape","count")# returns{"blue":{"circle":5,"square":10},"pink":{"circle":15},"yellow":{"square":29}}Can also accept callablesqsdict(lst,lambdax:x["colour"][0:2],"shape","count"){"bl":{"circle":5,"square":10},"pi":{"circle":15},"ye":{"square":29}}Access an arbitary number of argumentslst=[{"shape":"circle","colour":"blue","country":"France","count":5},{"shape":"circle","colour":"pink","country":"Germany","count":15},{"shape":"square","colour":"yellow","country":"France","count":29},{"shape":"square","colour":"blue","country":"China","count":10}]qsdict(lst,lambdax:x["colour"][0:2],"shape","country","count")# Returns{"bl":{"circle":{"France":5},"square":{"China":10}},"pi":{"circle":{"Germany":15}},"ye":{"square":{"France":29}}}Pass a tuple as the last argument if you prefer the leaf node to be a listqsdict(lst,lambdax:x["colour"][0:2],"shape",("country","count")){"bl":{"circle":["France",5],"square":["China",10]},"pi":{"circle":["Germany",15]},"ye":{"square":["France",29]}}dictutils.mergedictMerges two nested dictionaries. Note that the first dictionary is updated.d1={"blue":{"circle":{"France":5},"square":{"China":10}},"pink":{"circle":{"Germany":15}},"yellow":{"square":{"France":29}}}d2={"blue":{"brightness":4,},"pink":{"brightness":4,},"yellow":{"brightness":4,}}mergedict(d1,d2)print(d1){"blue":{"circle":{"France":5},"square":{"China":10},"brightness":4},"pink":{"circle":{"Germany":15},"brightness":4},"yellow":{"square":{"France":29},"brightness":4}}If you don't want to clobber the first dictionary, provide an empty dictionaryd0 = {}
mergedict(d0, d1)
mergedict(d0, d2)This can be repeated an arbitary number of times to create a complicated data structure while avoiding nested loops and unwieldy code. This code is courtsey of this Stack Overflowthread.dictutils.pivotPivots a dictionary by a given list of keysd1={"A":{"Category1":{"X":111111,"Y":222222,},"Category2":{"X":333333,"Y":444444,},"Category3":{"X":555555,"Y":666666,}},"B":{"Category1":{"X":777777,"Y":888888,},"Category2":{"X":999999,"Y":101010,},"Category3":{"X":101011,"Y":101012,}},}print(pivot(d,[2,1,0]){"X":{"Category1":{"A":111111,"B":777777,},"Category2":{"A":333333,"B":999999,},"Category3":{"A":555555,"B":101011,},},"Y":{"Category1":{"A":222222,"B":888888,},"Category2":{"A":444444,"B":101010,},"Category3":{"A":666666,"B":101012,},},}
Package: dict-utils
# dict-utils ![License MIT](https://go-shields.herokuapp.com/license-MIT-blue.png)[![Travis-CI Status](https://secure.travis-ci.org/glowdigitalmedia/dict-utils.png?branch=master)](http://travis-ci.org/#!/glowdigitalmedia/dict-utils)[![Coverage Status](https://coveralls.io/repos/glowdigitalmedia/dict-utils/badge.png?branch=master)](https://coveralls.io/r/glowdigitalmedia/dict-utils?branch=master)[![PyPI version](https://badge.fury.io/py/dict-utils.svg)](http://badge.fury.io/py/dict-utils)dict-utils is a set of utilities and accessory methods usablewith Python dicts.## Examples1. Search for a value in a dictionary, passing a key:```pythonfrom dict_utils import dict_utilsdict_1 = {'first_level': {'second_level': {'name': 'Joe', 'age': 30}}}found_value = dict_utils.dict_search_value(dict_1, 'name')```**found_value** will contain **'Joe'**2. Compare two different dictionaries having the same keys```pythonfrom dict_utils import dict_utilsdict_1 = {'first_level': {'second_level': {'name': 'Joe', 'age': 30}}}dict_2 = {'level_1': {'level_2': {'name': 'Joe', 'age': 30}}}dict_utils.compare_assert_dicts(self, ['name', 'age'], dict_1, dict_2)```## Running Tests```python setup.py test```
Package: dict-wrapper
dict_wrapperuser DictWrapper to visit the value like an objectInstallingInstall and update usingpip:pip install -U dict_wrapperA Simple Example.. code-block:: pythonfrom dict_wrapper import DictWrapper

data = {
    "who": 'your name',
    "area": ['specify', 'china'],
    "province": {
        "city": ['shenzhen', 'guangzhou']
    },
    "citys":[{
        "name":"shenzhen",
        "othername":"鹏城"
    }]
}
config, config1 = DW(data), DictWrapper(data)
assert config.who == 'your name'
assert config.province.city == ['shenzhen', 'guangzhou']
print(config.area)
print(config1.citys[0].name)
Package: dict-zip
dict_zipzip and zip_longest for dict.Installation$pipinstalldict-zipUsagedict_zipdict_zipiszipfor dict.>>>fromdict_zipimportdict_zip>>>dict_zip({'a':1,'b':2},{'a':3,'b':4}){'a':(1,3),'b':(2,4)}dict_zip_longestdict_zip_longestiszip_longestfor dict.
It fills with fillvalue (default:None) when argument dict doesn't have match key.>>>fromdict_zipimportdict_zip_longest>>>dict_zip_longest({'a':1,'b':2,'c':4},{'a':3,'b':4}){'a':(1,3),'b':(2,4),'c':(4,None)}Type hintsdict_zip supports for type hints.LICENSEThe 3-Clause BSD License. See also LICENSE file.
Package: dicy
DicyA simple dice objectFeaturesGenerate as many dice objects as you wantEach dice object by default allows random.choiceYou can easily iterate on the dice facesExamplesfrom dicy import dicy as d
dice_a = d.Dicy()

# this will be evaluated to 1, 2, 3
print(dice_a[0].face)
print(dice_a[1].face)
print(dice_a[2].face)
Package: didak
didakPython is a basic test case runner, that simulates input and verifies the whether the final output is correct.RequirementsDidak uses the following packages:arkivistautopep8maguroUsageInstall the latest didak package, upcoming versions might introduce unannounced changes, so a virtual environment is a must have before installation.pipinstall-UdidakTo integrate didak into your Python codes, check the code snippet below:importdidakdidak.didak(directory,testcase,identifier,sensitive=0,unzip=0,convert=0,loops=99,reset=0)CLI Usage# usage: runner [-h] -d directory -t testcase [-i identifier] [-s sensitive] [-u unzip] [-c convert] [-l loops] [-r reset]pyrunner.py-d"<path_to_files>"-t"<path_to_testcase>"-i"<keyword>"-s1-u1-c1-l99-r1-d <path>- Full path of the dirctory containing the files to execute.-t <*.txt>- Path to test case file-u <0>- Unzip/extract ZIP files (0-1; default = 0)-c <0>- Convert Jupyter notbooks to Python file (0-1; default = 0)-i <keyword>- Unique keyword found on files to execute-s <0>- Case-sensitivity (0-1; default = 0)-l <99>- Looping / max recursions (1-9999; default = 99)-r <0>- Reset analytics before execution (0-1; default = 0)Test CaseIs used to fill in expected input and function parameters before execution and verifying of expected output.
** Template*"Keyword1", "keyword1", "keyword 1" = value1
"Keyword2", "keyword2", "keyword 2" = value1
...
"Keyword3", "keyword3", "keyword 3" = value1
---
"Result1", "result1", "result 1"
"Result2", "result2", "result 2"
...
"Result3", "result3", "result 3"Sample"keyword1", "key" = "name"
"abcde", "abc" = 23.7
...
"qwerty", "qwe" = False
---
"Hello, name!", "hello, name!"
"76.87", "76.9", "77"Did you know?The repository namedidakwas inspired from the words deduce and Didache; deduce means to arrived at a consluion by reasoning, while Didache is a manuscript in the Christain theological literature.
Package: did-api
D-ID Python API WrapperThis Python library allows you to interact with the D-ID API easily. You can use it to create text-to-video clips and retrieve clip information, among other things.InstallationYou can install thedid-apimodule usingpip:pipinstalldid-apiGetting StartedObtain your D-ID API Key fromD-ID Studio.Import the library and initialize it with your API Key:fromD_IDimportClipsapi_key="your_api_key_here"d_id=Clips(api_key)Creating a Text-to-Video ClipTo create a text-to-video clip, use thecreate_text_to_video_clipmethod:text="Your text here"result=d_id.create_text_to_video_clip(text)This function takes the following optional parameters:presenter_id(default: 'amy-jcwCkr1grs')driver_id(default: 'uM00QMwJ9x')voice_provider_name(default: 'microsoft')voice_id(default: 'en-US-JennyNeural')WEBHOOK_URL(default: None)background_color(default: '#ffffff')extra_data(default: {})Theresultvariable will contain the API response, including information about the created clip.Retrieving Clip InformationYou can retrieve clip information using theget_clip_by_idmethod:clip_id="your_clip_id_here"clip_info=d_id.get_clip_by_id(clip_id)Theclip_infovariable will contain the API response, providing details about the specified clip.ExamplesHere are some examples of how to use this library:# Create a text-to-video cliptext="Hello, D-ID!"result=d_id.create_text_to_video_clip(text)"result => {'id': 'clip_id', 'created_at': '2023-09-06T21:45:50.298Z', 'object': 'clip', 'status': 'created'}"# Get information about a specific clipclip_id="your_clip_id_here"clip_info=d_id.get_clip_by_id(clip_id)LicenseThis library is provided under theMIT License.For more information about the D-ID API, please refer to theofficial documentation.
Package: didata_cli
A CLI tool to interact with the Dimension Data CloudDocumentation:didata_cli at ReadTheDocsPython package:didata_cli at PyPiSource code:didata_cli at GitHubFree software:Apache License (2.0)InstallationInstallation viapip:pip install didata_cliIt is highly recommended to also take the LATEST version oflibcloud:pip install git+https://github.com/apache/libcloud.git@trunk --upgradeQuickStartTo see all the commands:didata --helpThe easiest way to start using the CLI is to export environment variables for username and password:export DIDATA_USER='cloud_user'
export DIDATA_PASSWORD='cloud_password'You may also want to specify a region (Default is dd-na):export DIDATA_REGION='dd-eu'From there as a first command to list servers:didata server listContributingFork it (https://github.com/DimensionDataDevOps/didata_cli/fork)Create your feature branch (git checkout -b my-new-feature)Commit your changes (git commit -am ‘Add some feature’)Push to the branch (git push origin my-new-feature)Create a new Pull Request