Saravanan666/pypi-org huggingface dataset:
Package: objns
Simple Python utility module that allows to recursively transform any
dictionary or dictionary like object into a Python object with dot notation
access to its attributes.This is specially helpful when dealing with large configuration files
(from parsing YAML, JSON or TOML) or dealing with a large response from a
server.Installpip3installobjnsOptionally, install the following package to enable better pretty printing of
an object:pip3installpprintppUsageCreate an object from one or more dictionaries, and set values directly in the
constructor:>>>fromobjnsimportNamespace>>>ns=Namespace(...{'one':100},...{'two':300},...{'two':400,'three':{'four':400}},...one=200,...)>>>ns.two400>>>ns.one200>>>ns['two']400Get and set values recursively:>>>ns['two']=300>>>ns['two']300>>>ns.two=700>>>ns['two']700>>>ns.two700>>>ns.three.four400>>>ns['three'].four400>>>ns['three']['four']400Recursively copy an object:>>>nscopy=ns.copy()>>>id(ns)==id(nscopy)FalseTransform back to a dictionary:>>>asdict=dict(ns)>>>asdict{'one':200,'two':400,'three':{'four':400}}>>>type(asdict)<class'dict'>Iterate the object:>>>forkey,valueinns:...print(key,value)...one200two400three{'four':400}Recursively merge update with other dictionaries:>>>ns.update({...'one':'override1',...'three':{'four':'override2'},...})>>>ns.one'override1'>>>ns.three.four'override2'Pretty print the data structure:>>>ns{'one':'override1','three':{'four':'override2'},'two':400}>>>print(str(ns)){'one':'override1','three':{'four':'override2'},'two':400}Preservation of source datatype, such asOrderedDictand other Mapping
subclasses:>>>nso=Namespace(OrderedDict([('one',100),('two',200)]))>>>nsoOrderedDict([('one',100),('two',200)])>>>forkey,valueinnso:...print(key,value)...one100two200Repositoryhttps://github.com/kuralabs/objnsChangelog1.0.0 (2021-05-31)NewInitial release.LicenseCopyright (C) 2017-2021 KuraLabs S.R.L

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
Package: objopt
## objoptThis library provides object oriented optimization. This allows...1. using theoretic values (such as the strong convexity parameter)2. object-oriented definitions, both for models and optimization algorithms. This allows...* interacting with the optimization as an object. Want to compute somevalue partway through? Want to change the values as time goes on?* getting results intermediately (or in the presence of a keyboardinterrept)* having callbacks, etcA typical example:``` pythondef get_stats():# ...model = Model()opt = SGD(model.loss)data = []for _ in range(10):opt.step(steps=10)data += [get_stats(model)]```
Package: obj-tables
ObjTables: Tools for creating and reusing high-quality spreadsheetsObjTablesis a toolkit which makes it easy to use spreadsheets (e.g.,
XLSX workbooks) to work with complex datasets by combining spreadsheets
with rigorous schemas and an object-relational mapping system (ORM;
similar to Active Record (Ruby), Django (Python), Doctrine (PHP),
Hibernate (Java), Propel (PHP), SQLAlchemy (Python), etc.). This
combination enables users to use programs such as Microsoft Excel,
LibreOffice Calc, and OpenOffice Calc to view and edit spreadsheets and
use schemas and theObjTablessoftware to validate the syntax and
semantics of datasets, compare and merge datasets, and parse datasets
into object-oriented data structures for further querying and analysis
with languages such as Python.ObjTablesmakes it easy to:Use collections of tables (e.g., an XLSX workbook) to represent
complex data consisting of multiple related objects of multiple types
(e.g., rows of worksheets), each with multiple attributes (e.g.,
columns).Use complex data types (e.g., numbers, strings, numerical arrays,
symbolic mathematical expressions, chemical structures, biological
sequences, etc.) within tables.Use progams such as Excel and LibreOffice as a graphical interface
for viewing and editing complex datasets.Use embedded tables and grammars to encode relational information
into columns and groups of columns of tables.Define clear schemas for tabular datasets.Use schemas to rigorously validate tabular datasets.Use schemas to parse tabular datasets into data structures for
further analysis in languages such as Python.Compare, merge, split, revision, and migrate tabular datasets.TheObjTablestoolkit includes five components:Format for schemas for tabular datasetsNumerous data typesFormat for tabular datasetsSoftware tools for parsing, validating, and manipulating tabular
datasetsPython package for more flexibility and analysisPlease seehttps://objtables.orgfor more information.Installing the command-line program and Python APIPlease see thedocumentation.Examples, tutorials, and documentationPlease see theuser documentation,developer documentation, andtutorials.LicenseObjTablesis released under theMIT license.Development teamObjTableswas developed by theKarr Labat the Icahn School of Medicine at Mount Sinai in New York, USA and theApplied Mathematics and Computer Science, from Genomes to the
Environment research unitat theNational
Research Institute for Agriculture, Food and
Environmentin Jouy en Josas, FR.Jonathan KarrArthur
GoldbergWolfram
LiebermeisterJohn SekarBilal ShaikhQuestions and commentsPlease contact thedeveloperswith any
questions or comments.
Package: objtojson
Object-to-JSONJSON serializer for class instances with minimal declaration overhead.FeaturesAttributes that represent object state are automatically detected
by checking__init__argument namesCustom serializers for objects with complex stateAutomatic generation of__eq__methodUsageInstallationpip install objtojsonExamplefromobjtojsonimportSerializedclassSomeClass(Serialized):def__init__(self,someAttribute,other):self.someAttribute=someAttributeself.other=otherclassAnotherClass(Serialized):def__init__(self,a,b):self.a=aself.b=ba=SomeClass(4,[AnotherClass(['a','list'],{'mykey':34}),'somestring'])print(a.Serialize())Result:{"__someclass__":{"someAttribute":4,"other":[{"__anotherclass__":{"a":["a","list"],"b":{"mykey":34}}},"somestring"]}}Saving to file, loading from filefromobjtojsonimportSerializerSerializer.Save('data.json',a)a_reloaded=Serializer.Load('data.json')RestrictionsAttribute names must match__init__argument namesTuples will be serialized/deserialized as listsDict keys must be valid JSON object keys (i.e., strings)
Package: objwrap
objwrapEasy object wrapping in Python.This package enables creation of transparent objects that wrap
others already in memory. Basically, it offers a more sophisticated
view overgetattrthat hand-rewires object methods, including
magic methods (__add__,__len__etc).QuickstartFirst install the latest version of the package
withpip install --upgrade objwrap.Custom classes to wrap
attribute getters and magic methods.fromobjwrapimportWrapperclassNotify(Wrapper):def__wrapattr__(self,obj,name):print(f"Accessing{name}")returnsuper().__wrapattr__(obj,name)x=Notify(1)print(x+1)# Accessing __add__# 2Wrappers to transform inputs to method calls.fromobjwrapimportClosedWrapper,wrappedclassNotify(ClosedWrapper):def__after__(self,obj):returnNotify(obj)# this is the default behaviordef__before__(self,method,args,kwargs):method,args,kwargs=super().__before__(method,args,kwargs)print(f"Calling{method.__name__}on{wrapped(self)}with args{args}and kwargs{kwargs}")returnmethod,args,kwargsx=Notify(1)y=Notify(2)z=x+y# a Notify objectprint(wrapped(z))# Calling __add__ on 2 with args [2] and kwargs {}# 3Wrappers around dicts that call methods for their values.fromobjwrapimportClosedWrapper,wrappedfromobjwrap.closureimportPendingclassRunOnValues(ClosedWrapper):def__init__(self,obj):super().__init__(obj)self.symbols=obj.keys()def__unknown__(self,obj,name,args,kwargs):_,args,kwargs=super().__before__(None,args,kwargs)# convert other instances of RunOnValues to dictsassertisinstance(obj,dict)# enforce the typepending=dict()forsymbolinself.symbols:pending[symbol]=Pending(method=getattr(obj[symbol],name),args=[arg[symbol]forarginargs],kwargs={k:arg[symbol]fork,arginkwargs.items()})returnpendingx=RunOnValues({"a":1,"b":2})y=RunOnValues({"a":10,"b":20})z=x+yprint(wrapped(z))# {'a': 11, 'b': 22}
Package: objx
NAMEOBJX - objectsINSTALL$ pip install objxSYNOPSIS>>> from objx import Object, dumps, loads
>>> o = Object()
>>> o.a = "b"
>>> txt = dumps(o)
>>> loads(txt)
{"a": "b"}DESCRIPTIONOBJX provides an obx namespace that allows for easy json save//load
of objects. It provides an "clean namespace" Object class that only
has dunder methods, so the namespace is not cluttered with method
names. This makes storing and reading to/from json possible.

