Saravanan666/pypi-org huggingface dataset:
Package: objectmapper
A small module for mapping between object types.DocumentationSourcePyPi PackageInstallationobjectmapperrequiresPython >= 3.6because it relies on modern type annotations.pip install objectmapperExample>>> import objectmapper
>>> mapper = objectmapper.ObjectMapper()
>>> # One-to-one mappings
>>> def int_to_str(i: int) -> str:
...     return str(i)
>>> mapper.create_map(int, str, int_to_str)
>>> mapper.map(42, str)
'42'
>>> # Many-to-one mappings
>>> def int_float_to_str(i: int, f: float) -> str:
...     return str(i + f)
>>> mapper.create_map((int, float), str, int_float_to_str)
>>> mapper.map((42, 42.5), str)
'84.5'
Package: objectmodel
objectmodelPython typed object model for schema creation and validationA bit unpythonic object definition, but sometimes things should be strict and typed :)
Ideal for protocols and schemas.Objects populated by ObjectModel class guarantee to match the desired state and fully serializable at any time.InstallationThis library is still in a development state, so please dont use it right away - the API might change at any timepip install objectmodelTODOPerformance benchmarks (ObjectModel vs plain object, namedtuple, dict)__state__: Dict[str, Any]vs dynamically populated__slots__Better validation and state ensuranceStrict collections (ObjectModelListandObjectModelDict)?Separate key and value validation for collectionsBetter field APIPredefined fields (StringField,IntField,FloatField)Proxy fields:MethodFieldorComputedFieldReadonly fieldsMore tests!More examplesAuto-deployment to PyPI
Package: objectory
objectory = object + factoryOverviewA Python library for general purpose object factories.
In particular, it focuses on dynamic object factory implementations where objects can be registered
dynamically without changing the code of the factory.
An object factory can be used to instantiate an object from its configuration.
The current implementation contains both abstract factory and registry approaches.factory>>>fromobjectoryimportfactory>>>obj=factory("builtins.list")>>>print(obj)[]abstract factory>>>fromobjectoryimportAbstractFactory>>>classBaseClass(metaclass=AbstractFactory):...pass...>>>classMyClass(BaseClass):...pass...>>>obj=BaseClass.factory("MyClass")>>>print(obj)<__main__.MyClass object at 0x...>registry>>>fromobjectoryimportRegistry>>>registry=Registry()>>>@registry.register()...classMyClass:...pass...>>>obj=registry.factory("MyClass")>>>print(obj)<__main__.MyClass object at 0x...>Please read thedocumentationto learn more about these
approaches.DocumentationInstallationContributingAPI stabilityLicenseInstallationWe highly recommend installing
avirtual environment.objectorycan be installed from pip using the following command:pipinstallobjectoryIt is highly recommended to use the last stable version available.
Please check theget started pageto see other
alternatives to install the library.
The following is the correspondingobjectoryversions and supported dependencies.objectorytornadopythonmain>=6.0,<7.0>=3.9,<3.130.1.2>=6.0,<7.0>=3.9,<3.130.1.1>=6.0,<7.0>=3.9,<3.130.1.0>=6.0,<7.0>=3.9,<3.130.0.9>=6.0,<7.0>=3.9,<3.130.0.8>=6.0,<7.0>=3.9,<3.130.0.7>=6.0,<7.0>=3.9,<3.12ContributingPlease check the instructions inCONTRIBUTING.md.API stability:warning: Whileobjectoryis in development stage, no API is guaranteed to be stable from one
release to the next.
In fact, it is very likely that the API will change multiple times before a stable 1.0.0 release.
In practice, this means that upgradingobjectoryto a new version will possibly break any code
that was using the old version ofobjectory.Licenseobjectoryis licensed under BSD 3-Clause "New" or "Revised" license available
inLICENSEfile.
Package: objectpath
The agile NoSQL query language for semi-structured data#Python #NoSQL #Javascript #JSON #nested-array-objectObjectPath is a query language similar to XPath or JSONPath, but much
more powerful thanks to embedded arithmetic calculations, comparison
mechanisms and built-in functions. This makes the language more like SQL
in terms of expressiveness, but it works over JSON documents rather than
relations. ObjectPath can be considered a full-featured expression
language. Besides selector mechanism there is also boolean logic, type
system and string concatenation available. On top of that, the language
implementations (Python at the moment; Javascript is in beta!) are
secure and relatively fast.More atObjectPath siteObjectPath imgObjectPath makes it easy to find data in big nested JSON documents. It
borrows the best parts from E4X, JSONPath, XPath and SQL. ObjectPath is
to JSON documents what XPath is to XML. Other examples to ilustrate this
kind of relationship are:ScopeLanguagetext documentsregular expressionXMLXPathHTMLCSS selectorsJSON documentsObjectPathDocumentationObjectPath ReferenceCommand line usage$sudopipinstallobjectpath$objectpathfile.jsonor$gitclonehttps://github.com/adriank/ObjectPath.git$cdObjectPath$pythonshell.pyfile.jsonPython usage$sudopipinstallobjectpath$python>>>fromobjectpathimport*>>>tree=Tree({"a":1})>>>tree.execute("$.a")1>>>$gitclonehttps://github.com/adriank/ObjectPath.git$cdObjectPath$python>>>fromobjectpathimport*>>>tree=Tree({"a":1})>>>tree.execute("$.a")1>>>Contributing & bugsI appreciate all contributions and bugfix requests for ObjectPath,
however since I don’t code in Python any more, this library is not
maintained as of now. Since I can’t fully assure that code contributed
by others meets quality standards, I can’t accept PRs.If you feel you could maintain this code, ping me. I’d be more than
happy to transfer this repo to a dedicated ObjectPath organization on
GitHub and give the ownership to someone with more time for this project
than me.LicenseMITDownload
Package: objectpath-ng
|Downloads||License||Build
Status||Code
Health||Coverage
Status|The agile NoSQL query language for semi-structured data#Python #NoSQL #Javascript #JSON #nested-array-objectObjectPath is a query language similar to XPath or JSONPath, but much
more powerful thanks to embedded arithmetic calculations, comparison
mechanisms and built-in functions. This makes the language more like SQL
in terms of expressiveness, but it works over JSON documents rather than
relations. ObjectPath can be considered a full-featured expression
language. Besides selector mechanism there is also boolean logic, type
system and string concatenation available. On top of that, the language
implementations (Python at the moment; Javascript is in beta!) are
secure and relatively fast.This package is a maintained fork of theoriginal project<htttps://github.com/adriank/ObjectPath>and still compatible with the specification at theObjectPath site<http://objectpath.org/>.More atObjectPath siteObjectPath imgObjectPath makes it easy to find data in big nested JSON documents. It
borrows the best parts from E4X, JSONPath, XPath and SQL. ObjectPath is
to JSON documents what XPath is to XML. Other examples to ilustrate this
kind of relationship are:ScopeLanguagetext documentsregular expressionXMLXPathHTMLCSS selectorsJSON documentsObjectPathDocumentationObjectPath ReferenceWhat’s in this repo?ObjectPathPY - Python implementation of ObjectPath, used in production
for over two years without problems. Use objectpath.py file as a example
of usage.ObjectPathJS - beta version of Javascript implementation. Many tests
passed, {} and functions are not implemented yet. Javascript
implementation has the very same API as the Python version.Command line usage$ pip installobjectpath-ng$ objectpath file.jsonor$ git clonehttps://github.com/objectpath/ObjectPath.git$ cd ObjectPath $ python shell.py file.jsonPython usage$ pip install objectpath-ng
$ python
>>> from objectpath import *
>>> tree=Tree({"a":1})
>>> tree.execute("$.a")
1
>>>$ git clone https://github.com/objectpath/ObjectPath.git
$ cd ObjectPath
$ python
>>> from objectpath import *
>>> tree=Tree({"a":1})
>>> tree.execute("$.a")
1
>>>LicenseMITDownload
Package: objectpermissions
Django Object Permissions is a way to add a custom set of user-object or group-object permissions. It does not replace Django’s built-in permissions. Instead it augments them by adding additional ways to manage access to specific objects.You can add object permissions to existing apps (e.g. Flat Pages) without modifying the app’s code, or build it into your own application.It uses an efficient method of storing permissions; it requires only one row per user-object combination, regardless of the number of permissions granted.Our initial goals were pretty simple (in thought, not necessarily in deed):Have an easy way to set read/write/owner permissions on an object or rowEasy to discover if a given user has a level of permissionCustomizable permissions by modelAdmin viewing/editing integrationThis is a proof-of-concept right now and we are looking for feedback for tweaks in implementation or new ideas to implement.
Package: object_pool
object_poll is a simple thread-safe generic python object pool. Typical
use:importmemcacheimportobject_poolmemcache_pool=ObjectPool(lambda:memcache.Client(['127.0.0.1:11211']),max_size=10)withmemcache_pool.item()asmemcache:memcache.set(b'key',b'value')Thewithstatement is not required:try:memcache=memcache_pool.get()finally:memcache_pool.put(memcache)It supports atimeoutargument as well:try:memcache=memcache_pool.get(timeout=1.0)exceptObjectPoolTimeout:importlogginglogging.warning('timed out trying to get memcache connection')
Package: object-proxy
# ObjectProxy #**A minimalistic yet powerful object proxying utility**This readme attempts to explain the general use of this library.### Installation ###* Install from repository```pip install git+https://github.com/aviksama/objectproxy.git```* Install from pypi```pip install object-proxy```### Example ###Object proxy basically creates a proxy for any python object:```pythonclass MyClass(object):def __init__(self, array=None):self.array = array or []def get_array_element(self, index):try:return self.array[index]except IndexError:returndef create_dictionary_of_objects(*args):mydict = dict()for index, arg in enumerate(args):mydict[index] = arg```Now lets create proxies for the objects above in random fashion```python>>> from objectproxy import ProxyElement, eval_proxy>>> class_proxy = ProxyElement(MyClass, args=[[1,2,3],], kwargs={})>>> function_proxy = ProxyElement(create_dictionary_of_objects, args=[class_proxy], kwargs={})>>> class_proxy_ref = function_proxy.values()[0]>>> class_proxy_array_element = class_proxy_ref.get_array_element(0)>>> eval_proxy(class_proxy_array_element)1```until `eval_proxy` is called on the proxy object, It doesn't call the parent methods. Hence all the parent methods and attributes are lazily evaluated.### Contribution guidelines ###We appreciate your effort in contributing to this project. You can contribute in any of the following.* Writing tests* Code review* Other guidelines* Submit issuesIn order to contribute please fork the repository, And make a GitHub pull request to `dev` branch.### Who do I talk to? ###* Repo owner or admin* Other community or team contact
Package: objectref
objectrefobjectref is a library to parse object references and find referenced objects.NotationsObject references are notations to locate modules or objects from the top level of a module.package.module
package.module:object.attrThe first form simply refers a module, while the second form an object in module.
It is also described inhere.This library also supports relative object references (prefixed with dots).Usagefind(ref: str, package: str | None = None) -> AnyThefindfunction takes an object reference orparse()result,
and returns the object pointed by the reference.Thepackageargument must be set when the reference is relative.If qualified name is unspecified (the first form), the result is a module (types.ModuleTypeinstance).ModuleNotFoundErroris raised if the module cannot be found nor imported;LookupErrorif the object is not accessible from the top level of the module.parse(ref: str) -> tuple[str, str | None]Theparsefunction takes an object reference,
and results in a tuple of module name and qualified name.
The qualified name would beNonein first form.ValueErroris raised if the reference is invalid.Exampleimportos.pathimportobjectrefprint(objectref.find("os.path")==os.path)# Trueprint(objectref.find("os.path:join")==os.path.join)# Trueprint(objectref.parse("os.path"))# ("os.path", None)print(objectref.parse("os.path:join"))# ("os.path", "join")Entrypoint exampleThere are two main ways to execute a Python program.Runpython -m myapp.mainin shells, which executes the module as__main__under the hood.
This relates to the first form of notation.Runmyappinstalled by pip. It is generated according to entrypoint defined in the project metadata
(e.g.myapp = myapp.main:main).
This requires the second form notation with callable objects.Here is a code snippet to unify these two ways and start a program by its object reference.importobjectrefdefrun(ref:str,package:str|None=None):modname,qualname=objectref.parse(ref)ifqualnameisNone:# Use runpy to run a module with __name__ = "__main__"ifmodname.startswith("."):# runpy does not support relative module name.fromimportlib.utilimportresolve_namemodname=resolve_name(modname,package)importrunpyreturnrunpy.run_module(modname,run_name="__main__")fn=objectref.find((modname,qualname),package)returnfn()if__name__=="__main__":run("this")# run the "this" module dynamically.
Package: object-registry
Object RegistryKeep track of all instantiated objects of a class.Installationpipinstallobject-registryGetting startedFor any class whose objects you want to track, inherit fromObjectRegistryupon definition.fromobject_registryimportObjectRegistryclassMyClass(ObjectRegistry):...Instantiate objects of the derived class as usual. Each object will be automatically added to the registry.obj=MyClass()Usefrom_idto retrieve an object by its Python object ID.object_id=id(obj)retrieved_obj=MyClass.from_id(object_id)
Package: objectrest
ObjectRESTA Python package to handle REST API requests, JSON parsing, and pydantic object generation.InstallationFrom PyPi:python -m pip install objectrestFrom GitHubpython -m pip install git+https://github.com/nwithan8/objectrest.gitUsageThis package acts as a middle-man between the user and the Requests library.Users can call to methods directly, or use the RequestHandler class to set universal parameters (i.e. API tokens), universal headers and/or a universal base URL for all requestsUsers can retrieve the raw request, the JSON data from a request, or have the JSON data automatically parsed into a Pydantic model.Example:fromobjectrestimportRequestHandlerrequests=RequestHandler(base_url="http://rootoftheapi",universal_parameters={'api_key':"thisisanapikey"})my_object=requests.get_object(url="/object",model=MyObjectClass,params={"limit":10})DocumentationDocumentation available onReadTheDocs
Package: objectrocket
ObjectRocket Python ClientObjectRocket API interface library for Python.NOTICE:this client is still undergoing intial stages of development, and some public interfaces may change as development continues. We will increment the version of this package to 1.0.0 once the public interface to this library is deemed stable.examplesTo use the library, simply do the following:>>>importobjectrocket>>>client=objectrocket.Client()>>>client.authenticate('<username>','<password>')# Create a new instance.>>>client.instances.create(name='instance0',size=5,zone='US-West'<MongodbInstance{...}at0x10aedb990># Get an instances object.>>>client.instances.get('instance0')<MongodbInstance{...}at0x10aedb980># Get all instances.>>>client.instances.all()[<MongodbInstance{...}at0x10aedb980>]installationpipinstallobjectrocketdevelopmenttestTesting against local you will want to export a couple environment variables:exportOR_DEFAULT_API_URL='http://localhost:5050/v2/'exportOR_DEFAULT_ADMIN_API_URL='http://localhost:5050/admin/'Before you push your code, runtoxfrom the top level directory. If errors
are reported, fix them.coverageTo receive a test coverage report, runtox -e coveragefrom the top level directory.pypi buildUpdate version in setup.py
Pushing a tag following the pattern/^[0-9]+.[0-9]+.[0-9]+$/will automatically trigger a new version of the client to be built and uploaded topypi. A pattern of/^[0-9]+.[0-9]+.[0-9]+-rc[0-9]+$/will cause it to be pushed totestpypi.documentationTo build the documentation, invoketox -e docsfrom the top level directory.
The HTML index can then be found atdocs/build/html/index.html.
Package: objectscale-s3-client
objectscale-s3-client-pythonObjectScale S3 Client for Python (based on boto3)Link to Project Management Software:https://app.clickup.com/14398002/v/l/7-14398002-1Project summaryThis is a library developed for Dell Technologies extending the boto3 Python library for metadata search calls.The library takes existing S3 API calls designed for boto3 and implements new search indexes for metadata search functionality. It also generates new S3 API calls with metadata search functionality. A stretch goal for the project is implementation of client-side load balancing to improve preformance of the boto3 library.InstallationThe library will be accessible through PyPI. Project information can be seen here:PrerequisitesPython is neccessary to have installed before using the library. The project will function with Python versions past Python 3.9. If the user wants to contribute to the project, Git will also be neccessary. As this library extends the existing boto3 and botocore libraries, these are also necessary prerequisites.Installation StepsThe package can be installed through pip, which comes with the installation of Python. Installation of the package can be done by simply executing the following command:pip install PyscaleS3FunctionalityHigh-level functionality described in summary info. As the product is being developed this section will be updated with more specific info.TODO: Write usage instructions. Structuring it as a walkthrough can help structure this section,
and showcase your features.Known ProblemsAs the product is being developed, this section will be updated with known bugs.TODO: Describe any known issues, bugs, odd behaviors or code smells.
Provide steps to reproduce the problem and/or name a file or a function where the problem lives.ContributingContributions to the project are welcomed. Outline of steps for contributions are given below:Create a new GitHub issue or find one to work onAssign the issue to yourselfFork project, make changes, get reviewed by Dell project maintainerDCO sign offAdditional details for these requirements can be found in theCONTRIBUTING.mdfile in the project repository.Additional DocumentationThe documentation module Sphinx was used for documenting the code. This documentation can be accessed through the earlier linked github code.How to Generate DocumentationThe documentation can be generated using the following script.git checkout gh-pages
git rm -rf .
git checkout main -- docs

