Saravanan666/pypi-org huggingface dataset:
Package: dataspree-platform-sdk
Data Spree AI Platform SDKThe Platform SDK acts as an interface to the Data Spree AI Platform, contains all classes and functions to integrate
custom models into the platform, and it provides a command-line tool for importing datasets of the following formats:Data SpreeKITTICOCOFurthermore, it is possible to export datasets from the platform.UsageGeneral UsageUsage: ds [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  export
  importDataset ImportUsage: ds import [OPTIONS]

Options:
  --format [dataspree|kitti|coco]  Dataset format to import
  --dataset_name TEXT         Name of the newly created dataset.
  --dataset_id INTEGER        ID of the dataset to which new items should be
                              imported. If set to '-1', a new dataset will be
                              created
  --images PATH               Directory containing the images to import.
                              [required]
  --annotations PATH          Directory or file containing the annotations to
                              import.  [required]
  --http_retries INTEGER      Number of HTTP retries.  [default: 10]
  --username TEXT             Username for data spree vision platform.
  --password TEXT             Password for data spree vision platform.
  --url TEXT                  URL to the API of the platform.
  --help                      Show this message and exit.Dataset ExportUsage: ds export [OPTIONS]

Options:
  -o, --output_dir DIRECTORY   Output directory.  [required]
  -i, --id INTEGER             ID of the dataset to download.
  -n, --n_items INTEGER        Number of items to download. Download all
                               items: '-1'  [default: -1]
  --http_retries INTEGER       Number of HTTP retries.  [default: 10]
  --parallel_requests INTEGER  Number of parallel requests.  [default: 16]
  --username TEXT              Username for data spree vision platform.
  --password TEXT              Password for data spree vision platform.
  --url TEXT                   URL to the API of the platform.
  --help                       Show this message and exit.LicenseApache License 2.0
Package: datasquirrel
# Data Quirrel# Installation`pip install datasquirrel`# UsageSomething along the lines of:```from datasquirrel import lunofrom datasquirrel import btccimport timestart = time.time()-(24*3600*404)collector = luno.Collector()collector.new_collection(start) # For new collectioncollector.collect() # To continue where last one left offcollector = btcc.Collector()collector.new_collection(start) # For new collectioncollector.collect() # To continue where last one left off```# To Do-   Write a better readme-   Tests for some of the newly added endpoints-   Tests for the rate limiter
Package: datass
DataScienceShortcuts - DataSSThis time Ireallygot tired of rewriting the same old data analysis functions again.For now on I'll write them in this package.MIT License.InstallationDownload and install:gitclonehttps://gitlab.com/htbrandao/datass.gitcddatass/

pip3install-e.or, install from PyPI:pip3installdatassor, install a specific version:pip3installdatass==0.0.1UsageExample:importdatassimportpandasaspddf=pd.read_csv('some-file.csv')# find null valuesdatass.dataframe.inspection._isnull(df)# run value countsdatass.dataframe.inspection._value_counts()(df)# run describedatass.dataframe.inspection._describe(df)OtherDocumentation created usingSphinxPackaged using thisguideBootstrapthemeTODO & FIXME1 - keep on coding the actual module
1.1 - update docs
1.2 - fix proj page not fowarding to docs
1.3 - improve 404.md
2 - YOLO
Package: datastage
IBM DataStage SDK for PythonPython client library to interact with variousIBM Cloud Datastage APIs.Disclaimer: this SDK is being released initially as apre-releaseversion.
Changes might occur which impact applications that use this SDK.Table of ContentsOverviewPrerequisitesInstallationUsing the SDKQuestionsIssuesOpen source @ IBMContributingLicenseOverviewThe IBM Cloud Datastage Python SDK allows developers to programmatically interact with the following
IBM Cloud services:Service NameModule NameService Class NameDataStagedatastage_v3DatastageV3PrerequisitesAnIBM Cloudaccount.An IAM API key to allow the SDK to access your account. Create onehere.Python 3.6 or above.InstallationTo install, usepip:pipinstall--upgrade"datastage>=0.0.4"Using the SDKFor general SDK usage information, please seethis linkQuestionsIf you are having difficulties using this SDK or have a question about the IBM Cloud services,
please ask a questionStack Overflow.IssuesIf you encounter an issue with the project, you are welcome to submit abug report.
Before that, please search for similar issues. It's possible that someone has already reported the problem.Open source @ IBMFind more open source projects on theIBM Github PageContributingSeeCONTRIBUTING.md.LicenseThis SDK is released under the Apache 2.0 license.
The license's full text can be found inLICENSE.
Package: datastand
datastandWhy datastand?Data + UnderstandA python package to help Data Scientists, Machine Learning Engineers and Analysts better understand data. Gives quick insights about a given dataset.InstallationRun the following command on the terminal to install the package:pipinstalldatastandUsage :Code:fromdatastandimportdatastandimportpandasaspddf=pd.read_csv("path/to/target/dataframe")datastand(df)Output:Generalstats:==================ShapeofDataFrame:(1202,13)Numberofuniquedatatypes:{dtype('int64'),dtype('O')}Numberofnumericalcolumns:2Numberofnon-numericalcolumns:11Missingdata:=======================DataFramecontains2670missingvalues(17.09%)asfollowscolumn-wise:-----------------------------------------------------------------------Gender41Car_Category372Subject_Car_Colour697Subject_Car_Make248LGA_Name656State656dtype:int64-----------------------------------------------------------------------Doyouwishtolong-listmissingdatastatistics?(y/n):y...Code:# This function is already available in the DataStand class and also available separately# Here we're running it separatelyfromdatastandimportplot_missingplot_missing(df)Output:Code:fromdatastandimportimpute_missingimpute_missing(df)Output:Imputingmissingdata...100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████|80/80[00:02<00:00,30.52it/s]Imputationcomplete.Author/MaintainerVincent N.[LinkedIn][Twitter]
Package: datastax
updated: Thursday, 03rd August 2023Simplicity meets intelligencedataStaxWhat's New?Refactored TreesAdded Nodes SubPackageSeparated TreeNodes into NodesAdded Tables SubPackageAdded Colors and ColorCodes in UtilsRefactored ListsRemoved__repr__overridesAdded Exceptions in UtilsAdded Warnings in UtilsAdded new workflowsAdded datastax.WikiTable of ContentsWhat's NewIntroductionProblem StatementBenefitsRequirementsInstallationUsageDocumentationLicenseIntroductionThis library offers a simple yet powerful solution for implementing common abstract data structures.With a pure Python implementation, it provides representations of tree, linked list, and array-based data structures
accessible through a basic command prompt interface.The package includes visualization features that enhance the understanding of each data structure.Students can greatly benefit from utilizing this package for their learning and educational purposes.Please note that this project is currently a work in progress and undergoing active development.Problem StatementMany CS students encounter difficulties in comprehending the intricate internal architecture of complex
Abstract Data Types (ADTs) during the initial stages of their B.Tech course.When attempting to solve coding challenges that involve writing test cases using these ADTs, it becomes excessively
burdensome to manually create these data structures from scratch.Furthermore, while developing programs that implement these ADTs, numerous errors are encountered due to the
inability to visualize and understand the underlying processes of these data structures.BenefitsSwift installation processEfficient and prompt updatesMinimal disk space usage due to its small sizeNo additional modules or dependencies neededDeveloped entirely from scratchUpcoming user-friendly documentationCommand line demonstration for easy usageRequirementsRuns on latest Python 3.11+(Suggesting you to always update to the latest python version)InstallationUse the python package managerpipto install datastax.pipinstalldatastaxUsageDemoTo get a demo of the library use the following commandWindows:>py-mdatastaxUnix based systems:$python3-mdatastaxResultAvailablemodulesare:1.LinkedLists2.Trees3.Arrays

Usage
>pydatastax<data-structure>[data]DataStructures:
->TreesHierarchicalDS
->linkedlistsLinearDS
->arraysFixedSizeLinearDSThen follow as the instruction guides>py-mdatastaxlinkedlist1234VisualsforLinkedLists:1.SinglyLinkedList:HEADTAIL┌─────╥────┐┌─────╥────┐┌─────╥────┐┌─────╥────┐│1║----->│2║----->│3║----->│4║----->NULL└─────╨────┘└─────╨────┘└─────╨────┘└─────╨────┘2.DoublyLinkedList:HEADTAIL┌────╥─────╥────┐┌────╥─────╥────┐┌────╥─────╥────┐┌────╥─────╥────┐NULL<-----║1║<------->║2║<------->║3║<------->║4║----->NULL└────╨─────╨────┘└────╨─────╨────┘└────╨─────╨────┘└────╨─────╨────┘...Practical UsageQueueBinaryTreeMinHeapTreeThreadedBinaryTreeSumSegmentTreeHuffmanTreeRedBlackTreeDocumentationFor detailed documentation. Seedocumentation(Still in progress)LicenseseeLICENSEPritam, 2023
Package: datastep
datastepA base class and utility functions for creating pure functions steps for DAGs that are heavily tied to large amounts of
data.This library should rarely be used by itself, it was developed in pair withcookiecutter-stepworkflowand you should look there for more context rich documentation.InstallationStable Release:pip install datastepDevelopment Head:pip install git+https://github.com/AllenCellModeling/datastep.gitDocumentationFor full package documentation please visitAllenCellModeling.github.io/datastep.DevelopmentSeeCONTRIBUTING.mdfor information related to developing the
code.Free software: Allen Institute Software License
Package: data-steps
data-stepsThis projects provides a minmal framework to
organize data transformations in pandas.It is intended to be used in both notebooks
and code files.The main idea is to provide a simple decorator
syntax that is easy to maintains when data
transfromation steps get changed or added
throughout the project. A prime example
is data cleaning where only later in the project
some required cleaning steps become apparent.FeaturesAfter wrapping a pandas DataFrame in aDataStepsclass. The following features are available.register data transformations with the instances.stepdecoratorget an overview of the registered steps with.stepsinspect the original data the fully transformed data
and any partially transformed data in betweenchange parameters of registered stepsinteractively redefine or deactivate steps in jupyter notebooksregister steps that return secondary results, i.e. the main result is passed alon
the pipeline, whereas the secondary result is stored seperatelyconvert data steps pipelines to strings that can more easily be integrated into a non-eda code-baseUsage ExampleWrap your data in an instancefromdata_stepsimportDataStepsdata=DataSteps(my_pandas_df)#register transformation steps@data.stepdefdata_transformation(df):#transfromation steps...returntransformed_df@data.stepdeftransform_with_parameters(df,param1,param2=4):#transfromation steps...returntransformed_df#access original datadata.original#set or update transformation parametersdata.update_step_kwargs('transform_with_parameters',{'param1':10})#access data after all transformation stepsdata.transformed#get an overview of the registered stepsdata.steps#only execute some steps to help debugging transformationsdata.partial_transform(0)History0.0.1 (2021-01-31)First release on PyPi.0.1.0 (2021-02-11)Changed step decorator to work in bare format,
i.e.<instance>.stepinstead of<instance>.step()0.2.0 (2021-05-02)support for additional arguments in steps0.3.0 (2021-05-30)support for exporting a datasteps pipeline as a stringEnable steps to contain side results next to the transformed data. These could be summaries for diagnostics or plots for an intermediate result0.3.1 (2021-05-30)bugfixes0.3.2 (2021-05-30)bugfixes0.3.3 (2021-08-01)Downgraded python requirements to 3.7 to enable google colab support by default.Possible extensionsNo Concrete plans at the moment but feel free to open enhancement issues on github
Package: datastorage
To use simply do::>>> from datastorage import DataStorage
>>> data = DataStorage( a=(1,2,3),b="add",filename='store.npz' )>>> # data.a will be a dictionary
>>> data = DataStorage( myinfo = dict( name= 'marco', surname= 'cammarata'),\
>>>                     data   = np.arange(100) )>>>  # reads from file if it exists
>>>  data = DataStorage( 'mysaveddata.npz' ) ;>>>  create empty storage (with default filename)
>>>  data = DataStorage()
>>>  data.mynewdata = np.ones(10)
Package: datastore.aws
# datastore-aws## datastore implementation for awsSee [datastore](https://github.com/datastore/datastore).### InstallFrom pypi (using pip):sudo pip install datastore.awsFrom pypi (using setuptools):sudo easy_install datastore.awsFrom source:git clonehttps://github.com/datastore/datastore.aws/cd datastore.aws
sudo python setup.py install### Licensedatastore.aws is under the MIT License.### Contactdatastore.aws is written by [Juan Batiz-Benet](https://github.com/jbenet).
It was extracted from [datastore](https://github.com/datastore/datastore)
in Feb 2013.Project Homepage:
[https://github.com/datastore/datastore.aws](https://github.com/datastore/datastore.aws)Feel free to contact me. But please file issues in github first. Cheers!### Hello World>>> import datastore.aws
>>> from boto.s3.connection import S3Connection
>>>
>>> s3conn = S3Connection('<aws access key>', '<aws secret key>')
>>> s3bucket = s3conn.get_bucket('<bucket name>')
>>> ds = datastore.aws.S3BucketDatastore(s3bucket)
>>>
>>> hello = datastore.Key('hello')
>>> ds.put(hello, 'world')
>>> ds.contains(hello)
True
>>> ds.get(hello)
'world'
>>> ds.delete(hello)
>>> ds.get(hello)
None
Package: datastore-client
Simple DataStore ClientA simple Google DataStore client that exposes 3 functions on theDatastoreClientclass.classDatastoreClient:def__init__(self,namespace:str=None,**kwargs)->None:self.client=Client(namespace=namespace,**kwargs)defset_key(self,entity_name:str,key_name:str,**properties:Any,)->None:...defget_key(self,entity_name:str,key_name:str,)->Optional[Entity]:...defquery_entity(self,entity_name:str,*query_filters:Tuple[str,str,Any],projection:List[str]=None,limit:Optional[int]=None,)->Iterator:...ExamplesChanging thenamespaceYou can set thenamespacefor the client by passing it in to the constructorfromdatastore_client.clientimportDatastoreClientclient=DatastoreClient(namespace='namespace_A')The following will change the namespace for all subsequent function calls.fromdatastore_client.clientimportDatastoreClientclient=DatastoreClient()client.client.namespace='specific_namespace'set_keyfromdatastore_client.clientimportDatastoreClientclient=DatastoreClient()client.set_key(entity_name=RECHARGE_NOTES_ENTITY,key_name=note_key,username=username,reference=reference,note=notes,)# This can also be used in batch modewithclient.batch_update():client.set_key(...)client.set_key(...)# Both key updates will be done when the with block exitsget_keyfromdatastore_client.clientimportDatastoreClientclient=DatastoreClient()client.get_key(LOGIN_ENTITY,username)query_entityfromdatastore_client.clientimportDatastoreClientclient=DatastoreClient()product_list=list(client.query_entity(PRODUCT_ENTITY,('network','=',network_name),('product_type','=',product_code),('bundle_size','=',denomination),projection=['id'],limit=1,))print(product_list[0]['id'])
Package: datastoreflex
Adds the ability to read/write objects in a cloud bucket to datastore client.from datastoreflex import DatastoreFlex
client = DatastoreFlex(project="<project-id>", namespace="<namespace>")

# The following configuration means store a column/property named `v1`
# in a cloud bucket (protocol must be supported by cloudfiles).
# Value for `v1` will be stored in the path `gs://my_data_bucket/<group_id>/<user_id>`
# where <group_d> = entity["group_id"] and <user_id> = entity["user_id"]

config = {"v1": {"bucket_path": "gs://my_data_bucket", "path_elements": ["group_id", "user_id"]}}
client.add_config(config)
Package: datastore.git
# datastore-git## datastore implementation for gitSee [datastore](https://github.com/datastore/datastore).### InstallFrom pypi (using pip):sudo pip install datastore.gitFrom pypi (using setuptools):sudo easy_install datastore.gitFrom source:git clonehttps://github.com/datastore/datastore.git/cd datastore.git
sudo python setup.py install### Licensedatastore.git is under the MIT License.### Contactdatastore.git is written by [Juan Batiz-Benet](https://github.com/jbenet).
It was extracted from [datastore](https://github.com/datastore/datastore)
in Feb 2013.Project Homepage:
[https://github.com/datastore/datastore.git](https://github.com/datastore/datastore.git)Feel free to contact me. But please file issues in github first. Cheers!### Hello World>>> import datastore.git
>>>
>>> ds = datastore.git.GitDatastore('.datastore')
>>>
>>> hello = datastore.Key('hello')
>>> ds.put(hello, 'world')
>>> ds.contains(hello)
True
>>> ds.get(hello)
'world'
>>> ds.delete(hello)
>>> ds.get(hello)
None
Package: datastore.leveldb
# datastore-leveldb## datastore implementation for leveldbSee [datastore](https://github.com/datastore/datastore).
See [leveldb](https://pypi.python.org/pypi/leveldb).### InstallFrom pypi (using pip):sudo pip install datastore.leveldbFrom pypi (using setuptools):sudo easy_install datastore.leveldbFrom source:git clonehttps://github.com/datastore/datastore.leveldb/cd datastore.leveldb
sudo python setup.py install### Licensedatastore.leveldb is under the MIT License.### Contactdatastore.leveldb is written by [Juan Batiz-Benet](https://github.com/jbenet).Project Homepage:
[https://github.com/datastore/datastore.leveldb](https://github.com/datastore/datastore.leveldb)Feel free to contact me. But please file issues in github first. Cheers!### Hello World>>> import datastore.leveldb
>>>
>>> ds = datastore.leveldb.LevelDBDatastore('./db')
>>>
>>> hello = datastore.Key('hello')
>>> ds.put(hello, 'world')
>>> ds.contains(hello)
True
>>> ds.get(hello)
'world'
>>> ds.delete(hello)
>>> ds.get(hello)
None
Package: datastore.memcached
# datastore-memcached## datastore implementation for memcachedSee [datastore](https://github.com/datastore/datastore).### InstallFrom pypi (using pip):sudo pip install datastore.memcachedFrom pypi (using setuptools):sudo easy_install datastore.memcachedFrom source:git clonehttps://github.com/datastore/datastore.memcached/cd datastore.memcached
sudo python setup.py install### Licensedatastore.memcached is under the MIT License.### Contactdatastore.memcached is written by [Juan Batiz-Benet](https://github.com/jbenet).
It was extracted from [datastore](https://github.com/datastore/datastore)
in Feb 2013.Project Homepage:
[https://github.com/datastore/datastore.memcached](https://github.com/datastore/datastore.memcached)Feel free to contact me. But please file issues in github first. Cheers!### Hello World>>> import pylibmc
>>> import datastore.memcached
>>>
>>> mc = pylibmc.Client(['127.0.0.1'])
>>> ds = datastore.memcached.MemcachedDatastore(mc)
>>>
>>> hello = datastore.Key('hello')
>>> ds.put(hello, 'world')
>>> ds.contains(hello)
True
>>> ds.get(hello)
'world'
>>> ds.delete(hello)
>>> ds.get(hello)
None
Package: datastore.mongo
# datastore-mongo## datastore implementation for mongodbSee [datastore](https://github.com/datastore/datastore).### InstallFrom pypi (using pip):sudo pip install datastore.mongoFrom pypi (using setuptools):sudo easy_install datastore.mongoFrom source:git clonehttps://github.com/datastore/datastore.mongo/cd datastore.mongo
sudo python setup.py install### Licensedatastore.mongo is under the MIT License.### Contactdatastore.mongo is written by [Juan Batiz-Benet](https://github.com/jbenet).
It was extracted from [datastore](https://github.com/datastore/datastore)
in Feb 2013.Project Homepage:
[https://github.com/datastore/datastore.mongo](https://github.com/datastore/datastore.mongo)Feel free to contact me. But please file issues in github first. Cheers!### Hello World>>> import pymongo
>>> import datastore.mongo
>>>
>>> conn = pymongo.Connection()
>>> ds = datastore.mongo.MongoDatastore(conn.test_db)
>>>
>>> hello = datastore.Key('hello')
>>> ds.put(hello, 'world')
>>> ds.contains(hello)
True
>>> ds.get(hello)
'world'
>>> ds.delete(hello)
>>> ds.get(hello)
None
Package: datastore.objects
# datastore.objects[datastore.objects](https://github.com/datastore/datastore.objects) is a
simpleobject mapperon top of
[datastore](https://github.com/jbenet/datastore) (not relational). Thanks to
datastore’s versatility, it makes it easy to (serialize and) persist custom
classes to any sort of data storage service.Notice: please familiarize yourself withdatastorefirst.## Installpip install datastore.objects## Interface### Keydatastore.objectsuses the defaultdatastore.Key, making significant use
of thetypeandinstancefragments.`python >>> from datastore.objects import Key, Model >>> class Scientist(Model): >>>   pass >>> Scientist.keyKey('/Scientist')>>>Scientist('Tesla').keyKey('/Scientist:Tesla')`### Modeldatastore.objectsprovides a class that you inherit from to define your
models. datastore.objects.Model handles the datastore serializing and
deserializing, attribute validation, etc.`python >>> from datastore.objects import Model >>> class Scientist(Model): >>>   pass `### Attributedatastore.objectsuses descriptor Attributes to track the properties you wish
to store. This is heavily based on how other python ORMs (django, app engine)
do it. In short, you define model attributes like this:`python >>> from datastore.objects import Attribute, Model >>> class Scientist(Model): >>>   name = Attribute(required=True) >>>   field =Attribute(default='Physics')>>> tesla =Scientist('Tesla')>>> tesla.name = 'Nicola Tesla' >>> tesla.field 'Physics' >>> tesla.field = 'Electrical Engineering' >>> tesla.data {'name': 'Nicola Tesla', 'field': 'Electrical Engineering'} `### ObjectDatastoredatastore.objectsprovides aShimDatastorethat wraps any other datastore.
Thus you can use any of the various datastores to persist your objects.ObjectDatastoremakes sure to serialize (on put) and deserialize (on get)
data properly, and construct your classes.`python >>> import datastore >>> from datastore.objects import Attribute, Model, ObjectDatastore >>> >>> class Scientist(Model): >>>   name = Attribute(required=True) >>>   field =Attribute(default='Physics')>>> >>> tesla =Scientist('Tesla')>>> tesla.name = 'Tesla' >>> tesla.field = 'Electrical Engineering' >>> >>> dds = datastore.DictDatastore() >>> ods = ObjectDatastore(dds, model=Scientist) >>> ods.put(tesla.key, tesla) >>> dds.get(tesla.key) {'name': 'Tesla', 'field': 'Electrical Engineering'} >>> ods.get(tesla.key) <Model /Scientist:Tesla> `## About#### Authordatastore.objectsis written by [Juan Batiz-Benet](https://github.com/jbenet),
of [Athena](http://athena.ai).#### LicenseIt is free open-source software, available under
the MIT License.#### ContactProject webpage:https://github.com/datastore/datastore.objects.
Issues:https://github.com/jbenet/object-datastore/issues