OBJX is Public Domain.AUTHORBart Thate <bthate@dds.nl>COPYRIGHTOBJX is Public Domain.
Package: obkreator
Brief introPurposeCreate ESO observing blocks from a list of targets either specified in the command line or in a file. Instrument supported: WFI, FEROS, GROND at 2.2m telescope.InstallationIt is packaged asobkreator.Site-wide installation will be performed withsudo -H pip3 install obkreatoron unix-like systems. At a user level, within avirtual environment,pip3 install obkreator.Short examplesCreate FEROS OBs with 2 × 10 min integrations for a few SIMBAD targets.>mkfrsob--target"HD 10""HD 20""HD 30"--objcal--dit600--nint2--pid'0107.A-9032(A)'0107.A-9032(A):2.2/FEROSobservationsbyGREDEL,R
CoordinateshavebeenqueriedfromSIMBAD
OB#1 created: OB/FEROS-2.2/HD10.obdOB#2 created: OB/FEROS-2.2/HD20.obdOB#3 created: OB/FEROS-2.2/HD30.obdCreate WFI OBs from information in a table>cat<<EOF >WFI.datheredoc> target   ag    dit             nint filter       acq       acqdit offsetsheredoc> ------ ------  --------------- ---- ---------- ----------- ------ -------------heredoc> HD 1   auto    100,50,50,20,10    4 U,B,V,Rc,I movetopixel    200heredoc> HD 2           50 300          10 2 V,Halphaheredoc> HD 3   manual  20              2    Rc                            10,20 900,900heredoc> EOF>mkwfob--pid'0107.A-9031(A)'--tableWFI.dat0107.A-9031(A):2.2/WFIobservationsbyGREDEL,R
CoordinateshavebeenqueriedfromSIMBAD3OBstobegeneratedusingtable
Columnsare:target,coo,pm,ag,dit,nint,filter,acq,acqdit,offsets
OB#1 created: OB/WFI-2.2/HD1.obdOB#2 created: OB/WFI-2.2/HD2.obdOB#3 created: OB/WFI-2.2/HD3.obd>Create GROND OBs with several templates>mkgrndob--target'HD 1''HD 2''HD 3'--tpltype4m4td8m4td20m4td--pid'0107.A-9033(A)'--pi'Doe, J.'0107.A-9033(A):2.2/GRONDobservationsbyDoe,J.underGREDEL,RPID
CoordinateshavebeenqueriedfromSIMBAD
OB#1 created: OB/GROND-2.2/HD1.obdOB#2 created: OB/GROND-2.2/HD2.obdOB#3 created: OB/GROND-2.2/HD3.obdChanges0.3.2fix a bug in GROND IR DITs.modify WFI OBs according to newWFI_img_acq_MoveToPixeltemplate0.4fix a bug in obx creationadd entry pointsmigration to pyproject.toml0.4.1fix a bug in low-precision coordinates in obxuse requirements.txt
Package: oblate
Oblate — data, made easyOblate is a Python library that provides modern and robust interface for data and schema validation.Focused around simplicity and flexibility, Oblate has the following features:Intuitive and modern object oriented interfaceBuilt in support for commonly used data structuresEasily extendible and customizable to suit every use caseRobust with no compromise on performance and speedTyped and plays well with static type checkingDocumentation•Source Code•Python Package IndexInstallationOblate is available on PyPi and can be installed using pip.$ pip install oblateℹ️ Didn't work?Try prefixing the above command withpython -mif you don't havepipon PATH or the command doesn't work for some reason.UsageOblate is focused around simplicity and ease of usage. Below snippet is an example of how data
is handled using Oblate:fromoblateimportvalidate,fieldsimportoblate# A schema defines the structure of dataclassAuthor(oblate.Schema):name=fields.String()# Field must be a stringbio=fields.String(none=True)# Field allows None to be passedrating=fields.Integer(default=0)# Optional field that defaults to 0# Apply custom validations to a field@validate.field(rating)defvalidate_rating(self,value,ctx):assertvalue>=0andvalue<=10,'Rating must be in range 0-10 inclusive'classBook(oblate.Schema):title=fields.String()price=fields.Float()author=fields.Object(Author)data={'title':'Art of Data Validation','price':20.30,'author':{'name':'John','bio':None,'rating':4,}}book=Book(data)print(f"{book.title}by{book.author.name}")Check theQuickstartsection in
documentation for an introduction to the basics of library.
Package: oblif
oblifSee documentationhere!Oblif is a library that lets you write data-oblivious code in a non-data-oblivious way. For example:frommpyc.runtimeimportmpcdeftest(x):return1ifx==5else0mpc.run(mpc.start())print("test(5) is",mpc.run(mpc.output(test(type(5)))))mpc.run(mpc.shutdown())2021-05-08 13:56:22,858 Start MPyC runtime v0.7.4
Traceback (most recent call last):
    File "test-mpyc.py", line 14, in <module>
    print("test(5) is", mpc.run(mpc.output(test(type(5)))))
  File "test-mpyc.py", line 6, in test
    return 1 if x==5 else 0
  File "/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/mpyc-0.7.4-py3.8.egg/mpyc/sectypes.py", line 50, in __bool__