make html

git add .
git commit -s -m "updated docs"
git pushThe script checks out the orphan gh-pages branch, removes all existing files, then copies the updated docs in the main branch. "make html" generates the new documentation and the final commands push the updates to github.LicenseThis project uses the Apache License. The license can be viewed in theLICENSEfile in the project repository.Finding Dependencies of packageinstall objectscale python package using pip installinstall pipdeptree using pip installrun command 'pipdeptree -p obs-s3-client'dependency tree should be displayed
Package: objectsinpython
Objects In PythonInterface toObjects In SpaceforCircuitPythonembedded hardware.InstallDownload thecompiled moduleand copy them to your board. Note there are two
versions: "full" or regular for boards with more memory (eg, M4/samd51) and "tiny" for
boards with less memory (eg, M0/samd21). When using the tiny build, be sure to rename
the module tooip.mpy.$cp-Xoip.mpy/Volumes/CIRCUITPY/oip.mpyOR$cp-Xoip-tiny.mpy/Volumes/CIRCUITPY/oip.mpyOverviewObjects In Python uses a simple, event-based API to execute your functions when buttons
are pressed or game values update. Getting started is as easy as importing the module,
creating the interface, and starting the connection:fromoipimportOIPoip=OIP()...oip.start()Turn lights on or off when game state changes:@oip.on("IFF_ACTIVE")defiff_active(now,value):pixels[0]=BLUEifvalueelseREDConnect buttons to game commands:@oip.press(board.BUTTON_A)defthrust_while_holding(now,value):oip.execute("BURN_MAIN_ENGINE"ifvalueelse"STOP_MAIN_ENGINE")With the full build, use helper classes to mitigate typoes:@oip.on(Boolean.IFF_ACTIVE)defiff_active(now,value):...@oip.press(board.BUTTON_A)defthrust_while_holding(now,value):oip.execute(Command.BURN_MAIN_ENGINEifvalueelseCommand.STOP_MAIN_ENGINE)Check out theexample projectsfor more ideas.LicenseObjects In Python is copyrightJohn Reese, and licensed under the
MIT license.  I am providing code in this repository to you under an open source
license.  This is my personal repository; the license you receive to my code
is from me and not from my employer. See theLICENSEfile for details.
Package: object-symbols-parser
object_symbols_parserCommand line tool that reads object file symbol table, generate a sorted spreadsheet with the entries. Intended for embedded development where memory and code space needs to be optimized.UsageObject FileThis is particularly useful if you cannot compile a binary due to the code space being exceeded.object_symbols_parser.py -f src/FileSystem.o -f src/cpp_config.o -f src/main.o -o /tmp/out.xlsxELF/AXF Fileobject_symbols_parser.py -f project.axf -o /tmp/out.xlsxOutputGenerates a Pandas dataframe and saves it to a spreadsheet. By default the results are sorted as you're most likely looking for the largest entry in the symbols table.RequirementsclickpandasGNU Bintools
Package: objecttoclass
Object To Classa simple python script to convert dict into a class instanceexample# import the packagefromobjecttoclassimportObjectToClassasOTC# or : from objecttoclass import OTC (Variable holding the ObjectToClass instance )# set the data you want to convertdata={"name":"Hussein Naim"}# new OTC instanceinstance=OTC(data)# print out the name attrprint(instance.name)# output: Hussein Naim