TypeError: cannot use secure type in Boolean expressionsButfrommpyc.runtimeimportmpcfromoblif.decoratorimportoblif@oblifdeftest(x):return1ifx==5else0mpc.run(mpc.start())type=mpc.SecInt()type.ifelse=lambdaself,ifval,elseval:ifvalififvaliselsevalelsempc.if_else(self,ifval,elseval)type.__deepcopy__=lambdaself,memo:selfprint("test(5) is",mpc.run(mpc.output(test(type(5)))))mpc.run(mpc.shutdown())gives2021-05-08 13:58:47,387 Start MPyC runtime v0.7.4
test(5) is 1
2021-05-08 13:58:47,394 Stop MPyC runtime -- elapsed time: 0:00:00.006167
Package: oblique
Oblique Strategies for PythonShows koans fromOblique Strategies.You can get the officialphysical card setas well.❯ pip install oblique
❯ python -m oblique --help
Usage: python -m oblique [OPTIONS]

Options:
  --edition TEXT   Which OS editions to include?  [default: 1,2,3,4]
  --extra          Include additional koans found online  [default: False]
  --python         Include Monty Python quotes  [default: False]
  --count INTEGER  How many koans to show  [default: 3]
  --help           Show this message and exit.

❯ oblique
Faced with a choice, do both (from Dieter Rot)
Do something sudden, destructive and unpredictable
Move towards the unimportantLicenseCode is BSD-3 licensed. Koans attributed to Brian Eno and Peter Schmidt.
Package: obliquestrategies
Over One Hundred Worthwhile DilemmasCreated by Brian Eno and Peter Schmidt, first published in 1975This work is forked fromCrossNox’s Programming ExcusesDelving deep into the history and development ofDavid Bowie’s HeroesI found out that during the recording of the album, Brian Eno made use of his set of cards: Oblique Strategies.In 1975, the magnificentBrian EnoandPeter Schmidtdesigned a method for promoting creativity, where each card offers a way to break mental blocks. In the subsequent years more and more editions of the deck of cards were made.Unsurprisingly, considering the creative nature of programming, this works very well when trying to overcome a deadlock in the midst of coding.To understand more about this method, you should readhttp://www.rtqe.net/ObliqueStrategieswhich also serves as the original sources for every deck in this module.This Python module and terminal command gives you one Oblique Strategy per run, taken from any of the original three decks or from the fourth special one. This comprises the first edition (1975), the second one (1978), the third one (1979), and the fourth one (1996), which has apretty interesting storyInstallingpipinstallobliquestrategiesUsage>>>fromobliquestrategiesimportget_strategy>>>print(get_strategy())WorkatadifferentspeedDeck editions can be specified by edition number or edition year>>>print(get_strategy(1))Trustintheyouofnow>>>print(get_strategy(1975))Howwouldyouhavedoneit?From a terminal$obliquestrategiesWhatwouldyourclosestfrienddo?And once again, editions can be specified by numer or year with the--editionoption.$obliquestrategies--edition2Turnitupsidedown$obliquestrategies-e1978Repetitionisaformofchange
Package: obliquity
Infer the stellar obliquity distribution of transiting planet systems, followingMorton & Winn (2014).Makes use of thesimpledistpackage, which will be installed
as a dependency with installation of this package.There are two main tasks this package does:Calculate posteriors of cos(I) given measurements of Rstar, Prot, Vsin(I).Infer the Fisher distribution parameter $kappa$ given a sample of cos(I) posteriors.See below for a quick intro, and thenotebook demofor more.Installation$ pip install [--user] obliquityOr clone the repository and install:$ git clone https://github.com/timothydmorton/obliquity.git
$ cd obliquity
$ python setup.py install [--user]Basic usagefromobliquity.distributionsimportCosi_Distributioncosi_dist=Cosi_Distribution((1.3,0.1),(15,0.3),(3.5,0.5))#Radius, Prot, VsinIcosi_dist.summary_plot()Command-line scriptsIn addition to theobliquitymodule, this package also installs a few command-line scripts.write_cosi_dist: This calculates aCosi_Distributiongiven input parameters, and writes the distribution to
file (.h5format that can be easily re-loaded back). e.g.,$ write_cosi_dist test.h5 -R 1.3 0.1 -P 14 0.3 -V 4 0.5After having done this, you could launch up python and read in the distribution as follows:fromobliquityimportCosi_Distribution_FromH5cosi_dist=Cosi_Distribution_FromH5('test.h5')cosi_dist.summary_plot()This is particularly useful for running batch jobs and doing more analysis later.
Package: oblv-client
oblv-client-pythonPython bindings foroblvclient proxy.Installationpip install oblv_clientUsageimportoblv_clientasocimportuuidoc.set_log_level("info")enc_url="http://<some-enclave-url>enc_port=8000# For Pkiauthenclave=oc.Enclave(enc_url,enc_port,True,str(uuid.uuid4()),pcr0="",pcr1="",pcr2="",private_key="test_private.der",public_key="test_public.der",auth_type="pkiauth",)enc_public_key=enclave.attest()# for OAuthenclave=oc.Enclave(enc_url,enc_port,True,str(uuid.uuid4()),pcr0="",pcr1="",pcr2="",auth_type="oauth",client_id="<client-id>",client_secret="<client-secret>",oauth_audience=oauth_audience,oauth_url=oauth_url)# To attestaccess_token=enclave.attest()# Make HTTP Requestdata=e.get(f"http://{enc_url}:{enc_port}/get_report",headers={"Header1":"HeaderValue"},body=bytes("some body contents","utf-8"),params={"param1":"val1"},)status=data.statusheaders=data.headersbody=data.bodyprint(status)print(headers)print(body)data=e.post(f"http://{enc_url}:{enc_port}/get_report",headers={"Header1":"HeaderValue"},params={"param1":"val1"},json={"key":"val"})status=data.statusheaders=data.headersbody=data.bodyprint(status)print(headers)print(body)
Package: ob-metaflow
MetaflowMetaflow is a human-friendly library that helps scientists and engineers build and manage real-life data science projects. Metaflow wasoriginally developed at Netflixto boost productivity of data scientists who work on a wide variety of projects from classical statistics to state-of-the-art deep learning.For more information, seeMetaflow's websiteanddocumentation.From prototype to production (and back)Metaflow provides a simple, friendly API that covers foundational needs of ML, AI, and data science projects:Rapid local prototyping,support for notebooks, andbuilt-in experiment tracking and versioning.Horizontal and vertical scalability to the cloud, utilizing both CPUs and GPUs, andfast data access.Managing dependenciesandone-click deployments to highly available production orchestrators.Getting startedGetting up and running is easy. If you don't know where to start,Metaflow sandboxwill have you running and exploring Metaflow in seconds.Installing Metaflow in your Python environmentTo install Metaflow in your local environment, you can install fromPyPi:pipinstallmetaflowAlternatively, you can also install fromconda-forge:condainstall-cconda-forgemetaflowIf you are eager to try out Metaflow in practice, you can start with thetutorial. After the tutorial, you can learn more about how Metaflow workshere.Deploying infrastructure for Metaflow in your cloudWhile you can get started with Metaflow easily on your laptop, the main benefits of Metaflow lie in its ability toscale out to external compute clustersand todeploy to production-grade workflow orchestrators. To benefit from these features, follow thisguideto
configure Metaflow and the infrastructure behind it appropriately.ResourcesSlack CommunityAn activecommunityof thousands of data scientists and ML engineers discussing the ins-and-outs of applied machine learning.TutorialsIntroduction to MetaflowNatural Language Processing with MetaflowComputer Vision with MetaflowRecommender Systems with MetaflowAnd more advanced contenthereGenerative AI and LLM use casesInfrastructure Stack for Large Language ModelsParallelizing Stable Diffusion for Production Use CasesWhisper with Metaflow on KubernetesTraining a Large Language Model With Metaflow, Featuring DollyGet in touchThere are several ways to get in touch with us:Slack CommunityGithub IssuesContributingWe welcome contributions to Metaflow. Please see ourcontribution guidefor more details.
Package: obniz-cli
obniz_cliobniz_cliis cli tool for obnizOS(for ESP32) install.InstallationUsing pip,pip install obniz_cliPreparationConnect the ESP32 device from the serial port to your PC and check if the PC recognizes the device. The following command shows the list of devices.python -m serial.tools.list_ports(You can execute this command afterpip install obniz_cli.)In most cases, port name isdev/cu.SLAB_USBtoUARTor likeCOM3. If you can't find these port or can find but fail to install, you may need USB-driver for devices fromhere.Usageflashosobniz_cli flashos [-b] [-p]You can install obnizOS to your ESP32 device. If you execute without-poption, it is displayed as follows:0: /dev/cu.Bluetooth-Incoming-Port
1: /dev/cu.SLAB_USBtoUART

Select NUMBER from above list(or if you want to cancel, input N key):Select the device you want to install. (A device port can be passed to command with-poption likeobniz_cli flashos -p /dev/cu.SLAB_USBtoUART).Then, latest obnizOS is downloaded and installed to device. By default, installation is performed at 115200bps but if installation failed, try to decrease it byobniz_cli flashos -b 115200.After install, cli automatically change serial mode to set obnizOS configurationeraseosobniz_cli eraseos [-p]You can reset your device by this command.
Package: obob-condor
obob_condorA python module to make it simple to submit jobs to the OBOB cluster directly from pythonHow to usecoming up...Documentationcoming up....CodeThe source code can be found here:https://gitlab.com/obob/obob_condorLicenseThis module is developed by Thomas Hartmann at the Universität Salzburg. You are free to use, copy, modify, distribute it under the terms of the GPL3.
Package: obol
Obol is a command line utility to add, delete and modify users and
groups in an LDAP server.Perhaps the most common use of LDAP is as a centralised store for
usernames and passwords. The protocol for managing an LDAP server is
somewhat verbose. It is cumbersome to create an LDIF file to modify a
user attribute.For UNIX passwords, user and group management can be done using simple
command line tools like useradd and groupadd. Obol was created to
provide a similar interface, but to manage users and groups inside an
LDAP server.© 2016 Hans Then. Obol is released under GPLv3. seegpl.txtfor
details.